Aetus Designs

Project Euler Problem 40

Vikhyat Korrapati — Thu, 29 Oct 2009 10:21:42 +0000

In my opinion, this was the easiest problem so far. The brute-force method is easy to implement and runs very fast.

This is the code:

$fraction = ''
 
1.upto(1000000) do |i|
  $fraction << i.to_s
end
 
def d_(n)
  $fraction[n-1].to_i
end
 
puts d_(1) * d_(10) * d_(100) * d_(1000) * d_(10000) * d_(100000) * d_(1000000)

It runs in slightly lesser than one second.

The last line isn’t very Ruby-ish because I copied it from the problem description page, because I’m too lazy to write it myself. That’s also why I have a d_(n) function.

Project Euler Problem 21 (Ruby)

Vikhyat Korrapati — Thu, 24 Sep 2009 16:57:21 +0000

If you intend to solve the problem on your own, I wouldn’t recommend reading any further.

Let be defined as the sum of proper divisors of (numbers less than which divide evenly into ).
If and , where , then a and b are an amicable pair and each of a and b are called amicable numbers.

For example, the proper divisors of 220 are 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 and 110; therefore . The proper divisors of 284 are 1, 2, 4, 71 and 142; so .

Evaluate the sum of all the amicable numbers under 10000.

(Problem 21 – Project Euler)

def d(n)
  total = 0
  1.upto n/2 do |i|
    if (n % i) == 0
      total += i
    end  
  end
  total
end
 
amicable_sum = 0
 
10000.times do |a|
  b = d(a)
  if d(b) == a && b > a
    amicable_sum += a + b
  end
end
 
puts amicable_sum

My version of isn’t as efficient as the one in the PDF you get after solving the problem, but it gets the job done.

Running it takes around 8.5 seconds on my machine. That’s not too bad for ~20 lines of code.

Fajan’s Rules

Vikhyat Korrapati — Sat, 15 Aug 2009 09:56:24 +0000

Fajan’s Rules are a set of empirical rules that are used to predict whether an inorganic compound will be ionic or covalent.

I find it easier to remember stuff when it look’s like math, so I organized these rules in the form of proportions. Hopefully, it will help others as well.

Velox – Random Latin Words

Vikhyat Korrapati — Tue, 16 Jun 2009 10:49:04 +0000

I’ve always had a hard time naming the photographs I post on dA. Eventually, I started using a random Latin word. But going through a huge list of words looking for something that sounds cool was still tedious. So I did what anyone else in my situation would – write a web app to make my life easy. It’s called Velox (which was one of the words it came up with while testing it). As usual, it’s hosted at Heroku. Here’s a link to it- Velox – Random Latin Words.

Here’s the complete source code.

%w[ sinatra datamapper erb ].each do {|lib| require lib }
 
# Database stuff
DataMapper.setup(:default, ENV['DATABASE_URL'] || "sqlite3://#{Dir.pwd}/db.sqlite3")
 
class Word
  include DataMapper::Resource
  property :id, Serial
  property :wd, String, :length => 16
end
 
DataMapper.auto_upgrade!
# End of database stuff
 
# Build a database containing all of those words the first time the app is
# run. 'database.rb' basically contains a huge array of latin words and some
# code that iterates through it and adds each word to a database. It's quite
# slow on sqlite because (I think) every database query has to be written to the
# hard disk.
configure :production do
  require 'database'
end
 
get '/' do
  # Get a random word, make it small characters and get rid of any 
  # non-alphanumeric characters.
  @word = Word.get(1+rand(3402)).wd.downcase.gsub(/\W/, '')
  erb :index
end
 
use_in_file_templates!
 
__END__
 
@@ layout

  
    Velox - Random Latin Words
    
  
  
    Velox - Random Latin Words
    <%=yield%>
    Get Another!
    
      Aetus Designs
      |
      Revolution X
    
  

 
@@ index
<%=@word%>

Automatically Resize Large Images with Javascript

Vikhyat Korrapati — Sun, 24 May 2009 06:49:59 +0000

When you allow users to submit content, and allow that content to include images, there’s always a chance that some user will submit a really large image that will break your layout. One way to solve that is to check the content for large images and resize them using a server-side program. However, sometimes, that is simply not possible. In those cases, we use what’s left- Javascript.

