Ruby Challenges P1
Tags: ruby, programming, challenge, beginners
Published: 2023-02-16 08:56:13

As I prepare for a new side project using Ruby, I thought it'd be a good idea to brush up on my logic skills. So, I decided to tackle some fun coding challenges to get back into the groove, and then make a post about it where I walk you through how I solved it.

To be honest, I'm not the strongest at math, and I consider myself more of a creative type. But, even though these challenges were relatively easy, I felt `proud of myself` for figuring out the solutions on my own and `understanding the logic` behind them.

It's been only a few months since I started, but I'm already amazed by the `progress I've made`. I'm really excited to see where I'll be in a year if I keep up this pace!

Either way, lets get started! ✌🏼

---

Challenge Structure:
- Challenge Description.
- My psuedo code I made before completing the challenge
- My solution

## Find The Numbers
 **Challenge:** In a given array, find and count the numbers of integers with a value greater than 5.

```text
# -- Psuedo Code -- #
# 1. Create an array with mixed numbers
# 2. Create an final_array that will hold all the numbers we "find" that are greater than 5.
# 3. Go through each of the numbers in the array, checking it's value and comparing it with 5.
# 4. If the check is positive ( greater than 5 ) then push that number to our final_array
# 5. Get the total numbers of final_array to show result
# 6. Print result
```

```ruby
arr = [17,7,3,6,10,1]
final_arr = Array.new
arr.each {|number| number >= 5 ? new_arr << number : nil }
puts "this is how many numbers were bigger than 5: #{new_arr.count}"
```

## Prime Number?
**Challenge:** Create an algorithm that finds prime numbers, you have to decide if the number in question can only be divided by itself and 1.

_Going to be honest and say this confused me a lot. I didn't really understand the math/logic of a prime number at all at first_

```text
# -- Psuedo Code -- #
# 1. Create method that takes one argument
# 2. Check that the number is less or equal to 1, or if it's even. If it is, it's not a prime number.
# 3. Check if number is greater than 2, and loop through all numbers from 2 to the square root of number.
# 4. Check if it can be divided by the the integer without any remainder = not a prime number
# 5. If the loop completes without finding any of the previous things, then number is prime. Print "PRIME! ⭐️".
```

```ruby
def prime_number(number)
  if number <= 1 || number.even?
    puts 'NOT A PRIME NUMBER! ❌'
  elsif (2..Math.sqrt(number)).all? { |i| (number % i).nonzero? }
    puts 'PRIME! ⭐️'
  else
    puts 'NOT A PRIME NUMBER! ❌'
  end
end


prime_number(3)
```

## Sum of Prime Numbers
**Challenge:** # Identify and calculate the sum of prime numbers in an array.

```text
# -- Psuedo Code -- #
# 1. Create a method that takes an array of numbers
# 2. Create a variable containing the sum of found prime numbers
# 3. Iterate over the array, checking if the values are prime or not
# 4. If it's a prime number, add to sum
# 5. Print out total value of all the primes
```

```ruby
def find_prime_number(arr)
  total = arr.reduce(0) do |sum, number|
    if number <= 1 || number.even?
    sum
    elsif (2..Math.sqrt(number)).all? {|i| (number % i ).nonzero? }
      sum + number
    else
      sum
    end
  end
  puts "Total total of primes in array => #{total}"
end

find_prime_number([3,0,3, 54, 43, 11, 123, 322])
```


## Factorial Numbers?
**Challenge:** # The factorial of a number is the product of all the positive integers that are less than or equal to the number in question.
For example, for the number 6, the factorial would be 1 x 2 x 3 x 4 x 5 x 6 = 720.

```text
# -- Psuedo Code -- #
# 1. Create method that takes one argument(number)
# 2. Create an array containing all the numbers from 1 to number.
# 3. Iterate over the array and add the value to a sum.
# 4. Print out sum
```

```ruby
def factorial_numbers(number)
  arr = (1..number).to_a
  sum = arr.reduce(1) do |accmulator, value|
    accmulator * value
  end
  puts sum
end

factorial_numbers(6)
```


## Find repeated digits
**Challenge:** # Your objective is to use Ruby to validate whether or not the number is made up of a series of the same digit in a row.

_I must say I'm not EXACTLY sure what the expected result was here but, I managed to get a logic that outputs if it has a series of the same digit or not at least._

```text
# -- Psuedo Code -- #
# 1. Make a method that takes a number
# 2. Split the number into an array
# 3. Check if the number is unique or not
# 4. Unless 0, disqualify.
```

```ruby
def check_repeated_digits_option(number)
  arr = number.to_s.chars.map(&:to_i)
  puts arr.uniq.length != 1 ? "#{number} => Congrats! Digits are are all unique" : "#{number} => Disqualified. Contains duplicates."
end
```




## Fibonacci challenge
**Challenge:**  A Fibonacci Sequence is created by adding two numbers to create the next number in the sequence.
You then sum that number with the one preceding it to get the next number,, and so on.
For example, if you have the sequence 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, then the next number in the sequence is 55.

```text
# -- Psuedo Code -- #
# 1. Create a method that takes a max value
# 2. Have a variable that holds the count(total)
# 3. Give two numbers to start with
# 4. Create a loop that runs until given max value
# 5. While the loop runs, take the last item in the array, and add the second to last item in the array to count.
# 6. Add the new number to the array
# 7. Print out result
```

```ruby
def fibonnaci_count(max)
  count = 0
  arr = [0,1]
  while count <= max
    count = arr.last + arr[-2]
    arr << count
  end
  arr
end


sequence = fibonnaci_count(2000)
puts "The sequence is: #{sequence}"

```



# Missing Number Game
**Challenge:** Create a program that takes a series of numbers and examines it to find the numbers missing to make it a perfect range.

For example, the series of numbers could be [2, 1, 5, 4, 6, 9, 7, 8, 10].

This array is missing the number 3. The goal of this problem is to write code that finds which numbers are missing, and print them out.

```text
# -- Psuedo Code -- #
# 1. Create a method that takes an array of numbers.
# 2. Sort the array, to make it work in any order.
# 3. Get the smallest and biggest value to get a start and end point.
# 4. Create a new, perfect array with the range between those numbers
# 5. Use the new array and compare it to the old array
# 6. Create a new missing_numbers array that will be filled with the numbers not included in old_array when comparing.
```

```ruby
def missing_number(array)
  array = array.sort
  first = array.min
  last = array.max
  perf_arr = (first..last).to_a
  missing_numbers = []
  if array == perf_arr
    puts 'No missing numbers'
  else
    perf_arr.each do |number|
      missing_numbers << number unless array.include?(number)
    end
    puts "These are the numbers missing: #{missing_numbers}"
  end
end

missing_number([1,3,4,5,9,15,8,10,7,6])

```
---

## Conclusion

It was actually very fun going back to some good ol' logical thinking, as I had to troubleshoot and figure out what I was doing wrong along the way, and learn new techniques to get the same result.

Refactoring was also a big part of it during these tests, as my first versions were often too long and overly complicated for no reason, especially when Ruby is as smart as it is 🤩

**My takeaway** from all of this is that I'm making daily improvements, and it feels amazing. Although this might be like nothing to others, I'm very proud of my progress, especially in my weak areas such as this. 


> Live to learn, learn to live, then teach others.


Until next time! ✌🏼