rubyzip 0.5.12 → 0.9.1

data/lib/quiz1/t/solutions/Carlos/solitaire.rb

@@ -0,0 +1,111 @@
+class Numeric
+	def value
+		self
+	end
+	
+	def to_letter
+		((self-1)%26 + ?A).chr
+	end
+end
+
+class String
+	# returns an array with the code of the letters,
+	# padded with the code of X
+	def to_numbers
+		res=upcase.unpack("C*").collect { |b|
+			if b.between? ?A, ?Z
+				b - ?A + 1
+			else
+				nil
+			end
+		}.compact
+		# 24 == X
+		res.fill 24, res.length, (5 - res.length % 5) % 5
+	end
+	
+	def crypt (deck, decrypt=false)
+		numbers = to_numbers
+		keystream = deck.generate_keystream numbers.length
+		result = ""
+		numbers.zip(keystream) do |n, k|
+			k = -k if decrypt
+			result << (n+k).to_letter
+		end
+		result
+	end
+	
+	def encrypt (deck)
+		crypt deck, false
+	end
+	
+	def decrypt (deck)
+		crypt deck, true
+	end
+end
+
+class Joker
+	def value
+		53
+	end
+end
+
+A = Joker.new
+B = Joker.new
+
+class Array
+	def wrap_down pos
+		pos %= length
+		if pos == 0
+			pos = length
+		end
+		pos
+	end
+
+	def next_key
+		# step 2: move A joker down 1 card
+		pos = index A
+		slice! pos
+		pos = wrap_down(pos + 1)
+		self[pos, 0] = A
+		
+		# step 3: move B joker down 2 cards
+		pos = index B
+		slice! pos
+		pos = wrap_down(pos + 2)
+		self[pos, 0] = B
+		
+		# step 4: triple cut
+		first_joker, second_joker = [index(A), index(B)].sort
+		cards_above = slice! 0...first_joker
+		second_joker -= cards_above.length
+		cards_below = slice! second_joker+1..-1
+		push *cards_above
+		unshift *cards_below
+		
+		# step 5: count cut using the value of the bottom card.
+		#         reinsert above the last card
+		cut = slice! 0, last.value
+		self[-1,0] = cut
+		
+		# step 6: find the letter
+		card = self[first.value]
+		
+		return Joker===card ? nil : card.value
+	end
+	
+	def generate_keystream len
+		(1..len).collect {|i| next_key or redo }
+	end
+end
+
+def new_deck
+	(1..52).to_a + [A, B]
+end
+
+res = if ARGV[0] == "-d"
+		ARGV[1..-1].join("").decrypt(new_deck)
+	else
+		ARGV.join("").encrypt(new_deck)
+	end
+
+puts res.scan(/.{5}/).join(" ")

data/lib/quiz1/t/solutions/Dennis Ranke/solitaire.rb

