Programming Insight 1

\[\large\rm Program = Algorithm + Data\ Structure\]

• Algorithm: A series of steps needed for a process or a function

• Data Structure: A system of storing data in a way that can be retrieved.

Finding Prime Numbers

TEST FOR ALL POSSIBLE FACTORS

def find_primes1
  # SETUP A CONTAINER FOR THE RESULTS
  # FOR ALL NUMBERS IN TEST RANGE
    # PRESUME NUM AS PRIME 
    # CHECK FOR FACTORS LESS THAN NUM
      # IF FACTOR FOUND
         # MARK AS NON-PRIME
    # APPEND PRIME TO LIST OF PRIMES

USE RUBY LIBRARY FUNCTION

# LOAD PRIME LIBRARY CLASS

def find_primes3
  # SETUP A CONTAINER FOR THE RESULTS
  # FOR ALL NUMBERS IN TEST RANGE
    # IF A NUMBER IS PRIME
      # SAVE IT
      

Binary numbers

Decimal vs Hexidecimal

\[\begin{matrix} \hline xx \rightarrow & 00 & 01 & 10 & 11 & | & 00 & 01 & 10 & 11\\ \hline xx00 & 0 & 4 & 8 & 12 & | & 0 & 4 & 8 & C\\ xx01 & 1 & 5 & 9 & 13 & | &1 & 5 & 9 & D\\ xx10 & 2 & 6 &10 & 14 & | &2 & 6 &A & E \\ xx11 & 3 & 7 &11 & 15 & | &3 & 7 &B & F\\ \hline \end{matrix}\]

Big-endian vs Little-endian orientation

\[Given\ a\ 64\ bit\ number:\ 0xFEDCBA9876543210\]

\[\rm\eqalign{Byte:&\ \ 0\quad 1\quad 2\quad \ 3\quad 4\quad 5\quad 6\quad 7\quad 8\quad\\ Big-Endian: &\fbox{FE}\fbox{DC}\fbox{BA}\fbox{98}\fbox{76}\fbox{54}\fbox{32}\fbox{10}\\ &most\ significant\ byte\ first\\ Little-Endian:& \fbox{01}\fbox{23}\fbox{45}\fbox{67}\fbox{89}\fbox{AB}\fbox{CD}\fbox{EF}\\ & most\ significant\ byte\ last\\ }\]

Negative Integer in 3 steps

1. Represent the absolute value in binary

\[\abs(-11) \rightarrow 00001011\]

2. Invert the bits

\[00001011 \rightarrow 11110100\]

3. Add one to the result

\[11110100 + 00000001 \rightarrow 11110101\]

BCD Arithmetric

Addition with adjustment

Ruby installation

https://www.ruby-lang.org/en/downloads/

• Install Ruby
• Install robocop
• Notepad++

Basics .{scrollable}

• $ irb: to write ruby in the terminal
• don’t use ' in ruby, use " instead
• you can replace most {} with do end and vice versa –– not true for hashes or #{} escapings
• Best Practice: end names that produce booleans with question mark
• CRUD: create, read, update, delete
• [1,2].map(&:to_i)
• integer: number without decimal
• float: number with decimal
• tag your variables:
• • $: global variable
• • @: instance variable
• • @@: class variable
• 1_000_000: 1000000 –– just easier to read

Constants

MY_CONSTANT = # something

Arrays

my_array = [a,b,c,d,e]
my_array[1] # b
my_array[2..-1] # c , d , e
multi_d = [[0,1],[0,1]]
[1, 2, 3] << 4 # [1, 2, 3, 4] same as [1, 2, 3].push(4)

Hashes

hash = { "key1" => "value1", "key2" => "value2" } # same as objects in JavaScript
hash = { key1: "value1", key2: "value2" } # the same hash using symbols instead of strings
my_hash = Hash.new # same as my_hash = {} – set a new key like so: pets["Stevie"] = "cat"
pets["key1"] # value1
pets["Stevie"] # cat
my_hash = Hash.new("default value")
hash.select{ |key, value| value > 3 } # selects all keys in hash that have a value greater than 3
hash.each_key { |k| print k, " " } # ==> key1 key2
hash.each_value { |v| print v } # ==> value1value2

my_hash.each_value { |v| print v, " " }
# ==> 1 2 3

Symbols

