Wow. Day two messed with my head. I woke up a bit tired this morning to have a crack at it and got *really* baffled by how to make a fibonacci sequence. Just drew a total blank. So, I dug out some old c code I had and copied that into io. Which is sort of cheating, but got me going and also helped me feel a bit more comfortable with the language. Like Tate says, feeling comfortable with a new language is often about typing some code. Well, my homework excercises with some commentary looked like this.

### 1. fib.io

*A Fibonacci sequence starts with two 1s. Each subsequent number is the sum of the two numbers that came before: 1, 1, 2, 3, 5, 8, 13, 21, and so on. Write a program to find the nth Fibonacci number. fib(1) is 1, and fib(4) is 3. As a bonus, solve the problem with recursion and with loops.*

Like I said, my brain was totally blank at first, so I’ve pretty much rewritten C code. By the end of this I was starting to get the hang of how Io approaches stuff.
```
#!/usr/local/bin/io
# Iterative version. Probably faster.
fib := method( last_index,
# save a tiny bit of work
# we already know that fib(1) and fib(2) return 1
if (last_index < 3,
return 1
)
first := second := 1
for( unused, 1, last_index-1, running_total := first + second
first := second;
second = running_total;
)
return first
)
call_count := 0
# A naive and often seen recursive implementation
rfib := method ( n,
if(n<2,
return n
)
return rfib(n-1) + rfib(n-2)
)
# this and the next method iwork together and are a bit more efficient
new_rfib := method (n,
if ( n<1,
return 0
)
return new_rfib2(n, 0, 1)
)
new_rfib2 := method(n,first,second,
if( n<2,
return second
)
return new_rfib2(n-1, second, first+second)
)
"\nIterative version\n------------------" println
for(i,1,10,
writeln( "Iteration ",
i,
": ",
fib(i)
)
)
"\nRecursive version 1\n------------------" println
for(i,1,10,
writeln( "Iteration ",
i,
": ",
rfib(i)
)
)
"\nRecursive version 2\n------------------" println
for(i,1,10,
writeln( "Iteration ",
i,
": ",
new_rfib(i)
)
)
```

### 2. override_divide.io

*How would you change / to return 0 if the denominator is zero?*

This mostly took looking at the docs. I tooke the approach of making a copy of the default / operator and passing the figures on to it unless the denomonator was zero. Other people seem to have taken a similar approach.
```
#!/usr/local/bin/io
# store the 'core', original divide operator
Number div_method := Number getSlot("/")
# Now extend the Number class
Number / := method(denom,
if (denom == 0, return 0, return self div_method(denom))
)
# tests
"expect 2" println
(14/7) println
"expect 0" println
(14/0) println
```

### 3. list_sum.io

*Write a program to add up all of the numbers in a two-dimensional
array.*

Fortunately the docs for List are very well written, and I chanced across the sum and flatten methods. So it was pretty trivial to implement something that matched the spec. I note that Ben Nadel took a much more "from scratch approach". I’m lazy though.
```
#!/usr/local/bin/io
# you can flatten a list, then sum
list_sum := method ( list,
list flatten sum
)
"Expect 10" println
list_sum( list( list(1,2), list(3,4))) println
```

### 4. my_average.io

*Add a slot called myAverage to a list that computes the average of all the numbers in a list. What happens if there are no numbers in a list? (Bonus: Raise an Io exception if any item in the list is not a number.)*

Well, the last problem had already introduced the sum method. And reading the docs, sum throws an exception on NaN. So, being lazy, I reused that.
```
#!/usr/local/bin/io
List my_average := method (
return sum / size
)
x := list (1,2,3)
"Expect 2" println
x my_average println
x := list ("NaN",1,2,3)
"Expect Exception" println
x my_average println
```

### 5..7

All these questions were related so I was able to tackle them all in one lump of code

*
5. Write a prototype for a two-dimensional list. The dim(x, y) method should allocate a list of y lists that are x elements long. set(x, y, value) should set a value, and get(x, y) should return that value.
6. Bonus: Write a transpose method so that (new_matrix get(y, x)) == matrix get(x, y) on the original list.
7. Write the matrix to a file, and read a matrix from a file.
*

This was stretching for me, especially the transpose method. Not that the code is super difficult, its just expressing oneself in an unfamiliar language that feels like swimming in treacle.
```
#!/usr/local/bin/io
matrix := List clone;
matrix dim := method(x,y,
self setSize(x); // make first dimension this big
for (i, 0, (x - 1), 1,
self atPut(i,
(list setSize(y))
)
)
)
matrix get := method (x,y,
return self at(x) at(y)
)
matrix set := method (x,y,value,
self at(x) atPut(y,value)
return self
)
matrix transpose := method (
my_x := self size
my_y := self first size
my_matrix := matrix clone dim ( my_y, my_x ) // note x and y swapped
for (i, 0, (my_x-1),
for(j, 0, (my_y-1),
my_matrix set(j,i,self get(i,j))
)
)
# Ooh! you can not nother with 'return', just like perl
my_matrix
)
matrix save := method (
# Borrowed this cute syntax from http://stackoverflow.com/questions/4533478/how-do-i-deserialize-objects-in-io
File with("matrix.dat") open write(self serialized) close
)
matrix show := method (
for(i, 0, self size-1,
for(j, 0, self first size-1,
self get(i,j) print
if(j<self first size-1,
", " print
)
)
"" println
)
)
// Tests
m:=matrix clone dim(3,3)
"\nExpect 3x3 Matrix of nils" println
m println
m set(0,0,"O")
m set(0,1,"O")
m set(0,2,"X")
m set(2,2,"X")
"Expect X" println
m get(2,2) println
"Expect formatted-ish matrix" println
m show
m2 := m transpose
"Expect formatted transposed matrix" println
m2 show
m2 save
m := doFile("matrix.dat");
"Expect 3x3 matrix" println
m println
```

### 8. guesser.io

*Write a program that gives you ten tries to guess a random number
from 1â€“100. If you would like, give a hint of â€œhotterâ€ or â€œcolderâ€
after the first guess.
*

I felt like I was on the home strait with this question, and started to appreciate Tate's characterization of Io as being kinda like Ferris Bueller. The one place where I got stuck was having an "and" in my conditional. Parantheses to the rescue!
```
#!/usr/local/bin/io
to_guess := Random value(1,100) round
i := 0
prev_diff := nil
in := File standardInput;
"\n\nGuess my number (1-100, Q to quit)!" println
while(i<10,
guess := in readLine("Your guess: ")
if(guess=="Q", break) // Quit
guess := guess asNumber
if(guess isNan, continue) // Try again, not a number
difference := (to_guess - guess) abs
if( difference == 0,
"Congratulations, you win!" println
break
)
if((prev_diff and prev_diff != difference),
if(prev_diff > difference,
"Warmer" println,
"Colder" println
)
)
prev_diff := difference
)
```