Codigo sin utilidad

[[seoane]]

Cuando estaba buscando información sobre Python me encontré con esta pagina "Useless Python", y la idea en que se basa la pagina me parece interesante o por lo menos entretenida. Se basa en poner trozos de código pequeños, simples y que no tienen porque tener una utilidad concreta, se trata de jugar con el lenguaje y sus posibilidades.

Se me ocurrió hacer algo parecido por aquí, no se muy bien como plantearlo, pero consistiría en colocar en este mismo hilo, por ejemplo, trocitos de código que tengamos por ahí, no tienen que tener una utilidad concreta, pero deben ser simples y estar comentados.

Para dar ejemplo empiezo yo *:

Código Delphi [-]
// Esta funcion dibuja un texto usando letras, jeje
function StrToStr(Str: string): string;
var
  Bitmap: TBitmap;
  i,j: integer;
begin
  Result:= '';
  // Creamos un Bitmap
  Bitmap:= TBitmap.Create;
  try
    // Ajustamos el tipo y tamaño de la fuente
    Bitmap.Canvas.Font.Name:= 'Arial Black';
    Bitmap.Canvas.Font.Size:= 16;
    // Ajustamos el tamaño del Bitmap al tamaño del texto
    Bitmap.Width:= Bitmap.Canvas.TextWidth(Str);
    Bitmap.Height:= Bitmap.Canvas.TextHeight(Str);
    // Escribimos el texto en el bitmap
    Bitmap.Canvas.TextOut(0,0,Str);
    // Vamos leyendo pixel a pixel del bitmap
    for j:= 0 to Bitmap.Height - 1 do
    begin
      for i:= 0 to Bitmap.Width - 1 do
        // Por cada pixel blanco añadimos la letra _ al resultado
        if Bitmap.Canvas.Pixels[i,j] = $FFFFFF then
          Result:= Result + '_'
        else
          // y por cada pixel que no es blanco añadimos una X
          Result:= Result + 'X';
      // Al final de cada fila de pixeles añadimo al resultado un salto de linea
      Result:= Result + #13#10;
    end;
  finally
    // Eliminamos el bitmap, ya no lo necesitamos
    Bitmap.Free;
  end;
end;

// Por ejemplo
ShowMessage(StrToStr('ClubDelphi') );

* Nota: Algunos recordareis esta función de otro hilo, pero dispongo de poco código que no este ya publicado . Pero buscare por ahí, seguro que encuentro algo mas.

Alguno se anima ???

[[seoane]]

Ahora uno un poco mas complicado, aunque prometo buscar alguno mas sencillo

Pues bien, el siguiente código sirve para montar un servidor de números aleatorios. Cuando se ejecuta la función "Aleator" el programa se pone a escuchar por el puerto 1978, y cuando alguien se conecta a el, comienza a enviarle números aleatorios a intervalos de 100 milisegundos.

Código Delphi [-]
uses
  // Winsock tiene que estar en las uses
  Windows, SysUtils, Winsock;

// Cada conexion se ejecuta en un thread diferente
function ThreadProc(Socket: TSocket): Integer;
var
  Str: String;
begin
  Result:= 0;
  try
    // En este bucle se mandan los numeros
    repeat
      // Un retardo de 100 ms entre numero y numero
      Sleep(100);
      // Convertimos el numero a hexadecimal, para que quede bonito
      Str:= IntToHex(Random(MAXINT),8);
      // y lo mandamos hasta que nuestro cliente se desconecte 
    until send(Socket,PChar(Str)^,Length(Str)+1,0) = SOCKET_ERROR;
  finally
    // Cerramos la conexion
    Shutdown(Socket,SD_SEND);  // SD_SEND = 1;
    CloseSocket(Socket);
    // Terminamos el thread
    EndThread(0);
  end;
end;