$(document).ready(function() {
  (
    function(maxht, maxwt, minht, minwt) {
      var imgs = document.getElementsByTagName('img');
      // Image resizing function
      var resize_image = function(img, newht, newwt) {
        img.height = newht;
        img.width  = newwt;
      };
 
      for (var i = 0; i < imgs.length; i++) {
        // Set a variable for the current image to make the code
        // make more sense.
        var img = imgs[i];
        if (img.height > maxht || img.width > maxwt) {
          // Use Ratios to constraint proportions.
          var old_ratio = img.height / img.width;
          var min_ratio = minht / minwt;
          // If it can scale perfectly.
          if (old_ratio === min_ratio) {
            resize_image(img, minht, minwt);
          } 
          // We need to do some magic now.
          else {
            var newdim = [img.height, img.width];
            // Sort out the height first.
            newdim[0] = minht;
            // The logic behind this is that if ratio = ht / wt,
            // then wt = ht / ratio.
            newdim[1] = newdim[0] / old_ratio;
            // Do we still have to sort out the width?
            if (newdim[1] > maxwt) {
              // Just do what we did with the height
              newdim[1] = minwt;
              newdim[0] = newdim[1] * old_ratio;
            }
            // So yeah, resize the image
            resize_image(img, newdim[0], newdim[1]);
          }
        }
      }
    }
  )(500, 500, 500, 500);
});

To change the dimensions above which images should be resized, and the dimensions to which it should be resized, you’d want to edit line 43.

This script depends up on jQuery only to make it run after the page has loaded. If you want to get it to work without jQuery, you’d only need to swap out that part. You could also use jQuery’s wrap function to put the resized image in a frame with a notice and stuff. You can see that in action here.

Feel free to use this (as long as you give credit), and let me know if you do.

This work by Aetus Designs is licensed under a Creative Commons Attribution 3.0 Unported License.

Zenity.rb

Vikhyat Korrapati — Tue, 12 May 2009 06:55:18 +0000

Zenity is a command line based tool that helps shell scripts display GTK dialog boxes as a more interactive way to display error messages, get user input and other stuff like that. From it’s Freshmeat page,

Zenity is a tool that allows you to display Gtk+ dialog boxes from the command line and through shell scripts. It is similar to gdialog, but is intended to be saner. It comes from the same family as dialog, Xdialog, and cdialog, but it surpasses those projects by having a cooler name.

Zenity.rb is a gem (or optionally a single file that you can download and include in your script) that provides a easy way to display zenity dialogs. You can look at the Github and RubyForge project pages.

To install it, run this command in a shell (you may need to run it as su)

gem install Zenity.rb

Then try this out in irb:

require 'zenity'
Zenity::entry(:title => 'Enter some text', :text => 'This is a password dialog.', :arg => ['hide-text'])

The last line there gets translated to this: “zenity --entry --title='Enter some text' --text='This is a password dialog.' --hide-text” which is then passed to the operating system. So it basically depends upon the presence of zenity.

The code itself is very minimal. The only important file is listed below. If it doesn’t fit completely on your screen, you can also view it here.

