gitgitcode
diff --git a/‎cipher/transposition/transposition.go‎
Lines changed: 106 additions & 0 deletions b/‎cipher/transposition/transposition.go‎
Lines changed: 106 additions & 0 deletions
diff --git a/‎cipher/transposition/transposition_test.go‎
Lines changed: 103 additions & 0 deletions b/‎cipher/transposition/transposition_test.go‎
Lines changed: 103 additions & 0 deletions
@@ -0,0 +1,106 @@
+// transposition.go
+// description: Transposition cipher
+// details:
+// Implementation "Transposition cipher" is a method of encryption by which the positions held by units of plaintext (which are commonly characters or groups of characters) are shifted according to a regular system, so that the ciphertext constitutes a permutation of the plaintext [Transposition cipher](https://en.wikipedia.org/wiki/Transposition_cipher)
+// author(s) [red_byte](https://github.com/i-redbyte)
+// see transposition_test.go
+
+package transposition
+
+import (
+	"sort"
+	"strings"
+)
+
+type NoTextToEncryptError struct{}
+type KeyMissingError struct{}
+
+func (n *NoTextToEncryptError) Error() string {
+	return "No text to encrypt"
+}
+func (n *KeyMissingError) Error() string {
+	return "Missing Key"
+}
+
+func getKey(keyWord string) []int {
+	keyWord = strings.ToLower(keyWord)
+	word := []rune(keyWord)
+	var sortedWord = make([]rune, len(word))
+	copy(sortedWord, word)
+	sort.Slice(sortedWord, func(i, j int) bool { return sortedWord[i] < sortedWord[j] })
+	usedLettersMap := make(map[rune]int)
+	wordLength := len(word)
+	resultKey := make([]int, wordLength)
+	for i := 0; i < wordLength; i++ {
+		char := word[i]
+		numberOfUsage := usedLettersMap[char]
+		resultKey[i] = getIndex(sortedWord, char) + numberOfUsage + 1 //+1 -so that indexing does not start at 0
+		numberOfUsage++
+		usedLettersMap[char] = numberOfUsage
+	}
+	return resultKey
+}
+
+func getIndex(wordSet []rune, subString rune) int {
+	n := len(wordSet)
+	for i := 0; i < n; i++ {
+		if wordSet[i] == subString {
+			return i
+		}
+	}
+	return 0
+}
+
+func Encrypt(text []rune, keyWord string) (string, error) {
+	key := getKey(keyWord)
+	space := ' '
+	keyLength := len(key)
+	textLength := len(text)
+	if keyLength <= 0 {
+		return "", &KeyMissingError{}
+	}
+	if textLength <= 0 {
+		return "", &NoTextToEncryptError{}
+	}
+	n := textLength % keyLength
+
+	for i := 0; i < keyLength-n; i++ {
+		text = append(text, space)
+	}
+	textLength = len(text)
+	result := ""
+	for i := 0; i < textLength; i += keyLength {
+		transposition := make([]rune, keyLength)
+		for j := 0; j < keyLength; j++ {
+			transposition[key[j]-1] = text[i+j]
+		}
+		result += string(transposition)
+	}
+	return result, nil
+}
+
+func Decrypt(text []rune, keyWord string) (string, error) {
+	key := getKey(keyWord)
+	textLength := len(text)
+	if textLength <= 0 {
+		return "", &NoTextToEncryptError{}
+	}
+	keyLength := len(key)
+	if keyLength <= 0 {
+		return "", &KeyMissingError{}
+	}
+	space := ' '
+	n := textLength % keyLength
+	for i := 0; i < keyLength-n; i++ {
+		text = append(text, space)
+	}
+	result := ""
+	for i := 0; i < textLength; i += keyLength {
+		transposition := make([]rune, keyLength)
+		for j := 0; j < keyLength; j++ {
+			transposition[j] = text[i+key[j]-1]
+		}
+		result += string(transposition)
+	}
+	return result, nil
+}
@@ -0,0 +1,103 @@
+// transposition_test.go
+// description: Transposition cipher
+// author(s) [red_byte](https://github.com/i-redbyte)
+// see transposition.go
+
+package transposition
+
+import (
+	"errors"
+	"math/rand"
+	"strings"
+	"testing"
+)
+
+const enAlphabet = "abcdefghijklmnopqrstuvwxyz "
+
+func getTexts() []string {
+	return []string{
+		"Ilya Sokolov",
+		"A slice literal is declared just like an array literal, except you leave out the element count",
+		"Go is an open source programming language that makes it easy to build simple, reliable, and efficient software.",
+		"Go’s treatment of errors as values has served us well over the last decade. Although the standard library’s support for errors has been minimal—just the errors.New and fmt.Errorf functions, which produce errors that contain only a message—the built-in error interface allows Go programmers to add whatever information they desire. All it requires is a type that implements an Error method:",
+		"А тут для примера русский текст",
+	}
+}
+
+func getRandomString() string {
+	enRunes := []rune(enAlphabet)
+	b := make([]rune, rand.Intn(100))
+	for i := range b {
+		b[i] = enRunes[rand.Intn(len(enRunes))]
+	}
+	return string(b)
+}
+
+func TestEncrypt(t *testing.T) {
+	fn := func(text string, keyWord string) (bool, error) {
+		encrypt, err := Encrypt([]rune(text), keyWord)
+		if err != nil && !errors.Is(err, &NoTextToEncryptError{}) && !errors.Is(err, &KeyMissingError{}) {
+			t.Error("Unexpected error ", err)
+		}
+		return text == encrypt, err
+	}
+	for _, s := range getTexts() {
+		if check, err := fn(s, getRandomString()); check || err != nil {
+			t.Error("String ", s, " not encrypted")
+		}
+	}
+	if _, err := fn(getRandomString(), ""); err == nil {
+		t.Error("Error! empty string encryption")
+	}
+}
+
+func TestDecrypt(t *testing.T) {
+	for _, s := range getTexts() {
+		keyWord := getRandomString()
+		encrypt, errEncrypt := Encrypt([]rune(s), keyWord)
+		if errEncrypt != nil &&
+			!errors.Is(errEncrypt, &NoTextToEncryptError{}) &&
+			!errors.Is(errEncrypt, &KeyMissingError{}) {
+			t.Error("Unexpected error ", errEncrypt)
+		}
+		if errEncrypt != nil {
+			t.Error(errEncrypt)
+		}
+		decrypt, errDecrypt := Decrypt([]rune(encrypt), keyWord)
+		if errDecrypt != nil &&
+			!errors.Is(errDecrypt, &NoTextToEncryptError{}) &&
+			!errors.Is(errDecrypt, &KeyMissingError{}) {
+			t.Error("Unexpected error ", errDecrypt)
+		}
+		if errDecrypt != nil {
+			t.Error(errDecrypt)
+		}
+		if encrypt == decrypt {
+			t.Error("String ", s, " not encrypted")
+		}
+		if encrypt == s {
+			t.Error("String ", s, " not encrypted")
+		}
+	}
+}
+
+func TestEncryptDecrypt(t *testing.T) {
+	text := "Test text for checking the algorithm"
+	key1 := "testKey"
+	key2 := "Test Key2"
+	encrypt, errEncrypt := Encrypt([]rune(text), key1)
+	if errEncrypt != nil {
+		t.Error(errEncrypt)
+	}
+	decrypt, errDecrypt := Decrypt([]rune(encrypt), key1)
+	if errDecrypt != nil {
+		t.Error(errDecrypt)
+	}
+	if strings.Contains(decrypt, text) == false {
+		t.Error("The string was not decrypted correctly")
+	}
+	decrypt, _ = Decrypt([]rune(encrypt), key2)
+	if strings.Contains(decrypt, text) == true {
+		t.Error("The string was decrypted with a different key")
+	}
+}