Strings
Ciphers
Fundamentals
Cryptography
Algorithms
Creates two functions, encode and decode, that allow you to encrypt and decrypt a phrase using a custom encryption algorithm. The rules for encryption and decryption are as follows:
ENCODE:
- Given a text string called phrase and a text string called key, encrypt phrase according to the following rules.
- To encrypt a phrase letter, take the last digit of the ASCII value of that letter and add the last digit of the ASCII value of the corresponding letter in key. Then, add the length of the key.
- Find the corresponding letter in the alphabet according to the result obtained and add it to the encrypted string. If the sum is greater than the ASCII value of 'z' or 'Z' (depending on whether the original letter was lowercase or uppercase), it starts again from 'a' or 'A', respectively, and continues adding the excess.
Lowercase example without overflow:
phrase
deargod => [100] [101] [97] [114] [103] [111] [100]
key
fgh => [102] [103] [104]
length
fgh => [3]
Having the ASCII codes of the phrase and password and the length of the password, we proceed to make the sums of the last digit::
| deargod | ASCII |
|---|---|
| deargod | [100] [101] [97] [114] [103] [111] [100] |
| fgh (LAST DIGIT) | [2] [3] [4] [2] [3] [4] [2] |
| length fgh | [3] [3] [3] [3] [3] [3] [3] |
| encrypted key (SUM) | [105] [107] [104] [119] [109] [118] [105] |
encrypted key: ikhwmvi
import java.util.List; import java.util.stream.Collectors; public class Kata { // <<-CONSTANTS->> private static final int UpperCase_LOWER_LIMIT = 65; private static final int UpperCase_UPPER_LIMIT = 90; private static final int LowerCase_LOWER_LIMIT = 97; private static final int LowerCase_UPPER_LIMIT = 122; private static final int INTERMEDIATE_OFFSET = LowerCase_LOWER_LIMIT - UpperCase_UPPER_LIMIT - 1; // <<-METHODS->> private static int getLastDigit(final int digit) { String str = String.valueOf(digit); str = str.substring(str.length() - 1, str.length()); return Integer.valueOf(str); } private static List<Integer> getEncryptationOffsets(String key) { return key.chars() .map(n -> getLastDigit(n) + key.length()) .boxed() .toList(); } private static List<Integer> getPhraseChars(String phrase) { return phrase.chars() .boxed() .collect(Collectors.toList()); } private static String parseChars(List<Integer> traduction) { return traduction.stream() .map(n -> (char) n.intValue()) .map(c -> Character.toString(c)) .collect(Collectors.joining()); } public static String encode(String phrase, String key) { if (phrase == null || phrase.isEmpty()) return ""; if (key == null || key.isEmpty()) return phrase; List<Integer> offsets = getEncryptationOffsets(key); List<Integer> phraseChars = getPhraseChars(phrase); List<Integer> traduction = new java.util.ArrayList<>(); for (int i = 0; i < phrase.length(); i++) { int keyIndex = i % offsets.size(); int current = phraseChars.get(i); int result = current + offsets.get(keyIndex); if (current <= UpperCase_UPPER_LIMIT && result >= LowerCase_LOWER_LIMIT) { int offset = result - UpperCase_UPPER_LIMIT; result = LowerCase_LOWER_LIMIT + offset - 1; } if (result > UpperCase_UPPER_LIMIT && result < LowerCase_LOWER_LIMIT) { result += INTERMEDIATE_OFFSET; } else if (result > LowerCase_UPPER_LIMIT) { result = result - LowerCase_UPPER_LIMIT + UpperCase_LOWER_LIMIT - 1; } traduction.add(result); } return parseChars(traduction); } public static String decode(String phrase, String key) { if (phrase == null || phrase.isEmpty()) return ""; if (key == null || key.isEmpty()) return phrase; List<Integer> offsets = getEncryptationOffsets(key); List<Integer> phraseChars = getPhraseChars(phrase); List<Integer> traduction = new java.util.ArrayList<>(); for (int i = 0; i < phrase.length(); i++) { int keyIndex = i % offsets.size(); int current = phraseChars.get(i); int result = current - offsets.get(keyIndex); if (current >= LowerCase_LOWER_LIMIT && result <= UpperCase_UPPER_LIMIT) { int offset = LowerCase_LOWER_LIMIT - result; result = UpperCase_UPPER_LIMIT - offset + 1; } if (result < LowerCase_LOWER_LIMIT && result > UpperCase_UPPER_LIMIT) { result -= INTERMEDIATE_OFFSET; } else if (result < UpperCase_LOWER_LIMIT) { int offset = UpperCase_LOWER_LIMIT - result; result = LowerCase_UPPER_LIMIT - offset + 1; } traduction.add(result); } return parseChars(traduction); } }- import java.util.List;
- import java.util.stream.Collectors;
- public class Kata {
- // <<-CONSTANTS->>
- private static final int UpperCase_LOWER_LIMIT = 65;
- private static final int UpperCase_UPPER_LIMIT = 90;
- private static final int LowerCase_LOWER_LIMIT = 97;
- private static final int LowerCase_UPPER_LIMIT = 122;
- private static final int INTERMEDIATE_OFFSET = LowerCase_LOWER_LIMIT - UpperCase_UPPER_LIMIT - 1;
- // <<-METHODS->>
- private static int getLastDigit(final int digit) {
- String str = String.valueOf(digit);
- str = str.substring(str.length() - 1, str.length());
return Integer.valueOf(str);- return Integer.valueOf(str);
- }
- private static List<Integer> getEncryptationOffsets(String key) {
- return key.chars()
- .map(n -> getLastDigit(n) + key.length())
- .boxed()
- .toList();
- }
- private static List<Integer> getPhraseChars(String phrase) {
- return phrase.chars()
- .boxed()
- .collect(Collectors.toList());
- }
- private static String parseChars(List<Integer> traduction) {
- return traduction.stream()
- .map(n -> (char) n.intValue())
- .map(c -> Character.toString(c))
- .collect(Collectors.joining());
- }
- public static String encode(String phrase, String key) {
- if (phrase == null || phrase.isEmpty()) return "";
- if (key == null || key.isEmpty()) return phrase;
- List<Integer> offsets = getEncryptationOffsets(key);
- List<Integer> phraseChars = getPhraseChars(phrase);
- List<Integer> traduction = new java.util.ArrayList<>();
- for (int i = 0; i < phrase.length(); i++) {
- int keyIndex = i % offsets.size();
- int current = phraseChars.get(i);
- int result = current + offsets.get(keyIndex);
- if (current <= UpperCase_UPPER_LIMIT && result >= LowerCase_LOWER_LIMIT) {
- int offset = result - UpperCase_UPPER_LIMIT;
- result = LowerCase_LOWER_LIMIT + offset - 1;
- }
- if (result > UpperCase_UPPER_LIMIT && result < LowerCase_LOWER_LIMIT) {
- result += INTERMEDIATE_OFFSET;
- } else if (result > LowerCase_UPPER_LIMIT) {
- result = result - LowerCase_UPPER_LIMIT + UpperCase_LOWER_LIMIT - 1;
- }
- traduction.add(result);
- }
- return parseChars(traduction);
- }
- public static String decode(String phrase, String key) {
- if (phrase == null || phrase.isEmpty()) return "";
- if (key == null || key.isEmpty()) return phrase;
- List<Integer> offsets = getEncryptationOffsets(key);
- List<Integer> phraseChars = getPhraseChars(phrase);
- List<Integer> traduction = new java.util.ArrayList<>();
- for (int i = 0; i < phrase.length(); i++) {
- int keyIndex = i % offsets.size();
- int current = phraseChars.get(i);
- int result = current - offsets.get(keyIndex);
- if (current >= LowerCase_LOWER_LIMIT && result <= UpperCase_UPPER_LIMIT) {
- int offset = LowerCase_LOWER_LIMIT - result;
- result = UpperCase_UPPER_LIMIT - offset + 1;
- }
- if (result < LowerCase_LOWER_LIMIT && result > UpperCase_UPPER_LIMIT) {
- result -= INTERMEDIATE_OFFSET;
- } else if (result < UpperCase_LOWER_LIMIT) {
- int offset = UpperCase_LOWER_LIMIT - result;
- result = LowerCase_UPPER_LIMIT - offset + 1;
- }
- traduction.add(result);
- }
- return parseChars(traduction);
- }
- }
Strings
Ciphers
Fundamentals
Cryptography
Algorithms
Crea dos funciones, encode y decode, que permitan cifrar y descifrar una cadena de texto utilizando un algoritmo de cifrado personalizado. Las reglas para el cifrado y descifrado son las siguientes:
- Tanto encode como decode toman dos parámetros de entrada: una cadena de texto llamada texto y una cadena de texto llamada clave.
- El cifrado y descifrado deben tener en cuenta únicamente las letras mayúsculas y minúsculas del alfabeto inglés, excluyendo espacios y otros caracteres.
- La clave se repetirá dinámicamente según la longitud del texto a cifrar o descifrar.
Reglas para el cifrado (encode):
- Dada una cadena de texto llamada frase y una cadena de texto llamada clave, cifra frase de acuerdo con las siguientes reglas.
- Para cifrar una letra de frase, toma el último dígito del valor ASCII de esa letra y suma el último dígito del valor ASCII de la letra correspondiente en clave. Luego, suma la longitud de la clave.
- Encuentra la letra correspondiente en el alfabeto según el resultado obtenido y agrégala a la cadena cifrada. Si la suma es mayor que el valor ASCII de 'z' o 'Z' (dependiendo de si la letra original era minúscula o mayúscula), comienza nuevamente desde 'a' o 'A', respectivamente, y continúa sumando el excedente.
Reglas para el descifrado (decode):
- Dada una cadena de texto cifrada llamada frase y una cadena de texto llamada clave, descifra cifrada de acuerdo con las mismas reglas utilizadas en el cifrado...(editar)
Ejmplo:
texto = "ALaBamA"
clave = "hoME"
cifrada = encode(texto, clave) # cifrada = "IQlOirL"
descifrada = decode(cifrada, clave) # descifrada = "ALaBamA"
import static org.junit.jupiter.api.Assertions.assertEquals; import org.junit.jupiter.api.RepeatedTest; import org.junit.jupiter.api.Test; import java.util.Random; class SolutionTest { @Test void basicTest() { assertEquals("moqik", Kata.encode("abcde", "abcde")); assertEquals("abcde", Kata.decode("moqik", "abcde")); assertEquals("KMOUS", Kata.encode("ABCDE", "ABCDE")); assertEquals("ABCDE", Kata.decode("KMOUS", "ABCDE")); assertEquals("GIFUKTG", Kata.encode("DEARGOD", "FGH")); assertEquals("DEARGOD", Kata.decode("GIFUKTG", "FGH")); assertEquals("ikhwmvi", Kata.encode("deargod", "fgh")); assertEquals("deargod", Kata.decode("ikhwmvi", "fgh")); assertEquals("IQlOirL", Kata.encode("ALaBamA", "hoME")); assertEquals("ALaBamA", Kata.decode("IQlOirL", "hoME")); } @Test void fullTest() { assertEquals("CDEfA", Kata.encode("turbo", "TUXON")); assertEquals("turbo", Kata.decode("CDEfA", "TUXON")); assertEquals("skstzDvzwj", Kata.encode("helloworld", "afgh")); assertEquals("helloworld", Kata.decode("skstzDvzwj", "afgh")); assertEquals("JLN", Kata.encode("xyz", "ijklmn")); assertEquals("xyz", Kata.decode("JLN", "ijklmn")); assertEquals("riDREkxXFVygu", Kata.encode("hOmEsWeEtHoMe", "nOtSoSwEeT")); assertEquals("hOmEsWeEtHoMe", Kata.decode("riDREkxXFVygu", "nOtSoSwEeT")); assertEquals("qUlWuZXovQ", Kata.encode("gOdMoRNinG", "uSA")); assertEquals("gOdMoRNinG", Kata.decode("qUlWuZXovQ", "uSA")); assertEquals("byvNMwgiVt", Kata.encode("WonDErWaLl", "oASiS")); assertEquals("WonDErWaLl", Kata.decode("byvNMwgiVt", "oASiS")); assertEquals("MyynmpA", Kata.encode("Zumbido", "wow")); assertEquals("Zumbido", Kata.decode("MyynmpA", "wow")); assertEquals("BOywAJdrzSfbLMCuCnViNt", Kata.encode("wElovETerNaRyExpsaNdIj", "dAvID")); assertEquals("wElovETerNaRyExpsaNdIj", Kata.decode("BOywAJdrzSfbLMCuCnViNt", "dAvID")); } private String encode(String phrase, String key) { return ""; } private String decode(String phrase, String key) { return ""; } String generateString() { Random random = new Random(); byte[] buffer = new byte[random.nextInt(1501)]; random.nextBytes(buffer); return new String(buffer, java.nio.charset.Charset.forName("UTF-8")); } String generatePhrase() { return generateString(); } String generateKey() { return generateString(); } @RepeatedTest(100) void randomTest() { String phrase = generatePhrase(); String key = generateKey(); assertEquals(Kata.encode(phrase, key), encode(phrase, key)); assertEquals(Kata.decode(phrase, key), decode(phrase, key)); } }- import static org.junit.jupiter.api.Assertions.assertEquals;
- import org.junit.jupiter.api.RepeatedTest;
- import org.junit.jupiter.api.Test;
- import java.util.Random;
- class SolutionTest {
- @Test
- void basicTest() {
- assertEquals("moqik", Kata.encode("abcde", "abcde"));
- assertEquals("abcde", Kata.decode("moqik", "abcde"));
- assertEquals("KMOUS", Kata.encode("ABCDE", "ABCDE"));
- assertEquals("ABCDE", Kata.decode("KMOUS", "ABCDE"));
- assertEquals("GIFUKTG", Kata.encode("DEARGOD", "FGH"));
- assertEquals("DEARGOD", Kata.decode("GIFUKTG", "FGH"));
- assertEquals("ikhwmvi", Kata.encode("deargod", "fgh"));
- assertEquals("deargod", Kata.decode("ikhwmvi", "fgh"));
- assertEquals("IQlOirL", Kata.encode("ALaBamA", "hoME"));
assertEquals("ALaBamA", Kata.decode("IQlOirL","hoME"));- assertEquals("ALaBamA", Kata.decode("IQlOirL", "hoME"));
- }
- @Test
- void fullTest() {
- assertEquals("CDEfA", Kata.encode("turbo", "TUXON"));
- assertEquals("turbo", Kata.decode("CDEfA", "TUXON"));
- assertEquals("skstzDvzwj", Kata.encode("helloworld", "afgh"));
- assertEquals("helloworld", Kata.decode("skstzDvzwj", "afgh"));
- assertEquals("JLN", Kata.encode("xyz", "ijklmn"));
- assertEquals("xyz", Kata.decode("JLN", "ijklmn"));
- assertEquals("riDREkxXFVygu", Kata.encode("hOmEsWeEtHoMe", "nOtSoSwEeT"));
- assertEquals("hOmEsWeEtHoMe", Kata.decode("riDREkxXFVygu", "nOtSoSwEeT"));
- assertEquals("qUlWuZXovQ", Kata.encode("gOdMoRNinG", "uSA"));
- assertEquals("gOdMoRNinG", Kata.decode("qUlWuZXovQ", "uSA"));
- assertEquals("byvNMwgiVt", Kata.encode("WonDErWaLl", "oASiS"));
- assertEquals("WonDErWaLl", Kata.decode("byvNMwgiVt", "oASiS"));
- assertEquals("MyynmpA", Kata.encode("Zumbido", "wow"));
- assertEquals("Zumbido", Kata.decode("MyynmpA", "wow"));
- assertEquals("BOywAJdrzSfbLMCuCnViNt", Kata.encode("wElovETerNaRyExpsaNdIj", "dAvID"));
- assertEquals("wElovETerNaRyExpsaNdIj", Kata.decode("BOywAJdrzSfbLMCuCnViNt", "dAvID"));
- }
- private String encode(String phrase, String key) {
- return "";
- }
- private String decode(String phrase, String key) {
- return "";
- }
- String generateString() {
- Random random = new Random();
- byte[] buffer = new byte[random.nextInt(1501)];
- random.nextBytes(buffer);
- return new String(buffer, java.nio.charset.Charset.forName("UTF-8"));
- }
- String generatePhrase() {
- return generateString();
- }
- String generateKey() {
- return generateString();
- }
- @RepeatedTest(100)
- void randomTest() {
- String phrase = generatePhrase();
- String key = generateKey();
- assertEquals(Kata.encode(phrase, key), encode(phrase, key));
- assertEquals(Kata.decode(phrase, key), decode(phrase, key));
- }
- }
Strings
Ciphers
Fundamentals
Cryptography
Algorithms
Crea dos funciones, encode y decode, que permitan cifrar y descifrar una cadena de texto utilizando un algoritmo de cifrado personalizado. Las reglas para el cifrado y descifrado son las siguientes:
- Tanto encode como decode toman dos parámetros de entrada: una cadena de texto llamada texto y una cadena de texto llamada clave.
- El cifrado y descifrado deben tener en cuenta únicamente las letras mayúsculas y minúsculas del alfabeto inglés, excluyendo espacios y otros caracteres.
- La clave se repetirá dinámicamente según la longitud del texto a cifrar o descifrar.
Reglas para el cifrado (encode):
- Dada una cadena de texto llamada frase y una cadena de texto llamada clave, cifra frase de acuerdo con las siguientes reglas.
- Para cifrar una letra de frase, toma el último dígito del valor ASCII de esa letra y suma el último dígito del valor ASCII de la letra correspondiente en clave. Luego, suma la longitud de la clave.
- Encuentra la letra correspondiente en el alfabeto según el resultado obtenido y agrégala a la cadena cifrada. Si la suma es mayor que el valor ASCII de 'z' o 'Z' (dependiendo de si la letra original era minúscula o mayúscula), comienza nuevamente desde 'a' o 'A', respectivamente, y continúa sumando el excedente.
Reglas para el descifrado (decode):
- Dada una cadena de texto cifrada llamada frase y una cadena de texto llamada clave, descifra cifrada de acuerdo con las mismas reglas utilizadas en el cifrado...(editar)
Ejmplo:
texto = "ALaBamA"
clave = "hoME"
cifrada = encode(texto, clave) # cifrada = "IQlOirL"
descifrada = decode(cifrada, clave) # descifrada = "ALaBamA"
import static org.junit.jupiter.api.Assertions.assertEquals; import org.junit.jupiter.api.RepeatedTest; import org.junit.jupiter.api.Test; import java.util.Random; class SolutionTest { @Test void basicTest() { assertEquals("moqik", Kata.encode("abcde", "abcde")); assertEquals("abcde", Kata.decode("moqik", "abcde")); assertEquals("KMOUS", Kata.encode("ABCDE", "ABCDE")); assertEquals("ABCDE", Kata.decode("KMOUS", "ABCDE")); assertEquals("GIFUKTG", Kata.encode("DEARGOD", "FGH")); assertEquals("DEARGOD", Kata.decode("GIFUKTG", "FGH")); assertEquals("ikhwmvi", Kata.encode("deargod", "fgh")); assertEquals("deargod", Kata.decode("ikhwmvi", "fgh")); assertEquals("IQlOirL", Kata.encode("ALaBamA", "hoME")); assertEquals("ALaBamA", Kata.decode("IQlOirL","hoME")); } @Test void fullTest() { assertEquals("CDEfA", Kata.encode("turbo", "TUXON")); assertEquals("turbo", Kata.decode("CDEfA", "TUXON")); assertEquals("skstzDvzwj", Kata.encode("helloworld", "afgh")); assertEquals("helloworld", Kata.decode("skstzDvzwj", "afgh")); assertEquals("JLN", Kata.encode("xyz", "ijklmn")); assertEquals("xyz", Kata.decode("JLN", "ijklmn")); assertEquals("riDREkxXFVygu", Kata.encode("hOmEsWeEtHoMe", "nOtSoSwEeT")); assertEquals("hOmEsWeEtHoMe", Kata.decode("riDREkxXFVygu", "nOtSoSwEeT")); assertEquals("qUlWuZXovQ", Kata.encode("gOdMoRNinG", "uSA")); assertEquals("gOdMoRNinG", Kata.decode("qUlWuZXovQ", "uSA")); assertEquals("byvNMwgiVt", Kata.encode("WonDErWaLl", "oASiS")); assertEquals("WonDErWaLl", Kata.decode("byvNMwgiVt", "oASiS")); assertEquals("MyynmpA", Kata.encode("Zumbido", "wow")); assertEquals("Zumbido", Kata.decode("MyynmpA", "wow")); assertEquals("BOywAJdrzSfbLMCuCnViNt", Kata.encode("wElovETerNaRyExpsaNdIj", "dAvID")); assertEquals("wElovETerNaRyExpsaNdIj", Kata.decode("BOywAJdrzSfbLMCuCnViNt", "dAvID")); } private String encode(String phrase, String key) { return ""; } private String decode(String phrase, String key) { return ""; } String generateString() { Random random = new Random(); byte[] buffer = new byte[random.nextInt(1501)]; random.nextBytes(buffer); return new String(buffer, java.nio.charset.Charset.forName("UTF-8")); } String generatePhrase() { return generateString(); } String generateKey() { return generateString(); } @RepeatedTest(100) void randomTest() { String phrase = generatePhrase(); String key = generateKey(); assertEquals(Kata.encode(phrase, key), encode(phrase, key)); assertEquals(Kata.decode(phrase, key), decode(phrase, key)); } }- import static org.junit.jupiter.api.Assertions.assertEquals;
- import org.junit.jupiter.api.RepeatedTest;
- import org.junit.jupiter.api.Test;
- import java.util.Random;
- class SolutionTest {
- @Test
- void basicTest() {
- assertEquals("moqik", Kata.encode("abcde", "abcde"));
- assertEquals("abcde", Kata.decode("moqik", "abcde"));
- assertEquals("KMOUS", Kata.encode("ABCDE", "ABCDE"));
- assertEquals("ABCDE", Kata.decode("KMOUS", "ABCDE"));
- assertEquals("GIFUKTG", Kata.encode("DEARGOD", "FGH"));
- assertEquals("DEARGOD", Kata.decode("GIFUKTG", "FGH"));
- assertEquals("ikhwmvi", Kata.encode("deargod", "fgh"));
- assertEquals("deargod", Kata.decode("ikhwmvi", "fgh"));
- assertEquals("IQlOirL", Kata.encode("ALaBamA", "hoME"));
assertEquals("ALaBamA", Kata.decode("IQlOirL", "hoME"));- assertEquals("ALaBamA", Kata.decode("IQlOirL","hoME"));
- }
- @Test
- void fullTest() {
- assertEquals("CDEfA", Kata.encode("turbo", "TUXON"));
- assertEquals("turbo", Kata.decode("CDEfA", "TUXON"));
- assertEquals("skstzDvzwj", Kata.encode("helloworld", "afgh"));
- assertEquals("helloworld", Kata.decode("skstzDvzwj", "afgh"));
- assertEquals("JLN", Kata.encode("xyz", "ijklmn"));
- assertEquals("xyz", Kata.decode("JLN", "ijklmn"));
- assertEquals("riDREkxXFVygu", Kata.encode("hOmEsWeEtHoMe", "nOtSoSwEeT"));
- assertEquals("hOmEsWeEtHoMe", Kata.decode("riDREkxXFVygu", "nOtSoSwEeT"));
- assertEquals("qUlWuZXovQ", Kata.encode("gOdMoRNinG", "uSA"));
- assertEquals("gOdMoRNinG", Kata.decode("qUlWuZXovQ", "uSA"));
- assertEquals("byvNMwgiVt", Kata.encode("WonDErWaLl", "oASiS"));
- assertEquals("WonDErWaLl", Kata.decode("byvNMwgiVt", "oASiS"));
- assertEquals("MyynmpA", Kata.encode("Zumbido", "wow"));
- assertEquals("Zumbido", Kata.decode("MyynmpA", "wow"));
- assertEquals("BOywAJdrzSfbLMCuCnViNt", Kata.encode("wElovETerNaRyExpsaNdIj", "dAvID"));
- assertEquals("wElovETerNaRyExpsaNdIj", Kata.decode("BOywAJdrzSfbLMCuCnViNt", "dAvID"));
- }
- private String encode(String phrase, String key) {
- return "";
- }
- private String decode(String phrase, String key) {
- return "";
- }
- String generateString() {
- Random random = new Random();
- byte[] buffer = new byte[random.nextInt(1501)];
- random.nextBytes(buffer);
- return new String(buffer, java.nio.charset.Charset.forName("UTF-8"));
- }
- String generatePhrase() {
- return generateString();
- }
- String generateKey() {
- return generateString();
- }
- @RepeatedTest(100)
- void randomTest() {
- String phrase = generatePhrase();
- String key = generateKey();
- assertEquals(Kata.encode(phrase, key), encode(phrase, key));
- assertEquals(Kata.decode(phrase, key), decode(phrase, key));
- }
- }
Strings
Ciphers
Fundamentals
Cryptography
Algorithms
import static org.junit.jupiter.api.Assertions.assertEquals; import org.junit.jupiter.api.RepeatedTest; import org.junit.jupiter.api.Test; import java.util.Random; import java.nio.charset.Charset; class SolutionTest { @Test void basicTest() { assertEquals("moqik", Kata.encode("abcde", "abcde")); assertEquals("abcde", Kata.decode("moqik", "abcde")); assertEquals("KMOUS", Kata.encode("ABCDE", "ABCDE")); assertEquals("ABCDE", Kata.decode("KMOUS", "ABCDE")); assertEquals("GIFUKTG", Kata.encode("DEARGOD", "FGH")); assertEquals("DEARGOD", Kata.decode("GIFUKTG", "FGH")); assertEquals("ikhwmvi", Kata.encode("deargod", "fgh")); assertEquals("deargod", Kata.decode("ikhwmvi", "fgh")); assertEquals("IQlOirL", Kata.encode("ALaBamA", "hoME")); assertEquals("ALaBamA", Kata.decode("IQlOirL", "hoME")); } @Test void fullTest() { assertEquals("skstzDvzwj", Kata.encode("helloworld", "afgh")); assertEquals("helloworld", Kata.decode("skstzDvzwj", "afgh")); } private String encode(String phrase, String key) { return ""; } private String decode(String phrase, String key) { return ""; } String generateString() { Random random = new Random(); byte[] buffer = new byte[random.nextInt(1501)]; random.nextBytes(buffer); return new String(buffer, Charset.forName("UTF-8")); } String generatePhrase() { return generateString(); } String generateKey() { return generateString(); } @RepeatedTest(100) void randomTest() { String phrase = generatePhrase(); String key = generateKey(); assertEquals(Kata.encode(phrase, key), encode(phrase, key)); assertEquals(Kata.decode(phrase, key), decode(phrase, key)); } }- import static org.junit.jupiter.api.Assertions.assertEquals;
- import org.junit.jupiter.api.RepeatedTest;
- import org.junit.jupiter.api.Test;
- import java.util.Random;
- import java.nio.charset.Charset;
- class SolutionTest {
- @Test
- void basicTest() {
- assertEquals("moqik", Kata.encode("abcde", "abcde"));
- assertEquals("abcde", Kata.decode("moqik", "abcde"));
- assertEquals("KMOUS", Kata.encode("ABCDE", "ABCDE"));
- assertEquals("ABCDE", Kata.decode("KMOUS", "ABCDE"));
- assertEquals("GIFUKTG", Kata.encode("DEARGOD", "FGH"));
- assertEquals("DEARGOD", Kata.decode("GIFUKTG", "FGH"));
- assertEquals("ikhwmvi", Kata.encode("deargod", "fgh"));
- assertEquals("deargod", Kata.decode("ikhwmvi", "fgh"));
- assertEquals("IQlOirL", Kata.encode("ALaBamA", "hoME"));
- assertEquals("ALaBamA", Kata.decode("IQlOirL", "hoME"));
- }
- @Test
- void fullTest() {
- assertEquals("skstzDvzwj", Kata.encode("helloworld", "afgh"));
- assertEquals("helloworld", Kata.decode("skstzDvzwj", "afgh"));
- }
- private String encode(String phrase, String key) {
- return "";
- }
- private String decode(String phrase, String key) {
- return "";
- }
- String generateString() {
- Random random = new Random();
- byte[] buffer = new byte[random.nextInt(1501)];
- random.nextBytes(buffer);
- return new String(buffer, Charset.forName("UTF-8"));
- }
- String generatePhrase() {
- return generateString();
- }
- String generateKey() {
- return generateString();
- }
- @RepeatedTest(100)
- void randomTest() {
- String phrase = generatePhrase();
- String key = generateKey();
- assertEquals(Kata.encode(phrase, key), encode(phrase, key));
- assertEquals(Kata.decode(phrase, key), decode(phrase, key));
- }
- }