Adivina qué número estoy pensando

Juego con Perl POE

En este juego el ordenador piensa un número del 1 al 20 y te da 5 oportunidades para adivinar. Si le erras te da una pista sobre si su número es mayor o menor al número que le dijiste. Para ponerlo más difícil hay un timeout de 10 segundos para que adivines el número o perderás el juego.

Por qué POE

Cuando un programa necesita interacción con el usuario o con datos externos, necesitamos una estructura de programa que sea más expresiva.
POE es un framework para la creación de programas en Perl donde se presentan naturalmente tareas que implican reaccionar ante datos externos o eventos, como las comunicaciones de red o las interfaces de usuario. Los programas en POE son no-lineales, se configuran un montón de pequeñas subrutinas y se define la forma en que se llaman entre sí. POE cambiará automáticamente entre ellas mientras maneja la entrada y salida del programa.

#!/usr/bin/perl -w
use strict;

# Usar POE!
use POE qw/Wheel::ReadLine/;

# Necesitas hacer esto para Cygwin
#$/="\n\r";

# flush STDOUT automaticamente
$|++;


  POE::Session->create(
    inline_states =>
      { _start    => \&handler_start,
        gotLine   => \&handler_gotLine,
        prompt    => \&handler_prompt,
        gameover    => \&handler_gameover,
        timeout   => \&handler_timeout,
        #_stop     => \&handler_stop,
      }
  );

my $limite= 20;
my $intentos_total= 5;
my $intentos= $intentos_total;
my $numero= int(rand($limite-1)) + 1;
print "Adivina el numero$/";
print "Hola!!!, estoy pensando un número del 1 al $limite. ";
print "Tienes $intentos oportunidades para adivinarlo$/";
$poe_kernel->run();
print "\n";

sub handler_start {
  my ($kernel, $heap, $session) = @_[KERNEL, HEAP, SESSION];

  # POE::Wheel::ReadLine obtiene la entrada de tu terminal y viene con un historial
  # cuando una nueva linea es ingresada, se ejecuta el evento gotLine
  $heap->{wheel} = POE::Wheel::ReadLine->new
      (
        InputEvent => 'gotLine',
    );

  # pide por el evento prompt para que se ejecute otra vez
  $kernel->yield('prompt');
}
sub handler_prompt {
  my ($kernel, $heap, $session) = @_[KERNEL, HEAP, SESSION];
  my $tiempo= 10;
  print "Tienes $tiempo segundos para adivinar, o perderás el juego!$/";
  if (2>$intentos){ 
    print "Es tu última oportunidad$/";
  }
  $heap->{wheel}->get('Tipea rápido: ');

  # dispara el evento timeout para dentro de una cantidad de segundos
  $kernel->delay('timeout',$tiempo);
}
sub handler_timeout {
  my ($kernel, $heap, $session) = @_[KERNEL, HEAP, SESSION];

  # informar al usuario que perdió
  print "$/El número era $numero, tardaste demasiado tiempo, game over$/";

  # setear esta variable a undef hará que termine nuestro Wheel
  # sin wheel y sin el evento delay pendiente la cola del kernel
  # está vacia y se realiza un shutdown
  $heap->{wheel}=undef;
}

sub handler_gameover {
  my ($kernel, $heap, $session) = @_[KERNEL, HEAP, SESSION];

  # informar al usuario que perdió
  print "\nEl número era $numero, lo siento, game over\n";

  # setear un delay sin el número de timeout limpia el evento
  # sin el evento delay pendiente la cola del kernel
  # está vacia y se realiza un shutdown
  $kernel->delay('timeout');
}

sub handler_gotLine {
  my ($kernel, $heap, $session, $arg, $exception) = 
            @_[KERNEL, HEAP, SESSION, ARG0, ARG1];

  if(defined $arg) {
    $heap->{wheel}->addhistory($arg);
    $intentos--;
    if ($numero==$arg){
      print "Excelente! Mi número era el $numero. Lo conseguiste en " . ($intentos_total - $intentos) . " intentos!$/";
      # setear un delay sin el número de timeout limpia el evento
      $kernel->delay('timeout');
      # setear esta variable a undef hará que termine nuestro Wheel
      $heap->{wheel}=undef;
      return;
    }elsif($numero>$arg){
      print "El número es mayor que $arg$/";
    }else{
      print "El número es menor que $arg$/";
    }
    if (1>$intentos){
      # se acabaron las oportunidades para adivinar el número
      $kernel->yield('gameover');
      return;
    }
  }
  else {
    print "Got input exception '$exception'.  Exiting...$/";

    # setear esta variable a undef hará que termine nuestro Wheel
    $heap->{wheel}=undef;
    # setear un delay sin el número de timeout limpia el evento
    $kernel->delay('timeout');

    return;
  }

  # ejecuto el evento prompt de nuevo para resetear el timeout e
  # imprimir un nuevo prompt
  $kernel->yield('prompt');
}

Salida

Adivina el numero
Hola!!!, estoy pensando un número del 1 al 20. Tienes 5 oportunidades para adivinarlo

Tienes 10 segundos para adivinar, o perderás el juego!
Tipea rápido: 8
El número es mayor que 8
Tienes 10 segundos para adivinar, o perderás el juego!
Tipea rápido: 18
El número es menor que 18
Tienes 10 segundos para adivinar, o perderás el juego!
Tipea rápido: 
              El número era 14, tardaste demasiado tiempo, game over

