/*
| Programa 1 c
| Muestra el valor de la variable n
| y su direccion
|
| gcc ejemplo_1.cpp -o salida
|
| Salida:
| n = 75
| &n = 0xbfc4250c
|
| Notas:
| En la linea 
|	printf("&n= %p \n", &n);
| Se utiliza %p para imprimir la direccion del puntero, 
| en este caso, la direccion de n
*/

#include <stdio.h>

int main()
{
	int n = 75;
	printf("n = %d \n", n);
	printf("&n= %p \n", &n);

	return 0;
}

/*
| Programa 1 c++
| Muestra el valor de la variable n
| y su direccion
|
| g++ ejemplo_1.cpp -o salida
|
| Salida:
| n = 75
| &n = 0xbfd283fc
|
| Notas:
| La forma correcta de incluir la libreria es
| #include <iostream>
| no
| #include <iostream.h>
|
| Recuerda, cout solo se puede usar si incluyes iostream
*/

#include <iostream>

using namespace std;

int main()
{
	int n = 75;
	cout<<"n = "<<n<<endl;
	cout<<"&n = "<<&n<<endl;

	return 0;
}

Current time

select current_timestamp
go
-- output
2012-01-02 00:51:22.660

DATEADD
Returns a specified date with the number interval (signed integer) added to a specified datepart of that date.

DATEADD(datepart, number, date)

Some dateparts are year (yy, yyyy), month (m,mm), day (d,dd), hour (hh), minute (mi,n), second (ss,s), millisecond (ms), etc.

Get years

SELECT DATEADD(YEAR, -1, CURRENT_TIMESTAMP) AS previous_year,
DATEADD(YEAR,0,CURRENT_TIMESTAMP) AS present_year
DATEADD(YEAR,1,CURRENT_TIMESTAMP) AS next_year
GO

-- output
2011-01-02 01:10:24.733 -- previous year
2012-01-02 01:10:24.733 -- present year
2013-01-02 01:10:24.733 -- next year

More info:
Zen of SQL
Date and Time functions (Transact-SQL)

Aqui es un extracto

Un teleférico de San Francisco puede contener 60 personas. Este blog fue visto por 2.100 veces en 2011. Si el blog fue un teleférico, se necesitarían alrededor de 35 viajes para llevar tantas personas.

Haz click para ver el reporte completo.

El libro del dragón

Leer El libro del dragón
En el verano tuve la oportunidad de conocer a un doctor en una estancia. Entre muchas otras cosas, nos habló sobre el libro del dragón. En realidad el libro se llama Compilers:Principles, techniques, and tools, pero se le conoce de esta forma por su portada, un caballero medieval frente a un dragón rojo.

Más programación
¿Qué son los punteros a funciones?
¿Cómo funciona el stack y el heap?
¿scala, scheme, haskell, lenguajes funcionales?
¿usar android y c para saltar la maquina virtual y acceder al hardware del telefono?

Paradigmas y algoritmos
Distancias de edicion (en programación dinámica)
Colonia de hormigas
algoritmo matrimonios estables o perfectos

Bioloid
No soy fan de la robótica, pero ver un robot como este es fascinante y más cuando funciona bien.

How to design programs
El título lo dice todo.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using Excel = Microsoft.Office.Interop.Excel;

namespace my_excel
{
    class Program
    {
        static void Main(string[] args)
        {
            // archivo de entrada
            string file = "libro.xls";
            string dir = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
            string xlsFilePath = Path.Combine(dir, file);

            read_file(xlsFilePath);

            Console.ReadKey();
            
            
        }

