rubyzip 0.9.1 → 0.9.4

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

@@ -1,111 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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

@@ -1,301 +0,0 @@
-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