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
)
79 # Returns a rail-fence cipher from `self` with `depth` rails
81 # Rail works by drawing a zig-zag pattern on `depth` rails.
83 # Say we have "fuckingbehemoth".railfence(4)
85 # This happens in-memory :
91 # Therefore, yielding the ciphertext : "fgounbmtcieehkh"
93 # assert "fuckingbehemoth".railfence(4) == "fgounbmtcieehkh"
94 fun railfence
(depth
: Int): String do
95 var lines
= new Array[FlatBuffer].with_capacity
(depth
)
97 for i
in [0..depth
[ do
98 lines
[i
] = new FlatBuffer.with_capacity
(length
)
102 for j
in [0..depth
[ do
103 if j
== curr_depth
then
114 if curr_depth
== 0 then
117 if curr_depth
== (depth
- 1) then
121 var r
= new FlatBuffer.with_capacity
(length
)
123 r
.append i
.to_s
.replace
(".", "")
128 # Transforms a rail-fence-encrypted String to its original
130 # assert "fgounbmtcieehkh".unrail(4) == "fuckingbehemoth"
131 fun unrail
(depth
: Int): String do
132 var dots
= "." * length
133 var arr
= new FlatBuffer.from
(dots
)
135 var paces
= depth
.unrail_paces
136 for i
in [0..depth
[ do
137 var lp
= paces
[i
].first
138 var rp
= paces
[i
].second
141 while pos
< length
do
142 arr
[pos
] = chars
[start
]
158 # Generates the paces for each depth.
160 # Each entry of the returned array is a couple of the first pace
161 # and the second one, they are alternated when deciphering a rail-encrypted string.
163 # Say we have the encrypted string "fgounbmtcieehkh" on 4 rails
165 # To find the distance between each character on the original railed
166 # string, we need to compute the extremes.
168 # The extremes always have a distance of `depth - 1`, multiplied by 2, no pairing.
170 # In the example, that would be : [(4 - 1) * 2, (4 - 1) * 2] => [6,6]
172 # For every rail in-between, the first distance is the largest absolute value
173 # of the difference between the current depth and the extremes, multiplied by 2.
175 # Its pair is the distance of maximum and the distance yielded by the previous
178 # In our example, that would be :
180 # Maximums : (4 - 1) * 2 = 3 * 2 => [6,6]
181 # In between : Distance for depth 2 : max(2 - 1, 4 - 2) => 2
182 # The calculation yields the couple [(2 * 2), 6 - 4] => [4, 2]
183 # The symmetric couple is reversed : [2, 4]
185 # In fine, the example yields the array : [[6,6], [4,2], [2,4], [6,6]]
187 # In the end, our string is read using the generated array
189 # SEE: `String::unrail` for how the array is used
190 private fun unrail_paces
: Array[Couple[Int, Int]] do
191 var ret
= new Array[Couple[Int,Int]].with_capacity
(self)
192 var extremes
= new Couple[Int, Int]((self - 1) * 2, (self - 1) * 2)
193 for i
in [0..self[ do
196 var mid
= ((self.to_f
)/2.0).floor
.to_i
197 for i
in [1 .. mid
[ do
199 var lodepth
= self - rd
200 var hidepth
= (rd
- self).abs
202 if hidepth
> lodepth
then
207 var cp
= new Couple[Int, Int](dd
, extremes
.first-dd
)
208 var ccp
= new Couple[Int, Int](extremes
.first
- dd
, dd
)
213 if not self.is_even
then
214 ret
[mid
] = new Couple[Int, Int](extremes
.first
/2, extremes
.first
/2)