FilesExpand file tree

 master

/

Caesar.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

132 lines (106 loc) · 3.71 KB

 master

/

Caesar.java

Copy path

Top

File metadata and controls

• Code
• Blame

132 lines (106 loc) · 3.71 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

package ciphers;

import java.util.Scanner;

/**

*

* A Java implementation of Caesar Cipher. /It is a type of substitution cipher

* in which each letter in the plaintext is replaced by a letter some fixed

* number of positions down the alphabet. /

*

* @author FAHRI YARDIMCI

* @author khalil2535

*/

public class Caesar {

/**

* Encrypt text by shifting every Latin char by add number shift for ASCII

* Example : A + 1 -> B

*

* @param message

* @param shift

* @return Encrypted message

*/

public static String encode(String message, int shift) {

String encoded = "";

shift %= 26;

final int length = message.length();

for (int i = 0; i < length; i++) {

// int current = message.charAt(i); //using char to shift characters because ascii is in-order latin alphabet

char current = message.charAt(i); // Java law : char + int = char

if (IsCapitalLatinLetter(current)) {

current += shift;

encoded += (char) (current > 'Z' ? current - 26 : current); // 26 = number of latin letters

} else if (IsSmallLatinLetter(current)) {

current += shift;

encoded += (char) (current > 'z' ? current - 26 : current); // 26 = number of latin letters

} else {

encoded += current;

}

}

return encoded;

}

/**

* Decrypt message by shifting back every Latin char to previous the ASCII

* Example : B - 1 -> A

*

* @param encryptedMessage

* @param shift

* @return message

*/

public static String decode(String encryptedMessage, int shift) {

String decoded = "";

shift %= 26;

final int length = encryptedMessage.length();

for (int i = 0; i < length; i++) {

char current = encryptedMessage.charAt(i);

if (IsCapitalLatinLetter(current)) {

current -= shift;

decoded += (char) (current < 'A' ? current + 26 : current);// 26 = number of latin letters

} else if (IsSmallLatinLetter(current)) {

current -= shift;

decoded += (char) (current < 'a' ? current + 26 : current);// 26 = number of latin letters

} else {

decoded += current;

}

}

return decoded;

}

/**

*

* @param c

* @return true if character is capital Latin letter or false for others

*/

private static boolean IsCapitalLatinLetter(char c) {

return c >= 'A' && c <= 'Z';

}

/**

*

* @param c

* @return true if character is small Latin letter or false for others

*/

private static boolean IsSmallLatinLetter(char c) {

return c >= 'a' && c <= 'z';

}

/**

*

* @deprecated TODO remove main and make JUnit Testing

*/

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

System.out.println("Please enter the message (Latin Alphabet)");

String message = input.nextLine();

System.out.println(message);

System.out.println("Please enter the shift number");

int shift = input.nextInt() % 26;

System.out.println("(E)ncode or (D)ecode ?");

char choice = input.next().charAt(0);

switch (choice) {

case 'E':

case 'e':

System.out.println("ENCODED MESSAGE IS \n" + encode(message, shift)); //send our function to handle

break;

case 'D':

case 'd':

System.out.println("DECODED MESSAGE IS \n" + decode(message, shift));

}

input.close();

}

}