@@ -0,0 +1,111 @@
+class Deck
+  def initialize
+    @deck = Array.new(54) {|i| i}
+  end
+
+  def create_keystream(count)
+    stream = []
+    count.times do
+      letter = next_letter
+      redo unless letter
+      stream << letter
+    end
+    return stream
+  end
+
+  def next_letter
+    ##
+    # move the jokers
+    ##
+
+    2.times do |j|
+      # find the joker
+      index = @deck.index(52 + j)
+
+      # remove it from the deck
+      @deck.delete_at(index)
+
+      # calculate new index
+      index = ((index + j) % 53) + 1
+
+      # insert the joker at that index
+      @deck[index, 0] = 52 + j
+    end
+
+    ##
+    # do the tripple cut
+    ##
+
+    # first find both jokers
+    a = @deck.index(52)
+    b = @deck.index(53)
+
+    # sort the two indeces
+    low, hi = [a, b].sort
+
+    # get the lower and upper parts of the deck
+    upper = @deck.slice!((hi + 1)..-1)
+    lower = @deck.slice!(0, low)
+
+    # swap them
+    @deck = upper + @deck + lower
+
+    ##
+    # do the count cut
+    ##
+
+    # find out the number of cards to cut
+    count = value_at(53)
+
+    # remove them from the top of the deck
+    cards = @deck.slice!(0, count)
+
+    # reinsert them just above the lowest card
+    @deck[-1, 0] = cards
+
+    return letter_at(value_at(0))
+  end
+
+  def value_at(index)
+    id = @deck[index]
+    (id > 51) ? 53 : id + 1
+  end
+
+  def letter_at(index)
+    id = @deck[index]
+    (id > 51) ? nil : (id % 26) + 1
+  end
+
+  def to_s
+    @deck.map {|v| (v > 51) ? (v + 13).chr : (v + 1).to_s}.join(' ')
+  end
+end
+
+def encode(data, keystream)
+  result = []
+  data.size.times {|i| result << ((data[i] + keystream[i]) % 26)}
+  return result
+end
+
+def decode(data, keystream)
+  encode(data, keystream.map {|v| 26 - v})
+end
+
+def data_to_string(data)
+  data = data.map {|v| (v + 65).chr}.join
+  (0...(data.size / 5)).map {|i| data[i * 5, 5]}.join(' ')
+end
+
+if ARGV.size != 1
+  puts "Usage: solitaire.rb MESSAGE"
+  exit
+end
+
+data = ARGV[0].upcase.split(//).select {|c| c =~ /[A-Z]/}.map {|c| c[0] - 65}
+data += [?X - 65] * (4 - (data.size + 4) % 5)
+
+deck = Deck.new
+keystream = deck.create_keystream(data.size)
+
+puts 'encoded:', data_to_string(encode(data, keystream))
+puts 'decoded:', data_to_string(decode(data, keystream))

data/lib/quiz1/t/solutions/Florian Gross/solitaire.rb

@@ -0,0 +1,301 @@
+class Array
+  # Moves the item from a specified index to
+  # just before the item with the specified index.
+  def move(from_index, to_index)
+    from_index += self.size if from_index < 0
+    to_index += self.size if to_index < 0
+
+    item = self.slice!(from_index)
+    self.insert(to_index, item)
+  end
+end
+
+module Solitaire
+  extend self
+
+  Letters = ('A' .. 'Z').to_a
+
+  class Card < Struct.new(:face, :type)
+    Faces = [:ace, :two, :three, :four, :five, :six, :seven,
+             :eight, :nine, :ten, :jack, :queen, :king]
+    Types = [:clubs, :diamonds, :hearts, :spades, :special]
+    SpecialFaces = [:joker_a, :joker_b]
+
+    def self.deck
+      Types.map do |type|
+        if type == :special
+          SpecialFaces.map do |face|
+            new(face, type)
+          end
+        else
+          Faces.map do |face|
+            new(face, type)
+          end
+        end
+      end.flatten
+    end
+
+    def special?; type == :special; end
+
+    def value
+      if special? then 53
+      else
+        Faces.index(face) + 1 + 13 * Types.index(type)
+      end
+    end
+
+    def letter
+      Letters[(value - 1) % 26]
+    end
+
+    def name
+      if face == :joker_a then "JokerA"
+      elsif face == :joker_b then "JokerB"
+      else
+        face_str = face.to_s.capitalize.gsub(/_(\w)/) { $1.upcase }
+        type_str = type.to_s.capitalize
+        face_str + " of " + type_str
+      end
+    end
+
+    def compact_inspect
+      if face == :joker_a then "A"
+      elsif face == :joker_b then "B"
+      else value end
+    end
+
+    def inspect
+      "#<#{self.class} #{name} (#{letter}/#{value})>"
+    end
+    alias :to_s :inspect
+
+    deck.each do |card|
+      const_set(card.name.sub(" of ", "Of"), card)
+    end
+  end
+
+  class KeyStream
+    def initialize(key_method = nil)
+      case key_method
+        when true then
+          @deck = Card.deck.sort_by { rand }
+        when String then
+          @deck = Card.deck
+          generate_letter(key_method)
+        else
+          @deck = Card.deck
+      end
+    end
+
+    def generate_letter(seed_phrase = nil)
+      if seed_phrase
+        seed_phrase = Solitaire.clean(seed_phrase)
+        seed_phrase = nil if seed_phrase.empty?
+      end
+
+      result = nil
+
+      until result
+        deck_size = @deck.size
+
+        # Move JokerA down one card
+        old_a_pos = @deck.index(Card::JokerA)
+        new_a_pos = case old_a_pos
+          when deck_size - 1 then 1
+          else old_a_pos + 1
+        end
+        @deck.move(old_a_pos, new_a_pos)
+
+        # Move JokerB down two cards
+        old_b_pos = @deck.index(Card::JokerB)
+        new_b_pos = case old_b_pos
+          when deck_size - 1 then 2
+          when deck_size - 2 then 1
+          else old_b_pos + 2
+        end
+        @deck.move(old_b_pos, new_b_pos)
+
+        # Perform triple cut
+        top_pos, bot_pos = [@deck.index(Card::JokerA), @deck.index(Card::JokerB)].sort
+        @deck.replace(
+          @deck[(bot_pos + 1) .. -1] +
+          @deck[top_pos .. bot_pos] + 
+          @deck[0 ... top_pos])
+
+        # Perform count cut
+        top = @deck.slice!(0 ... @deck.last.value)
+        @deck.insert(-2, *top)
+
+        if seed_phrase
+          key = seed_phrase.slice!(0, 1)
+          top = @deck.slice!(0 ... Solitaire.letter_to_number(key))
+          @deck.insert(-2, *top)
+          result = true if seed_phrase.empty?
+        else
+          # Fetch result
+          card = @deck[@deck.first.value]
+          result = card.letter unless card.special?
+        end
+      end
+
+      return result
+    end
+    alias :shift :generate_letter
+  end
+
+  def letter_to_number(letter)
+    Letters.index(letter) + 1
+  end
+
+  def number_to_letter(number)
+    Letters[number - 1]
+  end
+
+  def clean(text)
+    text.upcase.delete("^A-Z")
+  end
+
+  def pretty(text)
+    clean(text).scan(/.{1,5}/).join(" ")
+  end
+
+  def encrypt(raw_text, keystream = nil, pretty = true)
+    keystream ||= KeyStream.new
+    text = clean(raw_text)
+    text += "X" * ((text.size / 5.0).ceil * 5 - text.size)
+
+    result = ""
+    0.upto(text.size - 1) do |index|
+      source_num = letter_to_number(text[index, 1])
+      key_num = letter_to_number(keystream.shift)
+      result << number_to_letter((source_num + key_num) % 26)
+    end
+
+    result = pretty(result) if pretty
+    return result
+  end
+
+  def decrypt(raw_text, keystream = nil, pretty = true)
+    keystream ||= KeyStream.new
+    text = clean(raw_text)
+
+    result = ""
+    0.upto(text.size - 1) do |index|
+      source_num = letter_to_number(text[index, 1])
+      key_num = letter_to_number(keystream.shift)
+      result << number_to_letter((source_num - key_num) % 26)
+    end
+
+    result = pretty(result) if pretty
+    return result
+  end
+end
+
+if __FILE__ == $0
+  require 'optparse'
+
+  options = {
+    :mode => nil,
+    :keystream => nil,
+    :keylength => 80,
+    :text => nil
+  }
+
+  ARGV.options do |opts|
+    script_name = File.basename($0)
+    opts.banner = "Usage: ruby #{script_name} [options]"
+
+    opts.separator ""
+
+    opts.on("-d", "--decrypt",
+      "Decrypt an encrypted message.",
+      "This is the default if the message looks encrypted.") do
+      options[:mode] = :decrypt
+    end
+    opts.on("-e", "--encrypt",
+      "Encrypt an unencrypted message.") do
+      options[:mode] = :encrypt
+    end
+    opts.on("-m", "--message message",
+      "Specify the message.",
+      "Default: Read from terminal.") do |text|
+      options[:text] = text
+    end
+    opts.on("-k", "--key=key",
+      "Specify the key that will be used for shuffling the deck.",
+      "Default: Use an unshuffled deck.") do |key|
+      options[:keystream] = Solitaire::KeyStream.new(key)
+    end
+    opts.on("-R", "--random-key length", Integer,
+      "Use a randomly generated key for shuffling the deck.",
+      "The key length can be specified. It defaults to 80.",
+      "The key will be printed to the first line of STDOUT.") do |width|
+      options[:keylength] = width if width
+      options[:keystream] = :random
+    end
+    opts.on("-W", "--word-key file",
+      "Use a randomly generated key phrase.",
+      "It will consist of random words in the specified file.",
+      "The key length can be specified via the -R option.",
+      "The key phrase and the key will be printed to STDOUT.") do |word_file|
+      options[:keystream] = :random_words
+      options[:word_file] = word_file
+    end   
+
+    opts.separator ""
+
+    opts.on("-h", "--help",
+      "Show this help message.") do
+      puts opts; exit
+    end
+
+    opts.parse!
+  end
+
+  input = options[:text] || STDIN.read
+
+  options[:mode] = :decrypt if /\A(?:[A-Z]{5}\s*)+\Z/.match(input)
+
+  case options[:keystream]
+    when :random then
+      key = Array.new(options[:keylength]) { Solitaire::Letters[rand(26)] }.join
+
+      puts "Key: " + Solitaire.pretty(key)
+      options[:keystream] = Solitaire::KeyStream.new(key)
+    when :random_words then
+      begin
+        words = File.read(options[:word_file]).scan(/\w+/)
+      rescue
+        STDERR.puts "Word file doesn't exist or can't be read."
+        exit -1
+      end
+
+      words_size = words.size
+
+      min_words = options[:keylength] / 6
+      if words_size < min_words
+        STDERR.puts "Word file must contain at least #{min_words} words," +
+          " but it contains only #{words_size} words!"
+        exit -2
+      end
+
+      key = []
+      until key.join("").length >= options[:keylength]
+        key << words[rand(words_size)]
+      end
+      key = key.join(" ")
+
+      puts "Keyphrase: " + key
+      puts "Key: " + Solitaire.pretty(key)
+      options[:keystream] = Solitaire::KeyStream.new(key)
+  end
+
+  if options[:mode] == :decrypt
+    puts Solitaire.decrypt(input, options[:keystream])
+  else
+    unless options[:keystream]
+      STDERR.puts "WARNING: Using an unshuffled deck for encrypting!"
+    end
+    puts Solitaire.encrypt(input, options[:keystream])
+  end
+end