Adivina el numero
Hola!!!, estoy pensando un número del 1 al 20. Tienes 5 oportunidades para adivinarlo

Tienes 10 segundos para adivinar, o perderás el juego!
Tipea rápido: 1
El número es mayor que 1
Tienes 10 segundos para adivinar, o perderás el juego!
Tipea rápido: 2
El número es mayor que 2
Tienes 10 segundos para adivinar, o perderás el juego!
Tipea rápido: 3
El número es mayor que 3
Tienes 10 segundos para adivinar, o perderás el juego!
Tipea rápido: 4
El número es mayor que 4
Tienes 10 segundos para adivinar, o perderás el juego!
Es tu última oportunidad
Tipea rápido: 5
El número es mayor que 5

El número era 13, lo siento, game over

Adivina el numero
Hola!!!, estoy pensando un número del 1 al 20. Tienes 5 oportunidades para adivinarlo

Tienes 10 segundos para adivinar, o perderás el juego!
Tipea rápido: 10
El número es mayor que 10
Tienes 10 segundos para adivinar, o perderás el juego!
Tipea rápido: 15
Excelente! Mi número era el 15. Lo conseguiste en 2 intentos!

Desafío

Como tarea final te dejo una modificación para que al finalizar el juego te pregunte que si quieres volver a jugar, y que puedas jugarlo otra vez.

Intervalos de horas que se superponen

Problema

Supongamos que tenemos una lista de horarios con hora de comienzo y de final. Y queremos saber si algún intervalo horario se superpone con algún otro. Los horarios vienen en formato 'HH:mm:ss' pero solo nos interesan las horas y los minutos. Supongamos también que está en formato de 24hs.
Deberíamos hacer una serie de consultas con cada intervalo, pero como puede haber intervalos que cruzan las 00hs, esas consultas se vuelven muy complicadas. Para simplificar, supongamos que sólo queremos saber si la hora de comienzo de un intervalo está superpuesta en algún otro intervalo. Por lo tanto si esa hora es mayor o igual al inicio de un intervalo pero menor estricto que el final de ese intervalo se considera que el intervalo examinado se encuentra superpuesto con el otro.

Por ejemplo el intervalo '21:00:00,23:00:00' se superpone con los intervalos '20:00:00,22:00:00', '22:00:00,01:30:00' y '09:00:00,21:00:00', pero no se superpone con el intervalo '23:00:00,04:00:00' ni con el intervalo '13:00:00,18:00:00'.

Solución

A continuación presento un script en Perl para solucionar este problema. Dado un array de intervalos y un índice que es el índice del array donde está el intervalo que quiero comparar con todos los demás, ejecuto una función que me retorna si se superpone con alguno de los otros intervalos.

#!/usr/bin/perl
use strict;
use Data::Dumper;

my @intervalos;
push(@intervalos,{'desde'=>'09:00:00','hasta'=>'12:00:00'});
push(@intervalos,{'desde'=>'12:00:00','hasta'=>'15:00:00'});
push(@intervalos,{'desde'=>'14:00:00','hasta'=>'17:00:00'});
push(@intervalos,{'desde'=>'17:30:00','hasta'=>'22:30:00'});
push(@intervalos,{'desde'=>'22:00:00','hasta'=>'00:00:00'});
push(@intervalos,{'desde'=>'23:59:00','hasta'=>'08:59:00'});

print Dumper(\@intervalos);

my $indice= 5;
my $es_superpuesto= ver_solapacion($indice,@intervalos);
print "Superpuesto: $es_superpuesto\n";

sub ver_solapacion{
  my ($indice,@intervalos)= @_;
  my $s= 0;
  my $pivote_indice= $intervalos[$indice]->{'desde'};
  print "Hora 'desde' del intervalo interesante: $pivote_indice \n";
  my $pivote= time_trans($pivote_indice);
  my $i= 0;
  foreach my $row (@intervalos){
    if ($i==$indice){ $i++; next; }
    my $a= time_trans($row->{'desde'});
    my $b= time_trans($row->{'hasta'});
    my $c= time_suma($a,$b);
    my $d= time_suma($a,$pivote);
    if ($d < $c){ $s=1; last; }
    $i++;
  }
  return $s;
}
sub time_trans{
  my ($hora)= @_;
  my @h= split(':',$hora);
  return  $h[0] + ($h[1]/100);
}
sub time_suma{
  my ($a,$b)= @_;
  if ($a>$b){ return 24 + $b; }
  return $b - $a;
}

Resultado: el intervalo está superpuesto

$intervalos = [
          {
            'hasta' => '12:00:00',
            'desde' => '09:00:00'
          },
          {
            'hasta' => '15:00:00',
            'desde' => '12:00:00'
          },
          {
            'hasta' => '17:00:00',
            'desde' => '14:00:00'
          },
          {
            'hasta' => '22:30:00',
            'desde' => '17:30:00'
          },
          {
            'hasta' => '00:00:00',
            'desde' => '22:00:00'
          },
          {
            'hasta' => '08:59:00',
            'desde' => '23:59:00'
          }
        ];
Hora 'desde' del intervalo interesante: 23:59:00 
Superpuesto: 1