my implementation of various algorithms in Ruby

Author: mesutcan

README

@@ -0,0 +1 @@
+Various implementations of Ruby algorithms, all the codes have explanations.

definewords.rb

@@ -0,0 +1,38 @@
+require "open-uri"
+
+unless ARGV[0]
+ puts "You must supply a word to define."
+ puts "USAGE: ruby define.rb <word to define>"
+ exit
+end
+
+word = ARGV[0].strip
+
+url = "http://dictionary.reference.com/browse/#{word}"
+
+begin 
+ 
+ open(url) do |source|
+  source.each_line do |x| 
+    if x=~ /No results found/
+    puts "\nPlease check spelling,no definition was found."
+    exit
+  end
+    if x=~  /(1\.)<\/td><td valign="top">(.*)<\/td/
+    puts "\n#{$1} #{$2}"
+    exit
+  end
+end
+   puts "Sorry, unable to find a definition."
+end
+rescue => e
+   puts "An error occurred, please try again."
+   puts e 
+end 
+#appending a word to the URL will automatically return the definition.
+
+#open-uri lets us type open(), pass the URL to the method and retrieve a webpage.
+
+#if the definition is found, the script will begin isolating exactly where the definition resides in the source code.
+
+

dijkstra.rb

@@ -0,0 +1,42 @@
+# Assign to every node a tentative distance value: set it to zero for our initial node and to infinity for all other nodes.
+# Mark all nodes except the initial node as unvisited. Set the initial node as current. Create a set of the unvisited nodes called the unvisited set consisting of all the nodes except the initial node.
+# For the current node, consider all of its unvisited neighbors and calculate their tentative distances. For example, if the current node A is marked with a distance of 6, and the edge connecting it with a neighbor B has length 2, then the distance to B (through A) will be 6+2=8. If this distance is less than the previously recorded distance, then overwrite that distance. Even though a neighbor has been examined, it is not marked as visited at this time, and it remains in the unvisited set.
+#When we are done considering all of the neighbors of the current node, mark it as visited and remove it from the unvisited set. A visited node will never be checked again; its distance recorded now is final and minimal.
+# The next current node will be the node marked with the lowest (tentative) distance in the unvisited set.
+# If the unvisited set is empty, then stop. The algorithm has finished. Otherwise, set the unvisited node marked with the smallest tentative distance as the next "current node" and go back to step 3.
+# Using adjacent lists and using a binary heap, pairing heap and Fibonacci heap as a priority queue to implement extracting minimum efficiency.
+
+
+require 'pqueue'
+
+class Dijkstra
+INFINITY = 1 << 32
+
+def self.dijkstra(source, edges, weights, n)
+ visited = Array.new(n, false)
+ shortest_distances = Array.new(n,infinity)
+ previous = Array.new(n,nil)
+ pq = PQueue.new(proc {|x,y| shortest_distances[x] < shortest_distances[y]})
+
+pq.push(source)
+visited = true
+shortest_distances = 0
+
+while pq.size != 0
+ v=pq.pop
+ visited[v] = true
+ if edges[v]
+  edges[v].each do |w|
+   if !visited[w] and shortest_distances[w] > shortest_distances[v] + weights[v][w]
+    shortest_distances[w]=shortest_distances[v] + weights[v][w]
+    previous[w] = v
+    pq.push(w)
+   end
+  end
+ end
+end
+return [shortest_distances, previous]
+end
+end
+
+

flashcards.rb

