1  class Mixer
 2      private
 3      def randomize(str)
 4          return str if str.length < 4
 5
 6          str =~ /\B.*\B/
 7          first = $`
 8          last = $'
 9          first + ($&.split(//).sort_by {rand}.join) + last
10      end
11
12      public
13      def mix_file(filename)
14          lines = IO.readlines(filename)
15
16          mix_lines(lines)
17      end
18
19      def mix_string(str)
20          mix_lines(str.split).join(" ")
21      end
22
23      def mix_lines(lines)
24          lines.collect! do |line|
25              words = Array.new
26
27              line.split(/\W/).each do |word|
28                  words << randomize(word)
29              end
30
31              words.join(" ")
32          end
33      end
34  end

 1  class Mixer
 2      private
 3      def randomize(str)
 4          if str.length < 4
 5              return str
 6          end
 7
 8          letters = str.split(//)
 9
10          first = letters[0]
11          mid = letters[1..(letters.length - 2)]
12          last = letters[letters.length - 1]
13
14          new_letters = ""
15
16          while mid && mid.length > 0
17              len = mid.length
18              r = rand(len)
19              new_letters << mid.delete_at(r)
20          end
21
22          first + new_letters + last
23      end
24
25      public
26      def mix_file(filename)
27          lines = IO.readlines(filename)
28
29          mix_lines(lines)
30      end
31
32      def mix_string(str)
33          new_str = ""
34
35          mix_lines(str.split).each do |line|
36              new_str << line
37          end
38
39          new_str
40      end
41
42      def mix_lines(lines)
43          lines.collect! do |line|
44              new_line = ""
45
46              line.split(/\s+|,|\.|\!|\(|\)|\"|\'/).each do |word|
47                  new_line << randomize(word) << " "
48              end
49
50              new_line
51          end
52
53          lines
54      end
55  end

 1  require 'test/unit'
 2  require 'mix'
 3
 4  class MixTest < Test::Unit::TestCase
 5      def setup()
 6          @mixer = Mixer.new
 7      end
 8
 9      def test_word()
10          x = @mixer.mix_string("testing")
11          puts x
12          assert_not_equal("testing", x, "String not randomized")
13      end
14
15      def test_string()
16          x = @mixer.mix_string("this is a humongous test, dangit")
17          puts x
18      end
19
20      def test_file()
21          article = @mixer.mix_file("testfile.txt")
22          #puts article
23      end
24  end

words = IO.readlines("wordlist.txt")

anagrams = Hash.new([])

words.each do |word|
    base = Array.new
    word.chomp!.downcase!

    word.each_byte do |byte|
        base << byte.chr
    end

    base.sort!

    anagrams[base.to_s] |= [word]
end

# Find the anagrams by eliminating those with only one word
anagrams.reject! {|k, v| v.length == 1}

values = anagrams.values.sort do |a, b|
    b.length <=> a.length
end

File.open("anagrams.txt", "w") do |file|
    values.each do |line|
        file.puts(line.join(", "))
    end
end

largest = anagrams.keys.max do |a, b|
    a.length <=> b.length
end

puts "Total: #{anagrams.length}" #
puts "Largest set of anagrams: #{values[0].inspect}" # 
print "Longest anagram: #{anagrams[largest].inspect} " # 
puts "at #{largest.length} characters each"

longest = anagrams.to_a.max do |a, b|
    a[1].length <=> b[1].length
end

#!/usr/local/bin/ruby

start = Time.now

# Arrays for each class of word
fourLetters = Array.new
threeLetters = Array.new
twoLetters = Array.new
sixLetters = Array.new

# Loop over the word list, segregating the words
#  to their respective array
IO.foreach("wordlist.txt") do |line|
    line.chomp!.downcase!

    case line.length
    when 2
        twoLetters << line
    when 3
        threeLetters << line
    when 4
        fourLetters << line
    when 6
        sixLetters << line
    end
end

candidates = Array.new

# Build up all combinations of four letters + two letters
#  and store in them as candidates
fourLetters.each do |four|
    twoLetters.each do |two|
        wc = four + two

        candidates << wc
    end
end

# Build up all combinations of three letters + three
#  letters and store them as candidates
threeLetters.each do |three|
    threeLetters.each do |otherThree|
        wc = three + otherThree
        candidates << wc
    end
end

# Finally, all combinations of two letters + two letters
#  + two letters and store those as candidates
twoLetters.each do |firstTwo|
    twoLetters.each do |secondTwo|
        twoLetters.each do |thirdTwo|
            wc = firstTwo + secondTwo + thirdTwo
            candidates << wc
        end
    end
end

# Now get rid of dups and sort in place
candidates.uniq!.sort!
puts "Candidates = #{candidates.length}" #

# And the two arrays together leaving only those words
#  that appear in both lists
matches = sixLetters & candidates

# Now write the matches to a file
File.open("matches.txt", "w") do |file|
    matches.each do |word|
        file.puts(word)
    end
end

finish = Time.now

puts "Started at #{start}"
puts "Finished at #{finish}"
puts "Total time #{finish.to_i - start.to_i}"