A Tour of Go, exercise rot13Reader

exercise.go

package main

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

type rot13Reader struct {
	r io.Reader
}

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] < 'Z' {
			p[i] = 65 + (((p[i] - 65) + 13) % 26)
		} else if p[i] >= 'a' && p[i] <= 'z' {
			p[i] = 97 + (((p[i] - 97) + 13) % 26)
		}
	}
	return
}

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

package main

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

type rot13Reader struct {
r io.Reader
}

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

func (rot rot13Reader) Read(b []byte) (int, error) {
v, err := rot.r.Read(b)

for i := 0; i < v; i++ {
	b[i] = rot13(string(b[i]))[0]
}

if err != nil {
	return 0, err
}

return v, nil

}

func rot13(s string) (string) {
s = strings.ToUpper(s)

for i := 0; i < len(s); i++ {

	if string(s[i]) < "M" {
		return string( s[i] + 13)
	}

	if string(s[i]) > "M" {
		return string( s[i] - 13)
	}
}

return s;

}

package main

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

type rot13Reader struct {
r io.Reader
}

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] < 'Z' {
p[i] = 65 + (((p[i] - 65) + 13) % 26)
} else if p[i] >= 'a' && p[i] <= 'z' {
p[i] = 97 + (((p[i] - 98) + 13) % 26)
}
}
return
}

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

package main

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

type rot13Reader struct {
	r io.Reader
}

func (r *rot13Reader) Read(b []byte) (int, error) {
	if n, err := r.r.Read(b); err != nil {
		return n, err
	}
	
	for i, v := range b {
		if v > 64 && v < 91 {
			b[i] = (v - 65 + 13) % 26 + 65
		} else if v > 96 && v < 123 {
			b[i] = (v - 97 + 13) % 26 + 97
		}
	}
	return len(b), nil
}
	
func main() {
	s := strings.NewReader("Lbh penpxrq gur pbqr!")
	r := rot13Reader{s}
	io.Copy(os.Stdout, &r)
}

package main

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

type rot13Reader struct {
	r io.Reader
}

func (rot13 rot13Reader) Read(out []byte) (int, error) {
	n, err := rot13.r.Read(out)
	if err != nil {
		return n, err	
	}
	
	for i := 0; i < len(out); i++ {
		if out[i] >= 'A' && out[i] <= 'Z' {
			out[i] = 'A' + (((out[i] - 'A') + 13) % 26)
		}
		if out[i] >= 'a' && out[i] <= 'z' {
			out[i] = 'a' + (((out[i] - 'a') + 13) % 26)
		}
	}
	return n, nil
}

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

I wanted to do compact & efficient :)

package main

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

type rot13Reader struct {
	r io.Reader
}


func rot13(c byte) byte {
	c += 13
	if (c > 'Z' && c < 'a') || c > 'z' {
		c -= 26
	}
	return c
}

func (rot *rot13Reader) Read(b []byte) (int, error) {
	message := make([]byte, len(b))
	n, err := rot.r.Read(message)
	for i := range message {
		b[i] = rot13(message[i])
	}
	return n, err
}

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

package main

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

type rot13Reader struct {
	r io.Reader
}

const (
        lowerMap = "nopqrstuvwxyzabcdefghijklm"
        upperMap = "NOPQRSTUVWXYZABCDEFGHIJKLM"
)

func rotateBytes(bytes []byte) {
	for i := range bytes {
	    if unicode.IsLower(rune(bytes[i])) {
                    bytes[i] = lowerMap[bytes[i]-'a']
	    } else if unicode.IsUpper(rune(bytes[i])) {
		    bytes[i] = upperMap[bytes[i]-'A']
	    }
	}
}

func (rot13 *rot13Reader) Read(bytes []byte) (int, error) {
	n, err := rot13.r.Read(bytes)
	rotateBytes(bytes)
	return n, err
}

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