Re: Translation Project

On 29/03/2013, at 7:00 AM, Jeremy Henderson <[e-mail]> =
wrote:

> Hello all! This is my first post! I started learning Ruby about 3 =
weeks
> ago and have a personal project I would like to do, so I was wondering
> if someone could help me out a bit, so I can get it started.
>=20
> I would like to have a request made by Ruby to the user for some text.
> Then Ruby would take their input and split the text up by every
> individual character and assign it a new value based on what letter it
> is.
>=20
> For instance if:
>=20
> "A" =3D [A,B,C,D,E,F] "B" =3D [G,H,I,J,K,L]
> "C" =3D [M,N,O,P,Q,R] "D" =3D [S,T,U,V,W,X,Y,Z]
>=20
> So with the info above, Ruby would look at a sentence like, "Hello
> World" and it would say, "Ok, "H" is in "B's" array, so it's new value
> is "B"... and would do that for each character in the text. Then, when
> it's done, it would show the result after it's been put together. So =
the
> final product would be, "BABBC DCCBA". Spaces being accounted for as
> they are shown in the original text.
>=20
> If you know how this would be done, I would greatly appreciate your
> help. Otherwise, if you know a portion of how it might work, I would
> appreciate that as well. I'm grateful for any help anyone could =
provide.
>=20
> Thank you
>=20
>=20

Hi Jeremy,

Ruby is a very concise and expressive programming language. It's =
possible to pack a lot of code in a short number of lines.

Thus, while this code that I wrote as a solution to your problem solves =
your problem, it's necessary to explain what it does.

input =3D "hello"
dict =3D {a: "abcdef", b: "ghijkl", c: "mnopqr", d: "stuvwxyz"}
puts input.each_char.map do |char|
  key, value =3D dict.detect{|key, value| value.include?(char)}
end.join


Here is an annotated version:

# set the input string to "hello"
input =3D "hello"

# create a Ruby Hash (also called a dictionary in some languages) and =
set it to the variable dict.
# we are using single letter strings for keys, and those keys are then =
defined by a string with a series of letters in each.=20
# Commas separate the key-value pairs, and keys are separated by values =
by =3D>
# thus, if we were to ask dict for what it defines as "a", we'd get back =
"abcdef"
# We can do this by saying dict["a"] and ruby will then return "abcdef"
# I suggest you read up on the Hash class and ruby hashes. They're very =
powerful and interesting.
dict =3D {"a" =3D> "abcdef", "b" =3D> "ghijkl", "c" =3D> "mnopqr", "d" =
=3D> "stuvwxyz"}

# this is an iterator - ie a loop. It's actually a reasonably complex =
one because I've chained two together.
# input.each_char will give an Enumerator, which effectively gives us =
the equivalent of an Array (a list) that has
# in it a series of strings, each with just one character in it. In =
other words, it will yield to us a series of items, each which
# is one single character string out of the "input" string.
# input.each_char.map is equivalent to setting a variable to =
input.each_char and then sending that variable
# the map message.
#=20
# now, map is a method that takes some enumerable object such as Array =
or Enumerator, and evaluates
# a chunk of code (called a block in ruby) on each element of that =
array. I.E. it gives us a new array where each element of the new
# array represents the result of evaluating the block of code that is =
passed to map against each element of the object that map is
# called on.
#=20
# it's much easier to understand it in examples than it is in =
explanation
# So, this is a good example:=20
# >> ["hello", "this", "is", "fun"].map{|item| item.upcase}
# this will yield:
# =3D> ["HELLO", "THIS", "IS", "FUN"]
# You can see each element of the input array, which is a string with a =
lowercase word in it, has been "processed" by the block (indicated with =
{} braces)
# in the block {|item| item.upcase}, item represents each element, and =
then the bit after (item.upcase) is the code that will be executed on =
each item.

# So, in summary, the following code goes through each character as a =
separate string and assigns it to the variable "char" in the block:
# the "puts" call just outputs the result of the input.each_char.map
puts input.each_char.map do |char|

# now, if we take the next bit in reverse, it'll be more easy to =
explain. There are three parts to it:
#
# string objects (in fact most enumerables) have a method called =
"include?" which basically returns true if it is included
# So:
# >> "doggie".include?("dog")
# =3D> true
# should make sense
#
# Hash or dictionary objects have a method called detect (or find) which =
is an iterator/enumerator that looks over each
# key and value pair, and returns the first pair (as an array) where the =
block it takes evaluates to true
# thus:
# >> {"hello" =3D> "goodbye", "yes" =3D> "no"}.detect{|key,value| key =3D=3D=
 "yes"}
# =3D> ["yes", "no"]
# ... should come as no surprise
#=20
# now, ruby has a way of pulling out values of an array and assigning =
them to other variables
# it's called multiple assignment and this should explain it
# >> x,y =3D [3,4]
# =3D> [3, 4]
# >> x
# =3D> 3
# >> y
# =3D> 4
# so, x is 3 and y is 4.
#
# so what I'm doing in the next line of code is assigning key and value =
to be the key and value of the first element
# of the dict variable whose value includes the char variable's value.
  key, value =3D dict.detect{|key, value| value.include?(char)}

# that is then returned as the result of the map. At this point, we =
would be fine to simply put end to mark the end of the map block
# (ruby can use {} or do ... end to mark blocks)
# but we want to build the single-char strings array into a single =
string. We do that with join.
# ie:
# >> ["cool", " beans"].join
# =3D> "cool beans"

end.join

# and that's all! :)
# hope that helped!

Julian