Problem Solving Challenge #1

gistfile1.md

Problem Solving Challenge #1

Problem solving challenges are fun. They make use of one's problem solving skills and stimulate the programmer's need to challenge themselves.

Here we go

These 1151159511610110199114 numbers represent a word.

• The word may only contain a-zA-Z_
• The word is of size 8.

In this particular case the secret word was s_ecrets.

Write two functionsthat can encrypt an arbitrary string and return a string of numbers such as the one above. The program should also be able to take a string of numbers and return the original word.

Happy hacking!

@Skalman, nice. I was not completely clear about the implementation so I've updated the description above. I've added the solution to my example.

Perhaps a little over-engineered, but I think a complete and robust solution:

module Encoder
  class << self 
    # Create a mapping of encoded string back to characters { "115" => "s" }  
    ASCII_TO_CHAR = {}
    chars = ("A".."Z").to_a + ("a".."z").to_a + ["_"]
    chars.each {|c| ASCII_TO_CHAR[c.bytes.to_a[0].to_s] = c }   

    # Encode a string - non-validating.
    def encode(string)
      riffle(string.each_byte.map {|b| b.to_s }).join
    end

    # Decode string - validating.
    def decode(string)
      pos = 0 # Current position in string.
      decoded = []

      # Code is 2 or 3 character strings. Take 2 characters and
      # see if it is valid, otherwise take another char and check that. 
      until pos >= string.length
        if (s = string[pos, 2]) and ASCII_TO_CHAR.has_key? s
          decoded << ASCII_TO_CHAR[s]
          pos += 2
        elsif (s << string[pos + 2]) and ASCII_TO_CHAR.has_key? s
          decoded << ASCII_TO_CHAR[s]
          pos += 3
        else
          raise "bad encoding at string position #{pos}"
        end
      end

      unriffle(decoded).join
    end

    protected
    # Take first and last element from array until array is empty,
    # to build a new array.
    def riffle(array)    
      # Split into two halves.
      first, second = array.each_slice(array.size / 2).to_a
      # Take from the start and end until empty.
      first.zip(second.reverse).inject([]) do |memo, (a, b)|
        memo.push a, b
      end     
    end

    protected
    # Reverse the effect of #riffle
    def unriffle(array)
      first, second = [], []
      array.each_slice(2).each do |a, b| 
        first << a
        second.unshift b
      end
      first + second
    end
  end
end

# Run with "rspec" rather than "ruby" on the command line to run the specs.
if defined? RSpec
  ENCODED = "1151159511610110199114"
  STRING = "s_ecrets" 

  describe Encoder do
    describe "encode" do
      it "should encode a string" do
        Encoder.encode(STRING).should eq ENCODED
      end    
    end

    describe "decode" do
      it "should decode a string" do
        Encoder.decode(ENCODED).should eq STRING
      end
    end

    describe "riffle" do
      it "should riffle an array" do
        Encoder.send(:riffle, [1, 3, 4, 2]).should eq [1, 2, 3, 4]
      end
    end

    describe "unriffle" do
      it "should unriffle an array" do
        Encoder.send(:unriffle, [1, 2, 3, 4]).should eq [1, 3, 4, 2]
      end
    end
  end
end

Actually, still bored, so I improved my solution in a separate gist. Might want to delete my previous comment!
https://gist.github.com/3819927

@spooner impressive. Great solution.