xiao's w7/d2/rubyQuestions

PrimeFactors.rb

@@ -0,0 +1,39 @@
+#### Prime Factors
+
+def PrimeNumber?(number)
+  a = 2
+  while a < ( (number/2) + 1 )
+    return false if number % a === 0
+    a += 1
+  end
+  return true
+end
+
+def primeFactors(number)
+  numStore = number
+  puts "The prime factors of " + number.to_s + " are:"
+  if PrimeNumber?(number)
+    puts number
+  else
+    while numStore > 1
+      if PrimeNumber?(numStore)
+        return puts numStore
+      end
+      a = 2
+      while a <= ( (numStore/2) + 1 )
+        if PrimeNumber?(a) 
+          if numStore % a === 0
+            numStore = numStore / a
+            puts a
+            a = 1
+          end
+        end
+        a += 1
+      end
+    end
+  end  
+end
+
+primeFactors(5)
+primeFactors(20)
+primeFactors(17893)

PrimeNumber.rb

@@ -0,0 +1,14 @@
+#### Prime Number
+
+def PrimeNumber?(number)
+  return puts false if number<2 || number%2 == 0
+  a = 3
+  while a < ( (number/2) + 1 )
+    return puts false if number % a === 0
+    a += 1
+  end
+  puts true
+end
+
+PrimeNumber?(10)
+PrimeNumber?(13)

caesarCipher.rb

@@ -0,0 +1,24 @@
+#### Caesar Cipher
+
+
+def encrypt(message)
+  key = 2
+  newMessage = []
+  message.each_codepoint do |i|
+    newMessage.push((i+key).chr)
+  end
+  puts newMessage.join
+  return newMessage.join
+end
+
+def decrypt(message)
+  key = 2
+  newMessage = []
+  message.each_codepoint do |i|
+    newMessage.push((i-key).chr)
+  end
+  puts newMessage.join
+end
+
+decrypt(encrypt("Hello"))
+decrypt(encrypt("Boomerang Harry"))

missingNumber.rb

@@ -0,0 +1,12 @@
+#### Missing Number
+
+def missingNumber(array)
+  n = array.length + 1
+  expectedSum = n * (n + 1) / 2
+  sum = array.reduce(:+)
+  missNum = expectedSum - sum
+  p missNum
+end
+
+missingNumber([1,2,3,4,5,6,7,8,10])
+missingNumber([1,2,3,4,5,6,7,8,9,11,12,13,14])

multiplicativePersistence.rb

@@ -0,0 +1,23 @@
+#### Multiplicative Persistence
+
+# In mathematics, the persistence of a number is the number of times one must apply a given operation to an integer before reaching a fixed point at which the operation no longer alters the number.
+
+# The multiplicative persistence of 39 is 3, because it takes three steps to reduce 39 to a single digit: 39 → 27 → 14 → 4.
+
+# Write a function to find the `multiplicative persistence` of a number. You must use recursion.
+
+def multiplicative_persistence(number)
+  product = 1
+  mulPersis = 0
+  while number > 10
+    number.to_s.each_char do |c|
+      product *= c.to_i
+    end
+    number = product
+    product = 1
+    mulPersis += 1
+  end
+  puts mulPersis
+end
+
+multiplicative_persistence(39)

numberPersistence.rb

@@ -0,0 +1,19 @@
+#### Number Persistence
+
+def additivePersistence(number)
+  memo = number
+  sum = 0
+  addPersis = 0
+  while memo > 10
+    memo.to_s.each_char do |c|
+      sum += c.to_i
+    end
+    memo = sum
+    sum = 0
+    addPersis += 1
+  end
+  puts addPersis
+end
+
+additivePersistence(2718)
+additivePersistence(999999997)

palindrome.rb

@@ -0,0 +1,9 @@
+#### Palindrome
+
+def isPalindrome(string)
+  reverse = string.reverse
+  string === reverse
+end
+
+puts isPalindrome('lol')
+puts isPalindrome('xiao')

reverse.rb

@@ -0,0 +1,7 @@
+#### Reverse String
+
+def reverse(string)
+  string.reverse
+end
+
+puts reverse('xiao')

tripleDouble.rb

@@ -0,0 +1,31 @@
+#### Triple double
+
+def tripleDouble(triple,double)
+  memo = ""
+  memo2 = ""
+  triples = []
+  triple.to_s.each_char do |c|
+    if c === memo && c === memo2
+      if !triples.include? c
+        triples.push(c)
+      end
+    end
+    if c === memo
+      memo2 = c
+    end
+    memo = c
+  end
+  if triples == []
+    puts 0
+  else 
+    triples.each do |i|
+      if double.to_s.include? i+i
+        return puts 1
+      end
+    end
+    return puts 0
+  end
+
+end
+
+tripleDouble(299994333,12321312390933)