Cómo hacer un Hello World! en distintos lenguajes de programación.

El Hello World es un ejercicio básico de programación. Casi en cualquier lenguaje de programación que estudies empezarás en la primera lección programando uno. Aquí te dejo diversos ejemplos en distintos lenguajes
, lo que además te permitirá ver algunas de las pequeñas diferencias que hay entre ellos.

ASP:

Response.Write "Hello World!" 

Script de Bash:

#!/bin/bash
echo "Hello, World!" 

C:

#include 
main(){
  printf ("Hello World!\n");
}

C++:

#include 
using namespace std;
void main(){
  cout << "Hello World!" << endl;
}

C#:

using System;
namespace HelloWorld
{
    class Hello 
    {
        static void Main() 
        {
            Console.WriteLine("Hello World!");            
        }
    }
}

Java:

class hellWorldJava{
  public static void main(String args[]){
    System.out.println("Hello World!");
  }
}

Javascript:

window.alert( 'Hello, world!' );

Objective C:

#import 

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        NSLog(@"Hello, World!");
    }
    return 0;
}

Perl:

#!/usr/bin/perl
print “Hello World.\n”;

PHP:

echo "Hello World!";

Script de Powershell:

$strString = "Hello World"
write-host $strString

Python:

print "Hello, World!"

R:

print("Hello World!", quote = FALSE)

Ruby:

puts 'Hello world'

Función palindrome? en Ruby

Otro de los ejercicios del Curso SAAS de Berkeley era hacer un método que comprobara un palíndromo (ej 1) e incluirlo dentro de la clase String (en el ej… 5 o el 6, no me acuerdo). En todo caso, puede parecer algo extremadamente simple, pero tiene un mínimo de chicha.

Digo que tiene más chicha porque más allá de hacer un simple reverse, que nos valdría para una palabra sola, la idea es hacerlo ignorando espacios y números, para poder aplicarlo a una frase completa, y que además no sea case sensitive (vamos, que no distinga mayúsculas de minúsculas). Tampoco tiene mucha complicación, es todo cuestioń de una expresión regular:

def palindrome?(string)
    letters = string.downcase.scan(/\w/)
    letters == letters.reverse
  end

Cuatro líneas… bueno, realmente dos porque las otras dos definen el método. ¿Y meterlo dentro de String? Dos líneas más, una modificación y vía. Es la potencia de Ruby, que puedes abrir cualquier clase cuando lo necesites:

class String
  def palindrome?
    letters = self.downcase.scan(/\w/)
    letters == letters.reverse
  end
end

El método devolverá true en caso de éxito y nulo en caso de que no haya coincidencia. Sencillo y liquidado.

Producto cartesiano de dos arrays en Ruby

Bueno, sigo con el curso de SAAS de Berkeley, y me ha dado por poner otro ejercicio (bueno, realmente es que llevo días sin escribir, estoy sin ideas y como acabo de hacerlo…). En este caso el último del “homework 1”, que ha sido todo un alivio porque me esperaba algo jodidérrimo pero… no, para nada, es una chorrada tan gorda como hacer una clase con un método each que muestre el producto cartesiano de dos arrays:

class CartesianProduct
  include Enumerable
  def initialize(col1, col2)
    @col1 = col1
    @col2 = col2
  end

  def each
    return to_enum unless block_given?
    @col1.each do |x| 
      @col2.each { |y| yield [x, y] }
    end
  end
end

Como ya ves el constructor de la clase recibe dos arrays (col1 y col2) para inicializar el objeto, y por otra parte el método each recorre el primero cruzando cada elemento con todos los elementos del segundo (de ahí que haya un each dentro de otro each).

Fácil, rápido y barato… por decir algo.

Piedra-papel-tijera en Ruby

Un pequeño ejercicio de Ruby que he tenido que hacer en el curso de SaaS de Berkeley (en EdX) es un método que “juegue” al tres en raya. Recibiendo un array bidimimensional (la variable game en el ejemplo) debe devolver el resultado de qué jugador sería el ganador. Si hay más de dos jugadores devuelve una excepción, y si alguno mete una letra que no sea R (rock), P (paper), S (scissors) lanza otra excepción (ambas vienen ya dadas en el código de ejemplo). Finalmente, si ambos sacan lo mismo da como ganador al jugador 1 (¿por qué? pues porque es lo que pide el enunciado a reclamarle al maese armero)

En fin, el código sería tal que así:

class WrongNumberOfPlayersError < StandardError ; end
class NoSuchStrategyError < StandardError ; end

