ColumnarTranspositionCipher.java

packagecom.thealgorithms.ciphers;

importjava.util.Objects;

/**
 * Columnar Transposition Cipher Encryption and Decryption.
 *
 * @author <a href="https://github.com/freitzzz">freitzzz</a>
 */
publicfinalclassColumnarTranspositionCipher {
privateColumnarTranspositionCipher() {
 }

privatestaticStringkeyword;
privatestaticObject[][] table;
privatestaticStringabecedarium;
publicstaticfinalStringABECEDARIUM = "abcdefghijklmnopqrstuvwxyzABCDEFG"
 + "HIJKLMNOPQRSTUVWXYZ0123456789,.;:-@";
privatestaticfinalStringENCRYPTION_FIELD = "≈";
privatestaticfinalcharENCRYPTION_FIELD_CHAR = '≈';

/**
 * Encrypts a certain String with the Columnar Transposition Cipher Rule
 *
 * @param word Word being encrypted
 * @param keyword String with keyword being used
 * @return a String with the word encrypted by the Columnar Transposition
 * Cipher Rule
 */
publicstaticStringencrypt(finalStringword, finalStringkeyword) {
ColumnarTranspositionCipher.keyword = keyword;
abecedariumBuilder();
table = tableBuilder(word);
Object[][] sortedTable = sortTable(table);
StringBuilderwordEncrypted = newStringBuilder();
for (inti = 0; i < sortedTable[0].length; i++) {
for (intj = 1; j < sortedTable.length; j++) {
wordEncrypted.append(sortedTable[j][i]);
 }
 }
returnwordEncrypted.toString();
 }

/**
 * Encrypts a certain String with the Columnar Transposition Cipher Rule
 *
 * @param word Word being encrypted
 * @param keyword String with keyword being used
 * @param abecedarium String with the abecedarium being used. null for
 * default one
 * @return a String with the word encrypted by the Columnar Transposition
 * Cipher Rule
 */
publicstaticStringencrypt(Stringword, Stringkeyword, Stringabecedarium) {
ColumnarTranspositionCipher.keyword = keyword;
ColumnarTranspositionCipher.abecedarium = Objects.requireNonNullElse(abecedarium, ABECEDARIUM);
table = tableBuilder(word);
Object[][] sortedTable = sortTable(table);

StringBuilderwordEncrypted = newStringBuilder();
for (inti = 0; i < sortedTable[0].length; i++) {
for (intj = 1; j < sortedTable.length; j++) {
wordEncrypted.append(sortedTable[j][i]);
 }
 }
returnwordEncrypted.toString();
 }

/**
 * Decrypts a certain encrypted String with the Columnar Transposition
 * Cipher Rule
 *
 * @return a String decrypted with the word encrypted by the Columnar
 * Transposition Cipher Rule
 */
publicstaticStringdecrypt() {
StringBuilderwordDecrypted = newStringBuilder();
for (inti = 1; i < table.length; i++) {
for (Objectitem : table[i]) {
wordDecrypted.append(item);
 }
 }
returnwordDecrypted.toString().replaceAll(ENCRYPTION_FIELD, "");
 }

/**
 * Builds a table with the word to be encrypted in rows by the Columnar
 * Transposition Cipher Rule
 *
 * @return An Object[][] with the word to be encrypted filled in rows and
 * columns
 */
privatestaticObject[][] tableBuilder(Stringword) {
Object[][] table = newObject[numberOfRows(word) + 1][keyword.length()];
char[] wordInChars = word.toCharArray();
// Fills in the respective numbers for the column
table[0] = findElements();
intcharElement = 0;
for (inti = 1; i < table.length; i++) {
for (intj = 0; j < table[i].length; j++) {
if (charElement < wordInChars.length) {
table[i][j] = wordInChars[charElement];
charElement++;
 } else {
table[i][j] = ENCRYPTION_FIELD_CHAR;
 }
 }
 }
returntable;
 }

/**
 * Determines the number of rows the table should have regarding the
 * Columnar Transposition Cipher Rule
 *
 * @return an int with the number of rows that the table should have in
 * order to respect the Columnar Transposition Cipher Rule.
 */
privatestaticintnumberOfRows(Stringword) {
if (word.length() % keyword.length() != 0) {
return (word.length() / keyword.length()) + 1;
 } else {
returnword.length() / keyword.length();
 }
 }

/**
 * @return charValues
 */
privatestaticObject[] findElements() {
Object[] charValues = newObject[keyword.length()];
for (inti = 0; i < charValues.length; i++) {
intcharValueIndex = abecedarium.indexOf(keyword.charAt(i));
charValues[i] = charValueIndex > -1 ? charValueIndex : null;
 }
returncharValues;
 }

/**
 * @return tableSorted
 */
privatestaticObject[][] sortTable(Object[][] table) {
Object[][] tableSorted = newObject[table.length][table[0].length];
for (inti = 0; i < tableSorted.length; i++) {
System.arraycopy(table[i], 0, tableSorted[i], 0, tableSorted[i].length);
 }
for (inti = 0; i < tableSorted[0].length; i++) {
for (intj = i + 1; j < tableSorted[0].length; j++) {
if ((int) tableSorted[0][i] > (int) table[0][j]) {
Object[] column = getColumn(tableSorted, tableSorted.length, i);
switchColumns(tableSorted, j, i, column);
 }
 }
 }
returntableSorted;
 }

/**
 * @return columnArray
 */
privatestaticObject[] getColumn(Object[][] table, introws, intcolumn) {
Object[] columnArray = newObject[rows];
for (inti = 0; i < rows; i++) {
columnArray[i] = table[i][column];
 }
returncolumnArray;
 }

privatestaticvoidswitchColumns(Object[][] table, intfirstColumnIndex, intsecondColumnIndex, Object[] columnToSwitch) {
for (inti = 0; i < table.length; i++) {
table[i][secondColumnIndex] = table[i][firstColumnIndex];
table[i][firstColumnIndex] = columnToSwitch[i];
 }
 }

/**
 * Creates an abecedarium with all available ascii values.
 */
privatestaticvoidabecedariumBuilder() {
StringBuildert = newStringBuilder();
for (inti = 0; i < 256; i++) {
t.append((char) i);
 }
abecedarium = t.toString();
 }
}