atom.xml

<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">

  <title><![CDATA[a bystander's contribution]]></title>
  <link href="http://raywu.github.com/atom.xml" rel="self"/>
  <link href="http://raywu.github.com/"/>
  <updated>2013-01-10T19:13:12+08:00</updated>
  <id>http://raywu.github.com/</id>
  <author>
    <name><![CDATA[Ray Wu]]></name>
    
  </author>
  <generator uri="http://octopress.org/">Octopress</generator>

  
  <entry>
    <title type="html"><![CDATA[TIL RubyGems.org is partially blocked in China]]></title>
    <link href="http://raywu.github.com/blog/2012/10/20/til-rubygems-dot-org-is-partially-blocked-in-china/"/>
    <updated>2012-10-20T14:02:00+08:00</updated>
    <id>http://raywu.github.com/blog/2012/10/20/til-rubygems-dot-org-is-partially-blocked-in-china</id>
    <content type="html"><![CDATA[<p>Today I tried to do <em>bundle install</em>:</p>

<div><script src='https://gist.github.com/3922248.js?file=ConsoleRubyGems.rb'></script>
<noscript><pre><code>$ bundle install
Fetching gem metadata from http://rubygems.org/.
Error Bundler::HTTPError during request to dependency API
Fetching full source index from http://rubygems.org/
^C
Quitting...</code></pre></noscript></div>


<p>According to the mirror site below, it is because RubyGems.org is being hosted on Amazon S3 AFAIK, and Amazon S3 is partially blocked (I have no way of knowing for sure).</p>

<p>A friend showed me a neat trick, which every Rails engineer first learns being behind the <em>Great Firewall of China</em>:</p>

<p>Replace the <strong>source</strong> with this line in GemFile: <strong>source &#8220;http://ruby.taobao.org&#8221;</strong></p>

<p>Go visit the <a href="http://ruby.taobao.org/">mirror site</a></p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Project Euler Problem 11: Ruby]]></title>
    <link href="http://raywu.github.com/blog/2012/10/02/project-euler-problem-11-ruby/"/>
    <updated>2012-10-02T02:28:00+08:00</updated>
    <id>http://raywu.github.com/blog/2012/10/02/project-euler-problem-11-ruby</id>
    <content type="html"><![CDATA[<h3><a href="http://projecteuler.net/problem=11">Problem 11:</a></h3>


<p><em>In the 2020 grid below, four numbers along a diagonal line have been marked in red.</em></p>

<p>08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08<br/>
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00<br/>
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65<br/>
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91<br/>
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80<br/>
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50<br/>
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70<br/>
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21<br/>
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72<br/>
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95<br/>
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92<br/>
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57<br/>
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58<br/>
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40<br/>
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66<br/>
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69<br/>
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36<br/>
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16<br/>
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54<br/>
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48</p>

<p><em>The product of these numbers is 26  63  78  14 = 1788696.</em></p>

<p><em>What is the greatest product of four adjacent numbers in any direction
(up, down, left, right, or diagonally) in the 2020 grid?</em></p>

<h3> My attempt </h3>




<div><script src='https://gist.github.com/3812900.js?file=problem11.rb'></script>
<noscript><pre><code>grid_string = &lt;&lt;EOS
08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48
EOS

grid = []
grid_string.each_line do |line|
  grid &lt;&lt; line.split #=&gt; array of rows
  end

grid.map! do |row|
  row.map! do |x|
    x.to_i
  end
end

$max = 0

def compute(array)
  product = []
  i = 0
  for line in array
    while line[i+3]
      product &lt;&lt; line[i] * line[i+1] * line[i+2] * line[i+3]
      i += 1
    end
    i = 0
  end
  product.max #=&gt; outputs max
end

def max?(x)
  if $max &lt; x
    $max = x
  end
end

# ==HORIZONTAL==

max?(compute(grid))

# ==VERTICAL==

num = []
arr_col = []

grid[i].each_index do |x|
  while grid[i]
    num &lt;&lt; grid[i][x]
    i += 1
  end
  arr_col &lt;&lt; num
  i = 0
  num = []
end

max?(compute(arr_col))

# ==DIAGNAL Upper Left to Bottom Right==

num = []
arr_utb = []

grid.each_index do |i|
  grid[i].each_index do |x|
    while grid[i]
      num &lt;&lt; grid[i][x]
      i += 1
      x += 1
    end
    arr_utb &lt;&lt; num.compact
    num = []
  end
end

max?(compute(arr_utb))

# ==DIAGNAL Bottom Left to Upper Right==

num = []
arr_btu = []

grid.each_index do |i|
  grid[i].each_index do |x|
    while grid[20-i]
      num &lt;&lt; grid[20-i][x]
      i += 1
      x += 1
     break if (20 - i) &lt; 0 # this prevents the collection to continue recursively
    end
    arr_btu &lt;&lt; num.compact
    num = []
  end
end

max?(compute(arr_btu))
  
puts &quot;The highest product is #{$max}&quot;</code></pre></noscript></div>


<p>My solution heavily relies on proper scoping.</p>

<p>I used the <strong>$max</strong> global variable so the method <strong>max?(x)</strong> can access and edit the same <strong>$max</strong>.</p>

<p><strong>There are also a few neat tricks that I learned:</strong></p>

<ul>
<li>I didn&#8217;t know about <a href="http://en.wikipedia.org/wiki/Here_document#Ruby">ruby here doc</a>; this will come in handy on Project Euler for inputs</li>
<li>Here Doc really helped visualizing the grid in nested arrays</li>
<li>Array method <a href="http://www.ruby-doc.org/core-1.9.3/Array.html#method-i-each_index">each_index</a> is super useful to loop through each item in the array</li>
<li>Around <strong>Line #103</strong>, it was an epiphany to use the inverse count <strong>( 20 - i )</strong></li>
<li><strong>Line #107</strong> is also crucial; otherwise, the output array will not stop at edge of the grid (will continue on and pick up the thread on the opposite side of the grid)</li>
</ul>


<h3> Conclusion </h3>


<p>The diagnal parts have much room for improvement. The current codes are not optimal. They also loop through a ton codes (<strong>arr_utb.uniq</strong> shed much light). Otherwise, I am pretty happy with the refactoring jobs I did up top for <strong>compute(array)</strong> and <strong>max?(x)</strong>.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Break if found]]></title>
    <link href="http://raywu.github.com/blog/2012/03/20/break-if-found/"/>
    <updated>2012-03-20T22:32:00+08:00</updated>
    <id>http://raywu.github.com/blog/2012/03/20/break-if-found</id>
    <content type="html"><![CDATA[<p>Ruby blocks are awesome. I find myself using a lot of enumerables &amp; enumerators.</p>

<p>Not knowing how to break out of a block is a problem I ran into a lot.</p>

<p>In Problem 9 of <a href="http://www.projecteuler.net">Project Euler</a>, the answer has to satisfy the condition of x ^ 2 + y ^ 2 = c ^ 2.</p>

<div><script src='https://gist.github.com/2093533.js?file=problem9false.rb'></script>
<noscript><pre><code># Problem 9
# A Pythagorean triplet is a set of three natural numbers, a  b  c, for which,
# a^2 + b^2 = c^2
# For example, 3^2 + 4^2 = 9 + 16 = 25 = 5^2.
# There exists exactly one Pythagorean triplet for which a + b + c = 1000.
# Find the product abc.

 found = []

 (1..1E3).each { |x|
   (1..1E3).each { |y|
     puts &quot;a = #{x}, b = #{y}, c = #{1000 - x - y}, product = #{x * y * (1000 - x - y)}&quot;
     found &lt;&lt; [x, y, (1000 - x - y)] if x ** 2 + y ** 2 == (1000 - x - y) ** 2
   }
 }
 
 p found.inspect</code></pre></noscript></div>


<p>This nested block describes the logic needed for the answer.
Printing out &#8216;found&#8217; displays the answer in an array. This took a while.</p>

<h3> Using Break </h3>




<div><script src='https://gist.github.com/2093533.js?file=problem9.rb'></script>
<noscript><pre><code> found = false

 (1..1E3).each { |x|
   (1..1E3).each { |y|
     puts &quot;a = #{x}, b = #{y}, c = #{1000 - x - y}, product = #{x * y * (1000 - x - y)}&quot;
     found = true if x ** 2 + y ** 2 == (1000 - x - y) ** 2
     break if found
   }
   break if found
 }</code></pre></noscript></div>


<p>In this scenario, by setting &#8216;found = false&#8217; (line 1), it gives the block a heads up to break out of the loop, when &#8216;found&#8217; returns true.</p>

<p>This dramatically reduces the time to run the script.</p>

<h3> Conclusion </h3>


<p>Blocks are awesome; but knowing when to break out of a loop is double awesome.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[OmniAuth Environment Handling]]></title>
    <link href="http://raywu.github.com/blog/2012/03/18/omniauth-environment-handling/"/>
    <updated>2012-03-18T12:01:00+08:00</updated>
    <id>http://raywu.github.com/blog/2012/03/18/omniauth-environment-handling</id>
    <content type="html"><![CDATA[<p>OmniAuth is very powerful, and it&#8217;s dramatically improved after 2.0 came out. I only started to feel more comfortable with its magic after the third time using it.</p>

<p>One thing I didn&#8217;t do before, was to set separate authentication keys
for development and production environments.</p>

<p>Doing this on the <a href="http://tourious.co/">Tourious</a> app made life so much easier!</p>

<h3>Here are the files</h3>


<p>This is the standard OmniAuth set up on initializer. Instead of passing authentication keys directly, set them to constants.</p>

<div><script src='https://gist.github.com/2076187.js?file=omniauth.rb'></script>
<noscript><pre><code># resides at config/initializer/omniauth.rb

Rails.application.config.middleware.use OmniAuth::Builder do
  provider :twitter, TWITTER_KEY, TWITTER_SECRET
  provider :facebook, FACEBOOK_KEY, FACEBOOK_SECRET
end
</code></pre></noscript></div>


<p>Pass the constants with a set of keys from Twitter and Facebook for
development environment:</p>

<div><script src='https://gist.github.com/2076187.js?file=development.rb'></script>
<noscript><pre><code>Tourious::Application.configure do
  # Settings specified here will take precedence over those in config/application.rb

  TWITTER_KEY = 'Development Keys'
  TWITTER_SECRET = 'Development Secret'
  FACEBOOK_KEY = 'Development Keys'
  FACEBOOK_SECRET = 'Development Secret'

  # In the development environment your application's code is reloaded on
  # every request. This slows down response time but is perfect for development
  # since you don't have to restart the web server when you make code changes.
  config.cache_classes = false

  # Log error messages when you accidentally call methods on nil.
  config.whiny_nils = true

  # Show full error reports and disable caching
  config.consider_all_requests_local       = true
  config.action_controller.perform_caching = false

  # Don't care if the mailer can't send
  config.action_mailer.raise_delivery_errors = false

  # Print deprecation notices to the Rails logger
  config.active_support.deprecation = :log

  # Only use best-standards-support built into browsers
  config.action_dispatch.best_standards_support = :builtin

  # Raise exception on mass assignment protection for Active Record models
  config.active_record.mass_assignment_sanitizer = :strict

  # Log the query plan for queries taking more than this (works
  # with SQLite, MySQL, and PostgreSQL)
  config.active_record.auto_explain_threshold_in_seconds = 0.5

  # Do not compress assets
  config.assets.compress = false

  # Expands the lines which load the assets
  config.assets.debug = true
end
</code></pre></noscript></div>


<p>Create another set of Twitter and Facebook authentication keys strictly for production:</p>

<div><script src='https://gist.github.com/2076187.js?file=production.rb'></script>
<noscript><pre><code>Tourious::Application.configure do
  # Settings specified here will take precedence over those in config/application.rb

  TWITTER_KEY = 'Production Keys'
  TWITTER_SECRET = 'Production Secret'
  FACEBOOK_KEY = 'Production Keys'
  FACEBOOK_SECRET = 'Production Secret'

  # Code is not reloaded between requests
  config.cache_classes = true

  # Full error reports are disabled and caching is turned on
  config.consider_all_requests_local       = false
  config.action_controller.perform_caching = true

  # Disable Rails's static asset server (Apache or nginx will already do this)
  config.serve_static_assets = false

  # Compress JavaScripts and CSS
  config.assets.compress = true

  # Don't fallback to assets pipeline if a precompiled asset is missed
  config.assets.compile = true

  # Generate digests for assets URLs
  config.assets.digest = true

  # Defaults to Rails.root.join(&quot;public/assets&quot;)
  # config.assets.manifest = YOUR_PATH

  # Specifies the header that your server uses for sending files
  # config.action_dispatch.x_sendfile_header = &quot;X-Sendfile&quot; # for apache
  # config.action_dispatch.x_sendfile_header = 'X-Accel-Redirect' # for nginx

  # Force all access to the app over SSL, use Strict-Transport-Security, and use secure cookies.
  # config.force_ssl = true

  # See everything in the log (default is :info)
  # config.log_level = :debug

  # Prepend all log lines with the following tags
  # config.log_tags = [ :subdomain, :uuid ]

  # Use a different logger for distributed setups
  # config.logger = ActiveSupport::TaggedLogging.new(SyslogLogger.new)

  # Use a different cache store in production
  # config.cache_store = :mem_cache_store

  # Enable serving of images, stylesheets, and JavaScripts from an asset server
  # config.action_controller.asset_host = &quot;http://assets.example.com&quot;

  # Precompile additional assets (application.js, application.css, and all non-JS/CSS are already added)
  # config.assets.precompile += %w( search.js )

  # Disable delivery errors, bad email addresses will be ignored
  # config.action_mailer.raise_delivery_errors = false

  # Enable threaded mode
  # config.threadsafe!

  # Enable locale fallbacks for I18n (makes lookups for any locale fall back to
  # the I18n.default_locale when a translation can not be found)
  config.i18n.fallbacks = true

  # Send deprecation notices to registered listeners
  config.active_support.deprecation = :notify

  # Log the query plan for queries taking more than this (works
  # with SQLite, MySQL, and PostgreSQL)
  # config.active_record.auto_explain_threshold_in_seconds = 0.5
end
</code></pre></noscript></div>




<h3> Conclusion </h3>


<p>This way, I can also set different call-back URL on Twitter and Facebook, and never have to touch the settings again.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Hello World!]]></title>
    <link href="http://raywu.github.com/blog/2012/03/17/hello-world/"/>
    <updated>2012-03-17T20:38:00+08:00</updated>
    <id>http://raywu.github.com/blog/2012/03/17/hello-world</id>
    <content type="html"><![CDATA[<p>A few months earlier, I started tackling <a
href="http://www.projecteuler.net">Project Euler</a>. Here is one of the
lessons I learned:</p>

<h3>Avoid Infinite Loops</h3>


<p>Yes, Infinite Loop. I thought I had you pinned to the wall, but I was wrong; I didn&#8217;t even realize what I got myself into. No, not until my buddy <a href="http://www.github.com/igrabes">Ian Grabill</a> pointed it out.</p>

<h3>Project Euler&#8217;s #3 problem:</h3>


<p> What is the largest prime factor of the number 600851475143 ?
The way I started out with this problem, was to get all the factors for the number in question. My approach was to wrap the number in question into a method as an argument:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="k">def</span> <span class="nf">factor</span><span class="p">(</span><span class="n">num</span><span class="p">)</span>
</span><span class='line'>  <span class="p">(</span><span class="mi">2</span><span class="o">.</span><span class="n">.num</span><span class="p">)</span><span class="o">.</span><span class="n">map</span> <span class="p">{</span> <span class="o">|</span><span class="n">n</span><span class="o">|</span> <span class="k">yield</span> <span class="n">n</span> <span class="k">if</span> <span class="n">num</span><span class="o">/</span><span class="n">n</span> <span class="o">*</span> <span class="n">n</span> <span class="o">==</span> <span class="n">num</span> <span class="p">}</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>This seemed straight forward enough. Boom, donzo.
I ran the script to test it out with 40, and factor(40) worked beautifully. Then I tried it withfactor(600,851,475,143); 10 seconds&#8217; went by, nothing yet. 120 seconds, nothing still. Next thing I knew, my computer was screeching noises I hadn&#8217;t ever heard before. Ctrl-C, Ctrl-C, Ctrl-C, abort, abort!!!</p>

<p>What happened?
While 40 spat out 8 numbers that are all divisble to 40, who knows how many of these factors are out there for 600851475143.
So, now what?</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="k">def</span> <span class="nf">factor</span><span class="p">(</span><span class="n">num</span><span class="p">,</span> <span class="n">limit</span><span class="p">)</span>
</span><span class='line'>  <span class="p">(</span><span class="mi">1</span><span class="o">.</span><span class="n">.limit</span><span class="p">)</span><span class="o">.</span><span class="n">map</span> <span class="k">do</span> <span class="o">|</span><span class="n">f</span><span class="o">|</span>
</span><span class='line'>    <span class="n">num</span> <span class="o">/</span> <span class="n">f</span>
</span><span class='line'>    <span class="k">yield</span> <span class="n">f</span> <span class="k">if</span> <span class="n">num</span> <span class="o">/</span> <span class="n">f</span> <span class="o">*</span> <span class="n">f</span> <span class="o">==</span> <span class="n">num</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>After talking to Ian at 2am ET about this ungodly problem of mine, he pointed me to this neat little trick. Ian had discovered that by dividing each number within a range of (1..limit) into the num (in this case 600851475143), would help you find all the factors within a contained range.</p>

<p>For instance, factor(600851475143, 10000) would only look for all the factors of 600851475143 that were within the range of (1..10000). This made my computer happy.</p>

<h3>Conclusion</h3>


<p>Granted, had my MacBook Pro had more computing power, and my memories a gizzillion GBs, I could have just left the script run until it got all the factors for 600851475143.</p>

<p>Okay, okay, IT&#8217;S NOT AN INFINITE LOOP. But my point is, if you have an inkling that you will run into this kind of technical problems (Hello Houston!), put a cap on it.</p>
]]></content>
  </entry>
  
</feed>