rubyzip 0.5.12 → 0.9.1

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

@@ -0,0 +1,268 @@
+#!/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

data/lib/quiz1/t/solutions/James Edward Gray II/solitaire.rb

@@ -0,0 +1,132 @@
+#!/usr/bin/ruby -w
+
+$deck = (1..52).to_a + ["A", "B"]		# Unkeyed deck - Keystream Step 1
+
+def encrypt(message)
+	# Step 1
+	message = message.upcase.tr("^A-Z", "")
+	i = 5
+	while i < message.size
+		message[i, 0] = " "
+		i += 6
+	end
+	message += "X" while message.rindex(" ") != message.size - 6
+	
+	# Step 2
+	key_stream = generate(message.count("^ "))
+	
+	# Step 3
+	values = message.split("").map { |letter| letter[0] - ?A + 1 }
+
+	# Step 4
+	key_values = key_stream.split("").map { |letter| letter[0] - ?A + 1 }
+	
+	# Step 5
+	values.each_with_index do |value, index|
+		next if value < 0
+		values[index] = value + key_values[index]
+		values[index] -= 26 if values[index] > 26
+	end
+	
+	# Step 6
+	message = (values.map { |number| (number - 1 + ?A).chr }).join("")
+	
+	return message
+end
+
+def decrypt(message)
+	# Step 1
+	key_stream = generate(message.size)
+	
+	# Step 2
+	values = message.split("").map { |letter| letter[0] - ?A + 1 }
+
+	# Step 3
+	key_values = key_stream.split("").map { |letter| letter[0] - ?A + 1 }
+	
+	# Step 4
+	values.each_with_index do |value, index|
+		next if value < 0
+		if value <= key_values[index]
+			values[index] = value + 26 - key_values[index]
+		else
+			values[index] = value - key_values[index]
+		end
+	end
+	
+	# Step 5
+	message = (values.map { |number| (number - 1 + ?A).chr }).join("")
+	
+	return message
+end
+
+def generate(count)		# Keystream Steps
+	key_stream = [ ]
+
+	until key_stream.size == count
+		# Step 2
+		a = $deck.index("A")
+		if a == 53
+			$deck.insert(1, $deck.pop)
+		else
+			$deck.insert(a + 1, $deck.delete_at(a))
+		end
+
+		# Step 3
+		b = $deck.index("B")
+		if b == 53
+			$deck.insert(2, $deck.pop)
+		elsif b == 52
+			$deck.insert(1, $deck.delete_at(b))
+		else
+			$deck.insert(b + 2, $deck.delete_at(b))
+		end
+
+		# Step 4
+		a = $deck.index("A")
+		b = $deck.index("B")
+		top = [a, b].min
+		bottom = [a, b].max
+		$deck = $deck.values_at((bottom + 1)..53, top..bottom, 0...top)
+
+		# Step 5
+		if $deck[53].kind_of? Integer
+			$deck = $deck.values_at($deck[53]..52, 0...$deck[53], 53)
+		end
+
+		# Step 5
+		if $deck[0].kind_of? Integer
+			if $deck[$deck[0]].kind_of? Integer
+				key_stream.push($deck[$deck[0]])
+			end
+		else
+			if $deck[53].kind_of? Integer
+				key_stream.push($deck[53])
+			end
+		end
+	end		# Step 7
+
+	key_stream.map! do |number|
+		if number > 26
+			(number - 26 - 1 + ?A).chr
+		else
+			(number - 1 + ?A).chr
+		end
+	end
+	key_stream = key_stream.join("")
+	i = 5
+	while i < key_stream.size
+		key_stream[i, 0] = " "
+		i += 6
+	end
+	return key_stream
+end
+
+# Mind reading interface
+if ARGV.size == 1 and ARGV[0] =~ /^(?:[A-Z]{5} )*[A-Z]{5}$/
+	puts decrypt(ARGV[0])
+elsif ARGV.size == 1
+	puts encrypt(ARGV[0])
+else
+	puts "Usage:  solitaire.rb MESSAGE"
+end

data/lib/quiz1/t/solutions/Jamis Buck/bin/main.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require 'copland'
+
+libdir = File.join( File.dirname( __FILE__ ), "..", "lib" )
+$: << libdir
+
+registry = Copland::Registry.build libdir, :log_device => STDOUT
+
+cli = registry.service( "solitaire.cipher.CLI" )
+cli.run
+
+registry.shutdown

data/lib/quiz1/t/solutions/Jamis Buck/lib/cipher.rb