        public static void read_file(string xlsFilePath)
        {
            if (!File.Exists(xlsFilePath))
                return;

            Excel.Application xlApp;
            Excel.Workbook xlWorkBook;
            Excel.Worksheet xlWorkSheet;
            Excel.Range range;
            var misValue = Type.Missing;//System.Reflection.Missing.Value;

            // abrir el documento
            xlApp = new Excel.ApplicationClass();
            xlWorkBook = xlApp.Workbooks.Open(xlsFilePath, misValue, misValue,
                misValue, misValue, misValue, misValue, misValue, misValue,
                misValue, misValue, misValue, misValue, misValue, misValue);

            // seleccion de la hoja de calculo
            // get_item() devuelve object y numera las hojas a partir de 1
            xlWorkSheet = (Excel.Worksheet)xlWorkBook.Worksheets.get_Item(1);

            // seleccion rango activo
            range = xlWorkSheet.UsedRange;


            // leer las celdas
            int rows = range.Rows.Count;
            int cols = range.Columns.Count;


            for (int row = 1; row <= rows; row++)
            {
                for (int col = 1; col <= cols; col++)
                {

                    // lectura como cadena
                    string str_value = (range.Cells[row, col] as Excel.Range).Value2.ToString();

                    // conversion
                    int int_value = Convert.ToInt32(str_value, 10);

                    Console.WriteLine("string:{0}", str_value);
                    Console.WriteLine("int:{0}", int_value);
                }


            }


            // cerrar
            xlWorkBook.Close(false, misValue, misValue);
            xlApp.Quit();

            // liberar
            releaseObject(xlWorkSheet);
            releaseObject(xlWorkBook);
            releaseObject(xlApp);

        }


        public static void releaseObject(object obj) 
        {
            try
            {
                System.Runtime.InteropServices.Marshal.ReleaseComObject(obj);
                obj = null;
            }
            catch (Exception ex)
            {
                Console.WriteLine("Unable to release the object(object:{0})", obj.ToString());
            }
            finally 
            {
                obj = null;
                GC.Collect();
            }
        }
    }
}

Fuente:
CSharp
DotNetPerls

A diferencia de otros algoritmos, como el de Vigenére, se emplea una sola llave para cifrar todo el mensaje.

Para saber más sobre el método de César, este es un libro excelente Cryptography Decrypted

Implementación
Vamos a crear cuatro funciones para el algoritmo:

• get_alphabet()
• get_index()
• crypt()
• decrypt()

La función get_alphabet() devolverá una lista con todos los elementos del alfabeto y otros, como números lo que se desee agregar.

def get_alphabet():
	"""Devuelve una lista con mayusculas, minuscula, numeros y un espacio"""
	alphabet = []

	# mayusculas:65-90
	for i in range(65,91):
		alphabet.append(chr(i))

	# minusculas:97-122
	for i in range(97,123):
		alphabet.append(chr(i))

	# numeros
	for i in range(10):
		alphabet.append(str(i))

	# espacio
	#alphabet.append(" ")

	return alphabet

La función get_index() se usa para validar la llave. En nuestro caso el alfabeto consta de 62 elementos (length), por lo que nuestro índice máximo (max_index) dentro de la lista es de 61 y el índice mínimo (min_index) es 0. Para que un índice sea válido, debe estar en este rango.

En teoría, el algoritmo sólo sirve para un cierto valor de llaves. En un alfabeto de 25 elementos, habrá un máximo de 25 llaves distintas, ya que después se repetirán los valores, es decir, si la llave vale 26, producirá el mismo cifrado que la llave con valor de 1.

def get_index(index = 0, length = 0):
	"""Devuelve un indice valido dentro de un rango, evitando desbordamiento"""
	
	min_index = 0			# indice minimo
	max_index = length - 1		# indice maximo = longitud - 1

	while True:
		
		# index excede el limite superior
		if index > max_index:
			index -= length

		# index es menor al limite inferior
		elif index < min_index:
			index += length
			
		# index es valido
		else:
			break

	return index

La función crypt() recibe dos parámetros, el mensaje a cifrar y la llave. Inicia con la declaración de variables. Enseguida, recorre cada letra del mensaje. Si la letra se encuentra dentro de alphabet, se devolverá su índice dentro de la lista. Sino es así, letter no existe dentro de alphabet, provocando una excepción y continuando con la siguiente letra.

