Tour of Go exercise #23: rot13Reader

I'm trying to solve the Tour of Go exercise rot13Reader:

Here is my solution:

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)
}

It returns You prnpxrq tur poqr!, that means only the first word of "Lbh penpxrq gur pbqr!" is cracked. How can I crack the whole sentence?

EDIT:

Basically your solution is good and works, you just mistyped 1 character:

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

Change it to:

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

Your input and output:

Lbh penpxrq gur pbqr!
You prnpxrq tur poqr!

There is change in every word. The problem is not that only the first word is read and decoded, the problem is in your decoding algorithm.

In ROT13 if shifting goes outside of the letter range, you have to start from the beginning of the alphabet (or at the end). For example shifting 'N' would be 'Z' + 1, so it becomes 'A', the first letter. See this simple character mapping:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm

So what you should do is after shifting by 13, if the letter goes outside of the alphabet, shift it by -26 (number of letters in the English alphabet) which has the desired effect (that after the last letter you continued from the first).

An example solution:

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
}

And its output:

You cracked the code!

Try it on the Go Playground.

You could also use instead:

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]
}

I prefer manipulate directly integers in rot13 function

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)
}

func (reader rot13Reader) Read(bytes []byte) (int, error) {
	n, err := reader.r.Read(bytes)
	for i, val := range bytes[:n] {
		if val >= 'a' && val <= 'z' {
			bytes[i] = (val-'a'+13)%26 + 'a'
		} else if val >= 'A' && val <= 'Z' {
			bytes[i] = (val-'A'+13)%26 + 'A'
		}
	}
	return n, err
}

The problem is that your function does not work as you want. To verify this, just try to run your function on "Lbh penpxrq Lbh gur pbqr!". As you see first word is decoded (as well as the third one). So this means that your function does not run only on the first word, but in fact runs on all the words (it just happened that nothing else is changed).

func (rot *rot13Reader) Read(p []byte) (n int, err error) {
	n, err = rot.r.Read(p)
	for i := 0; i < len(p); i++ {
		if (p[i] >= 'A' && p[i] < 'N') || (p[i] >='a' && p[i] < 'n') {
			p[i] += 13
		} else if (p[i] > 'M' && p[i] <= 'Z') || (p[i] > 'm' && p[i] <= 'z'){
			p[i] -= 13
		}
	}
	return
}

And here is a <kbd>Playground</kbd>. Code is taken from here.

My code also works, it's more simple!

func (rd *rot13Reader) Read(b []byte) (int, error) {
	m := make(map[byte]byte)
	input := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
	output := "NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm"
	for idx := range input {
		m[input[idx]] = output[idx]
	}

	n, err := rd.r.Read(b)
	for i := 0; i < n; i++ {
	    if val, ok := m[b[i]]; ok {
		  b[i] = val
	    }
	}
	return n, err
}

package main

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

type rot13Reader struct {
	r io.Reader
}

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

	for i := range b {
		var base byte
		if b[i] >= 'a' && b[i] <= 'z' {
			base = 'a'
		} else if b[i] >= 'A' && b[i] <= 'Z' {
			base = 'A'
		} else {
			continue
		}
		b[i] = (((b[i] - base) + 13) % 26) + base
	}
	return n, err
}

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

As a follow up to the answer by @icza, rather than hard-coding the checks for whether the byte is alphabetic or not, create a small function to determine it instead. It makes for much cleaner code.

func alphabetic(x byte) bool {
return (x >= 'A' && x <='Z') || (x >= 'a' && x <= 'z')
}
func capital(x byte) bool {
return x >= 'A' && x <= 'Z'
}
func rot13(x byte) byte {
// byte isn't a letter
if !alphabetic(x) {
return x
}
original_is_capital := capital(x)
// apply rot13  
x += 13
// the new letter should loop around
if !alphabetic(x) || original_is_capital {
x -= 26
}
return x
}

func rot13(x byte) byte {
if (x >=  'A' && x <= 'M') || (x >=  'a' && x <= 'm') {
return x + 13
} else if (x >=  'N' && x <= 'Z') || (x >=  'n' && x <= 'z') {
return x - 13
} else {
return x
}
}

A simple code snippet that changes alphabets and ignores other characters

func (rot *rot13Reader) Read(b [] byte) (int, error) {
size,e := rot.r.Read(b)
for i := 0; i < size; i++ {
if b[i] < byte('A') || b[i] > byte('z') {
continue
}
if b[i] > byte('a') {
b[i] = byte('a') + (b[i] - byte('a') + 13)%26
} else {
b[i] = byte('A') + (b[i] - byte('A') + 13)%26
}
}
return size, e
}

Throwing my 2 cents in as well:

https://play.golang.org/p/1Wze47kL-bA

package main
import (
"io"
"os"
"strings"
"unicode"
)
type rot13Reader struct {
r io.Reader
}
func (r rot13Reader) Read(buf []byte) (int, error) {
n, err := r.r.Read(buf)
if err != nil {
return n, err
}
for i := 0; i < n; i++ {
r := rune(buf[i])
if !unicode.IsLetter(r) {
continue
}
isUpper := unicode.IsUpper(r)
r += 13
if !unicode.IsLetter(r) || isUpper && r >= 'a' {
r -= 26
}
buf[i] = byte(r)
}
return n, err
}
func ExampleRot13Reader() {
s := strings.NewReader("Lbh penpxrq gur pbqr!")
r := rot13Reader{s}
io.Copy(os.Stdout, &r)
// Output: You cracked the code!
}

Preparing for comments such as "Simply providing code as an answer is not very helpful"... this is a special case where the questioner is asking for other solutions, and this is a fun way to compare various approaches. No need to really explain much.