module Zenity
  class << self
 
    # Let's just use method_missing instead of defining all of those.
    def method_missing(m, options=false)
      # Check if the dialog box we have to show is allowed
      if [ :calendar, :entry, :error, :'file-selection', :info, :list,
           :notification, :progress, :question, :'text-info', :warning, :scale 
      ].include? m
        # It's in the array and everything seems to be fine
        ret = %x[ #{parseopts('zenity --' + m.to_s, options)} ]
      else
        # We don't know about this dialog, raise an error
        raise "Unknown dialog #{m}"
      end
      # Check if any of the options passed were invalid.
      if ret.rstrip == 'This option is not available. Please see --help for all possible usages.'
        # Write a message to STDERR if there were invalid options, but don't
        # raise an error.
        STDERR << "Invalid option"
      else
        # Everything looks fine. Return what we got.
        return ret
      end
    end
 
 
    private
    # Very confusing code that generates the shell command.
    def parseopts(cmd, options)
      if options != false
        options.each do |k, v|
          cmd << " --#{k}='#{v}'" if k != :arg
        end
        options[:arg].each { |opt| cmd << " --#{opt}" } if options.has_key?(:arg)
      end
      cmd
    end
 
  end
end

As you can see, I chose to use method_missing to reduce the amount of code I’d need to write. As a possible side-effect of this, you may not be able to mix the module into your own classes or into the global namespace.

Overall, the purpose of packaging this in a gem was more for convenience of usage than anything else.

Getting a Method to Accept an Arbitary Number of Arguments in Ruby

Vikhyat Korrapati — Sat, 09 May 2009 10:42:35 +0000

In LISP-like languages such as Scheme, you can do arithmetic with code like this:

(+ 5 5)           ; => 10
(- 3 2)           ; => 1

The + operator there behaves like a function. The striking thing is that it can accept any number of arguments. So you can also do stuff like this:

(+ 1 2 3 4 5)     ; => 15

You can also do that in Ruby, using the splat(*) operator. The splat operator can do a lot of fancy stuff, but I’m not going to cover all of that here.

This is how you would use the splat operator in a method definition to achieve that.

def func(param1, *rest)
  # Code goes here
end

Due to the way we defined that method, it needs to have at least one argument passed to it when we call it. We can, however, pass it more arguments if we wish to.

func('test')              # param1 = 'test', rest = []
func('test', 1, 2, 3)     # param1 = 'test', rest = [1, 2, 3]

We can implement a LISP-style add function like this:

def add(*args)
  args.inject { |m, n| m += n } || 0
end
 
# Let's try out the add method
add               # => 0
add 5, 5          # => 10
add 5, 5, 5       # => 15

Very Simple Metronome in Ruby

Vikhyat Korrapati — Thu, 23 Apr 2009 10:52:27 +0000

A metronome is basically something that beeps periodically, indicating the exact tempo of some music. I wanted one for my guitar practice, but the only one in Ubuntu’s repos (GTick) wouldn’t work, so I wrote this up.

# Emit a tick
def beep
  Thread.new { print "\a" }
end
 
def every(delay)
  loop do
    sleep(delay)
    yield
  end
end
 
# Get the BPM
if ARGV[0] == nil
  puts "Enter the BPM"
  bpm = gets.to_f
else
  bpm = ARGV[0].to_f
end
 
# Convert beats per minute to the number of seconds to wait. For 
# example, a bpm of 60 would equal a one second wait.
delay_seconds = 60.0 / bpm
 
every delay_seconds { beep }

If you want to change how the beeping happens, you only have to edit the beep method right at the top. To do that on Windows, have a look at this post on the win32-sound library. On Linux you could write to /dev/dsp but it might be better to use ALSA. The ruby/audio library is also worth having a look over.

How to Learn a New Programming Language

Vikhyat Korrapati — Sat, 04 Apr 2009 17:40:44 +0000

Learning a new language isn’t the easiest thing to do. It can, however, be a very rewarding experience if you are persistent enough. Luckily, if you know how to code in one language, it is much, much easier to learn another language. Here are some tips that can help you.

Practice

Really, practicing is the only way you can learn a programming language. It is useful to have some standard programs that are the first programs you try out. Since you would already have the logic worked out, the focus would be more on grasping the language’s syntax. Here are some program ideas you can start off with:

Ask the user for his/her favorite number, and then send back a message saying that (favorite_number+1) would have been a bigger and better favorite number.
Implement some form of fractal terrain generation.
An implementation of the HQ9+ programming language. It is very simple to do and will give you a good idea of flow control.

There is a more exhaustive list here.

Use It

You aren’t going to get anywhere if you keep going back to your favorite language to solve everyday problems. You need to pro-actively force yourself to use the language you are trying to master. If, for instance, you know Ruby and want to learn C, stop writing those small, everyday code snippets in Ruby and do them in C instead.

Do it Often

Learn a new language every once in a while. If you keep doing it, you never get out of the flow or settle down with what you know so much that learning something new becomes a struggle. Some people say that you should learn a new language every year, but I think that’s too often. Do what seems right to you.

Don’t Blatantly Reject New Ideas

Seriously, don’t. You need to change your perspective, and even if you can’t move on. Every language has it’s pros and cons. There is no ‘One True Way’, and something need not be right just because you believe it to, or because it’s how your current favorite language implements it. I think I’ll mention an example here. Python forces indentation, so what? It may not be so bad after all, maybe you’ll prefer it’s way later on, and even if you don’t, so what? There are loads of other cool features in it.

Read Code

I can’t possibly stress this enough. Read as much code written by people proficient in the language you are learning. You need to read loads of code. Reading code helps you learn a lot about the language itself, common idioms, quirks and lots of other stuff. Ideally, you should be reading at least as much code as you write.

Summary

This isn’t the first or the final article about this. It’s just what I have to say. Having said that, I’m open to criticism. I’d like to know what you liked and what you didn’t like about this article. I’d appreciate it if you left a comment here.

Be open and be sure to enjoy learning. It shouldn’t be mechanical or forced.

Implemeting HQ9+ in 10 lines of Ruby

Vikhyat Korrapati — Fri, 03 Apr 2009 05:43:32 +0000

HQ9+ is a excessively simple esoteric programming language. It has only four commands:
H: Print “Hello, World!”
Q: Prints the contents of the program onto the screen
9: Print the canonical lyrics of the song, “99 bottles of beer”.
+: Increment the accumulator

Here’s the entire implementation:

def hq9(src)
  src.downcase.split('').each do |i|
    case i
      when 'h'; puts "Hello, World!"
      when 'q'; puts src
      when '9'; 99.downto(0) { |b| puts "#{b==0?'No more b':"#{b} B"}ottle#{'s'if b!=1} of beer on the wall, #{b==0?'No more':b} bottle#{'s'if b!=1} of beer.#{b==0?"nGo to the store and buy some more, 99 bottles of beer on the wall.":"nTake one down and pass it around, #{b-1} bottle#{'s'if b!=2} of beer on the wall.nn"}" }
      when '+'; $i = $i ? $i + 1 : 0;
    end
  end
end

Note: I got the lyric printing code from here.