La sustitución se realiza de esta forma. Se incrementa index el valor de key y se guarda en move. Si move no fuese un índice válido se evaluará con get_index(). Por ejemplo, si move vale 63 excede el valor de max_index, por lo que se devolverá 1.

Por último se agrega el elemento de alphabet en la posición move al crypted.

def crypt(message = "", key = 0):
	"""Cifra un mensaje usando sustitucion"""
	
	crypted = ""			# mensaje cifrado

	alphabet = get_alphabet()	# alfabeto
	length = len(alphabet) 		# longitud del alfabeto
	index = 0			# indice de la letra en el alfabeto

	for letter in message:

		# se obtiene el indice de letter dentro de alphabet, si existe
		try:		
			index = alphabet.index(letter)	# indice dentro del alfabeto
		except:
			print "No existe %s en el alfabeto" % (letter,)
			continue


		# se obtiene la nueva posicion, evitando desbordamiento
		move = index + key		# nueva posicion
		move = get_index(move,length)	
	
		# debug
		if debug:
			print "move %d"%(move,)

		crypted += alphabet[move]	# agrega la letra al mensaje cifrado

		#debug
		if debug:
			print "%s = %s" % (alphabet[index],alphabet[move])

	return crypted

La función decrypt() es similar a la anterior, pero en lugar de incrementar el valor de key, se decrementa.

def decrypt(message = "", key = 0):
	"""Decifra un mensaje usando sustitucion"""
	
	decrypted = ""			# mensaje decifrado

	alphabet = get_alphabet()	# alfabeto
	length = len(alphabet)		# longitud del alfabeto
	index = 0

	for letter in message:

		try:
			index = alphabet.index(letter)	# indice dentro del alfabeto
		except:
			print "No existe %s en el alfabeto" % (letter,)
			continue		

		move = index - key		# nueva posicion
		move = get_index(move,length)

		# debug
		if debug:
			print "move %d"%(move,)


		decrypted += alphabet[move]	# agrega al mensaje decifrado
		
		#debug
		if debug:
			print "%s = %s" % (alphabet[index],alphabet[move])

	return decrypted

Por último, este es todo el código. Al final, se manda llamar la función crypted() y se imprime el mensaje cifrado.

#!/usr/bin/python

debug = False

# Cifrado por sustitucion

def get_alphabet():
	"""Devuelve una lista con mayusculas, minuscula, numeros y un espacio"""
	alphabet = []

	# mayusculas:65-90
	for i in range(65,91):
		alphabet.append(chr(i))

	# minusculas:97-122
	for i in range(97,123):
		alphabet.append(chr(i))

	# numeros
	for i in range(10):
		alphabet.append(str(i))

	# espacio
	#alphabet.append(" ")

	return alphabet
	

def get_index(index = 0, length = 0):
	"""Devuelve un indice valido dentro de un rango, evitando desbordamiento"""
	
	min_index = 0			# indice minimo
	max_index = length - 1		# indice maximo = longitud - 1

	while True:
		
		# index excede el limite superior
		if index > max_index:
			index -= length

		# index es menor al limite inferior
		elif index < min_index:
			index += length
			
		# index es valido
		else:
			break

	return index	




def crypt(message = "", key = 0):
	"""Cifra un mensaje usando sustitucion"""
	
	crypted = ""			# mensaje cifrado

	alphabet = get_alphabet()	# alfabeto
	length = len(alphabet) 		# longitud del alfabeto
	index = 0			# indice de la letra en el alfabeto

	for letter in message:

		# se obtiene el indice de letter dentro de alphabet, si existe
		try:		
			index = alphabet.index(letter)	# indice dentro del alfabeto
		except:
			print "No existe %s en el alfabeto" % (letter,)
			continue


		# se obtiene la nueva posicion, evitando desbordamiento
		move = index + key		# nueva posicion
		move = get_index(move,length)	
	
		# debug
		if debug:
			print "move %d"%(move,)

		crypted += alphabet[move]	# agrega la letra al mensaje cifrado

		#debug
		if debug:
			print "%s = %s" % (alphabet[index],alphabet[move])

	return crypted