@@ -0,0 +1,230 @@
+require 'optparse'
+
+class Deck
+
+  def initialize
+    @deck = (1..52).to_a + [ "A", "B" ]
+    @length = @deck.length
+  end
+
+  def cipher_shuffle!
+    # move joker A down one card, circularly
+    reposition_card( "A", 1 )
+
+    # move joker B down two cards, circularly
+    reposition_card( "B", 2 )
+
+    joker_A = @deck.index( "A" )
+    joker_B = @deck.index( "B" )
+
+    # move all cards above the top-most joker, below the bottom-most joker, and
+    # all cards below the bottom-most joker, above the top-most joker.
+    top    = ( joker_A < joker_B ? joker_A : joker_B )
+    bottom = ( joker_A > joker_B ? joker_A : joker_B )
+    @deck = @deck[bottom+1..-1] + @deck[top..bottom] + @deck[0,top]
+
+    # take value of the bottom-most card, and cut that many cards off the
+    # top, inserting them just before the bottom-most card.
+    cut = @deck.last
+    @deck = @deck[cut..-2] + @deck[0,cut] + [ @deck.last ]
+  end
+
+  def cipher_letter
+    count = @deck.first
+    count = 53 if count.is_a?( String )
+    result = @deck[ count ]
+    return nil unless result.is_a? Fixnum
+    result -= 26 while result > 26
+    return (result+64).chr
+  end
+
+  def to_a
+    @deck.dup
+  end
+
+  def cards=( deck )
+    @deck = deck
+    @length = @deck.length
+    raise "the deck must contain an 'A' joker" unless @deck.include?("A")
+    raise "the deck must contain a 'B' joker" unless @deck.include?("B")
+  end
+
+  def reposition_card( card, delta )
+    pos = @deck.index card
+    @deck.delete_at pos
+    new_pos = pos + delta
+    new_pos = 1 + new_pos % @length if new_pos >= @length
+    @deck.insert new_pos, card
+    new_pos
+  end
+  private :reposition_card
+
+end
+
+class KeyingAlgorithms
+
+  attr_writer :algorithms
+  attr_writer :registry
+
+  def get( name )
+    svc_name = @algorithms[ name ]
+    raise "No such algorithm #{name.inspect}" if svc_name.nil?
+
+    return @registry.service( svc_name )
+  end
+
+end
+
+class UnkeyedAlgorithm
+
+  def new_deck
+    Deck.new
+  end
+
+end
+
+class KeyStream
+
+  attr_writer :deck
+
+  def next
+    loop do
+      @deck.cipher_shuffle!
+      letter = @deck.cipher_letter
+      return letter if letter
+    end
+  end
+
+end
+
+class SolitaireCipher
+
+  attr_writer :algorithms
+  attr_writer :stream
+
+  def initialize( default_algorithm )
+    @algorithm = default_algorithm
+  end
+
+  def use_algorithm( keying_algorithm )
+    @algorithm = @algorithms.get( keying_algorithm )
+  end
+
+  def encrypt( message )
+    reset
+
+    chars = message.split(//).map { |c| c.upcase }. reject { |c| c !~ /[A-Z]/ }
+    chars.concat ["X"] * ( 5 - chars.length % 5 ) if chars.length % 5 > 0
+    chars.map! { |c| c[0] - 64 }
+    key = generate_key( chars.length )
+    code = chars.zip( key ).map { |c,k| ( c + k > 26 ? c + k - 26 : c + k ) }.map { |c| (c+64).chr }
+
+    msg = ""
+    (code.length/5).times do
+      msg << " " if msg.length > 0
+      5.times { msg << code.shift }
+    end
+
+    return msg
+  end
+
+  def decrypt( message )
+    raise "bad decrypt message: #{message.inspect}" if message =~ /[^A-Z ]/
+
+    reset
+    chars = message.split(//).reject { |c| c == " " }.map { |c| c[0] - 64 }
+    key = generate_key( chars.length )
+    chars.zip( key ).map { |c,k| ( k >= c ? c + 26 - k : c - k ) }.map { |c| (c+64).chr }.join
+  end
+
+  def generate_key( length )
+    key = []
+    length.times { key << @stream.next }
+    key.map { |c| c[0] - 64 }
+  end
+  private :generate_key
+
+  def reset
+    @stream.deck = @algorithm.new_deck
+  end
+  private :reset
+
+end
+
+class Options
+
+  attr_reader :strings
+  attr_reader :keying_algorithm
+
+  def initialize( argv = ARGV )
+    @named_options = Hash.new
+    @run_app = true
+    @keying_algorithm = "unkeyed"
+
+    OptionParser.new do |opts|
+      opts.banner = "Usage: #{$0} [options] [strings]"
+      opts.separator ""
+
+      opts.on( "-o", "--option NAME=VALUE",
+               "Specify a named value, for use by a component of the cipher."
+      ) do |pair|
+        name, value = pair.split( / *= */, 2 )
+        @named_options[ name ] = value
+      end
+
+      opts.on( "-k", "--key NAME", "Specify the keying algorithm to use" ) do |value|
+        @keying_algorithm = value
+      end
+
+      opts.separator ""
+
+      opts.on_tail( "-h", "--help", "This help text" ) do
+        puts opts
+        @run_app = false
+      end
+
+      opts.parse!( argv )
+    end
+
+    @strings = argv
+  end
+
+  def []( value )
+    @named_options[ value ]
+  end
+
+  def run_app?
+    @run_app
+  end
+
+end
+
+
+class BackwardsAlgorithm
+
+  def new_deck
+    deck = Deck.new
+    deck.cards = deck.to_a.reverse
+    deck
+  end
+
+end
+
+class ShuffleAlgorithm
+
+  attr_writer :options
+
+  def new_deck
+    deck = Deck.new
+    cards = deck.to_a
+
+    seed = ( @options[ "seed" ] || 0 ).to_i
+    srand seed
+
+    7.times { cards.sort! { rand(3)-1 } }
+    deck.cards = cards
+
+    return deck
+  end
+
+end