:symbol # symbol is like an ID in html. :symbol != "symbol"
# Symbols are often used as Hash keys or referencing method names.
# They can not be changed once created. They save memory (only one copy at a given time). Faster.
:test.to_s # converts to "test"
"test".to_sym # converts to :test
"test".intern # :test
# Symbols can be used like this as well:
my_hash = { key: "value", key2: "value" } # is equal to { :key => "value", :key2 => "value" }

Functions to create Arrays

"bla,bla".split(“,”) # takes string and returns an array (here  ["bla","bla"])

Methods

Methods

def greeting(hello, *names) # *names is a split argument, takes several parameters passed in an array 
  return "#{hello}, #{names}"
end

start = greeting("Hi", "Justin", "Maria", "Herbert") # call a method by name

def name(variable=default)
  ### The last line in here gets returned by default
end

Inheritance

class DerivedClass < Base
  def some_method
    super(optional args) # 
      # Some stuff
    end
  end
end

Modules

module ModuleName 
end

Math::PI # using PI constant from Math module. 

require 'date' # to use external modules.
puts Date.today # 2016-03-18

module Action
  def jump
    @distance = rand(4) + 2
    puts "I jumped forward #{@distance} feet!"
  end
end

class Rabbit
  include Action 
  extend Action 
  attr_reader :name
  def initialize(name)
    @name = name
  end
end

peter = Rabbit.new("Peter")
peter.jump # include
Rabbit.jump # extend

Blocks & Procs

Code Blocks

Blocks are not objects. A block is just a bit of code between do..end or {}. It’s not an object on its own, but it can be passed to methods like .each or .select.

def yield_name(name)
  yield("Kim") # print "My name is Kim. "
  yield(name) # print "My name is Eric. "
end

yield_name("Eric") { |n| print "My name is #{n}. " } 
yield_name("Peter") { |n| print "My name is #{n}. " }

Proc

Saves blocks and are objects. A proc is a saved block we can use over and over.

cube = Proc.new { |x| x ** 3 }
[1, 2, 3].collect!(&cube) # [1, 8, 27]
cube.call 

Lambdas

lambda { |param| block }
multiply = lambda { |x| x * 3 }
y = [1, 2].collect(&multiply) # 3 , 6

Commenting

=begin
Bla
Multiline comment
=end

# single line comment

Printing & Putting

print "bla"
puts "test" # puts the text in a separate line

User Input

gets # reads a line
gets.chomp # removes new line char

For loop

for i in 1...10 
  puts i
end

Loop iterator

i = 0
loop do
  i += 1
  print "I'm currently number #{i}” 
  break if i > 5
end

Next

for i in 1..5
  next if i % 2 == 0
  print i
end

.each

things.each do |item|
  print “#{item}"
end

on hashes like so:

hashes.each do |x,y|
  print "#{x}: #{y}"
end

.times

10.times do |i|
  print "#{i} this text will appear 10 times"
end

.upto / .downto

1.upto(5) { |x| print x, " " } # 1 2 3 4 5
"a".upto("c") { |x| print x, " " } # a b c

Sorting & Comparing

array = [5,4,1,3,2]
array.sort! # = [1,2,3,4,5] 
"a" <=> "b" # 0 if a = b, 1 if a > b, -1 if a < b
array.sort! { |a, b| b <=> a } # to sort from Z to A 

Useful Methods

Table of Contents

• Basics
  
• Vars, Constants, Arrays, Hashes & Symbols
  
• Methods
• Classes
• Modules
• Blocks & Procs
  
• Lambdas
• Calculation
  
• Commenting
  
• Conditions
  
• Printing & Putting
  
• User Input
  
• Loops
• Sorting & Comparing
  
• Useful Methods

1.is_a? Integer # returns true
:1.is_a? Symbol # returns true
"1".is_a? String # returns true
[1,2,3].collect!() # does something to every element (overwrites original with ! mark)
.map() # is the same as .collect
1.2.floor # 1 # rounds down to the nearest integer.
cube.call # call calls procs directly
Time.now # displays the actual time

Characters

String

Literal

     a = 'apple'
     b = 'banana'

Dynamic

     c = 'I love ' + a.pluralize + ' and ' +
        b.pluralize + '.'
        
     d = <<EOM # Hereis document
 I love #{a.pluralize} and #{b.pluralize}.
 EOM
 
     e = "I love #{a.pluralize} and #{b.pluralize}."


     f =  "I love %s and %s." %
             [a.pluralize, b.pluralize]