def decrypt(message = "", key = 0):
	"""Decifra un mensaje usando sustitucion"""
	
	decrypted = ""			# mensaje decifrado

	alphabet = get_alphabet()	# alfabeto
	length = len(alphabet)		# longitud del alfabeto
	index = 0

	for letter in message:

		try:
			index = alphabet.index(letter)	# indice dentro del alfabeto
		except:
			print "No existe %s en el alfabeto" % (letter,)
			continue		

		move = index - key		# nueva posicion
		move = get_index(move,length)

		# debug
		if debug:
			print "move %d"%(move,)


		decrypted += alphabet[move]	# agrega al mensaje decifrado
		
		#debug
		if debug:
			print "%s = %s" % (alphabet[index],alphabet[move])

	return decrypted


# inicio
print "Cifrado por sustitucion"
print "Mensaje:"
message = raw_input()

print "Llave:"
key = int(raw_input())

# mensaje cifrado
crypted = crypt(message,key)
print crypted
	

Ejemplos

# key = 1
auraham@machine:~/projects/python$ python -i cifrar_sustitucion.py 
Cifrado por sustitucion
Mensaje:
hola
Llave:
1
ipmb

# key = 62, tiene el mismo efecto de key = 0, es decir, no cifra
auraham@machine:~/projects/python$ python -i cifrar_sustitucion.py 
Cifrado por sustitucion
Mensaje:
hola
Llave:
62
hola

# key = 63, tiene el mismo efecto que key = 1
auraham@machine:~/projects/python$ python -i cifrar_sustitucion.py 
Cifrado por sustitucion
Mensaje:
hola
Llave:
63
ipmb

#!/usr/bin/python

# Mutables e inmutables (personal)
# Las listas y los diccionarios son mutables porque es posible modificar sus elementos
# aun despues de haber sido definidos

# definicion
lista = [1,2,3]
print lista

# modificacion
lista[0] = "modificado"
print lista

# definicion
dic = {"uno":1, "dos":2}
print dic

# modificacion
dic["uno"] = "modificado"
print dic

# Las tuplas en cambio, son inmutables, ya que no es posible modificar sus elementos
# despues de hacer sido definidos

# definicion
tupla = (1,2,3)
print tupla

# no se podra modificar y mostrara este error
# TypeError: 'tuple' object does not support item assigment
tupla[0] = "no se puede modificar, mostrando un error"

Fuente:
Python para todos

#!/usr/bin/python 

# Funciones
# Una funcion es un fragmento de codigo con un nombre asociado
# que realiza una serie de tareas y devuelve un valor.
# 
# Un procedimiento es similar a la funcion, pero no devuelve valor.
# 
# En Python no existen los procedimientos, ya que cuando no se especifica
# un valor de retorno, se devuelve None
# 
# def function_name(params):
#	"""docstring"""
#	...
# 
# Para mostrar la ayuda de la funcion, el docstring, usa
# help(function_name)
# 
# Para salir usa q
# 


def mi_funcion(param1, param2):
	"""imprime dos valores"""
	print param1
	print param2


# Mostrar ayuda
help(mi_funcion)

# Llamada a la funcion
# 1
# 2
print "llamada a la funcion"
mi_funcion(1,2)

# Para no cerrar el interprete al terminar el programa, usa
#	python -i script.py
# 
#
# Valores por defecto
# Cuando se manda llamar una funcion se debe pasar el numero 
# de parametros de acuerdo a la declaracion de la funcion, sino se mostrara
# un error. Por ejemplo, al pasar solo un parametro, se mostrara
# TypeError: mi_funcion() takes exactly 2 arguments (1 given)
#
# Se puede evitar eso colocando valores por defecto en los parametros
def otra_funcion(param1 = "param1", param2 = "param2"):
	print param1
	print param2