// Este es el bucle principal
procedure Aleator;
var
  WSADATA: TWSADATA;
  ServerSocket: TSocket;
  LocalAddr: TSockaddr;
  ClientSocket: TSocket;
  RemoteAddr: TSockaddr;
  AddrSize: Integer;
  FDSet: TFDSet;
  TimeVal: TTimeVal;
  ThreadId: LongWord;
begin  
  Randomize;
  // Inicializamos Winsock
  if WSAStartup(MAKEWORD(1, 1), WSADATA) = 0 then
  try
    // Creamos el Socket del servidor
    ServerSocket := socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
    if ServerSocket <> INVALID_SOCKET then
    begin
      // Configuramos la ip y el puerto que vamos a usar
      with LocalAddr do
      begin
        sin_family := AF_INET;
        // Aqui colocamos el puerto a usar
        sin_port := htons(1978);
        // Aqui indicamos que usaremos cualquier ip de nuestro equipo
        sin_addr.s_addr := htonl(INADDR_ANY);
        // Si queremos limitarnos a una ip en concreto usaremos la siguiente linea
        // sin_addr.s_addr:= Inet_Addr('127.0.0.1');
      end;
      // Ponemos el Socket a la escucha ...
      if bind(ServerSocket, LocalAddr, sizeof(LocalAddr)) <> SOCKET_ERROR then
        if listen(ServerSocket, SOMAXCONN) <> SOCKET_ERROR then
        begin
          repeat
            TimeVal.tv_sec := 0;
            TimeVal.tv_usec := 500;
            FD_ZERO(FDSet);
            FD_SET(ServerSocket, FDSet);
            // Comprobamos el estado del socket
            if select(0, @FDSet, nil, nil, @TimeVal) > 0 then
            begin
              AddrSize := sizeof(RemoteAddr);
              // Aceptamos la nueva conexion y creamos un nuevo Thread
              ClientSocket := accept(ServerSocket, @RemoteAddr, @AddrSize);
              if ClientSocket <> INVALID_SOCKET then
                // Creamos un nuevo tread usando la API
                BeginThread(nil, 0, @ThreadProc, Pointer(ClientSocket),
                  0, ThreadID);
            end;
          until FALSE; // Aquí ponemos la condición que nos apetezca
        end;
    end;
  finally
    WSACleanup();
  end;
end;

Para probarlo solo tenemos que usar, por ejemplo, el telnet:

telnet 127.0.0.1 1978

[[Héctor Randolph]]

No creo que haya problema conmigo, la mayoría del código que escribo no tiene utilidad .

Hablando en serio, las rutinas que escribiste están muy buenas y siempre aprendo mucho de ellas.

Saludos

[[seoane]]

El siguiente código baja las tiras de Raulito el friki, en el rango especificado. Si se utiliza un rango muy grande tarda un poco así que paciencia.

Código Delphi [-]
uses UrlMon, ShellApi;

procedure Raulito(Min, Max: Integer);
var
  i: Integer;
  Path: Array[0..MAX_PATH] of Char;
