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

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)

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

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)

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

score( [1,1,1,1,5])

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(".")

puts int32_to_ip 2154959208

puts int32_to_ip 0

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

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

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

def weirdcase string

a = string.downcase.split.map{|word| word.chars.map.with_index{|c, i| i.even? ? c.upcase : c}.join}

string

0,0,0,1,2,3,5,6,6,6,6,7,7,7,8,8,9,10,11,11,11,12,13,13,14,13,13,14,14,15,16,17,18,18,18,18,18,18,19,20,21,21,22,23,27,27,29,31,32,33,34,34,35,36,36,37,38,39,39,40,41,41,41,42,43,45,46,47,49,49,50,50,50,51,51,52,56,59,59,60,62,64,65,65,65,65,65,66,68,70,73,74,74,74,74,74,74,74,74,74,74,75,76,77,78,79,80,81,81,82,83,83,83,84,85,85,87,88,89,90,91,92,93,94,95,96,97,98,98,99,100,102,104,105,106,106,106,107,108,108,110,111,111,113,113,113,113,114,115,116,119,120,121,121,121,121,122,124,124,125,126,129,130,132,133,136,138,141,142,143,145,148,152

= Playing Greed

Greed is a dice game played among 2 or more players, using 5

six-sided dice.

== Playing Greed

Each player takes a turn consisting of one or more rolls of the dice.

On the first roll of the game, a player rolls all five dice which are

scored according to the following:

Three 1's => 1000 points

Three 6's => 600 points

Three 5's => 500 points

Three 4's => 400 points

Three 3's => 300 points

Three 2's => 200 points

One 1 => 100 points

One 5 => 50 points

A single die can only be counted once in each roll. For example,

a "5" can only count as part of a triplet (contributing to the 500

points) or as a single 50 points, but not both in the same roll.

Example Scoring

Throw Score

--------- ------------------

5 1 3 4 1 50 + 2 * 100 = 250

1 1 1 3 1 1000 + 100 = 1100

2 4 4 5 4 400 + 50 = 450

The dice not contributing to the score are called the non-scoring

dice. "3" and "4" are non-scoring dice in the first example. "3" is

a non-scoring die in the second, and "2" is a non-score die in the

final example.

After a player rolls and the score is calculated, the scoring dice are

removed and the player has the option of rolling again using only the

non-scoring dice. If all of the thrown dice are scoring, then the

player may roll all 5 dice in the next roll.

The player may continue to roll as long as each roll scores points. If

a roll has zero points, then the player loses not only their turn, but

also accumulated score for that turn. If a player decides to stop

rolling before rolling a zero-point roll, then the accumulated points

for the turn is added to his total score.

== Getting "In The Game"

Before a player is allowed to accumulate points, they must get at

least 300 points in a single turn. Once they have achieved 300 points

in a single turn, the points earned in that turn and each following

turn will be counted toward their total score.

== End Game

Once a player reaches 3000 (or more) points, the game enters the final

round where each of the other players gets one more turn. The winner

is the player with the highest score after the final round.

== References

Greed is described on Wikipedia at

http://en.wikipedia.org/wiki/Greed_(dice_game), however the rules are

a bit different from the rules given here.