Hello back again, Golang is just a new syntax for me. Even though behind the scenes they developers have simplified many things, for a consumer like me writing a program is more about learning the new syntax and getting familiarized with the control and stack.
In my constant quest to try something different, today I try and solve the simple cipher which by definition is a text replacement algorithm that makes the text a little difficult to break while reading with naked eyes.
SimpleCipher: Code available in GitHub
Version 1.0#
The first version was a basic logic writing which allowed to check for the code and decode capability.// Encrypt struct
type Encrypt struct {
distance int
key string
}
// NewCaesar Object that implements the interface Cipher
func NewCaesar() Cipher {
return Encrypt{distance: 3, key: ""}
}
// NewShift Object that implements the interface Cipher
func NewShift(distance int) Cipher {
// Corner case when of 0, 26, -26
if distance < -26 || distance > 26 || distance == 0 {
return nil
}
return Encrypt{distance, ""}
}
// NewVigenere Object that implements the interface Cipher
func NewVigenere(key string) Cipher {
if key == "" || checkKeyInvalid(key) {
return nil
}
return Encrypt{0, key}
}
// checkAllAs Checks for all A's in the key.
func checkKeyInvalid(s string) (f bool) {
// If any invalid character matches
if matched, _ := regexp.MatchString(`[^a-z]`, s); matched {
return true
}
for _, m := range s {
switch m {
case 'a':
f = true
default:
f = false
return
}
}
return
}I also wrote a utility to remove all invalid character basically all the chars that were not either of A-Z or a-z.
// removeAllOtherCharcterBeforeEncoding replace all the other elements
func removeAllOtherCharcterBeforeEncoding(s string) (o string) {
o = RegularExp.ReplaceAllString(s, "")
log.Printf(" String: %s", o)
o = strings.ToLower(o)
return
}
var RegularExp = regexp.MustCompile(`[^A-Za-z]`)The basic logic of transforming the input string to encoded string was written in these two functions below
func transformWithString(s string, e string, flag bool) string {
var sb strings.Builder
em := []rune(e)
for i, sm := range s {
// The key has to be repeated
var d rune = 0
if i < len(em) {
d = em[i] - 'a'
} else {
d = em[(i%len(em))] - 'a'
}
if flag {
switch {
case sm >= 'a' && sm <= 'z':
fmt.Fprintf(&sb, "%s", string('a'+(sm-'a'+d)%26))
}
} else {
switch {
case sm >= 'a' && sm <= 'z':
diff := ((sm - 'a' - d) % 26)
newChar := ""
if diff < 0 {
newChar = string('z' + diff + 1)
} else {
newChar = string('a' + diff)
}
fmt.Fprintf(&sb, "%s", newChar)
}
}
}
return sb.String()
}
// transformWithDistance Allows transformation based on distance.
func transformWithDistance(s string, d int) string {
rotateFunction := func(r rune) rune {
switch {
case r >= 'a' && r <= 'z':
val := (r - 'a' + rune(d))
if val < 0 && d < 0 {
return 'z' + ((val + 1) % 26)
}
return 'a' + (val % 26)
default:
log.Printf(" Not a charcter: %s", string(r))
}
return ' '
}
return strings.Map(rotateFunction, s)
}The basic functions that invoke these encode and decode functions are as under
// Encode Implements the interface Cipher
func (e Encrypt) Encode(s string) (o string) {
o = ""
s = removeAllOtherCharcterBeforeEncoding(s)
if s == "" || len(s) <= 0 {
return
}
// Iterate throught the runes
switch {
case e.distance != 0:
o = strings.ReplaceAll(transformWithDistance(s, e.distance), " ", "")
default:
o = transformWithString(s, e.key, true)
}
return
}
// Decode decides the encrypted string
func (e Encrypt) Decode(s string) (o string) {
o = ""
log.Printf(" Decode: %s", s)
if s == "" || len(s) <= 0 {
return
}
switch {
case e.distance != 0:
log.Printf(" Distance: %d", e.distance)
o = transformWithDistance(s, -e.distance)
default:
o = transformWithString(s, e.key, false)
}
return
}Now the general feeling after writing this was I have too much the same code that I should remove for example
- transformWithDistance
- transformWithString
They are essentially doing the same thing?
Version 2…. to follow soon.