begin
  FillChar(Path,Sizeof(Path),#0);
  // Obtenemos el directorio temporal
  if GetTempPath(Sizeof(Path)-1, @Path) <> 0 then
  begin
    // Creamos el directorio "Raulito", dentro del temporal, si no existe ya 
    if DirectoryExists((String(Path) + 'Raulito')) or
      CreateDir(String(Path) + 'Raulito') then
    begin
      // Comenzamos el bucle
      for i:= Min to Max do
        // Bajamos la imagen al directorio "Raulito"
        UrlDownloadToFile(nil,
          PChar(Format('http://www.telefonica.net/web2/recurrente/tira/tira%d.png',[i])),
          PChar(String(Path) + Format('Raulito\tira%d.png',[i])),0,nil);
      // Mostramos la carpeta "Raulito"
      Shellexecute(0,nil,PChar(String(Path) + 'Raulito'),nil,nil,SW_SHOW);
    end;
  end;
end;


// Por ejemplo
Raulito(80,89);
// O si queremos todas (hasta hoy)
Raulito(0,89);

[[seoane]]

Ahora es el turno de un interprete de Brainfucker

La wikipedia define este lenguaje de la siguiente manera:

Empezado por Wikipedia

Brainfuck (jodecerebros) es un lenguaje de programación esotérico, diseñado por Urban Müller en 1993, con el objetivo de hacer un lenguaje que fuera a la vez muy simple, Turing completo y que requiriese un compilador pequeño. Müller basó Brainfuck en la máquina de Turing.

Para saber mas sobre este lenguaje:
http://es.wikipedia.org/wiki/Brainfuck (Español)
http://en.wikipedia.org/wiki/Brainfuck (Ingles)

Ahora que ya sabemos algo sobre el Brainfucker, vamos con su interprete:

Código Delphi [-]
program bf;

{$APPTYPE CONSOLE}

uses Windows, SysUtils, Classes;

// Esta funcion interpreta el codigo
procedure Brainfuck(Codigo: String);
const
  // El tamaño del array, el estandar es 30000
  Size = 30000;
  // Mensajes de error del interprete
  strPointerError = 'El puntero no es valido';
  strBracketError = 'Se encontro un bracket sin pareja';
var
  i,j: Integer;
  Min, Max, P: PByte;
begin
  // Obtenemos memoria para alojar el array de bytes
  GetMem(Min,Size);
  try
    // Inicializamos el array a cero
    FillChar(Min^,Size,#0);
    // Establecemos el limite superior e inferior
    Max:= Min;
    inc(Max,Size - 1);
    // Inicializamos el puntero en la primera posicion del array
    P:= Min;
    i:= 1;
    // Comenzamos a recorrer el codigo
    while (i <= Length(Codigo)) do
    begin
      case Codigo[i] of
        '>': begin  // Incrementamos el puntero
               if P = Max then
                 raise Exception.Create(strPointerError);
               inc(P);
             end;
        '<': begin  // Decrementamos el puntero
               if P = Min then
                 raise Exception.Create(strPointerError);
               dec(P);
             end;
        '+': inc(P^); // Incrementamos el valor actual
        '-': dec(P^); // Leemos el valor actual
        '.': Write(Char(P^)); // Imprimime el valor actual
        ',': Read(Char(P^)); // Lee un valor de la entrada
        '[': if P^ = 0 then // Comienza un bucle
             begin
               j:= 1;
               // Como la condicion es cero saltamos al final del bucle
               repeat
                 inc(i);
                 if i > Length(Codigo) then
                    raise Exception.Create(strBracketError);
                  case Codigo[i] of
                    '[': inc(j);
                    ']': dec(j);
                  end;
               until (j=0);
             end;
        ']': if P^ <> 0 then // Finaliza un bucle
             begin
               j:= 1;
               repeat
                 dec(i);
                 // Como la condicion no es cero saltamos al principio del bucle
                 if i < 1 then
                    raise Exception.Create(strBracketError);
                  case Codigo[i] of
                    '[': dec(j);
                    ']': inc(j);
                  end;
               until (j=0);
             end;
      end;
      inc(i);
    end;
  finally
    // Liberamos la memoria del array
    FreeMem(Min);
  end;
end;

begin
  // Comprobamos que nos han pasado el fichero con el codigo
  if ParamCount = 1 then
  try
    with TStringList.Create do
    try
      // Abrimos el fichero con el codigo
      LoadFromFile(ParamStr(1));
      // Lo interpretamos
      Brainfuck(Text);
    finally
      Free;
    end;
  except
    // Si ocurre una excepcion la imprimimos
    On E: Exception do
    begin
      Writeln(E.Message);
    end;
  end;
end.

Ya tenemos nuestro flamante interprete de Brainfucker, pero haciendo honor a su nombre, es jodidamente complicado programar en este lenguaje . Así que sera mejor que pongamos algunos ejemplo para probarlo.

El hola mundo:

++++++++++
[>+++++++>++++++++++>+++>+<<<<-] The initial loop to set up useful values in the array
>++.                             Print 'H'
>+.                              Print 'e'
+++++++.                         Print 'l'
.                                Print 'l'
+++.                             Print 'o'
>++.                             Print ' '
<<+++++++++++++++.               Print 'W'
>.                               Print 'o'
+++.                             Print 'r'
------.                          Print 'l'
--------.                        Print 'd'
>+.                              Print '!'
>.                               Print newline

La serie de Fibbonaci:

>++++++++++>+>+[
    [+++++[>++++++++<-]>.<++++++[>--------<-]+<<<]>.>>[
        [-]<[>+<-]>>[<<+>+>-]<[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-
            [>+<-[>+<-[>+<-[>[-]>+>+<<<-[>+<-]]]]]]]]]]]+>>>
    ]<<<
]
This program doesn't terminate; you will have to kill it.
Daniel B Cristofani (cristofdathevanetdotcom)
http://www.hevanet.com/cristofd/brainfuck/

