did a few kata on codewars

SamGerber · SamGerber · commit 1589999d4e01 · 2015-10-12T02:36:32.000-05:00
diff --git a/codewars/00-next_bigger_number_with_same_digits.rb b/codewars/00-next_bigger_number_with_same_digits.rb
@@ -0,0 +1,27 @@
+def next_bigger(n)
+  return unless n.integer? && n > 0
+
+  digits = n.to_s.split("").map{|digit| digit.to_i}
+  least_significant_digits = []
+  loop do
+    least_significant_digits << digits.pop
+    break if digits.empty?
+    if digits.last < least_significant_digits.max
+      temp = least_significant_digits.select{|digit| digit > digits.last}.sort.first
+      least_significant_digits.delete_at(least_significant_digits.index(temp))
+      least_significant_digits << digits.pop
+      digits << temp
+      return (digits + least_significant_digits.sort).join.to_i
+    end
+  end
+  return -1
+end
+
+puts next_bigger(12)
+puts next_bigger(513)
+puts next_bigger(2017)
+puts next_bigger(414)
+puts next_bigger(144)
+puts next_bigger(9)
+puts next_bigger(111)
+puts next_bigger(531)
diff --git a/codewars/01-text_align_justify.rb b/codewars/01-text_align_justify.rb
@@ -0,0 +1,59 @@
+# Your task in this Kata is to emulate text justification in monospace font.
+# You will be given a single-lined text and the expected justification width.
+# The longest word will never be greater than this width.
+#
+# Here are the rules:
+#
+# *Use spaces to fill in the gaps between words.
+# *Each line should contain as many words as possible.
+# *Use '\n' to separate lines.
+# *Gap between words can't differ by more than one space.
+# *Lines should end with a word not a space.
+# *'\n' is not included in the length of a line.
+# *Large gaps go first, then smaller ones: 'Lorem---ipsum---dolor--sit--amet'
+#    (3, 3, 2, 2 spaces).
+# *Last line should not be justified, use only one space between words.
+# *Last line should not contain '\n'
+# *Strings with one word do not need gaps ('somelongword\n').
+
+
+
+def justify(text, width)
+    # Split the string into words
+    words = text.split
+    result = ""
+
+    # shift words from the words array into the line array until required
+      # characters exceeds width.
+    loop do
+      line = []
+      characters_in_line = 0
+      while characters_in_line + words.first.length  <= width
+        line << words.shift
+        characters_in_line += line.last.length + 1
+        if words.empty?
+          characters_in_line = width + 1
+          break
+        end
+      end
+
+      # add spaces & newline
+      characters_in_line -= 1
+      extra_spaces = width - characters_in_line
+      until line.count == 1
+        spaces = 1 + extra_spaces.fdiv(line.count - 1).ceil
+        result += line.shift + " " * spaces
+        extra_spaces -= (spaces - 1)
+      end
+      result += line.shift
+
+      return result if words.empty?
+      result += "\n"
+    end
+end
+
+test_text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc consequat ligula et lorem facilisis posuere. Proin nec lacus ac turpis vestibulum pretium vitae ac felis. Nulla rhoncus, ante et dapibus maximus, eros nunc sodales sem, ut semper massa erat non ipsum. Suspendisse pretium, massa ut hendrerit semper, felis ex elementum leo, ut faucibus quam eros eu libero. Suspendisse gravida ut turpis non dignissim. Suspendisse sit amet mauris neque. Cras eget urna velit. Sed ultricies, lacus ut rutrum ultrices, erat ligula venenatis ex, et ornare risus ipsum id urna. Integer accumsan hendrerit aliquam. Quisque semper dictum nulla, ac ornare nisl pulvinar lacinia. Quisque rutrum turpis et augue ullamcorper, a placerat ex consequat. Pellentesque euismod est eu ex pharetra pulvinar. Donec tincidunt mattis pharetra. Donec urna ligula, mattis a convallis eget, mollis at urna. Ut tincidunt sagittis semper."
+short_text = "123 45 6"
+
+puts justify(test_text, 30)
+puts justify(short_text, 7)
diff --git a/codewars/02-roman_numerals_encoder.rb b/codewars/02-roman_numerals_encoder.rb
@@ -0,0 +1,8 @@
+# Create a function taking a positive integer as its parameter and '
+# returning a string containing the Roman Numeral representation of that integer.
+#
+# Modern Roman numerals are written by expressing each digit separately starting
+# with the left most digit and skipping any digit with a value of zero.
+# In Roman numerals 1990 is rendered: 1000=M, 900=CM, 90=XC; resulting in MCMXC.
+# 2008 is written as 2000=MM, 8=VIII; or MMVIII. 1666 uses each Roman symbol in
+# descending order: MDCLXVI.
diff --git a/codewars/greed.rb b/codewars/greed.rb
@@ -0,0 +1,15 @@
+def score( dice )
+  score = 0
+  dice = dice.sort.join
+  (1..6).each do |n|
+    dice.scan(/#{n}{3}/) do |triple|
+      score += (triple[0] == "1" ? 1000 : triple[0].to_i * 100)
+      dice = dice.sub(triple, "")
+    end
+  end
+  dice.scan(/[1]/) {|n| score += 100}
+  dice.scan(/[5]/) {|n| score += 50}
+  score
+end
+
+score( [1,1,1,1,5])
diff --git a/codewars/int32_to_IPv4.rb b/codewars/int32_to_IPv4.rb
@@ -0,0 +1,7 @@
+def int32_to_ip(int32)
+  binary = int32.to_s(2).rjust(32, "0")
+  ip_address = binary.scan(/\d{8}/).map {|octet| octet.to_i(2).to_s}.join(".")
+end
+
+puts int32_to_ip 2154959208
+puts int32_to_ip 0
diff --git a/codewars/pagination_helper.rb b/codewars/pagination_helper.rb
@@ -0,0 +1,59 @@
+# TODO: complete this class
+
+class PaginationHelper
+
+  # The constructor takes in an array of items and a integer indicating how many
+  # items fit within a single page
+  def initialize(collection, items_per_page)
+    @items_per_page = items_per_page
+    @pages = Array.new(collection.count.fdiv(items_per_page).ceil) do |i|
+      Array.new()
+    end
+    page_number = 0
+    until collection.empty?
+      @items_per_page.times do |item_number|
+        @pages[page_number][item_number] = collection.shift
+        break if collection.empty?
+      end
+      page_number += 1
+    end
+  end
+
+  # returns the number of items within the entire collection
+  def item_count
+    @pages.inject(0){|item_count, page| item_count + page.count}
+  end
+
+  # returns the number of pages
+  def page_count
+    @pages.count
+  end
+
+  # returns the number of items on the current page. page_index is zero based.
+  # this method should return -1 for page_index values that are out of range
+  def page_item_count(page_index)
+    return -1 if page_index < 0 || page_index >= self.page_count
+    @pages[page_index].count
+  end
+
+  # determines what page an item is on. Zero based indexes.
+  # this method should return -1 for item_index values that are out of range
+  def page_index(item_index)
+    return -1 if item_index < 0 || item_index >= self.item_count
+    location = item_index.divmod @items_per_page
+    location[0]
+  end
+end
+
+helper = PaginationHelper.new(['a','b','c','d','e','f'], 4)
+puts helper.page_count # should == 2
+puts helper.item_count # should == 6
+puts helper.page_item_count(0)  # should == 4
+puts helper.page_item_count(1) # last page - should == 2
+puts helper.page_item_count(2) # should == -1 since the page is invalid
+
+# page_ndex takes an item index and returns the page that it belongs on
+puts helper.page_index(5) # should == 1 (zero based index)
+puts helper.page_index(2) # should == 0
+puts helper.page_index(20) # should == -1
+puts helper.page_index(-10) # should == -1 because negative indexes are invalid
diff --git a/codewars/weirdcase.rb b/codewars/weirdcase.rb
@@ -0,0 +1,6 @@
+def weirdcase string
+  a = string.downcase.split.map{|word| word.chars.map.with_index{|c, i| i.even? ? c.upcase : c}.join}
+  string
+end
+
+weirdcase('This is a test')
