Програмиране с Ruby

Курс във Факултета по Математика и Информатика към СУ

Шифър на Цезар

Краен срок
01.12.2012 14:00

Срокът за предаване на решения е отминал

Шифърът на Цезар е един от най-простите алгоритми за криптиране. При него всяка буква се замества с друга буква, като еднаквите букви се заместват с еднакви, т.е. навсякъде „а“ е заместено с „ф“, „б“ с „х“ и т.н. Класическата реализация на шифъра се прави чрез „завъртане“ на буквите от азбуката, напр. при завъртане с две позиции в българската азбука ще имаме следните съответствия: „а“ - „в“, „б“ - „г“, „в“ - „д“ и т.н. Дешифрирането се осъществява чрез „завъртане“ в обратната посока.

Напишете клас Caesar, който да имплементира шифъра на Цезар за произволни азбуки.

Конструктурът му трябва да приема един задължителен аргумент - броят букви, с които „завъртаме“, и един незадължителен низ, който да съдържа всички букви от някаква азбука. Ако низът не бъде подаден, то азбуката по подразбиране се състои от малките латински букви 'abcdefghijklmnopqrstuvwxyz':

latin_encrypter = Caesar.new 4
dna_encrypter = Caesar.new 3, 'ACTG'

Ако числото за завъртане надвишава дължината на азбуката, го завъртаме на (числото mod дължина на азбуката), т.е. Caesar.new 4 трябва да се държи както Caesar.new 30.

Инстанциите на класа трябва да имат два метода - encrypt и decrypt, които да извърщват съответните действия:

latin_encrypter.encrypt 'hello' # "lipps"
latin_encrypter.decrypt 'lipps' # "hello"

dna_encrypter.encrypt 'ACCTGA' # "GAACTG"

Примете, че получавате само валидни параметри, т.е. няма да ви караме да криптирате/декриптирате низове съдържащи букви, които ги няма в предварително зададената азбука. Всеки символ се счита за буква, включително интервали, пунктуация и прочее.

Решения