Este es la leche, introduces un numero y el lo dibuja girado 45 grados:

>>>>+>+++>+++>>>>>+++>>+[
    -,[----------[---[+<++++[>-----<-]+>[<+>--------[<+>-
    [--->>+++++++++++++[<<[-<+>>]>[<]>-]<<
    [+>+++++[<-------->-]<[<+>-]]]]]]]]
    <
    [<<++[>>>>>>>>>>>+<<<<<<<<<<<-]<<+>+>+>>>+>+>>+>+<<<<<-
    [<<+>>>+>+>>>+<<<<<-
    [<<<<+>>->>>>->>+<<<<-
    [<<<<->+>>>>->>>->-<<<<<-
    [<<<->>>>+<-
    [<<<+>>>>->+>>+<<<<-
    [<<<<+>->+>>>+>>>>+<<<<<-
    [<<->>>->->>>-<<<<<-
    [<<<<->+>>>>+>+>>>+<<<<<-
    [<<<<+>>>>>>-<<-
    [<<+>>>->>>>-<<<<<-
    [>+>>>->+<<<<<-
    [>>+<<-
    [<<<->->>>->->>+<<<<-
    [<<<+>+>>>+>+<<-
    [>->-<<-
    [<<->>>+>+<<-
    [<<+>>>>>>->-<<<<<-
    [<<<<->>->>-
    [<<<<+>>>>>>>>+<<<<-
    [<<<<->>+>>>>>>>+<<<<<-
    [>->>>-<<<<-]]]]]]]]]]]]]]]]]]]]]
    >[[<<<<<<<<<<<+>>>>>>>>>>>-]>]+>>>>>>>+>>+<]>
]<<[-]<[-[>>>>+<<<<-]]<<<<<<++<+++<+++[>]<[
    >>>>>++++++++[<++++++<++++>>-]>>>[-[<+<<<<.>>>>>-]]<<+<<-<<<<[
        -[-[>+<-]>]>>>[.[>]]<<[<+>-]>>>[<<-[<++>-]>>-]
        <<[++[<+>--]>+<]>>>[<+>-]<<<<<<<<
    ]>>>>>++++++++++.>+[[-]<]<<<
]
[Enter a number using ()-./0123456789abcdef and space, and hit return.
Daniel B Cristofani (cristofdathevanetdotcom)
http://www.hevanet.com/cristofd/brainfuck/]

Como podéis ver, este interprete si que es algo de lo mas inútil en el mundo real, pero puede resultar fascinante para algún friki como yo

PD: La función de entrada ',' no termina de convencerme como esta implementada, si alguien se anima a mejorarla ...

[dec]

Hola,

Joroba con el BrainFucker...

[[ArdiIIa]]

Pues mira, quería aportar mi granito a este hilo, y de momento va a ser que no. Parece que todo lo que hago resulta útil .
Esto no es código pero buscando en la sección de trucos un poco de código, resulta que me he encontrado con algo que me ha resultado inútil...

• si buscas por sector: no devuelve nada
• si buscas por cluster: no devuelve nada
• si buscas por sector cluster: el resultado es inútil...