Staircase Challenge Revisited: Ruby Version
Tags: ruby, challenge, codenewbie
Published: 2020-06-16 11:38:13

As I've been practicing code challenges in JavaScript recently, I couldn't help but feel that I had neglected my old friend Ruby. As I result, I decided to start going back to some of the same problems I had already solved, and come up with a few Ruby solutions. I'll start with the Staircase Challenge.

[Check out my old post if you're more interested in the JavaScript version.](https://dev.to/jessesbyers/staircase-challenges-repeat-iteration-and-recursion-strategies-2f67)

Similar to my previous post, I'm solving the [HackerRank Staircase problem](https://www.hackerrank.com/challenges/staircase/problem). In this problem, we are given a number of levels, n, and are asked to print out a staircase with n levels ascending from left to right. The output should look like this:

```
staircase(4)

   #
  ##
 ###
####
```

### String Repeat Strategy

For my first JavaScript solution, I had used the repeat method to generate the correct number of spaces and pound symbols for each row. In Ruby, I found that I could use `*` to repeat a specific character as many times as I needed.

1. Set up a counter, starting at n-1
  `i = n-1`

2. Set up a loop, decrementing from i down to zero (once for each row of the staircase)
  `while i >= 0`

3. Use the i and n number variables to repeat spaces and pound characters for each row
    `spaces = " " * i`
    `pounds = "#" * (n-i)`
    `row = spaces + pounds`

4. Print out the row before decrementing the counter for the next row
    `puts row`
    `i -= 1`

Taken altogether, the repeat strategy solution looks like this:

```
def staircase(n)
  i = n-1

  while i >= 0
    spaces = " " * i
    pounds = "#" * (n-i)
    row = spaces + pounds
    puts row
    i -= 1
  end
end
```

### Iteration Strategy
In JavaScript, I also used an iteration strategy to achieve the same result. To see the logic behind the strategy, look back at the original post. In Ruby, the process looks like this:

1. Iterate through rows
  `row = 0`
  `while row < n`
    
2. Set up empty string for the given row
    `string = ""`

3. Iterate through columns
    `column = 0`
    `while column < n`

4. If the column number is less than or equal to the row 
      `if column <= row`

5. Add "#"" to the end of the string
        `string = string + "#"`
      `else`

6. Add an empty space to the beginning of the string
        `string = " " + string`
      
7. Increment the column 
      `column += 1`

8. Print the string for the row, then increment the row
    `puts string`
    `row += 1`

The final iterative solution, without comments:

```
def staircase(n) 
  row = 0
  
  while row < n
    string = ""
    column = 0

    while column < n

      if column <= row 
        string = string + "#"
      else 
        string = " " + string
      end
      
      column += 1
    end

    puts string
    row += 1
  end
end
```
### Recursion Strategy

Finally, we can attempt a recursion strategy in Ruby. To start, we can use the same pseudo-code that we used in JavaScript to help us build the solution.

1. Set default values for arguments that will be needed in each function call (row number, and string)
     `def staircase(n, row=0, string="")`

2. Set up a base case so that the recursive function calls will stop (when n reaches zero)
`if n == row`
  `return`
`end`

3. Set up a conditional to account for the cases when the string length for a row is full (n===string.length)
`if n == string.length`

4. Print out the row (string)
`puts string`

5. Call the function to start work on the next row (row + 1)
`return staircase(n, row+1)`

6. Account for adding characters to the string if the row is not yet full (n < string.length), based on comparing the string length with the row number
`add = string.length <= row ? "#" : " "`

7. Call the function to continue working on the row, with the current row and updated string passed as arguments
`staircase(n, row, add + string)`

In code, this will result in the following recursive solution:

```
def staircase(n, row=0, string="") 
    if n == row
        return
    end

    if n == string.length
        puts string
        return staircase(n, row+1)
    end

    add = string.length <= row ? "#" : " "

    staircase(n, row, add + string)
  end
```

### The Pyramid Challenge

I'll end this post the same way as my JavaScript post: With a challenge. 

>Write a function that will take in one parameter, the height of a pyramid, and will print out the shape of a pyramid with that many levels.

For example, pyramid(4) would result in the output:

```
   x  
  xxx
 xxxxx
xxxxxxx
```

*How can you use the strategies above to solve the pyramid challenge? Did you use a repeating, iteration, or recursive solution?*