DEV Community

Jesse Smith Byers

Posted on

Staircase Challenge Revisited: Ruby Version

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.

Similar to my previous post, I'm solving the HackerRank 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 ? "#" : " "

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?