def rps_game_winner(game)
  raise WrongNumberOfPlayersError unless game.length == 2
  game[0][1] = game[0][1].downcase
  game[1][1] = game[1][1].downcase
  raise NoSuchStrategyError if game[0][1] != 'r' and game[0][1] != 'p' and game[0][1] != 's'
  raise NoSuchStrategyError if game[1][1] != 'r' and game[1][1] != 'p' and game[1][1] != 's'
  ganador = 0
  if game[0][1] == 'r'
   if game[1][1] == 'r'
   elsif game [1][1] == 'p'
   ganador = 1
   else
   end
  elsif game[0][1] == 'p'
   if game[1][1] == 'r'
   elsif game [1][1] == 'p'
   else
   ganador = 1
   end
  else
   if game[1][1] == 'r'
   ganador = 1
   elsif game [1][1] == 'p'
   else
   end
  end
  return game[ganador]
end

La chicha viene con la segunda parte del ejercicio, el modo tournament. Este recibe un array de arrays bidimensionales con todos los enfrentamientos (hay que suponer que están bien formados y bien anidados, y debe permitir cualquier cantidad de jugadores, siempre que crezcan en progresión de potencias de 2: 4,8,16,32… piensa el cualquier Play off de cualquier deporte) y los recorre como una eliminatoria. Ponen como ejemplo que reciba algo tal que así:

[
    [
        [ ["Armando", "P"], ["Dave", "S"] ],
        [ ["Richard", "R"],  ["Michael", "S"] ],
    ],
    [
        [ ["Allen", "S"], ["Omer", "P"] ],
        [ ["David E.", "R"], ["Richard X.", "P"] ]
    ]
]

Ok, ¿qué hacer frente al anidamiento? Pues recursividad, tema que ya explicamos. En este caso, el método comprobará que cada array a su vez contenga un array y si es así vuelve a llamarse a si mismo hasta que llegue a un enfretamiento, donde entonces llamará al método de la primera parte para devolver al ganador.

def rps_tournament_winner(tournament)
  if tournament[0][0].kind_of?(Array)
       rps_game_winner([rps_tournament_winner(tournament[0]), rps_tournament_winner(tournament[1])])
  else
   rps_game_winner(tournament)
  end
end

Y con esto y un bizcocho, ejercicio realizado. Lo he enviado y ya está corregido, y me ha dado el 100%, así que espero que os aclare las dudas. (Como dice un colega mío “no me copiar, me cago en Satán”… en fin, o sí, que yo tampoco soy ni profesor ni vuestro padre). En todo caso veis que con la recursividad un simple if/else resuelve toda la carga de trabajo en cinco líneas (bueno, realmente dos)

Parsear un XML en Ruby

Ando mirando cosillas de Ruby ya que mañana empiezo un curso de SAAS y entre otras cosas he encontrado cómo parsear un xml tirando de Ruby. En Yahoo respuestas me he encontrado dos opciones: Usar REXML o XML-Simple.

En el caso del primero comentan que es lo más típico, ya que REXML es parte de la librería estandard de Ruby. Y como ejemplo de su uso explican cómo utilizarlo para parsear los datos devueltos por el API de Yahoo Web Search.:

require 'net/http'
require 'rexml/document'

# Búsqueda web de la palabra "madonna"
url = 'http://api.search.yahoo.com/WebSearchService/V1/webSearch?appid=YahooDemo&query=madonna&results=2'

# obtener los datos xml como una cadena
xml_data = Net::HTTP.get_response(URI.parse(url)).body

# extraer la información del evento
doc = REXML::Document.new(xml_data)
titles = []
links = []
doc.elements.each('ResultSet/Result/Title') do |ele|
   titles << ele.text
end
doc.elements.each('ResultSet/Result/Url') do |ele|
   links << ele.text
end

# imprimir todos los eventos
titles.each_with_index do |title, idx|
   print "#{title} => #{links[idx]}\n"
end

En fin, la cosa no parece muy compleja. Para XMLSimple tampoco hay mucha complicación. Se trata de un port de la librería de Perl XMLSimple que os podéis descargar en este enlace y que para muchos es más intuitivo que REXML. En el ejemplo se haría la misma operación que en el anterior, para que compruebes las diferencias en la sintaxis:

require 'net/http'
require 'rubygems'
require 'xmlsimple'

#buscamos "madonna" y lo cogemos como XML
url = 'http://api.search.yahoo.com/WebSearchService/V1/webSearch?appid=YahooDemo&query=madonna&results=2'
xml_data = Net::HTTP.get_response(URI.parse(url)).body

data = XmlSimple.xml_in(xml_data)

#Pateamos los datos y los imprimimos.
data['Result'].each do |item|
   item.sort.each do |k, v|
      if ["Title", "Url"].include? k
         print "#{v[0]}" if k=="Title"
         print " => #{v[0]}\n" if k=="Url"
      end
   end
end

XMLSimple lo que hace es transformar los datos XML a una estructura de datos nativa de Ruby.

En fin, son dos ejemplillos simplones de cómo funcionan ambas librerías para parsear XML. En este enlace tenéis más info sobre REXML y en este sobre XMLSimple para profundizar.