My try:

package main

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

const a byte = byte('a')
const n byte = byte('n')
const z byte = byte('z')

const A byte = byte('A')
const N byte = byte('N')
const Z byte = byte('Z')


type rot13Reader struct {
	r io.Reader
}

func rot13(b byte) byte {
	switch {
		case ((b >= A && b < N) || (b >= a && b < n)):
			b += 13
		case ((b >= N && b <= Z) || (b >= n && b <= z)):
			b -= 13
	}
	return b
}

func (r13 rot13Reader) Read(b []byte) (int, error) {
	n, err := r13.r.Read(b)
	
	for x := range b[:n] {
		b[x] = rot13(b[x])
	}
	
	return n, err
}

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

A simple and intuitive approach

Or, if you neither want to use maps nor those fancy-schmancy functions/operators other folks are using, you can set up an array-based translation table that needs no searching. Trick it to have all the rot13-ing be done ahead of time by using an array of bytes where the index has the rot-13'd value.

Note that the translation array is programmatically generated as an example, and frankly, the code is easier to read / crosscheck than:

x = [256]byte{0, 1, 2,..., (lower rot13 values), ..., (upper...), ...,255}

Code as below

package main
import (
"io"
"os"
"strings"
)
type rot13Reader struct {
r io.Reader
r13array [256]byte
}
// Don't forget the *, or it will do all the work on a copy and throw
// it away
func (r *rot13Reader) initialize_r13() {
// Must be called before doing any rot-13-ing
var cap_A_offset int = int('A')
var low_a_offset int = int('a')
// For simplicity's sake, initialize the entire array, index=itself
for c := 0; c < 256; c++ {
r.r13array[c] = byte(c)
}
// Now pre-calculate the rot-13 values for A-Z and a-z
// These will override the value in the array
for c := 0; c <= 26; c++ {
rot_13 := (c + 13) % 26
r.r13array[c + cap_A_offset] = byte(rot_13 + cap_A_offset)
r.r13array[c + low_a_offset] = byte(rot_13 + low_a_offset)
}
}
func (r rot13Reader) Read(b []byte) (int, error) {
numread, e := r.r.Read(b)
if e == nil {
for i := 0; i < numread; i+= 1 {
c := r.r13array[b[i]]
// Just not worth doing something like "if in != out"
// before setting...I suspect that might even be slower.
b[i] = c
}
}
return numread, e	
}
func main() {
s := strings.NewReader("Lbh penpxrq gur pbqr!")
r := rot13Reader{s, [256]byte{}}
r.initialize_r13()
io.Copy(os.Stdout, &r)
}

Here's how I solved it:

package main
import (
"io"
"os"
"strings"
)
type rot13Reader struct {
r io.Reader
}
func rot13(r byte) byte {
sb := rune(r)
if sb >= 'a' && sb <= 'm' || sb >= 'A' && sb <= 'M' {
sb = sb + 13
}else if sb >= 'n' && sb <= 'z' || sb >= 'N' && sb <= 'Z' {
sb = sb - 13
}
return byte(sb)
}
func (r13 *rot13Reader) Read(b []byte) (i int, e 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)
}

Here are my two cents:

(Note that 'Z' ASCII code is 90 and 'h' is 114)

func (r rot13Reader) Read(p []byte) (n int, err error) {
n, err = r.r.Read(p)
if err == nil {
for i := range p {
if c := p[i] + 13; c > 'z' || (c > 'Z' && c < 'h') {
p[i] = c - 26
} else {
p[i] = c
}
}
}
return n, err
}

My Try:

package main
import (
"io"
"os"
"strings"
)
type rot13Reader struct {
io.Reader
}
func (r rot13Reader) Read(p []byte) (n int, err error) {
n, _ = r.Reader.Read(p)
for i := 0; i < n; i++ {
if p[i] != byte(' ') {
if p[i] > byte('m') {
p[i] = p[i] - 13
} else {
p[i] = p[i] + 13
}
}
}
err = io.EOF
return
}
func main() {
s := strings.NewReader("Lbh penpxrq gur pbqr!")
r := rot13Reader{s}
_, _ = io.Copy(os.Stdout, &r)
}

My solution was this:

func rot13(b byte) byte {
in := []byte("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")
out := []byte("NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm")
for i, v := range in {
if v == b {
return out[i]
}
}
return b
}
type rot13Reader struct {
r io.Reader
}
func (rot *rot13Reader) Read(b []byte) (int, error) {
n, err := rot.r.Read(b)
for i := range b {
b[i] = rot13(b[i])
}
return n, err
}

two years has already passed since the question asked, but I want to share my code which was very simple compared to.

func (rot rot13Reader) Read(p []byte) (n int, err error) {
n, err = rot.r.Read(p)  // read the string into byte array, n holds the length
for i := 0; i < n; i++ {
upper := p[i] >='A'||p[i]<='Z' //new
lower := p[i]>='a'||p[i]<='z'  //new
if (upper||lower){ //new
p[i] += 13   // we are simply decoding here
if (upper && p[i] > 'Z') || (lower && p[i] > 'z') { //new
p[i] -= 26 // and semi-circle the table if it goes beyond
}
}
}
return
}

the result? You cracked the code. Of course it would be better to implement all ascii scale, but it still does most of the job.

EDIT: After a year and a half, a bugged edit by someone else, and a critic about that bug led me to edit this post. The edit still keeps the simplicity of the code while providing few extra conditionals. Moreover, one can turn this code into a rot13 encoder easily. Previous output was You-cracked-the-code.