rubyzip 0.9.1 → 2.3.2

data/lib/quiz1/t/solutions/Jim Menard/solitaire_cypher.rb

@@ -1,204 +0,0 @@
-#! /usr/bin/env ruby
-
-RANKS = %w(A 2 3 4 5 6 7 8 9 10 J Q K)
-SUITS = %w(C D H S)
-JOKER_RANK = 'joker'
-JOKER_VALUE = -1
-
-class Card
-    def Card.value_to_chr(value)
-	i = value
-	i -= 26 while i > 26
-	(i + ?A - 1).chr
-    end
-    def Card.chr_to_value(chr)
-	i = chr[0] - ?A + 1
-	i += 26 while i < 0
-	i
-    end
-
-    def initialize(rank, suit)
-	@rank = rank
-	@suit = suit
-	if rank == JOKER_RANK
-	    @value = JOKER_VALUE
-	else
-	    @value = (SUITS.index(suit) * 13) + RANKS.index(rank) + 1
-	end
-    end
-
-    def to_s
-# 	return @value.to_s if @value != JOKER_VALUE
-# 	return @suit.to_s
- 	"#{@rank}#{@suit} #{@value.to_s}"
-    end
-
-    def to_i
-	@value
-    end
-
-    def chr
-	Card.value_to_chr(@value)
-    end
-end
-
-class Deck
-
-    def initialize
-	@cards = []
-	SUITS.each { | suit |
-	    RANKS.each { | rank | @cards << Card.new(rank, suit) }
-	}
-	@joker_a = Card.new(JOKER_RANK, 'A')
-	@cards << @joker_a
-	@joker_b = Card.new(JOKER_RANK, 'B')
-	@cards << @joker_b
-    end
-
-    # Keys the deck and returns itself.
-    def key
-	# do nothing; keyed when initialized
-	self
-    end
-
-    # Return the next kestream value as a number (not a string).
-    # Keep going until we have a non-joker value.
-    def next_keystream
-	val = JOKER_VALUE
-	until val != JOKER_VALUE
-	    val = generate_next_keystream_value
-	end
-	val
-    end
-
-    # Return the next keystream value as a number 1-26 (not a string).
-    def generate_next_keystream_value
-	move(@joker_a, 1)
-	move(@joker_b, 2)
-	triple_cut()
-	count_cut()
-	return output_number()
-    end
-
-    # Move a card a certain distance. Wrap around the end of the deck.
-    def move(card, distance)
-	old_pos = @cards.index(card)
-	new_pos = old_pos + distance
-	new_pos -= (@cards.length-1) if new_pos >= @cards.length
-	@cards[old_pos,1] = []
-	@cards[new_pos,0] = [card]
-    end
-
-    # Perform a triple cut around the two jokers. All cards above the top
-    # joker move to below the bottom joker and vice versa. The jokers and the
-    # cards between them do not move.
-    def triple_cut
-	i = @cards.index(@joker_a)
-	j = @cards.index(@joker_b)
-	j, i = i, j if j < i	# make sure i < j
-	@cards = slice(j+1, -1) + slice(i, j) + slice(0, i-1)
-    end
-
-    # Perform a count cut using the value of the bottom card. Cut the bottom
-    # card's value in cards off the top of the deck and reinsert them just
-    # above the bottom card.
-    def count_cut
-	i = @cards[@cards.length - 1].to_i
-	@cards = slice(i, -2) + slice(0, i-1) + [@cards[@cards.length-1]]
-    end
-
-    # Returns a non-nil cut of cards from the deck.
-    def slice(from, to)
-	slice = @cards[from..to]
-	return slice || []
-    end
-
-    # Return the output number (not letter). Convert the top card to it's
-    # value and count down that many cards from the top of the deck, with the
-    # top card itself being card number one. Look at the card immediately
-    # after your count and convert it to a letter. This is the next letter in
-    # the keystream. If the output card is a joker, no letter is generated
-    # this sequence. This step does not alter the deck.
-    def output_number
-	i = @cards[0].to_i
-	i -= @cards.length if i >= @cards.length
-	num = @cards[i].to_i
-	num -= 26 if num > 26
-	num
-    end
-
-    def to_s
-	@cards.join(' ')
-    end
-end
-
-class CryptKeeper
-
-    def initialize(deck)
-	@keyed_deck = deck
-    end
-
-    def decrypt(str)
-	@deck = @keyed_deck.dup
-	answer = ""
-	str.split(//).each { | c |
-	    if c == ' '
-		answer << ' '
-		next
-	    end
-
-	    msg_num = Card.chr_to_value(c)
-	    key = @deck.next_keystream
-	    diff = msg_num - key
-	    diff += 26 if diff < 1
-	    answer << Card.value_to_chr(diff)
-	}
-	answer
-    end
-
-    def encrypt(str)
-	@deck = @keyed_deck.dup
-	answer = ''
-	str.split(//).each { | c |
-	    if c == ' '
-		answer << ' '
-		next
-	    end
-
-	    msg_num = Card.chr_to_value(c)
-	    key = @deck.next_keystream
-	    sum = msg_num + key
-	    sum -= 26 if sum > 26
-	    answer << Card.value_to_chr(sum)
-	}
-	answer
-    end
-
-    def crypto_each(str)
-	@deck = @keyed_deck.dup
-	str.split(//).each { | c | yield c }
-    end
-
-end
-
-def prep_arg(str)
-    str = str.upcase.gsub(/[^A-Z]/, '')
-    words = []
-    while str.length > 0
-	words << str[0...5]
-	str[0...5] = ''
-    end
-
-    last_len = words[words.length-1].length
-    words[words.length-1] += ('X' * (5 - last_len)) if last_len < 5
-    words.join(' ')
-end
-
-if __FILE__ == $0
-    if ARGV[0]
-	puts CryptKeeper.new(Deck.new.key).decrypt(prep_arg(ARGV[0]))
-    else
-	puts CryptKeeper.new(Deck.new.key).decrypt('CLEPK HHNIY CFPWH FDFEH')
-	puts CryptKeeper.new(Deck.new.key).decrypt('ABVAW LWZSY OORYK DUPVH')
-    end
-end

data/lib/quiz1/t/solutions/Jim Menard/test.rb

@@ -1,47 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'test/unit.rb'
-require 'test/unit/ui/console/testrunner'
-require 'solitaire_cypher.rb'
-
-class SolitaireCypherTest < Test::Unit::TestCase
-
-    KNOWN_PLAINTEXT = 'CODEI NRUBY LIVEL ONGER'
-    KNOWN_CYPHER = 'GLNCQ MJAFF FVOMB JIYCB'
-
-    def setup
-	@deck = Deck.new.key
-	@crypt_keeper = CryptKeeper.new(@deck)
-    end
-
-    def test_value_to_chr
-	assert_equal('A', Card.value_to_chr(1))
-	assert_equal('Z', Card.value_to_chr(26))
-    end
-
-    def test_chr_to_value
-	assert_equal(1, Card.chr_to_value("A"))
-	assert_equal(26, Card.chr_to_value("Z"))
-    end
-
-    def test_keystream
-	expected = %w(D W J X H Y R F D G)
-	deck = Deck.new.key
-	expected.each { | exp |
-	    key = deck.next_keystream
-	    if exp != Card.value_to_chr(key)
-		@errors << "expected #{exp}, key = #{Card.value_to_chr(key)}"
-	    end
-	}
-    end
-
-    def test_decrypt_known_cypher
-	assert_equal(KNOWN_PLAINTEXT, @crypt_keeper.decrypt(KNOWN_CYPHER))
-    end
-
-    def test_encrypt_known_message
-	assert_equal(KNOWN_CYPHER, @crypt_keeper.encrypt(KNOWN_PLAINTEXT))
-    end
-end
-
-Test::Unit::UI::Console::TestRunner.run(SolitaireCypherTest)

data/lib/quiz1/t/solutions/Moses Hohman/cipher.rb

@@ -1,97 +0,0 @@
-#!/usr/bin/env ruby
-require 'util'
-require 'deck'
-
-module Solitaire
-	ASCII_OFFSET = 64
-	ALPHABET_SIZE = 26
-		
-	class Chunker
-		CHUNK_SIZE = 5
-
-		def initialize(text)
-			@legal_chars_only = text.gsub(/[^A-Za-z]/, "").upcase
-			@legal_chars_only <<= "X" * (-@legal_chars_only.size % CHUNK_SIZE)
-			raise "Nothing to chunk (non-alphabet characters removed): #{text}" if @legal_chars_only.size==0
-			@chunks = []
-			@number_chunks = []
-		end
-
-		def chunks
-			@chunks if @chunks.size > 0
-			@chunks = @legal_chars_only.gsub(/(.{#{CHUNK_SIZE}})/, '\1 ').rstrip.split(" ")
-		end
-
-		def number_chunks
-			@number_chunks if @number_chunks.size > 0
-			chunks.collect { |chunk| chunk.split("").collect { |char_string| char_string[0]-ASCII_OFFSET } }
-		end
-
-		def Chunker.to_letters(number_chunks)
-			number_chunks.collect { |chunk| chunk.collect { |num| (num+ASCII_OFFSET).chr }.join }
-		end
-	end
-
-	class Keystream
-		A_JOKER = Card.joker(?A)
-		B_JOKER = Card.joker(?B)
-
-		def initialize(deck=Deck.new)
-			@deck = deck
-		end
-
-		def keystream_letters(chunks)
-			chunks.collect { |chunk| (1..chunk.size).collect { next_keystream_letter }.join }
-		end
-
-		def Keystream.card_to_letter(card)
-			return "" if card.is_joker?
-			(card.value.offset_mod(ALPHABET_SIZE)+ASCII_OFFSET).chr
-		end
-
-		private
-
-		def next_keystream_letter
-			process_deck
-			top_card = @deck[0]
-			keystream_card = @deck[top_card.value]
-			letter = Keystream.card_to_letter(keystream_card)
-			letter = next_keystream_letter if letter==""
-			letter
-		end
-
-		def process_deck
-			@deck.move_card!(A_JOKER, +1)
-			@deck.move_card!(B_JOKER, +2)
-			@deck.triple_cut!([A_JOKER, B_JOKER])
-			@deck.count_cut!
-		end
-	end
-
-	class Cipher
-		ENCRYPTED_TEXT_PATTERN = /\A[A-Z]{5}( [A-Z]{5})*\Z/
-
-		def initialize(text, deck=Deck.new)
-			@chunker = Chunker.new(text)
-			keystream = Keystream.new(deck)
-			@keystream_chunker = Chunker.new(keystream.keystream_letters(@chunker.chunks).join)
-			if text =~ ENCRYPTED_TEXT_PATTERN
-				@mode = "decrypt"
-				@calc_number = proc { |num, keystream_num| num - keystream_num }
-			else
-				@mode = "encrypt"
-				@calc_number = proc { |num, keystream_num| num + keystream_num }
-			end
-		end
-		attr_reader :mode
-
-		def crypt
-			ciphered = [@chunker.number_chunks, @keystream_chunker.number_chunks].collect_peel do |num_chunk, keystream_num_chunk|
-				[num_chunk, keystream_num_chunk].collect_peel do |num, keystream_num|
-					@calc_number.call(num,keystream_num).offset_mod(ALPHABET_SIZE)
-				end
-			end
-			Chunker.to_letters(ciphered).join(" ").rstrip
-		end
-	end
-end

data/lib/quiz1/t/solutions/Moses Hohman/deck.rb

@@ -1,140 +0,0 @@
-require 'util'
-
-module Solitaire
-	class Deck
-		NUM_CARDS = 54
-
-		def initialize(order=nil)
-			if order.nil?
-				@order = Array.new(NUM_CARDS) { |x| x+1 }
-			else
-				@order = order.collect { |val| val.instance_of?(Range) ? val.to_a : val }.flatten
-				@order.collect! { |val| Card.parse(val).code }
-			end
-		end
-		attr_reader :order
-		protected :order
-
-		def [](index)
-			Card.parse(@order[index])
-		end
-
-		def move_card!(card, offset)
-			current_index = @order.index(card.code)
-			new_index = current_index+offset
-			if new_index >= NUM_CARDS
-				new_index -= NUM_CARDS - 1
-			elsif new_index < 0
-				new_index += NUM_CARDS - 1
-			end
-			@order.delete_at(current_index)
-			@order.insert(new_index, card.code)
-		end
-
-		def triple_cut!(cards)
-			raise "exactly two cards required for triple cut: #{cards}" unless cards.size==2 
-			indices = [@order.index(cards[0].code), @order.index(cards[1].code)].sort
-			@order = @order[(indices[1]+1)..@order.size] + @order[indices[0]..indices[1]] + @order[0..(indices[0]-1)]
-		end
-
-		def count_cut!
-			num_moved = Card.parse(@order.last).value
-			if num_moved!=53
-				@order = @order[num_moved, NUM_CARDS - num_moved - 1] + @order[0..(num_moved-1)] + [@order.last]
-			end
-			self
-		end
-
-		def to_s
-			"<Deck: #{@order.inspect}>"
-		end
-		
-		def ==(val)
-			@order == val.order
-		end
-	end
-
-	class Card
-		ACE = 1
-		JACK = 11
-		QUEEN = 12
-		KING = 13
-
-		def initialize(suit, value)
-			@code = suit.value + value
-		end
-		attr_reader :code
-		alias_method :value, :code
-
-		def Card.parse(code)
-			if (1..52).member?(code)
-				Card.new(Suit.by_value(code), code.offset_mod(13)) 
-			elsif (53..54).member?(code)
-				Card.joker(code+12)
-			elsif (65..66).member?(code)
-				Card.joker(code)
-			elsif code =~ /\A[AB]\Z/
-				Card.joker(code[0])
-			else
-				raise "Illegal class or value for parameter value, #{code.class} #{code.inspect}"
-			end
-		end
-
-		def Card.joker(char)
-			JokerCard.new(char.chr)
-		end
-
-		def is_joker?
-			false
-		end
-
-		def ==(other)
-			code==other.code
-		end
-
-		def <=>(other)
-			code<=>other.code
-		end
-
-		def to_s
-			"Card: #{@code}"
-		end
-	end
-
-	class JokerCard < Card
-		JOKER_VALUE = 53
-
-		def initialize(which_one)
-			raise "No such joker: #{which_one}" unless which_one =~ /\A[AB]\Z/
-			@code = 52 + (which_one[0].to_i-64)
-		end
-
-		def is_joker?
-			true
-		end
-
-		def value
-			JOKER_VALUE
-		end
-	end
-
-	class Suit
-		@@byValue = {}
-
-		def Suit.by_value(val)
-			@@byValue[(val-1)/13*13]
-		end
-
-		def initialize(name, value)
-			@name = name
-			@value = value
-			@@byValue[value] = self
-		end
-		attr_reader :name, :value
-
-		CLUBS = Suit.new("clubs", 0)
-		DIAMONDS = Suit.new("diamonds", 13)
-		HEARTS = Suit.new("hearts", 26)
-		SPADES = Suit.new("spades", 39)
-	end
-end

data/lib/quiz1/t/solutions/Moses Hohman/solitaire.rb

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-require 'cipher'
-require 'yaml'
-
-module Solitaire
-	text = ARGV.join(" ")
-	if FileTest::readable?("deck.yaml")
-		deck = Deck.new(YAML::load(File.open("deck.yaml")))
-	else
-		deck = Deck.new
-	end
-	cipher = Cipher.new(text, deck)
-	puts "#{cipher.mode}ed: #{cipher.crypt}"
-end

data/lib/quiz1/t/solutions/Moses Hohman/test_cipher.rb

@@ -1,68 +0,0 @@
-#!/usr/bin/env ruby
-require 'test/unit'
-require 'cipher'
-
-module Solitaire
-	class TestChunker < Test::Unit::TestCase
-		def test_chunks
-			chunker = Chunker.new("Code in Ruby, live longer!")
-			assert_equal(["CODEI","NRUBY","LIVEL","ONGER"], chunker.chunks)
-		end
-
-		def test_pads_with_Xs
-			chunker = Chunker.new("sty")
-			assert_equal(["STYXX"], chunker.chunks)
-		end
-
-		def test_number_chunks
-			chunker = Chunker.new("Code in Ruby, live longer!")
-			assert_equal([[3,15,4,5,9], [14,18,21,2,25], [12,9,22,5,12], [15,14,7,5,18]], chunker.number_chunks)
-		end
-
-		def test_to_letters
-			assert_equal(["CODEI","NRUBY","LIVEL","ONGER"],
-				Chunker.to_letters([[3,15,4,5,9], [14,18,21,2,25], [12,9,22,5,12], [15,14,7,5,18]]))
-		end
-	end
-
-	class TestKeystream < Test::Unit::TestCase
-		def setup
-			@keystream = Keystream.new
-		end
-
-		def test_keystream_letters
-			chunker = Chunker.new("Code in Ruby, live longer!")
-			assert_equal(["DWJXH","YRFDG","TMSHP","UURXJ"], @keystream.keystream_letters(chunker.chunks))
-		end
-
-		def test_card_to_letter
-			assert_equal("", Keystream.card_to_letter(Card.joker(?A)), "A joker")
-			assert_equal("", Keystream.card_to_letter(Card.joker(?B)), "B joker")
-			assert_equal("A", Keystream.card_to_letter(Card.new(Suit::CLUBS, Card::ACE)), "AC")
-			assert_equal("Z", Keystream.card_to_letter(Card.new(Suit::DIAMONDS, Card::KING)), "KD")
-			assert_equal("A", Keystream.card_to_letter(Card.new(Suit::HEARTS, Card::ACE)), "AH")
-			assert_equal("Z", Keystream.card_to_letter(Card.new(Suit::SPADES, Card::KING)), "KS")
-		end
-	end
-
-	class TestCipher < Test::Unit::TestCase
-		def test_encrypt
-			cipher = Cipher.new("Code in Ruby, live longer!")
-			assert_equal("encrypt", cipher.mode)
-			assert_equal("GLNCQ MJAFF FVOMB JIYCB", cipher.crypt)
-		end
-
-		def test_decrypt
-			cipher = Cipher.new("GLNCQ MJAFF FVOMB JIYCB")
-			assert_equal("decrypt", cipher.mode)
-			assert_equal("CODEI NRUBY LIVEL ONGER", cipher.crypt)
-		end
-
-		def test_crypt_idempotent
-			cipher = Cipher.new("GLNCQ MJAFF FVOMB JIYCB")
-			assert_equal("decrypt", cipher.mode)
-			assert_equal("CODEI NRUBY LIVEL ONGER", cipher.crypt)
-			assert_equal("CODEI NRUBY LIVEL ONGER", cipher.crypt)
-		end
-	end
-end

data/lib/quiz1/t/solutions/Moses Hohman/test_deck.rb

@@ -1,146 +0,0 @@
-#!/usr/bin/env ruby
-require 'test/unit'
-require 'deck'
-
-module Solitaire
-	class TestDeck < Test::Unit::TestCase
-		def test_constructor_accepts_ranges_in_array
-			assert_equal(Deck.new, Deck.new([1, 2, 3, 4..52, 53..54]))
-		end
-
-		def test_construcor_accepts_chars_for_jokers
-			assert_equal(Deck.new, Deck.new((1..52).to_a + [?A, ?B]))
-		end
-
-		def test_move_card_lower
-			deck = Deck.new
-			deck.move_card!(Card.new(Suit::DIAMONDS, 6), +5)
-			assert_equal(Deck.new([1..18,20..24,19,25..54]).to_s, deck.to_s)
-		end
-
-		def test_move_card_one_lower
-			deck = Deck.new
-			deck.move_card!(Card.new(Suit::DIAMONDS, 6), +1)
-			assert_equal(Deck.new([1..18,20,19,21..54]).to_s, deck.to_s)
-		end
-
-		def test_move_card_higher
-			deck = Deck.new
-			deck.move_card!(Card.new(Suit::DIAMONDS, 6), -5)
-			assert_equal(Deck.new([1..13,19,14..18,20..54]), deck)
-		end
-
-		def test_move_card_is_cyclic_plus_1
-			deck = Deck.new
-			deck.move_card!(Card.joker(?A), +2)
-			assert_equal(Deck.new([1,53,2..52,54]), deck)
-		end
-
-		def test_move_card_to_end
-			deck = Deck.new
-			deck.move_card!(Card.joker(?A), +1)
-			assert_equal(Deck.new([1..52,54,53]), deck)
-		end
-
-		def test_move_card_to_one_before_end
-			deck = Deck.new([2..54,1])
-			deck.move_card!(Card.joker(?A), +1)
-			assert_equal(Deck.new([2..52,54,53,1]).to_s, deck.to_s)
-		end
-
-		def test_move_card_to_beginning
-			deck = Deck.new
-			deck.move_card!(Card.new(Suit::CLUBS, 2), -1)
-			assert_equal(Deck.new([2,1,3..54]), deck)
-		end
-
-		def test_move_card_is_cyclic_pass_end_forward
-			deck = Deck.new
-			deck.move_card!(Card.joker(?B), +1)
-			assert_equal(Deck.new([1,54,2..53]), deck)
-		end
-
-		def test_move_card_is_cyclic_pass_end_backward
-			deck = Deck.new
-			deck.move_card!(Card.new(Suit::CLUBS, Card::ACE), -1)
-			assert_equal(Deck.new([2..53,1,54]), deck)
-		end
-
-		def test_move_card_cyclic_backward_five
-			deck = Deck.new
-			deck.move_card!(Card.new(Suit::CLUBS, 5), -5)
-			assert_equal(Deck.new([1..4,6..53,5,54]), deck)
-		end
-
-		def test_triple_cut
-			deck = Deck.new
-			deck.triple_cut!([Card.new(Suit::CLUBS, Card::JACK), Card.new(Suit::HEARTS, Card::KING)])
-			assert_equal(Deck.new([40..54,11..39,1..10]), deck)
-		end
-
-		def test_triple_cut_with_empty_side
-			deck = Deck.new([2..53,1,54])
-			deck.triple_cut!([Card.joker(?A), Card.joker(?B)])
-			assert_equal(Deck.new([53,1,54,2..52]), deck)
-		end
-
-		def test_count_cut
-			deck = Deck.new
-			deck.move_card!(Card.new(Suit::CLUBS, 5), 49)
-			deck.count_cut!
-			assert_equal(Deck.new([7..54,1..4,6,5]), deck)
-		end
-	end
-
-	class TestCard < Test::Unit::TestCase
-		def test_parse_joker_string
-			assert_equal(Card.joker(?A), Card.parse("A"))
-		end
-
-		def test_parse_joker_char
-			assert_equal(Card.joker(?A), Card.parse(?A))
-		end
-
-		def test_parse_normal_card
-			assert_equal(Card.new(Suit::CLUBS, 5), Card.parse(5))
-		end
-
-		def test_value
-			assert_equal(1, Card.new(Suit::CLUBS, Card::ACE).value, "AC")
-			assert_equal(7, Card.new(Suit::CLUBS, 7).value, "7C")
-			assert_equal(11, Card.new(Suit::CLUBS, Card::JACK).value, "JC")
-			assert_equal(13, Card.new(Suit::CLUBS, Card::KING).value, "KC")
-			assert_equal(14, Card.new(Suit::DIAMONDS, Card::ACE).value, "AD")
-			assert_equal(26, Card.new(Suit::DIAMONDS, Card::KING).value, "KD")
-			assert_equal(29, Card.new(Suit::HEARTS, 3).value, "3H")
-			assert_equal(39, Card.new(Suit::HEARTS, Card::KING).value, "KH")
-			assert_equal(40, Card.new(Suit::SPADES, Card::ACE).value, "AS")
-			assert_equal(52, Card.new(Suit::SPADES, Card::KING).value, "KS")
-			assert_equal(53, Card.joker(?A).value, "A Joker")
-			assert_equal(53, Card.joker(?B).value, "B Joker")
-		end
-
-		def test_is_joker_when_joker
-			assert(Card.joker(?A).is_joker?, "A joker not joker")
-			assert(Card.joker(?B).is_joker?, "B joker not joker")
-		end
-
-		def test_is_joker_when_not_joker
-			assert(!Card.new(Suit::SPADES, 7).is_joker?)
-		end
-	end
-
-	class TestSuit < Test::Unit::TestCase
-		def test_by_value_clubs
-			assert_equal("clubs", Suit.by_value(1).name)
-		end
-
-		def test_by_value_hearts
-			assert_equal("hearts", Suit.by_value(27).name)
-		end
-
-		def test_hearts
-			assert_equal("hearts", Suit::HEARTS.name)
-		end
-	end
-end