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"
    //"fmt"

)

//GIVEN INTERFACE FOR -> rot13Reader
type rot13Reader struct {
    r io.Reader
}

//MY READ METHOD: (needs to return (n int, err error))
func (passedR rot13Reader) Read(p []byte) (int, error){
    
    //FIRST GETTING VARIABLES FROM rot13Reader that was passed in.
    n, err := passedR.r.Read(p)
    
    //THEN LOOP length of p and get / change each letter (without the loop below the program works but stays the same!
    
    for i := 0; i < len(p); i++ {
	    
	    //DEPENDING ON INPUT, ADD OR SUBTRACT 13 ACCORDINGLY:
	    switch {
	    case(p[i]>='A' && p[i]<='M'):
		    p[i] += 13
        case(p[i]>='N' && p[i]<='Z'):
		    p[i] -= 13
	    case(p[i]>='a' && p[i]<='m'):
		    p[i] += 13
        case(p[i]>='n' && p[i]<='z'):
		    p[i] -= 13		
	    default:
		    p[i]=p[i]
        }
    }
    
    //FINALLY RETURN n and error
    return n, err
    
}

func main() {
    //MAKE A NEW STRING
    s := strings.NewReader("Lbh penpxrq gur pbqr!")
    
    //MAKE A NEW rot13Reader with string above
    r := rot13Reader{s}
    
    //now copy it?
    io.Copy(os.Stdout, &r)
}

OUTPUT:
​
You cracked the code!

package main

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

type rot13Reader struct {
	r io.Reader
}

func rot13(b byte) byte {
	var a, z byte
	
	switch {
		case 'a' <= b && b <= 'z':
			a, z = 'a', 'z'
		case 'A' <= b && b <= 'Z':
			a, z = 'A', 'Z'
		default:
			return b
	}
	
	return (b-a+13)%(z-a+1) + a
}

func (reader rot13Reader) Read(b []byte) (int, error) {
	n, err := reader.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)
}

Easier for understanding

package main

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

type rot13Reader struct {
	r io.Reader
}

func (r rot13Reader) Read(b []byte) (int, error) {
	n, err := r.r.Read(b)
	for i := 0; i < n; i++ {
		switch {
		case b[i] >= byte('A') && b[i] < byte('N'):
			b[i] += 13
		case b[i] >= byte('a') && b[i] < byte('n'):
			b[i] += 13
		case b[i] >= byte('N') && b[i] <= byte('Z'):
			b[i] -= 13
		case b[i] >= byte('n') && b[i] <= byte('z'):
			b[i] -= 13
		}
	}
	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"
)

type rot13Reader struct {
	r io.Reader
}

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

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

package main

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

const input = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
const output = "NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm"

type rot13Reader struct {
	r io.Reader
}

func (r *rot13Reader) Read(b []byte) (int, error) {
	n, err := r.r.Read(b)
	if err != nil {
		return n, err
	}

	for i := range b {
		inputIndex := strings.Index(input, string(b[i]))
		if inputIndex < 0 {
			continue
		}
		b[i] = output[inputIndex]
	}

	return n, 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 (r rot13Reader) Read(bytes []byte) (int, error) {
	n, err := r.r.Read(bytes)

	for i := 0; i < n; i++ {
		byte := bytes[i]

		if byte >= 'A' && byte <= 'M' {
			bytes[i] += 13
		}

		if byte >= 'N' && byte <= 'Z' {
			bytes[i] -= 13
		}

		if byte >= 'a' && byte <= 'm' {
			bytes[i] += 13
		}

		if byte >= 'n' && byte <= 'z' {
			bytes[i] -= 13
		}
	}

	return n, err
}

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

	io.Copy(os.Stdout, &r)
}