围棋练习之旅#23:rot13Reader

Question

我正在尝试解决围棋练习之旅，读者：

下面是我的解决方案：

package main

import (
    "io"
    "os"
    "strings"
)

type rot13Reader struct {
    r io.Reader
}

func rot13(x byte) byte {
    switch {
    case x >= 65 && x <= 77:
        fallthrough
    case x >= 97 && x <= 109:
        x = x + 13
    case x >= 78 && x <= 90:
        fallthrough
    case x >= 110 && x >= 122:
        x = x - 13
    }
    return x
}

func (r13 *rot13Reader) Read(b []byte) (int, error) {
    n, err := r13.r.Read(b)
    for i := 0; i <= n; i++ {
        b[i] = rot13(b[i])
    }
    return n, err
}

func main() {
    s := strings.NewReader("Lbh penpxrq gur pbqr!")
    r := rot13Reader{s}
    io.Copy(os.Stdout, &r)
}

它返回You prnpxrq tur poqr！，这意味着只有第一个单词lbh penpxrq gur pbqr！是裂开的。我怎样才能破解整个句子？

Answer 1

我更喜欢直接操作Rot13函数中的整数

package main

import (
    "io"
    "os"
    "strings"
)

type rot13Reader struct {
    r io.Reader
}

const a int = int('a')
const z int = int('z')

const A int = int('A')
const Z int = int('Z')

func rot13(b int) int {

    isLower := b >= a && b <= z
    isUpper := b >= A && b <= Z

    if isLower {
        return a + ((b - a + 13) % 26)
    }

    if isUpper {
        return A + ((b - A + 13) % 26)
    }

    return b
}

func (rot *rot13Reader) Read(b []byte) (int, error) {
    n, err := rot.r.Read(b)
    if err == io.EOF {
        return 0, err
    }

    for x := range b {
        b[x] = byte(rot13(int(b[x])))
    }
    return n, err
}

func main() {
    s := strings.NewReader("Lbh penpxrq gur pbqr!")
    r := rot13Reader{s}
    io.Copy(os.Stdout, &r)
}

Answer 2

您也可以使用：

func rot13(x byte) byte {
    input := []byte("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")
    output := []byte("NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm")
    match := bytes.Index(input, []byte{x})
    if match == -1 {
        return x
    }
    return output[match]
}

Answer 3

编辑：

基本上你的解决方案是好的，工作，你只是输入错误的1个字符：

case x >= 110 && x >= 122:

将其更改为：

case x >= 110 && x <= 122:

您的输入和输出：

Lbh penpxrq gur pbqr!
You prnpxrq tur poqr!

每个单词都有变化。问题不在于只读取和解码第一个单词，而在于解码算法。

在ROT13中，如果移位超出了字母范围，您必须从字母表的开头（或结尾）开始。例如，将'N'移位为'Z'1，因此它成为'A'，第一个字母。看到这个简单的字符映射：

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm

所以你应该做的是在移位13后，如果字母超出了字母表，移位26（英语字母表中的字母数量），这具有预期的效果（在最后一个字母之后，你继续从第一个字母开始）。

一个示例解决方案：

func rot13(x byte) byte {
    capital := x >= 'A' && x <= 'Z'
    if !capital && (x < 'a' || x > 'z') {
        return x // Not a letter
    }

    x += 13
    if capital && x > 'Z' || !capital && x > 'z' {
        x -= 26
    }
    return x
}

其输出：

You cracked the code!

在运动场上试试看。