Александър Иванов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Александър Иванов
class Caesar
def initialize(delta, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@delta, @alphabet = delta, alphabet
end
def encrypt(value)
translate(value, @delta)
end
def decrypt(value)
translate(value, -@delta)
end
private
def translate(value, delta)
value.split('').map { |character| translate_character(character) }.join('')
end
def translate_character(character, delta)
@alphabet[(@alphabet.index(character) + delta) % @alphabet.length]
end
end
Станислав Гатев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Станислав Гатев
class Caesar
def initialize(offset, alphabet='abcdefghijklmnopqrstuvwxyz')
@offset, @alphabet = offset % alphabet.length, alphabet
end
def encrypt(text)
shift_letters text, @offset
end
def decrypt(text)
shift_letters text, -@offset
end
private
def shift_letters(text, offset)
text.chars.map do |char|
@alphabet[(@alphabet.index(char) + offset) % @alphabet.length]
end.join
end
end
Георги Гърдев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Георги Гърдев
class Caesar
def initialize(shift_size, alphabet = "abcdefghijklmnopqrstuvwxyz")
@shift_size, @alphabet = shift_size, alphabet
end
def encrypt(string)
string.chars.map{ |i| shift i }.join
end
def decrypt(string)
string.chars.map{ |i| shift i, true }.join
end
private
def shift(char, backwards = false)
new_char_index = @alphabet.index(char).to_i
new_char_index += backwards ? -@shift_size : @shift_size;
@alphabet[new_char_index % @alphabet.length]
end
end
Никола Таушанов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Никола Таушанов
class Caesar
def initialize(shift, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@shift = shift
@alphabet = alphabet.chars.with_index.with_object(Hash.new) do |(x, i), res|
res[x] = i
end
@size = alphabet.size
end
def encrypt(text)
text.gsub /./ do |x|
@alphabet.keys[(@alphabet[x] + @shift) % @size]
end
end
def decrypt(text)
text.gsub /./ do |x|
@alphabet.keys[(@alphabet[x] - @shift + @size) % @size]
end
end
end
Николай Колев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Николай Колев
class Caesar
def initialize(shift_number, letters = 'abcdefghijklmnopqrstuvwxyz')
@shift_number = shift_number
@letters = letters
end
def encrypt(text)
text.split(//).map do |char|
@letters[(@letters.index(char) + @shift_number) % @letters.length]
end.join
end
def decrypt(text)
text.split(//).map do |char|
@letters[(@letters.index(char) - @shift_number) % @letters.length]
end.join
end
end
Елена Денева
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Елена Денева
class Caesar
attr_accessor :number, :letters, :decryptedLetters
def initialize number, letters = 'abcdefghijklmnopqrstuvwxyz'
@number = number % letters.length
@letters = letters
@decryptedLetters = letters[- letters.length + @number..-1]
@decryptedLetters.concat letters[0..@number-1]
end
def encrypt word
word.tr letters, decryptedLetters
end
def decrypt word
word.tr decryptedLetters, letters
end
end
Петко Борджуков
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Петко Борджуков
class Caesar
def initialize(offset, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@offset, @alphabet = offset, alphabet
@encryption_map = Hash.new { |hash, char| hash[char] = shift(char) }
end
def encrypt(string)
string.gsub(/./, @encryption_map)
end
def decrypt(string)
Caesar.new(-@offset, @alphabet).encrypt string
end
private
def shift(char)
@alphabet.slice (@alphabet.index(char) + @offset) % @alphabet.size
end
end
Тихомир Янев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Тихомир Янев
class Caesar
def initialize(offset, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@original_alphabet = alphabet
offset = alphabet[offset] ? offset.abs : alphabet.size
@crypt_alphabet = alphabet[offset..-1] << alphabet[0...offset]
end
def encrypt(string)
string.gsub!(%r<[#{@original_alphabet}]+?>) do |char|
@crypt_alphabet[@original_alphabet.index(char)]
end
string
end
def decrypt(string)
string.gsub!(%r<[#{@crypt_alphabet}]+?>) do |char|
@original_alphabet[@crypt_alphabet.index(char)]
end
string
end
end
Методи Димитров
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Методи Димитров
class Caesar
attr_reader :alphabet
attr_reader :symbol_offset
def initialize(offset, alphabet = "abcdefghijklmnopqrstuvwxyz")
@symbol_offset, @alphabet = offset % alphabet.length, alphabet.split("")
end
def crypt(sign, text)
text.gsub(/./) { |letter| @alphabet[(@alphabet.index(letter) + (@symbol_offset * sign)) % @alphabet.length]}
end
def encrypt(text)
crypt(1, text)
end
def decrypt(text)
crypt(-1, text)
end
end
Милан Миланов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Милан Миланов
class Caesar
def initialize(offset, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@offset, @alphabet = offset, alphabet
end
def encrypt(word)
word.each_char.map { |letter| @alphabet[(@alphabet.index(letter) + @offset) % @alphabet.length] }.join('')
end
def decrypt(word)
word.each_char.map { |letter| @alphabet[(@alphabet.index(letter) - @offset) % @alphabet.length] }.join('')
end
end
Иван Георгиев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Иван Георгиев
#encoding: utf-8
class Caesar
def initialize(number, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@alphabet = alphabet
if number > @alphabet.length then @number = number.remainder(@alphabet.length)
else @number = number
end
end
def encrypt(text)
text.split('').map { |letter| encrypt_transform(@alphabet, letter, @number) }.join('')
end
def decrypt(text)
text.split('').map { |letter| @alphabet[@alphabet.index(letter) - @number] }.join('')
end
def encrypt_transform(word, letter, number)
difference = word.length - word.index(letter)
if difference <= number then word[number - difference]
else word[word.index(letter) + number]
end
end
end
Филарета Йорданова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Филарета Йорданова
class Ceaser
attr_accessor :count, :alphabet, :size
def initialize(count, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@alphabet = alphabet
@size = alphabet.size
if(@size < count)
@count = count % @size
else
@count = count
end
end
def language
result = {}
0.upto(size - 1) do |i|
if i + count < size
result[alphabet[i]] = alphabet[i + count]
else
result[alphabet[i]] = alphabet[(i + count - 1) % count]
end
end
result
end
def encrypt(word)
word.gsub(/[[:alpha:]]/,language)
end
def decrypt(word)
word.gsub(/[[:alpha:]]/,language.invert)
end
end
Николай Димитров
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Николай Димитров
class Caesar
def initialize(shift, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@shift, @alphabet = shift, alphabet
end
def encrypt(message)
message.gsub(/./) { |letter| @alphabet[(@alphabet.index(letter) + @shift) % @alphabet.length] }
end
def decrypt(message)
message.gsub(/./) { |letter| @alphabet[(@alphabet.index(letter) - @shift) % @alphabet.length] }
end
end
Мартин Попов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Мартин Попов
#encoding: utf-8
class Caesar
attr_reader :caesar_hash, :alphabet_pattern
LATIN_ALPHABET = "abcdefghijklmnopqrstuvwxyz"
def initialize(shift, alphabet = LATIN_ALPHABET)
@caesar_hash = {}
@alphabet_pattern = /[#{alphabet}]/u
simplified_shift = shift % alphabet.length
1.upto(alphabet.length).each do |index|
caesar_hash[alphabet[index - 1]] = alphabet[(index - 1 + simplified_shift) % alphabet.length]
end
end
def encrypt(text)
text.gsub(alphabet_pattern, caesar_hash)
end
def decrypt(text)
text.gsub(alphabet_pattern, caesar_hash.invert)
end
end
Михаил Жеков
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Михаил Жеков
class Caesar
def initialize step, alphabet = 'abcdefghijklmnopqrstuvwxyz'
@step = step
@alphabet = alphabet
end
def encrypt string
result = ""
string.each_char { |char| result += @alphabet[((@alphabet.index(char) + @step) % @alphabet.length)] }
result
end
def decrypt string
result = ""
string.each_char { |char| result += @alphabet[(@alphabet.index(char) - @step)] }
result
end
end
Живко Чобанов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Живко Чобанов
class TestBonus2 < MiniTest::Unit::TestCase
def test_caesar
assert Caesar.new 4
assert Caesar.new 4, 'abcd'
assert_equal 1, Caesar.new(9, 'abcd').instance_variable_get(:@shift_count)
assert_equal 'bbac', Caesar.new(1, 'abdc').encrypt('aacd')
assert_equal 'ddba', Caesar.new(6, 'abdc').encrypt('aacd')
assert_equal 'hello', Caesar.new(4).decrypt('lipps')
end
end
class Caesar
def initialize(shift_count, alphabet_characters_glued = 'abcdefghijklmnopqrstuvwxyz')
@alphabet_characters_glued = alphabet_characters_glued
@shift_count = shift_count % @alphabet_characters_glued.size
end
def encrypt(text)
shift text, @shift_count
end
def decrypt(text)
shift text, (@alphabet_characters_glued.size - @shift_count)
end
private
def shift(text, shift_count)
text.each_char.inject('') do |shifted_text, char|
shifted_text += @alphabet_characters_glued[
(@alphabet_characters_glued.index(char) + shift_count) %
@alphabet_characters_glued.size
]
end
end
end
Георги Георгиев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Георги Георгиев
class Caesar
def initialize(offset, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@alphabet = alphabet
@offset = offset % alphabet.length
end
def encrypt(text)
text.gsub(/./) { |symbol| @alphabet[(@alphabet.index(symbol) + @offset) % @alphabet.length] }
end
def decrypt(text)
text.gsub(/./) { |symbol| @alphabet[(@alphabet.index(symbol) - @offset) % @alphabet.length] }
end
end
Пламен Тотев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Пламен Тотев
class Caesar
def initialize(indentation, alphabet = Array('a'..'z'))
@indentation = indentation % alphabet.size
@alphabet = alphabet
end
def encrypt(text)
text.gsub(/./) { |char| @alphabet[(@alphabet.index(char) + @indentation) % @alphabet.size] }
end
def decrypt(text)
text.gsub(/./) { |char| @alphabet[@alphabet.index(char) - @indentation] }
end
end
Камелия Пандаклиева
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Камелия Пандаклиева
# -*- coding: utf-8 -*-
class Caesar
Latin = 'abcdefghijklmnopqrstuvwxyz'
def initialize(step, sigma = Latin)
pairs = sigma.unpack('U*').zip sigma.unpack('U*').rotate step
@decryption_key = {}
pairs.each { |pair| @decryption_key.store pair[0], pair[1] }
@encryption_key = @decryption_key.invert
end
def encrypt(text)
code text, @encryption_key
end
def decrypt(text)
code text, @decryption_key
end
def code(text, code_key)
text.unpack('U*').map { |symbol| code_key.key symbol }.pack('U*')
end
end
Ангел Николов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Ангел Николов
class Caeser
DEFAULT_ALPHABET = ('a'..'z').inject(&:+)
def initialize(offset, alphabet = DEFAULT_ALPHABET)
mod = alphabet.size
alphabet = alphabet.split ''
encrypted = alphabet.map.with_index { |_, i| alphabet[(i + offset) % mod] }
@encryption = Hash[alphabet.zip encrypted]
end
def encrypt(string)
string.gsub /./, @encryption
end
def decrypt(string)
string.gsub /./, @encryption.invert
end
end
Йордан Стефанов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Йордан Стефанов
class Caesar
def initialize secret_offset, alphabet = ('a'..'z').to_a
@secret_offset = secret_offset.remainder alphabet.size
@alphabet = alphabet
end
def encrypt source_text
source_text.gsub( /./mu ) do |letter|
@alphabet[ ( @alphabet.index( letter ) + @secret_offset ).modulo @alphabet.size ]
end
end
def decrypt source_text
source_text.gsub( /./mu ) do |letter|
@alphabet[ ( @alphabet.index( letter ) - @secret_offset ).modulo @alphabet.size ]
end
end
end
Петър Костов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Петър Костов
class Caeser
def initialize(shift, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@original = alphabet
@shifted = @original.chars.to_a.rotate(shift).join
end
def encrypt(word)
word.chars.map { |char| @original.index char }.map { |index| @shifted[index] }.join
end
def decrypt(word)
word.chars.map { |char| @shifted.index char }.map { |index| @original[index] }.join
end
end
Виктория Христова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Виктория Христова
#encoding: utf-8
class Caesar
def initialize (rotation, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@rotation = rotation
@alphabet = alphabet
@code = Hash[0.upto(alphabet.size - 1).zip alphabet.chars]
end
def encrypt (word)
word.gsub(/./u) {|s| @code[(@code.key(s) + @rotation) % @alphabet.size]}
end
def decrypt (word)
word.gsub(/./u) {|s| @code[(@code.key(s) - @rotation) % @alphabet.size]}
end
end
Светлана Величкова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Светлана Величкова
# encoding: utf-8
class Caesar
attr_accessor :rotation_count, :alphabet
def initialize(rotation_count, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@alphabet = alphabet.split(//)
@rotation_count = rotation_count%alphabet.length
end
def encrypt(string)
result = string.split(//).fill {|i| alphabet[alphabet.index(string[i])+rotation_count]}
result.join
end
def decrypt(string)
result = string.split(//).fill {|i| alphabet[alphabet.index(string[i])-rotation_count]}
result.join
end
end
Румен Палетов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Румен Палетов
class BiDictionary
def initialize
@keyValueHash = {}
@valueKeyHash = {}
end
def set(key, value)
raise ArgumentError, "Duplicate Keys (#{key}) are not allowed." if @keyValueHash.has_key? key
raise ArgumentError, "Duplicate Values (#{value}) are not allowed." if @valueKeyHash.has_key? value
@keyValueHash[key] = value
@valueKeyHash[value] = key
end
def getValue(key)
@keyValueHash[key]
end
def getKey(value)
@valueKeyHash[value]
end
end
class Caesar
def initialize(step, alphabet = "abcdefghijklmnopqrstuvwxyz")
@step = step
@alphabet = alphabet.chars.to_a
@biDictionary = BiDictionary.new
@alphabet.each_index { |i| @biDictionary.set(@alphabet[i], @alphabet[get_next_letter(i)]) }
end
def get_next_letter(pos)
(pos + @step) % @alphabet.length
end
def encrypt(text)
text.chars.to_a.map { |s| @biDictionary.getValue(s) }.join
end
def decrypt(text)
text.chars.to_a.map { |s| @biDictionary.getKey(s) }.join
end
end
Радослав Върбанов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Радослав Върбанов
# encoding: utf-8
class Caesar
def initialize(rotation, alphabet = "abcdefghijklmnopqrstuvwxyz")
@alphabet, @offset = alphabet, (rotation.modulo alphabet.length)
end
def encrypt(text)
new_text, offset = "", @offset - @alphabet.length
text.each_char do |c|
(0..@alphabet.length).each { |i| new_text << (c == @alphabet[i] ? @alphabet[i + offset] : '') }
end
new_text
end
def decrypt(text)
old_text = ""
text.each_char do |c|
(0..@alphabet.length).each { |i| old_text << (c == @alphabet[i] ? @alphabet[i - @offset] : '') }
end
old_text
end
end
Валентин Ейткен
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Валентин Ейткен
class Caesar
def initialize(rotate_with, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@rotate_with, @alphabet = rotate_with, alphabet
end
def encrypt(string)
string.each_char.map do |letter|
@alphabet[@alphabet.index(letter) + @rotate_with < @alphabet.length ?
@alphabet.index(letter) + @rotate_with :
(@alphabet.index(letter) + @rotate_with) % @alphabet.length]
end.join
end
def decrypt(string)
string.each_char.map do |letter|
@alphabet[@alphabet.index(letter) - @rotate_with < 0 ?
@alphabet.length - @rotate_with :
@alphabet.index(letter) - @rotate_with]
end.join
end
end
Кирчо Кирев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Кирчо Кирев
class Caesar
def initialize(shift, alphabet = nil)
letters = alphabet ? alphabet.split("") : "a".upto("z").inject([], &:<<)
@encrypt = {}
letters.each_with_index do |letter, index|
@encrypt[letter] = letters[(index + shift) % letters.size]
end
@decrypt = @encrypt.invert
end
def encrypt(value)
value.gsub /[#@encrypt.keys]/, @encrypt
end
def decrypt(value)
value.gsub /[#@decrypt.keys]/, @decrypt
end
end
Красимир Георгиев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Красимир Георгиев
class Caesar
def initialize(positions, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@positions = positions % alphabet.length
@alphabet = alphabet
end
def shift_char(char, positions)
index = (@alphabet.index(char) + positions) % @alphabet.length
@alphabet[index]
end
def encrypt(text)
text.split("").map { |char| shift_char(char, @positions) }.join
end
def decrypt(text)
text.split("").map { |char| shift_char(char, -@positions) }.join
end
end
Илиян Бобев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Илиян Бобев
class Caesar
attr_accessor :alphabet,:key
def initialize(key,alphabet='abcdefghijklmnopqrstuvwxyz')
@alphabet = alphabet
@key = key
end
def encrypt(text)
text.each_char.collect { |char| @alphabet[(@alphabet.index(char)+@key).modulo(@alphabet.size)] }.join
end
def decrypt(text)
text.each_char.collect { |char| @alphabet[(@alphabet.index(char)-@key).modulo(@alphabet.size)] }.join
end
end
Явор Лилянов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Явор Лилянов
class Ceasar
def initialize(length, text = 'abcdefghijklmnopqrstuvwxyz')
@hash = {}
length = length % text.length if length > text.length
text.chars do |char|
step = text.index(char) + length
step = step - text.length if step >= text.length
@hash[char] = text[step]
end
end
def encrypt(text)
text.gsub(/./) { |char| @hash[char]}
end
def decrypt(text)
text.gsub(/./){ |char| @hash.invert[char] }
end
end
Стоян Стоянов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Стоян Стоянов
class Caesar
attr_reader :letter_count, :alphabet
def initialize(letter_count, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@alphabet = alphabet
if letter_count > alphabet.size
@letter_count = letter_count % alphabet.size
else
@letter_count = letter_count
end
end
def encrypt(word)
word.gsub(/./).each do |s|
shift = alphabet.index(s) + letter_count
if shift >= alphabet.size
shift = shift % alphabet.size
end
alphabet[shift]
end
end
def decrypt(word)
word.gsub(/./).each do |s|
shift = alphabet.index(s) - letter_count
alphabet[shift]
end
end
end
Йордан Петров
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Йордан Петров
class Cesar
def initialize(step, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@step = step
@alphabet = alphabet
end
def encrypt(text)
text.gsub(/(.)/u) { @alphabet[position $1, :encrypt] }
end
def decrypt(text)
text.gsub(/(.)/u) { @alphabet[position $1, :decrypt] }
end
private
def position(symbol ,operation)
if operation == :encrypt then (@alphabet.index(symbol) + @step) % @alphabet.size
else (@alphabet.index(symbol) - @step) % @alphabet.size
end
end
end
Георги Пачов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Георги Пачов
class Caesar
def initialize(crypt_size, crypt_alphabet = 'abcdefghijklmnopqrstuvwxyz')
@crypt_size = crypt_size
@crypt_alphabet = to_array(crypt_alphabet)
end
def encrypt(text)
encrypted_string = ""
text.each_char { |char| encrypted_string << get_character_for((get_index_for(char) + @crypt_size)%@crypt_alphabet.size) }
encrypted_string
end
def decrypt(text)
decrypted_string = ""
text.each_char { |char|decrypted_string << get_character_for((get_index_for(char) - @crypt_size)%crypt_alphabet.size) }
decrypted_string
end
private
def to_array(string)
string.split(//)
end
def get_index_for(element)
@crypt_alphabet.each_with_index { |el, index| return index if element == el }
end
def get_character_for(index)
@crypt_alphabet[index]
end
end
Чанита Иванова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Чанита Иванова
class Caesar
attr_accessor :change, :alfabet, :hash
def initialize(change, alfabet='abcdefghijklmnopqrstuvwxyz')
@change = change
@alfabet = alfabet
@hash={}
@change = (change % alfabet.size) if (change > alfabet.size)
fill_hash
end
def fill_hash
alfabet.each_char{ |c|
index = alfabet.index(c)
if (index + change) > (alfabet.size - 1)
hash[c]= alfabet[(change - (alfabet.size - index))]
else hash[c]=alfabet[index + change]
end
}
end
def encrypt(text)
result = []
text.each_char { |c| result<<hash[c] }
result.join
end
def decrypt(text)
result = []
text.each_char { |c| result<<hash.invert[c] }
result.join
end
end
Цвета Гергичанова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Цвета Гергичанова
class Caesar
def initialize(shift, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@encrypted = {}
0.upto(alphabet.size - 1).each do |index|
@encrypted = @encrypted.merge(alphabet[index] => alphabet[(index + shift)%alphabet.size])
end
@decrypted = @encrypted.invert
end
def encrypt(word)
result = word
0.upto(word.size-1).each do |index|
result[index] = @encrypted[word[index]]
end
result
end
def decrypt(word)
result = word
0.upto(word.size-1).each do |index|
result[index] = @decrypted[word[index]]
end
result
end
end
Мартина Величкова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Мартина Величкова
class Caesar
def initialize(shift_with, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@shift_with = shift_with
@alphabet = alphabet
end
def encrypt(word)
encrypt_word = word.each_char.map do |char|
index = @alphabet.index("#{char}")
index_in_alphabet = (index + @shift_with) % @alphabet.size
@alphabet[index_in_alphabet]
end
encrypt_word.join
end
def decrypt(word)
encrypt_word = word.each_char.map do |char|
index = @alphabet.index("#{char}")
index_in_alphabet = (index - @shift_with) % @alphabet.size
@alphabet[index_in_alphabet]
end
encrypt_word.join
end
end
Свилен Андонов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Свилен Андонов
class Caesar
attr_accessor :language, :move , :size
def initialize move, language = 'abcdefghijklmnopqrstuvwxyz'
@move = move
@language = language.split("")
@size = @language.length
end
def decrypt value
value = value.split("")
result = []
value.each { |m| result<< @language[( @language.index(m) + @size - @move) % @size]}
result.join
end
def encrypt value
value = value.split("")
result = []
value.each { |m| result << @language[( @language.index(m) + @move) % @size]}
result.join
end
end
Нели Хатева
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Нели Хатева
class Caesar
def initialize(shift, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@shift, @alphabet_as_array = shift % alphabet.length, alphabet.split(//)
initialize_hash_for_encryption
initialize_hash_for_decryption
end
def initialize_hash_for_encryption
shifted_alphabet = @alphabet_as_array.rotate(@shift)
@encrypt = {}
@alphabet_as_array.each_index { |character| @encrypt[@alphabet_as_array[character]] = shifted_alphabet[character] }
end
def initialize_hash_for_decryption
shifted_alphabet = @alphabet_as_array.rotate(-@shift)
@decrypt = {}
@alphabet_as_array.each_index { |character| @decrypt[@alphabet_as_array[character]] = shifted_alphabet[character] }
end
def encrypt(text)
encrypted_text = ''
text.each_char { |character| encrypted_text << @encrypt[character] }
encrypted_text
end
def decrypt(text)
decrypted_text = ''
text.each_char { |character| decrypted_text << @decrypt[character] }
decrypted_text
end
end
Атанас Пройчев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Атанас Пройчев
class Caesar
def initialize code, alphabet = 'abcdefghijklmnopqrstuvwxyz'
if code > alphabet.size
@code = code % alphabet.size
else @code = code
end
@alphabet = alphabet
end
def encrypt text
new_text = ''
text.each_char do |char|
new_char_index = if ((@alphabet =~ /#{char}/) + @code) > @alphabet.size - 1
((@alphabet =~ /#{char}/) + @code) % @alphabet.size
else ((@alphabet =~ /#{char}/) + @code)
end
new_text << @alphabet[new_char_index]
end
new_text
end
def decrypt text
new_text = ''
text.each_char do |char|
new_char_index = if ((@alphabet =~ /#{char}/) - @code) < 0
((@alphabet =~ /#{char}/) - @code) + @alphabet.size
else ((@alphabet =~ /#{char}/) - @code)
end
new_text << @alphabet[new_char_index]
end
new_text
end
end
Мирослав Крамолински
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Мирослав Крамолински
# encoding: utf-8
class Caesar
def initialize step, alphabet = 'abcdefghijklmnopqrstuvwxyz'
@step, @alphabet, @rev_alphabet = step, alphabet, alphabet.reverse
self
end
def encrypt text
text.gsub(/./) { |s| @alphabet[(@alphabet.index(s) + @step) % @alphabet.length] }
end
def decrypt text
text.gsub(/./) { |s| @rev_alphabet[(@rev_alphabet.index(s) + @step) % @rev_alphabet.length] }
end
end
Гергана Петрова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Гергана Петрова
class Caesar
attr_accessor :plain_alphabet, :cipher_alphabet
def initialize(shift_number, alphabet = 'abcdefghigklmnopqrstuvwxuz')
shift_number = shift_number % alphabet.size
@plain_alphabet = alphabet
@cipher_alphabet = alphabet[shift_number..alphabet.size] + alphabet[0...shift_number]
end
def encrypt(text)
text.tr plain_alphabet, cipher_alphabet
end
def decrypt(text)
text.tr cipher_alphabet, plain_alphabet
end
end
Теодор Илиев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Теодор Илиев
class Caesar
def initialize(step, alphabet = ('a'..'z').to_a.join)
@step = step
@alphabet = Hash[alphabet.chars.with_index.to_a]
@alphabet_index = @alphabet.invert
@alphabet_length = alphabet.length
end
def encrypt(text)
text.chars.map do |char|
@alphabet_index[(@alphabet[char] + @step) % @alphabet_length]
end.join
end
def decrypt(text)
text.chars.map do |char|
@alphabet_index[(@alphabet[char] - @step) % @alphabet_length]
end.join
end
end
Илия Ячев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Илия Ячев
class Caeser
def initialize(rotate_step, alphabet = "abcdefghijklmnopqrstuvwxyz")
@old_alphabet = alphabet
@rotate_step = rotate_step % alphabet.length
@new_alphabet = alphabet[@rotate_step..-1] + alphabet[0...@rotate_step]
end
def encrypt(text)
text.chars.map { |char| encryption[char] }.join
end
def decrypt(text)
text.chars.map { |char| decryption[char] }.join
end
private
def encryption
Hash[@old_alphabet.chars.zip(@new_alphabet.chars)]
end
def decryption
Hash[@new_alphabet.chars.zip(@old_alphabet.chars)]
end
end
Орлин Христов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Орлин Христов
class Caesar
def initialize(shift, alphabet=nil)
@alphabet = alphabet ? alphabet.dup : 'abcdefghijklmnopqrstuvwxyz'
shift %= @alphabet.length
@encrypt_shift = shift - @alphabet.length
@decrypt_shift = -shift
end
def encrypt(text)
process text, @encrypt_shift
end
def decrypt(text)
process text, @decrypt_shift
end
private
def process(text, shift)
text.each_char.map { |symbol| @alphabet[@alphabet.index(symbol) + shift] }.join
end
end
Александър Иванов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Александър Иванов
class Caesar
attr_reader :step, :alphabet
def initialize(step, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@alphabet = alphabet
@step = step % alphabet.length
@shifted_alphabet = @step == 0 ? alphabet : alphabet[@step..-1] + alphabet[0..(@step-1)]
end
def encrypt(text)
text.tr(@alphabet, @shifted_alphabet)
end
def decrypt(text)
text.tr(@shifted_alphabet, @alphabet)
end
end
Деян Гюрджеклиев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Деян Гюрджеклиев
class Caesar
attr_reader :key,:alphabet
def initialize(key,alphabet='abcdefghijklmnopqrstuvwxyz')
@key = key
@alphabet = alphabet
end
def encrypt(text)
text.chars.map do |char|
encrypted_index = (alphabet.chars.to_a.index(char) + key) % alphabet.size
alphabet[encrypted_index]
end.join
end
def decrypt(text)
text.chars.map do |char|
decrypted_index = (alphabet.chars.to_a.index(char) - key)
alphabet[decrypted_index]
end.join
end
end
Йоана Тодорова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Йоана Тодорова
#!usr/bin/env ruby -w -Ku
class Caesar
def initialize(count, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@count, @alphabet = count, {}
alphabet.split(//).each_with_index { |letter, index| @alphabet[index]=letter }
end
def encrypt(text)
text.gsub (/./u) { |char| @alphabet[ (@alphabet.key(char) + @count) % @alphabet.length ] }
end
def decrypt(text)
text.gsub (/./u) { |char| @alphabet[ (@alphabet.key(char) - @count) % @alphabet.length ] }
end
end
Иван Арабаджиев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Иван Арабаджиев
class Caesar
def initialize(key, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@alphabet = alphabet.chars.to_a
@key = key % alphabet.length
@shortcut = [ {}, {} ]
cheat # вероятно под 1-2MB text ще работи по-бързо 'иначе' ...
end
def encrypt(shallow_secret)
shallow_secret.gsub /./, @shortcut.first
end
def decrypt(deep_secret)
deep_secret.gsub /./, @shortcut.last
end
private
def cheat
alphabet_size = @alphabet.length
@alphabet.each_with_index do |char, id|
@shortcut.first[char] = @alphabet.fetch (id + @key) % alphabet_size
@shortcut.last[char] = @alphabet.fetch (id - @key) % alphabet_size
end
end
end
Изабела Недялкова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Изабела Недялкова
class Caesar
def initialize(step, alphabet = "abcdefghijklmnopqrstuvwxyz")
@step = step
@alphabet = alphabet
end
def encrypt(word)
crypt(word, @step)
end
def decrypt(word)
crypt(word, -@step)
end
private
def crypt(word, step)
word.split("").map { |char|
@alphabet[(@alphabet.index(char) + step) % @alphabet.size]
}.join
end
end
Илиян Величков
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Илиян Величков
class Caesar
LOWER_LATIN_LETTERS = 'abcdefghijklmnopqrstuvwxyz'
def initialize(shift, alphabet = LOWER_LATIN_LETTERS)
shift = shift % alphabet.size
@alphabet = alphabet
@shifted_alphabet = @alphabet[shift..@alphabet.size] + @alphabet[0...shift]
end
def encrypt(string)
string.tr(@alphabet, @shifted_alphabet)
end
def decrypt(string)
string.tr(@shifted_alphabet, @alphabet)
end
end
Ростислав Градинаров
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Ростислав Градинаров
#encoding: utf-8
class Caesar
attr_accessor :number, :alphabet
def initialize(number, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@number = number < alphabet.length ? number : number % alphabet.length
@alphabet = alphabet
end
def encrypt(text)
encrypted_text = ""
text.each_char do |char|
encrypted_text << @alphabet[(@alphabet.index(char) + @number) % @alphabet.length]
end
encrypted_text
end
def decrypt(text)
decrypted_text = ""
text.each_char do |char|
decrypted_text << @alphabet[(@alphabet.index(char) - @number) % @alphabet.length]
end
decrypted_text
end
end
Николай Шегунов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Николай Шегунов
# encoding: utf-8
class Caesar
def initialize(shift, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@shift = shift % alphabet.length
@alphabet = alphabet
end
def encrypt(string)
crypt(string,@shift)
end
def decrypt(string)
crypt(string,-1*@shift)
end
private
def crypt(string,shift)
crypted_string = ''
string.each_char do |char|
crypted_string << @alphabet[(@alphabet.index(char) + shift) % @alphabet.length]
end
crypted_string
end
end
Даяна Беркова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Даяна Беркова
# encoding: utf-8
class Caesar
def initialize(letters_offset, alphabet = 'abcdefghijklmnopqrstuvwxyz')
@alphabet = alphabet
@letters_offset = letters_offset % @alphabet.length
end
def encrypt(text)
text.gsub(/./).each_with_index {|letter, index| text[index] = encrypt_letter(letter, index) }
end
def decrypt(text)
text.gsub(/./).each_with_index {|letter, index| text[index] = decrypt_letter(letter, index) }
end
def encrypt_letter(letter, index)
return @alphabet[@alphabet.index(letter) + @letters_offset] if @alphabet.index(letter) + @letters_offset < @alphabet.length
@alphabet[@alphabet.index(letter) + @letters_offset - @alphabet.length]
end
def decrypt_letter(letter, index)
return @alphabet[@alphabet.index(letter) - @letters_offset] if @alphabet.index(letter) - @letters_offset >= 0
@alphabet[@alphabet.length - @letters_offset + @alphabet.index(letter)]
end
end
Христо Владев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Христо Владев
class Caesar
def initialize(shift, alphabet = nil)
@alphabet = alphabet ? alphabet : 'abcdefghijklmnopqrstuvwxyz'
@shift = shift.remainder @alphabet.length
@cipher_alphabet = cipher_alphabet
end
def encrypt(text)
text.chars.map { |letter| @cipher_alphabet[@alphabet.index(letter)] }.join
end
def decrypt(text)
text.chars.map { |letter| @alphabet[@cipher_alphabet.index(letter)] }.join
end
private
def cipher_alphabet
@alphabet.chars.map do |letter|
letter_index = @alphabet.reverse.index(letter)
@alphabet.reverse[letter_index - @shift]
end.join
end
end
Кирил Владимиров
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Кирил Владимиров
# encoding: utf-8
class Caesar
def initialize(shift, alphabet='abcdefghijklmnopqrstuvwxyz')
@shift = shift % alphabet.length
@alphabet = alphabet
end
def encrypt(input)
result = input.split('').map do |char|
@alphabet[(@alphabet.index(char) + @shift) % @alphabet.length]
end
result.join
end
def decrypt(input)
result = input.split('').map do |char|
@alphabet[(@alphabet.index(char) - @shift) % @alphabet.length]
end
result.join
end
end
Снежана Спасова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Снежана Спасова
class Caesar
attr_accessor :number, :alphabet
def initialize( number , alphabet = "abcdefghijklmnopqrstuvxyzw" )
@alphabet = alphabet
number > alphabet.size ? @number = number % alphabet.size : @number = number
end
def encode_char( char )
alphabet.index(char) + number < alphabet.size ? alphabet.index(char) + number : (alphabet.index(char) + number ) % alphabet.size
end
def decode_char( char )
alphabet.index(char) - number >= 0 ? alphabet.index(char) - number : alphabet.size + alphabet.index(char) - number
end
def encrypt( string )
string.gsub(/./){|char| char = alphabet[encode_char char]}
end
def decrypt( string )
string.gsub(/./){|char| char = alphabet[decode_char char]}
end
end