rubyzip 0.9.1 → 2.3.2

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

data/lib/quiz1/t/solutions/Glen M. Lewis/solitaire.rb

@@ -1,268 +0,0 @@
-#!/usr/bin/env ruby
-# Solitaire Cipher
-# Ruby-lang quiz #1
-# Solution by Glenn M. Lewis - 9/27/04
-
-$debug = nil
-
-class Card
-  attr_reader :value, :face_value, :suit
-
-  def initialize(face_value, suit)
-    @face_value = face_value
-    @suit = suit
-    if suit then
-      @value = calc_value(face_value, suit)
-      return
-    end
-    case face_value
-    when "AJoker"
-      @value = 53
-    when "BJoker"
-      @value = 53
-    else
-      puts "ERROR: Unknown joker: #{joker}, should be 'AJoker' or 'BJoker'"
-      exit
-    end
-  end
-
-  def calc_value(face_value, suit)
-    val = 0
-    case suit
-    when "S" then val += 39
-    when "H" then val += 26
-    when "D" then val += 13
-    when "C"
-    else
-      puts "ERROR: Unknown suit: #{suit}, should be C,D,H,S"
-    end
-    case face_value
-    when 2..10 then val += face_value
-    when "A" then val += 1
-    when "J" then val += 11
-    when "Q" then val += 12
-    when "K" then val += 13
-    else
-      puts "ERROR: Unknown card face value: #{face_value}, should be A,2-10,J,Q,K"
-    end
-    return val
-  end
-end
-
-class Deck < Array
-  def initialize
-    ["C", "D", "H", "S"].each do |suit|
-      ["A", 2, 3, 4, 5, 6, 7, 8, 9, 10, "J", "Q", "K"].each do |face_value|
-	self.push(Card.new(face_value, suit))
-      end
-    end
-    self.push(Card.new("AJoker", nil))
-    self.push(Card.new("BJoker", nil))
-    @deck_size = self.size
-  end
-
-  def dump
-    self.each do |c|
-      if (c.value == 53)
-        print c.face_value
-      else
-	print c.value
-      end
-      print " "
-    end
-    print "\n\n"
-    if (@deck_size != self.size) then
-      puts "ERROR!  Deck size changed to #{self.size}"
-      exit
-    end
-  end
-
-  def find_joker(j)
-    self.each_index do |i|
-      if (self[i].face_value == j)
-	return i
-      end
-    end
-    puts "ERROR: Could not find joker '#{j}' in deck."
-  end
-
-  def move_card_down(pos, num)
-    print "before move_card_down(#{pos}, #{num}): " if $debug
-    self.dump if $debug
-    dest = pos + num
-    dest -= (self.size-1) if (dest >= self.size)
-    card = self.delete_at(pos)
-    temp = self.dup
-    self.clear
-    temp.slice(0, dest).each {|x| self.push(x) }
-    self << card
-    temp.slice(dest..(-1)).each {|x| self.push(x) }
-    print "after move_card_down(#{pos}, #{num}): " if $debug
-    self.dump if $debug
-  end
-
-  def triple_cut_split(a, b)
-    a,b=b,a if (a > b)
-    print "before triple_cut_split(#{a}, #{b}): " if $debug
-    self.dump if $debug
-    temp = self.dup
-    self.clear
-    temp.slice((b+1)..-1).each {|x| self.push(x) }
-    temp.slice(a..b).each {|x| self.push(x) }
-    temp.slice(0..(a-1)).each {|x| self.push(x) }
-    print "after triple_cut_split(#{a}, #{b}): " if $debug
-    self.dump if $debug
-  end
-
-  def count_cut
-    print "before count_cut: " if $debug
-    self.dump if $debug
-    temp = self.dup
-    self.clear
-    num = temp[-1].value
-    temp.slice(num..-2).each {|x| self.push(x) }
-    temp.slice(0..(num-1)).each {|x| self.push(x) }
-    self.push(temp[-1])
-    print "after count_cut: " if $debug
-    self.dump if $debug
-  end
-
-  def output_letter
-    num = self[0].value
-    card = self[num]
-    return nil if (card.value == 53)
-    num = (card.value > 26 ? card.value-26 : card.value)
-    char = (num-1 + "A"[0]).chr
-    puts "card.value=#{card.value}, char=#{char}" if $debug
-    return char
-  end
-
-  def keystream_message(msg)
-    # result = "DWJXHYRFDGTMSHPUURXJ"
-    result = ""
-    while (result.length < msg.length) do
-      # Step 2 - Move the A Joker down one card
-      pos = find_joker("AJoker")
-      move_card_down(pos, 1)
-      # Step 3 - Move the B Joker down two cards
-      pos = find_joker("BJoker")
-      move_card_down(pos, 2)
-      # Step 4 - Triple cut split around two jokers
-      apos = find_joker("AJoker")
-      bpos = find_joker("BJoker")
-      triple_cut_split(apos, bpos)
-      # Step 5 - Count cut
-      count_cut
-      # Step 6 - Output letter - might be nil
-      letter = output_letter
-      result << letter if letter
-    end
-    return result
-  end
-end
-
-message = ARGV[0].dup
-
-encrypted = true
-encrypted = false if (message =~ /[a-z]/)
-words = message.split(/\s+/)
-words.each do |word|
-  encrypted = false if (word.length != 5)
-  encrypted = false if (word =~ /[^A-Z]/)
-end
-
-def message2nums(msg)
-  result = []
-  msg.each_byte do |c|
-    result.push(c+1-"A"[0])
-  end
-  return result
-end
-
-def nums2message(nums)
-  result = ""
-  nums.each do |val|
-    result << (val-1+"A"[0]).chr
-  end
-  return result
-end
-
-deck = Deck.new
-
-if encrypted then
-  puts "Encrypted message: '#{message}'"
-  message.gsub!(/[^A-Z]/, '')
-
-  # Step 1
-  keystream_message = deck.keystream_message(message)
-  # puts "keystream_message = #{keystream_message}"
-
-  # Step 2
-  num_message = message2nums(message)
-  # puts "num_message = "
-  # p num_message
-
-  # Step 3
-  num_keystream = message2nums(keystream_message)
-  # puts "num_keystream = "
-  # p num_keystream
-
-  # Step 4
-  num_result = []
-  num_message.each_index do |index|
-    num_result[index] = num_message[index] - num_keystream[index]
-    num_result[index] += 26 if (num_result[index] < 1)
-  end
-
-  # Step 6
-  result = nums2message(num_result)
-  print "Unencrypted message: "
-  count = 0
-  result.each_byte do |c|
-    print c.chr
-    count += 1
-    print " " if ((count % 5) == 0)
-  end
-  print "\n"
-
-else
-  puts "Unencrypted message: '#{message}'"
-
-  # Step 1
-  message.upcase!
-  message.gsub!(/[^A-Z]/, '')
-  message << "X" * ((message.length % 5)==0 ? 0 : (5-(message.length % 5)))
-  # puts "message: #{message}"
-
-  # Step 2
-  keystream_message = deck.keystream_message(message)
-  # puts "keystream_message = #{keystream_message}"
-
-  # Step 3
-  num_message = message2nums(message)
-  # puts "num_message = "
-  # p num_message
-
-  # Step 4
-  num_keystream = message2nums(keystream_message)
-  # puts "num_keystream = "
-  # p num_keystream
-
-  # Step 5
-  num_result = []
-  num_message.each_index do |index|
-    num_result[index] = num_message[index] + num_keystream[index]
-    num_result[index] -= 26 if (num_result[index] > 26)
-  end
-
-  # Step 6
-  result = nums2message(num_result)
-  print "Encrypted message: "
-  count = 0
-  result.each_byte do |c|
-    print c.chr
-    count += 1
-    print " " if ((count % 5) == 0)
-  end
-  print "\n"
-end