@@ -0,0 +1,31 @@
+unless ARGV[0]
+ puts "\n\nUsage is flashCards.rb <file>\n\n"
+ exit
+end
+
+flash = []
+card = Struct.new(:question,:answer)
+# Use Struct to create our own data structure called card.
+File.open(ARGV[0],"rb").each do |line| 
+   if line =~ /(.*)\s{3,10}(.*)/
+    flash << card.new($1.strip,$2.strip)
+    end
+end
+
+flash.replace(flash.sort_by{rand})
+
+until flash.empty?
+  drill = flash.pop
+   print "#{drill.question}?"
+  guess = $stdin.gets.chomp
+  
+  if guess.downcase == drill.answer.downcase
+    puts "\n\nCorrect -- The answer is: #{drill.answer}\n\n\n"
+  else
+    puts "\n\nWRONG -- The answers is :#{drill.answer}\n\n\n"
+  end
+end
+
+# Flash card file inline is broken down line by line. Each flash card is added to an aray called flash. Once it reaches the end-of-file, the array flash has a complete collection of cards with questions and answers on them.
+
+

luhn_algorithm.rb

@@ -0,0 +1,43 @@
+#         Luhn algorithm
+#         1. Starting with the next to last digit and continuing with every other
+#            digit going back to the beginning of the card, double the digit
+#         2. Sum all doubled and untouched digits in the number
+#         3. If that total is a multiple of 10, the number is valid
+
+card_num = ARGV.join
+
+case
+    when (card_num=~/^(34|37)\d{13}$/): print 'AMEX '
+    # it is amex when it  begins with 34 vor 36 and the length is 15 numbers in total.
+    when (card_num=~/^6011\d{12}$/): print 'Discover '
+    # it is discover when it  begins with 6011 and the length is 16 numbers in total.
+    when (card_num=~/^5[1-5]\d{14}$/): print 'MasterCard '
+    # it is mastercard when it  begins with 51-55 and the length is 16 numbers in total.
+    when (card_num=~/^4(\d{12}|\d{15})$/): print 'Visa '
+    # it is visa when it  begins with 4 and the length is 13 or 16 numbers in total.
+    else print 'Unknown '
+end
+
+i = 0
+
+luhn_number = ''
+
+card_num.reverse.each_byte {|char|
+    if (i%2==1) then
+        char = (char.chr.to_i * 2).to_s
+        else
+        char = char.chr
+    end
+    luhn_number = char + luhn_number
+    i += 1
+}
+
+sum = 0
+
+luhn_number.each_byte {|char| sum += char.chr.to_i }
+
+if (sum%10==0) then
+    print "Valid credit card\n"
+    else
+    print "Invalid credit card\n"
+end

piglatin.rb

@@ -0,0 +1,23 @@
+#Implementation of piglatin algorithm
+class PigLatin
+   def pig(word)
+     leadingCap = word =~ /^A-Z?
+      word.downcase!
+      res = case word
+       #when vowels word + way
+         when /^aeiouy/
+           word+"way"
+       #otherwise, start from the back to concatanete with the first letter and add ay
+         when /^([^aeiouy]+)(.*)/
+           $2 + $1 + "ay"
+         else
+           word
+         end
+       leadingCap ? res.capitalize : res
+   end
+
+   def showPig
+     #split the value into array and collect the words and join them into a string. 
+     @text.value = @text.value.split.collect{|w| pig(w)}.join(" ")
+   end
+end

word_frequency.rb

@@ -0,0 +1,21 @@
+puts 'What is the name and path of the file?'
+filename = gets.chomp
+text = String.new
+File.open(filename) { |f| text = f.read }
+
+#matches anything that isn't alphabetical character
+words = text.split(/[^a-zA-Z]/)
+
+freqs = Hash.new(o)
+#key will be a unique word and it's value is the # of times it occurs in the text.
+words.each{|word| freqs[word] +=1}
+freqs = freqs.sort_by{|x,y| y}
+freqs.reverse!
+freqs.each{|word,freq| puts word+ ' '+freq.to_s}
+
+
+words = File.open('filename.txt') {|f| f.read}.split
+freqs = Hash.new(0)
+words.each {|word| freqs[word] +=1}
+freqs.sort_by{|x,y| y}.reverse.each{|w,f| puts w+ '' + f.to_s}
+