ox

// compile it with:
//   javac Anagram.java
// run it with:
//   java Anagram word1 word2
// where word1 and word2 are words of your choosing

public class Anagram {
    public static boolean is_anagram(String a, String b) {
        System.out.println("a: " + a + ", b: " + b );
        //if a == b or if their lengths are 0 then we are done and can return true

ox

// compile with:
//   javac Palindrome.java
// run it with:
//   java Palindrome word
// where word is a word of your choosing

public class Palindrome {
    public static boolean is_palindrome(String s) {
        // if s is an empty string or s is a single character, return true
        if(s == "" || s.length() == 1) return true;

ox

Recursion

Recursion is really easy to understand. It is essentially a function calling itself. Just imagine writing a function that calculates the factorial of a number n (n!). Lets see how it would expand for 4!. Remember that 1! = 1.

(factorial 4)
(4 * (factorial 3))
(4 * (3 * (factorial 3)))
(4 * (3 * (2 * (factorial 1))))
(4 * (3 * (2 * 1)))

ox

module Aleph
  class Application
    def self.run!
      puts "hello world"
    end
  end
  
  # here is where the trick with sinatra is!
  # all of your path defenitions and such have built up a hash
  # of routes. When ruby reaches EOF in your script, it calls this

ox

require 'actor'

Ping = Struct.new :sender
Pong = Struct.new :sender

Actor.spawn do
  Actor.register(:ping, Actor.current)
  loop do
    Actor.receive do |msg|
      msg.when(Ping) do |p|

ox

#!/usr/bin/env ruby
require 'aws/s3'

def help
  puts "S3Console usage:\n"
  puts "s3con <bucket>"
  exit
end

help if ARGV.empty?

ox

 typedef struct stump {
    char * name;
    int data;
 } stump;
 
 typedef struct container {
    stump ** node_array;
 } container;
 
 int compare_stumps(const void *a, const void *b) {

ox

#tell whether the tree is visually symmetric (it is)
class Node
  attr_reader :value, :left, :right
  def initialize(value, left, right)
    @value, @left, @right = value, left, right
  end
  
  #added in to see output
  def to_s; @value.to_s; end
  def inspect; @value.to_s; end

ox

require 'rack'
require 'flea'

interpreter = Flea::Interpreter.new

run Proc.new { |env|
  interpreter.run(File.read(File.new("server.scm")))
  a = interpreter.evaluate([:call, env]).map! {|x| 
    interpreter.evaluate(x)
  }

ox

class Router
  attr_accessor :routes
  
  def initialize
    @routes = {}
  end
  
  def add_route(path, &block)
    @routes[path] = block
  end