1 # This file is part of NIT ( http://www.nitlanguage.org ).
3 # Licensed under the Apache License, Version 2.0 (the "License");
4 # you may not use this file except in compliance with the License.
5 # You may obtain a copy of the License at
7 # http://www.apache.org/licenses/LICENSE-2.0
9 # Unless required by applicable law or agreed to in writing, software
10 # distributed under the License is distributed on an "AS IS" BASIS,
11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 # See the License for the specific language governing permissions and
13 # limitations under the License.
15 # Mix of all things cryptography-related
21 # NOTE: works on letters only
23 # assert 'x'.rot(6) == 'd'
24 # assert 'T'.rot(15) == 'I'
25 # assert '1'.rot(10) == '1'
26 # assert '$'.rot(10) == '$'
27 # assert 'z'.rot(-2) == 'x'
28 fun rot
(x
: Int): Char do
29 if not is_letter
then return self
39 if val
> 122 then val
-= 26
46 # Performs a Rotation of `x` on each letter of self
48 # Works by replacing every character in `self` by its
51 # Say we have a rotation of `3` (Caesar rotation, for
52 # culture) for a string : "aybabtu"
54 # a, rotated by 3 becomes d
55 # y, rotated by 3 becomes b
56 # b, rotated by 3 becomes e
57 # t, rotated by 3 becomes w
58 # u, rotated by 3 becomes x
60 # We then replace every letter in our original string by
61 # their rotated representations, therefore yielding : "dbedewx"
63 # assert "All your base are belong to us".rot(13) == "Nyy lbhe onfr ner orybat gb hf"
64 # assert "This is no moon.".rot(4).rot(22) == "This is no moon."
66 # NOTE : Works on letters only
67 # NOTE : This cipher is symmetrically decrypted with an `x` of 26-`x`
68 fun rot
(x
: Int): String do
70 if rot
< 0 then rot
+= 26
71 var d
= new FlatBuffer.with_capacity
(length
)
78 # Returns a rail-fence cipher from `self` with `depth` rails
80 # Rail works by drawing a zig-zag pattern on `depth` rails.
82 # Say we have "fuckingbehemoth".railfence(4)
84 # This happens in-memory :
90 # Therefore, yielding the ciphertext : "fgounbmtcieehkh"
92 # assert "fuckingbehemoth".railfence(4) == "fgounbmtcieehkh"
93 fun railfence
(depth
: Int): String do
94 var lines
= new Array[FlatBuffer].with_capacity
(depth
)
96 for i
in [0..depth
[ do
97 lines
[i
] = new FlatBuffer.with_capacity
(length
)
101 for j
in [0..depth
[ do
102 if j
== curr_depth
then
113 if curr_depth
== 0 then
116 if curr_depth
== (depth
- 1) then
120 var r
= new FlatBuffer.with_capacity
(length
)
122 r
.append i
.to_s
.replace
(".", "")
127 # Transforms a rail-fence-encrypted String to its original
129 # assert "fgounbmtcieehkh".unrail(4) == "fuckingbehemoth"
130 fun unrail
(depth
: Int): String do
131 var dots
= "." * length
132 var arr
= new FlatBuffer.from
(dots
)
134 var paces
= depth
.unrail_paces
135 for i
in [0..depth
[ do
136 var lp
= paces
[i
].first
137 var rp
= paces
[i
].second
140 while pos
< length
do
141 arr
[pos
] = chars
[start
]
157 # Generates the paces for each depth.
159 # Each entry of the returned array is a couple of the first pace
160 # and the second one, they are alternated when deciphering a rail-encrypted string.
162 # Say we have the encrypted string "fgounbmtcieehkh" on 4 rails
164 # To find the distance between each character on the original railed
165 # string, we need to compute the extremes.
167 # The extremes always have a distance of `depth - 1`, multiplied by 2, no pairing.
169 # In the example, that would be : [(4 - 1) * 2, (4 - 1) * 2] => [6,6]
171 # For every rail in-between, the first distance is the largest absolute value
172 # of the difference between the current depth and the extremes, multiplied by 2.
174 # Its pair is the distance of maximum and the distance yielded by the previous
177 # In our example, that would be :
179 # Maximums : (4 - 1) * 2 = 3 * 2 => [6,6]
180 # In between : Distance for depth 2 : max(2 - 1, 4 - 2) => 2
181 # The calculation yields the couple [(2 * 2), 6 - 4] => [4, 2]
182 # The symmetric couple is reversed : [2, 4]
184 # In fine, the example yields the array : [[6,6], [4,2], [2,4], [6,6]]
186 # In the end, our string is read using the generated array
188 # SEE: `String::unrail` for how the array is used
189 private fun unrail_paces
: Array[Couple[Int, Int]] do
190 var ret
= new Array[Couple[Int,Int]].with_capacity
(self)
191 var extremes
= new Couple[Int, Int]((self - 1) * 2, (self - 1) * 2)
192 for i
in [0..self[ do
195 var mid
= ((self.to_f
)/2.0).floor
.to_i
196 for i
in [1 .. mid
[ do
198 var lodepth
= self - rd
199 var hidepth
= (rd
- self).abs
201 if hidepth
> lodepth
then
206 var cp
= new Couple[Int, Int](dd
, extremes
.first-dd
)
207 var ccp
= new Couple[Int, Int](extremes
.first
- dd
, dd
)
212 if not self.is_even
then
213 ret
[mid
] = new Couple[Int, Int](extremes
.first
/2, extremes
.first
/2)