# Llama a la funcion con solo un parametro
# un parametro
# param2
print "parametros por defecto"
otra_funcion("un parametro")


# Cambio de orden
# Es posible cambiar el orden de los valores en los parametros
# indicando el nombre del parametro al momento de llamar a la funcion
# 
# param 2
# param 1
print "cambio de orden"
otra_funcion(param2 = "param 1", param1 = "param 2")


# Multiples parametros
# Se pueden pasar un numero variable de argumentos antecediendo un *
# al parametro en la definicion
# Se crea una tupla llamada parametros en la funcion indefinidos
def funcion_lista(*parametros):
	for item in parametros:
		print item

# Llamada a la funcion
# 1
# 2
# 3
# 4
print "lista de parametros"
funcion_lista(1,2,3,4)

# Tambien es posible usar ** antes de la definicion del parametro
# creando un diccionario. Al momento de llamar a la funcion se deben
# pasar los valores en pares, (key, value) para cada elemento del diccionario
# 
# Para mostrar los valores (y no las llaves) del diccionario se usa la el metodo items()
def funcion_diccionario(**params):
	for item in params.items():
		print item

# Llamada a la funcion
print "diccionario de parametros"
funcion_diccionario(param1 = "param 1", param2 = "param 2", param3 = "param 3")

Fuente
Python para todos

#!/usr/bin/python

# condicional

cadena = "arenita"

if cadena == "arenita":
	print("es una ardilla")	# es una ardilla
elif cadena == "bob":
	print("es una esponja")
else:
	print("mmmm no se que es :p")

# A if C else B
# se evalua C y devuelve 
# A si es correcto
# B si no es correcto
numero = 10
par = True if (numero %2 == 0) else False

print(numero)		# True

#!/usr/bin/python

# Diccionarios
# O tambien matrices asociativas, contienen pares de la forma {key:value}

d = {"bob":"esponja","patricio":"estrella","calamardo":"tentaculos"}
print(d)		# {'bob':'esponja','patricio':'estrella','calamardo':'tentaculos'}

# Donde key es cualquier valor inmutable, como numeros, cadenas, boleanos, tuplas
# pero no listas o diccionarios, los cuales son mutables.
#
# NOTA PERSONAL: Las tuplas no son mutables porque una vez definidas no se pueden modificar 
# sus elementos. Las listas y diccionarios son mutables porque se pueden modificar sus elementos
# aun despues de ser definidos. Vease mutables.py
#
# Esto es asi porque los diccionarios se implementan como tablas hash
# y cuando se inserta un nuevo par key:value se calcula el hash de key para
# despues encontrarlo rapidamente.
# Si se cambiara el valor de key, tambien cambiaria el hash, por lo que no se podria
# encontrar el par

# para acceder a los elementos no se usa un indice (porque no estan ordenados)
# sino que se usa el valor de key dentro del operador []
print(d["bob"])		# esponja

# al igual que las listas, (pero no las tuplas, pag 26)
# se pueden editar con el operador []
d["bob"] = False
print(d["bob"])		# False

# pero no se puede usar slicing, entre otras cosas, debido a que
# los diccionarios no son secuencias, sino mappings (mapeados o asociaciones)



# Recorrido de un diccionario
# Se puede usar el ciclo for in de varias formas, dependiendo de lo que se
# se desee usar, la llave o el valor 
dic = {"key_1":1,"key_2":2,"key_3":3}

# Mostrar solo llaves
# Se recorre de manera normal
print "Mostrar solo llaves"
for item in dic:
	print item		# key_1

# Mostrar el par de llave y valor
# Para recuperar el valor, se usa el metodo items(), propio 
# de los diccionarios, el cual devuelve una tupla por cada par 
print "Mostra llaves y valores"
for item in dic.items():
	print item		# ('key_1',1)
	print type(item)	# <type 'tuple'>
	print "key:" + item[0] + ",value:" + str(item[1])