rubyzip 0.9.1 → 0.9.4

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

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

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

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

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