[-CONCURSO-] PHP Maraton script #1 - Desafios

NSD · #1 (**permalink**) 14/06/2015, 10:27

NIVEL 1

Este primer nivel es para calentamiento, la dificultad de estos desafíos es la mínima de la maratón. ¡En marcha!

A.- En este desafió, se deberá mostrar la frase "Hola mundo"... ¡Pero con algunas restricciones!
- Script: php_maraton_v1_level_1A.php

- El script no puede decir "Hola mundo" de forma explicita en ningún lado, es decir, no se pueden hacer cosas como:

Código PHP:

Ver original<?php
        $saludo = "Hola mundo";
        $saludo = implode(" ", ["Hola", "mundo"]);
        // Etc..

Dicho de otra forma, al mirar el código fuente no se deben poder leer directamente ninguna de las dos palabras, ya sea juntas o separadas, por lo que hay que pensar una forma de ocultarlas.

CONDICIÓN DE MERITO:
- No se pueden utilizar ninguna de las funciones de manejo de string que figuran en esta lista del manual.

B.- En este desafió, la tarea a realizar sera identificar y saludar al visitante... ¡Pero con algunas restricciones!
- Script: php_maraton_v1_level_1B.php
- El script deberá ser capaz de realizar una interaccion en 3 pasos con el usuario, para ello agregue al inicio de su script la definicion del siguiente array que contiene el codigo html de cada pantalla:

Código PHP:

Ver original<?php
        $pantallas = [
            '<!DOCTYPE html>
                <html>
                    <head>
                        <title>PHP MARATON SCRIPT V1 - NIVEL 1 B</title>
                    </head>
                    <body>
                        <form action="php_maraton_v1_level_1B.php">
                            <input type="text" name="nombre">
                            <input type="submit" value="IDENTIFICARME">
                        </form>
                    </body>
                </html>',
            '<!DOCTYPE html>
                <html>
                    <head>
                        <title>PHP MARATON SCRIPT V1 - NIVEL 1 B</title>
                        <meta http-equiv="Refresh" content="1;URL=php_maraton_v1_level_1B.php">
                    </head>
                    <body>
                        ¡Has sido identificado correctamente! <a href="php_maraton_v1_level_1B.php">Hay click aqui si el navegador no te redirige automaticamente</a>
                    </body>
                </html>',
            '<!DOCTYPE html>
                <html>
                    <head>
                        <title>PHP MARATON SCRIPT V1 - NIVEL 1 B</title>
                    </head>
                    <body>
                        ¡Hola -NOMBRE-! ¡Te tengo identificado!
                    </body>
                </html>'
        ];

1) Si el usuario esta cargando el script "php_maraton_v1_level_1B.php" y no esta identificado, mostrar la pantalla $pantallas[0] para solicitar un nombre.

2) Si el usuario se acaba de identificar (osea que acaba de enviar el formulario del paso 1, debe mostrar la pantalla $pantallas[1] que lo llevara a su pagina de bienvenida.

3) Cuando el usuario es redireccionado a su pagina de bienvenida luego de identificarse, deberá ver un saludo cordial, puesto ya se ha identificado previamente, dicho saludo es la pantalla $pantallas[2] pero reemplazando a "-NOMBRE-" por el nombre que ingreso en el paso 1.

CONDICIÓN DE MERITO:
No utilizar para resolver a este desafió ninguna de las siguientes opciones:

Sesiones ($_SESSION, session_*, etc).
Cookies.
Archivos (file_put_contents, file_get_contents, fopen, etc).
Bases de datos.
Memcache.

IMPORTANTE:
Para simplificar la lectura del código a la hora de publicar la solución de este desafió, no publique el array con las definiciones de las pantallas, puesto que ya esta en este mensaje y es el mismo para todos los concursantes.

NIVEL 2

Este es el segundo nivel de la maratón, ambos desafíos propuestos están relacionados con un juego de poker. ¡En marcha!

NOTA: Para que no halla disputas, la siguiente tabla muestra las combinaciones en orden ganador de un juego de poker y las probabilidades de obtener cada combinación, los desafios se evaluaran en base a esta tabla:

Para ambos desafíos se usara la siguiente clase:

Código PHP:

Ver original<?php
  class Poker {
      
      public function jugada($cartas) {
          /*...*/
          return /*... Ej: "Escalera real" ...*/;
      }
      
      public function partida($cartas1, $cartas2) {
          /*...*/
          return /*... Ej: -1, 0, 1 ...*/;
      }
      
      public function probabilidades($cartas) {
          /*...*/
          return [ "win" : /*...*/, "lost" : /*...*/, "tied" : /*...*/ ];
      }
      
      public function apuesta($cartas, $maximo = 100) {
          /*...*/
          return /*... Ej: 50 ...*/;
      }           
      
  }

Considere ademas, que en todos los casos $cartas es un array de 5 string de dos caracteres cada uno, donde el primer carácter indica el numero de la carta:
Ej: 1,2,3,4,5,6,7,8,9,0,J,Q,K
NOTA: El 0 representa al 10
y el segundo el color:
Ej: P,C,D,T
las letras pueden estar en mayusculas o minusculas o ambas ¡Ojo con eso!.

Ej: $cartas = ["1P", "2T", "JC", "KD", "5D"];

A.- En este desafió, se deberá programar el método jugada($cartas), que deberá retornar el nombre de la jugada (primer columna de la tabla) de acuerdo a la mano obtenida.
No esta permitido hacer uso de los métodos del punto B.

CONDICIÓN DE MERITO:
Desarrollar el método partida($cartas1, $cartas2) que determine quien es el ganador de una partida, en caso de empate debe retornar 0, si la jugada de $cartas1 es mejor que la de $cartas2 debe retornar 1, y si la jugada de $cartas2 es mejor que la de $cartas1 debe retornar -1.
Recuerde que en caso de que la jugada de ambos sea "Carta alta" ganara el que tenga la carta mas alta.
Esta permitido llamar al método creado previamente.

B.- En este desafió, se deberá programar el método probabilidades($cartas), que deberá retornar la probabilidad de ganar, perder y empatar que tiene una mano de cartas determinada basándose en los datos de la ultima columna del cuadro.
Esta permitido llamar al método creado en el punto A.
NOTA MATEMÁTICA: Tenga en cuenta que la suma de estas 3 probabilidades debe ser 1 si o si.

CONDICIÓN DE MERITO:
Desarrollar el método apuesta($cartas, $maximo = 100) que determine en base a las probabilidades de ganar, perder y empatar de la jugada, cuando deberia ser la apuesta del jugador en términos económicos, teniendo en cuenta que la mesa solo permite hasta un tope de apuestas, este tope esta definido en el parámetro $maximo, por lo tanto el mono a sugerir nunca puede exceder ese techo.
Esta permitido llamar al método creado previamente.
Para realizar el calculo deben aplicarse las siguientes consideraciones:
- Se sugiere apostar una parte directamente proporcional a la probabilidad de ganar.
- Se sugiere apostar la mitad de la parte directamente proporcional a probabilidad de empatar.
- Se sugiere no apostar nada de la parte directamente proporcional a la probabilidad de perder.

Cita:

Ej:
$maximo = 100
$prob_ganar = 0.5
$prob_empatar = 0.4
$prob_perder = 0.1
$apuesta_sugerida = 70

CONDICIÓN DE MERITO EXTRA:
En el metodo probabilidades($cartas) debe considerar que si la jugada es carta alta, la probabilidad varia segun el valor de la carta mas alta.

IMPORTANTE: Recuerde publicar las soluciones en 2 mensajes diferentes, si bien pertenecen a la misma clase, se evalúan por separado de forma independiente.

marlanga · #2 (**permalink**) 14/06/2015, 17:05

NIVEL 1 - A

Código PHP:

Ver original<?php
abstract class Char
{
    private $charMap;
    private $map;
 
    public function __construct($map)
    {
        $this->map = $map;
        $this->charMap = array( 
            0 => ' ',
            1 => '_',
            2 => '|',
            3 => "'",
            4 => '"',
            5 => '/',
            6 => '\\',
            7 => 'U',
            8 => '(',
            9 => ')',
            10 => '>',
            11 => '<',
            12 => '.',
            13 => '-',
            14 => ','
        );
    }
 
    final protected function getChar($index)
    {
        return $this->charMap[$index];
    }
 
    final public function getTotalLines()
    {
        return count($this->map);
    }
 
    final public function getLine($index)
    {
        $str = '';
        foreach ($this->map[$index] as $character) {
            $str .= $this->getChar($character);
        }
        return $str;
    }
}
 
class CharSpace extends Char
{
    public function __construct()
    {
        parent::__construct(array(
            array( 0, 0, 0, 0, 0, 0, 0),
            array( 0, 0, 0, 0, 0, 0, 0),
            array( 0, 0, 0, 0, 0, 0, 0),
            array( 0, 0, 0, 0, 0, 0, 0),
            array( 0, 0, 0, 0, 0, 0, 0),
            array( 0, 0, 0, 0, 0, 0, 0),
            array( 0, 0, 0, 0, 0, 0, 0)
        ));
    }
}
 
class CharH extends Char
{
    public function __construct()
    {
        parent::__construct(array(
            array( 0, 0, 1, 0, 0, 0, 1, 0, 0),
            array( 0, 2, 3, 2, 0, 2, 3, 2, 0),
            array( 5, 2, 0, 2, 1, 2, 0, 2, 6),
            array( 7, 2, 0, 0, 1, 0, 0, 2, 7),
            array( 0, 2, 1, 2, 0, 2, 1, 2, 0),
            array( 0, 5, 5, 0, 0, 0, 6, 6, 0),
            array( 8, 1, 4, 9, 0, 8, 4, 1, 9)
        ));
    }
}
 
class CharO extends Char
{
    public function __construct()
    {
        parent::__construct(array(
            array( 0, 0, 0, 7, 0, 0, 1, 1, 1, 0, 7),
            array( 0, 0, 0, 0, 6, 5, 4, 0, 0, 6, 5),
            array( 0, 0, 0, 0, 2, 0, 2, 0, 2, 0, 2),
            array(12,13,14, 1, 2, 0, 2, 1, 2, 0, 2),
            array( 0, 6, 1, 9,13, 6, 1, 1, 1, 5, 0),
            array( 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0),
            array( 0, 0, 0, 0, 0, 8, 4, 1, 9, 0, 0)
        ));
    }
}
 
class CharL extends Char
{
    public function __construct()
    {
        parent::__construct(array(
            array( 0, 0, 0, 1, 0, 0, 0, 0, 0),
            array( 0, 0, 2, 4, 2, 0, 0, 0, 0),
            array( 7, 0, 2, 0, 2, 0, 7, 0, 0),
            array( 0, 6, 2, 0, 2, 5, 1, 1, 0),
            array( 0, 0, 2, 1, 1, 1, 1, 1, 2),
            array( 0, 0, 5, 5, 0, 0, 6, 6, 0),
            array( 0, 8, 1, 4, 9, 8, 4, 1, 9)
        ));
    }
}
 
class CharA extends Char
{
    public function __construct()
    {
        parent::__construct(array(
            array( 0, 0, 0, 0, 1, 0, 0, 0, 0, 0),
            array( 7, 0, 0, 5, 4, 6, 0, 0, 7, 0),
            array( 0, 6, 5, 0, 1, 0, 6, 5, 0, 0),
            array( 0, 5, 0, 1, 1, 1, 0, 6, 0, 0),
            array( 5, 1, 5, 0, 0, 0, 6, 1, 6, 0),
            array( 0, 6, 6, 0, 0, 0, 0, 6, 6, 0),
            array( 8, 4, 1, 9, 0, 0, 8, 4, 1, 9)
        ));
    }
}
 
class CharM extends Char
{
    public function __construct()
    {
        parent::__construct(array(
            array( 0, 0, 1, 1, 0, 0, 1, 1, 0, 0),
            array( 7, 2, 3, 0, 6, 5, 0, 3, 2, 7),
            array( 6, 2, 0, 2, 6, 5, 2, 0, 2, 5),
            array( 0, 2, 0, 2, 0, 0, 2, 0, 2, 0),
            array( 0, 2, 1, 2, 0, 0, 2, 2, 2, 0),
            array( 0,11,11, 0, 0, 0, 0,10,10, 0),
            array( 0, 8,12, 5, 0, 0, 6,12, 9, 0)
        ));
    }
}
 
class CharU extends Char
{
    public function __construct()
    {
        parent::__construct(array(
            array( 0, 0, 0, 1, 0, 0, 0, 1, 0),
            array( 7, 0, 2, 4, 2, 7, 2, 0, 2),
            array( 0, 6, 2, 0, 2, 6, 2, 0, 2),
            array( 0, 0, 2, 0, 2, 1, 2, 0, 2),
            array( 0,11,11, 6, 1, 1, 1, 5, 0),
            array( 0, 8, 1, 1, 9, 2, 2, 0, 0),
            array( 0, 0, 0, 0, 8, 1, 1, 9, 0)
        ));
    }
}
 
class CharN extends Char
{
    public function __construct()
    {
        parent::__construct(array(
            array( 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0),
            array( 0, 2, 0, 6, 0, 2, 4, 2, 0, 0, 0),
            array(11, 2, 0, 0, 6, 2, 0, 2,10, 0, 0),
            array( 7, 2, 0, 2, 6, 0, 0, 2, 7, 0, 0),
            array( 0, 2, 1, 2, 0, 6, 1, 2, 0, 0, 0),
            array( 0, 2, 2, 0, 0, 0, 6, 6,14,13,12),
            array( 0, 8, 1, 4, 9, 0, 0, 8, 1, 5, 0)
        ));
    }
}
 
class CharD extends Char
{
    public function __construct()
    {
        parent::__construct(array(
            array( 0, 0, 1, 1, 1, 1, 0, 0, 0),
            array( 0, 2, 0, 0, 1, 4, 6, 0, 0),
            array( 5, 2, 0, 2, 0, 2, 0, 2, 0),
            array( 7, 2, 0, 2, 1, 2, 0, 2, 6),
            array( 0, 2, 1, 1, 1, 1, 5, 0, 7),
            array( 0, 0, 2, 2, 2, 1, 0, 0, 0),
            array( 0, 8, 1, 1, 9, 1, 9, 0, 0)
        ));
    }
}
 
class CharCollection
{
    private $list;
 
    public function __construct()
    {
        $this->list = array();
    }
 
    public function add(Char $character)
    {
        $this->list[] = $character;
    }
 
    public function toArrayString()
    {
        if (empty($this->list)) {
            return array();
        }
        $strArr = array();
        for ($i = 0, $n = $this->list[0]->getTotalLines(); $i < $n; $i++) {
            $str = '';
            foreach ($this->list as $character) {
                $str .= $character->getLine($i) . '  ';
            }
            $strArr[] = $str;
        }
        return $strArr;
    }
 
    public function toImage()
    {
        $arr = $this->toArrayString();
        $w = 1050;
        $h = 140;
        $img = imagecreatetruecolor($w, $h);
        $white = imagecolorallocate($img, 255, 255, 255);
        $black = imagecolorallocate($img, 0, 0, 0);
        imagefilledrectangle($img, 0, 0, $w, $h, $white);
        foreach ($arr as $i => $line) {
            imagestring($img, 5, 10, $i * 15, $line, $black);
        }
        return $img;
    }
}
 
$hm = new CharCollection();
$hm->add(new CharH());
$hm->add(new CharO());
$hm->add(new CharL());
$hm->add(new CharA());
$hm->add(new CharSpace());
$hm->add(new CharM());
$hm->add(new CharU());
$hm->add(new CharN());
$hm->add(new CharD());
$hm->add(new CharO());
 
$img = $hm->toImage();
 
header('Content-Type: image/png');
imagepng($img);
imagedestroy($img);

http://www.jlabstudio.com/webgl/ejem...dw/nivel1a.php

marlanga · #3 (**permalink**) 14/06/2015, 17:28

NIVEL 1 - B

Código PHP:

Ver original<?php
session_start();
$pantallas = [....];
 
$showView = 0;
if (array_key_exists('nombre', $_GET) && !empty($_GET['nombre'])) {
    $showView = 1;
    $_SESSION['name'] = $_GET['nombre'];
} elseif (array_key_exists('name', $_SESSION)) {
    $showView = 2;
    $pantallas[$showView] = str_replace('-NOMBRE-', $_SESSION['name'], $pantallas[$showView]);
}
 
echo $pantallas[$showView];

Apolo_13 · #4 (**permalink**) 15/06/2015, 03:53

NIVEL 1 - A

Código PHP:

Ver original<?php
    /*
    * @script: php_maraton_v1_level_1A.php
    * @author: Apolo_13
    * @date: 14/06/2015
    */
    $letrasMin = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'];
    $letrasMay = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'];
    
    echo $letrasMay[7].$letrasMin[14].$letrasMin[11].$letrasMin[0]." 
    ".$letrasMin[12].$letrasMin[20].$letrasMin[13].$letrasMin[3].$letrasMin[14];
 
?>

Apolo_13 · #5 (**permalink**) 15/06/2015, 03:55

NIVEL 1 - B

Código PHP:

Ver original<?php
/*
* @script: php_maraton_v1_level_1B.php
* @author: Apolo_13
* @date: 15/05/2015
*/
 
//aqui copiar el array de las pantallas.
 
    if(!isset($_GET['nombre'])) {
        if(isset($_GET['name'])) {
            $pantallas[2] = str_replace('-NOMBRE-',$_GET['name'],$pantallas[2]);
            echo utf8_encode($pantallas[2]);
        } else {
            echo $pantallas[0];
        }
    } else {
        $pantallas[1] = str_replace('php_maraton_v1_level_1B.php','php_maraton_v1_level_1B.php?name='.$_GET["nombre"],$pantallas[1]);
        echo utf8_encode($pantallas[1]);
    }
?>

truman_truman · #6 (**permalink**) 17/06/2015, 21:26

NIVEL 1 A , Gané!

Código PHP:

Ver originalecho base64_decode('SG9sYSBtdW5kbw==');

Alexis88 · #7 (**permalink**) 17/06/2015, 21:50

Nivel 1 A:

Código PHP:

Ver originalecho strrev('odnum aloH');

Técnicamente, las palabras no se muestran tal cual las leeríamos.

truman_truman · #8 (**permalink**) 17/06/2015, 22:46

NIVEL 1 - B

Código PHP:

Ver originalif (isset($_GET['nombre']) && $_GET['nombre'] != ''){
  echo str_replace(".php",".php?r=".$_GET['nombre'],$pantallas[1]);
}else if (isset($_GET['r']) && $_GET['r'] != ''){
  echo str_replace("-NOMBRE-", $_GET['r'], $pantallas[2]);
}else{
  echo $pantallas[0];
}

Alexis88 · #9 (**permalink**) 18/06/2015, 00:54

Nivel 1 B:

Código PHP:

Ver originalecho !isset($_GET['nombre']) ? 
        (isset($_GET['nuevoNombre']) ? 
            str_replace('-NOMBRE-', $_GET['nuevoNombre'], $pantallas[2]) : 
            $pantallas[0]) : 
        (!isset($_GET['nuevoNombre']) ? str_replace('.php', ".php?nuevoNombre={$_GET['nombre']}", $pantallas[1]) : $pantallas[0]);

Apolo_13 · #10 (**permalink**) 26/06/2015, 05:46

NIVEL 2 - A (mensaje 1)

Este Script es el manejador, el que lanza todo. Este es el que se puede tocar para hacer las pruebas.

Código PHP:

  
<?php 
 
    require_once 'Baraja.php'; 
    require_once 'Carta.php'; 
    require_once 'Algoritmo.php'; 
    require_once 'ManoJugador.php'; 
    require_once 'Poker.php'; 
 
    header('Content-Type: text/html; charset=UTF-8'); 
 
 
    /* * ************************* 
     * MODO REAL (CARTAS DE MANERA ALEATORIA (2 PLAYERS)) 
     * ************************* */ 
    $baraja = new Baraja(); 
    $mazo = $baraja->getBaraja(); 
 
    $poker1 = new Poker(); 
 
    $player1 = array($mazo[0], $mazo[2], $mazo[4], $mazo[6], $mazo[8]); 
    $player2 = array($mazo[1], $mazo[3], $mazo[5], $mazo[7], $mazo[9]); 
 
    $jugadaPlayer1 = $poker1->jugada($player1); 
    print "<br>MODO REAL(player 1) --> {$jugadaPlayer1}"; 
    $ganador = $poker1->partida($player1, $player2); 
    print "<br>MODO REAL(ganador): {$ganador}"; 
 
     
    print "<br><br>--------------------------<br><br>"; 
 
 
    /* * ************************* 
     * MODO DEBUG (CARTAS ELEGIDAS POR EL USER (2 PLAYERS)) 
     * ************************* */ 
    $poker2 = new Poker(); 
 
    $barajaDebug1 = array(new Carta("4", "c"), new Carta("4", "p"), new Carta("3", "c"), new Carta("3", "c"), new Carta("a", "c")); 
    $barajaDebug2 = array(new Carta("4", "p"), new Carta("4", "c"), new Carta("3", "p"), new Carta("3", "p"), new Carta("5", "p")); 
 
    $jugadaDebug = $poker2->jugada($barajaDebug1); 
    print "MODO DEBUG(player 1) --> {$jugadaDebug}"; 
    $ganadorDebug = $poker2->partida($barajaDebug1, $barajaDebug2); 
    print "<br>MODO DEBUG(ganador player1): {$ganadorDebug}"; 
?>

La clase Poker:

Código PHP:

  <?php 
 
class Poker { 
 
    public function Poker() { 
         
    } 
 
    public function jugada($cartas) { 
        $mano = new ManoJugador($cartas); 
        if ($mano->getBoolEscaleraReal()) { 
            $result = "Escalera real"; 
        } elseif ($mano->getBoolEscaleraColor()) { 
            $result = "Escalera de color"; 
        } elseif ($mano->getBoolPoker()) { 
            $result = "Póker"; 
        } elseif ($mano->getBoolFull()) { 
            $result = "Full"; 
        } elseif ($mano->getBoolColor()) { 
            $result = "Color"; 
        } elseif ($mano->getBoolEscalera()) { 
            $result = "Escalera"; 
        } elseif ($mano->getBoolTrio()) { 
            $result = "Trío"; 
        } elseif ($mano->getBoolDoblesParejas()) { 
            $result = "Dobles parejas"; 
        } elseif ($mano->getBoolPareja()) { 
            $result = "Pareja"; 
        } else { 
            $result = "Carta alta"; 
        } 
 
        return $result; 
    } 
 
    public function partida($cartas1, $cartas2) { 
        $ordenJugadas = array("Carta alta" => 0, "Pareja" => 1, "Dobles parejas" => 2, "Trío" => 3, "Escalera" => 4, 
            "Color" => 5, "Full" => 6, "Póker" => 7, "Escalera de color" => 8, "Escalera real" => 9); 
        $manoPlayer1 = new ManoJugador($cartas1); 
        $manoPlayer2 = new ManoJugador($cartas2); 
 
 
 
        if ($this->jugada($cartas1) == $this->jugada($cartas2)) { 
            //si es la misma jugada ver quien tiene la carta mas alta 
            if ($this->jugada($cartas1) != "Escalera real") { 
                switch ($this->jugada($cartas1)) { 
                    case "Escalera de color": 
                        $player1 = $manoPlayer1->getEscaleraColor(); 
                        $player2 = $manoPlayer2->getEscaleraColor(); 
                        $key = "max"; 
                        break; 
                    case "Póker": 
                        $player1 = $manoPlayer1->getPoker(); 
                        $player2 = $manoPlayer2->getPoker(); 
                        $key = "val"; 
                        break; 
                    case "Full": 
                        $player1 = $manoPlayer1->getFull(); 
                        $player2 = $manoPlayer2->getFull(); 
                        $key = "val"; 
                        break; 
                    case "Color": 
                        $player1 = $manoPlayer1->getColor(); 
                        $player2 = $manoPlayer2->getColor(); 
                        $key = "val"; 
                        break; 
                    case "Escalera": 
                        $player1 = $manoPlayer1->getEscalera(); 
                        $player2 = $manoPlayer2->getEscalera(); 
                        $key = "max"; 
                        break; 
                    case "Trío": 
                        $player1 = $manoPlayer1->getTrio(); 
                        $player2 = $manoPlayer2->getTrio(); 
                        $key = "val"; 
                        break; 
                    case "Dobles parejas": 
                        $player1 = $manoPlayer1->getParejasODobles(); 
                        $player2 = $manoPlayer2->getParejasODobles(); 
                        $key = "val"; 
                        break; 
                    case "Pareja": 
                        $player1 = $manoPlayer1->getParejasODobles(); 
                        $player2 = $manoPlayer2->getParejasODobles(); 
                        $key = "val"; 
                        $jugada = "pareja"; 
                        break; 
                    case "Carta alta": 
                        $player1 = $manoPlayer1->getCartaAlta(); 
                        $player2 = $manoPlayer2->getCartaAlta(); 
                        $key = "val"; 
                        $jugada = "cartAlta"; 
                        break; 
                    default: 
                        return 0; 
                } 
 
                if (!is_array($player1[$key])) { 
                    if ($player1[$key] > $player2[$key]) { 
                        return 1; 
                    } elseif ($player1[$key] < $player2[$key]) { 
                        return -1; 
                    } else { 
                        if (isset($jugada) && $jugada == "pareja") { 
                            $max = 3; 
                            $cont = 0; 
                            $excp = array(array($player1[$key]), array($player2[$key])); 
                            do { 
                                $alta1 = $manoPlayer1->getCartaAlta($excp[0]); 
                                $alta2 = $manoPlayer2->getCartaAlta($excp[1]); 
                                $excp[0][] = $alta1['val']; 
                                $excp[1][] = $alta2['val']; 
                                $cont += 1; 
                            } while (($alta1 == $alta2) && ($cont != $max)); 
                            if ($alta1 == $alta2) { 
                                return 0; 
                            } elseif ($alta1 > $alta2) { 
                                return 1; 
                            } else { 
                                return -1; 
                            } 
                        } elseif (isset($jugada) && $jugada == "cartAlta") { 
                            $max = 5; 
                            $cont = 1; 
                            $excp = array(array($player1[$key]), array($player2[$key])); 
                            do { 
                                $alta1 = $manoPlayer1->getCartaAlta($excp[0]); 
                                $alta2 = $manoPlayer2->getCartaAlta($excp[1]); 
                                $excp[0][] = $alta1['val']; 
                                $excp[1][] = $alta2['val']; 
                                $cont += 1; 
                            } while (($alta1 == $alta2) && ($cont != $max)); 
                            if ($alta1 == $alta2) { 
                                return 0; 
                            } elseif ($alta1 > $alta2) { 
                                return 1; 
                            } else { 
                                return -1; 
                            } 
                        } else { 
                            return 0; 
                        } 
                    } 
                } else { 
                    $play1 = 0; 
                    $play2 = 0; 
                    if ($player1[$key][0] > $player2[$key][0]) { 
                        $play1 += 1; 
                    } elseif ($player1[$key][0] < $player2[$key][0]) { 
                        $play2 += 1; 
                    } 
                    if ($player1[$key][1] > $player2[$key][1]) { 
                        $play1 += 1; 
                    } elseif ($player1[$key][1] < $player2[$key][1]) { 
                        $play2 += 1; 
                    } 
                    if ($play1 > $play2) { 
                        return 1; 
                    } elseif ($play1 < $play2) { 
                        return -1; 
                    } else { 
                        $excp = array(array($player1[$key][0], $player1[$key][1]), array($player2[$key][0], $player2[$key][1])); 
                        $alta1 = $manoPlayer1->getCartaAlta($excp[0]); 
                        $alta2 = $manoPlayer2->getCartaAlta($excp[1]); 
                        if ($alta1 == $alta2) { 
                            return 0; 
                        } elseif ($alta1 > $alta2) { 
                            return 1; 
                        } else { 
                            return -1; 
                        } 
                    } 
                } 
            } else { 
                return 0; 
            } 
        } elseif ($ordenJugadas[$this->jugada($cartas1)] > $ordenJugadas[$this->jugada($cartas2)]) { 
            return 1; 
        } else { 
            return -1; 
        } 
    } 
 
} 
 
?>

Apolo_13 · #11 (**permalink**) 26/06/2015, 05:49

NIVEL 2 - A (mensaje 2)

La clase Baraja:

Código PHP:

  <?php 
 
class Baraja { 
 
    private $baraja; 
    private $palos; 
    private $valores; 
 
    public function Baraja() { 
        $this->baraja = array(); 
        $this->palos = array("p", "c", "d", "t"); 
        $this->valores = array("2", "3", "4", "5", "6", "7", "8", "9", "10", "j", "q", "k", "a"); 
        $this->llenarBaraja(); 
        $this->barajarBaraja(); 
    } 
 
    private function llenarBaraja() { 
        foreach ($this->palos as $palo) { 
            for ($i = 0; $i < 13; $i++) { 
                $this->baraja[] = new Carta($this->valores[$i], $palo); 
            } 
        } 
    } 
 
    private function barajarBaraja() { 
        shuffle($this->baraja); 
    } 
 
    public function getBaraja() { 
        return $this->baraja; 
    } 
 
} 
 
?>

La clase Carta:

Código PHP:

  <?php 
 
class Carta { 
 
    private $valor; 
    private $palo; 
 
    public function Carta($val, $pal) { 
        $this->valor = $val; 
        $this->palo = strtolower($pal); 
    } 
 
    public function getValor() { 
        return $this->valor; 
    } 
 
    public function getPalo() { 
        return $this->palo; 
    } 
 
} 
?>

La clase ManoJugador:

Código PHP:

  <?php 
 
class ManoJugador { 
 
    private $analizadorMano; 
    private $cartasOrd; 
     
 
    public function getBoolEscaleraReal() { 
        $aux = $this->escaleraReal; 
        return $aux['bool']; 
    } 
 
    public function getBoolEscaleraColor() { 
        $aux = $this->escaleraColor; 
        return $aux['bool']; 
    } 
 
    public function getBoolPoker() { 
        $aux = $this->poker; 
        return $aux['bool']; 
    } 
 
    public function getBoolFull() { 
        $aux = $this->full; 
        return $aux['bool']; 
    } 
 
    public function getBoolColor() { 
        $aux = $this->color; 
        return $aux['bool']; 
    } 
 
    public function getBoolEscalera() { 
        $aux = $this->escalera; 
        return $aux['bool']; 
    } 
 
    public function getBoolTrio() { 
        $aux = $this->trio; 
        return $aux['bool']; 
    } 
 
    public function getBoolDoblesParejas() { 
        $aux = $this->parejasODobles; 
        if ($aux['modo'] == "dobles") { 
            return $aux['bool']; 
        } else { 
            return false; 
        } 
    } 
 
    public function getBoolPareja() { 
        $aux = $this->parejasODobles; 
        if ($aux['modo'] == "normal") { 
            return $aux['bool']; 
        } else { 
            return false; 
        } 
    } 
 
    public function getBoolCartaAlta() { 
        $aux = $this->cartaAlta; 
        return $aux['bool']; 
    } 
 
    public function getEscaleraReal() { 
        return $this->escaleraReal; 
    } 
 
    public function getEscaleraColor() { 
        return $this->escaleraColor; 
    } 
 
    public function getPoker() { 
        return $this->poker; 
    } 
 
    public function getFull() { 
        return $this->full; 
    } 
 
    public function getColor() { 
        return $this->color; 
    } 
 
    public function getEscalera() { 
        return $this->escalera; 
    } 
 
    public function getTrio() { 
        return $this->trio; 
    } 
 
    public function getParejasODobles() { 
        return $this->parejasODobles; 
    } 
 
    public function getCartaAlta($excluir = null) { 
        if($excluir == null) { 
            return $this->cartaAlta; 
        } else { 
            return  $this->analizadorMano->cartaAlta($this->cartasOrd, $excluir); 
        } 
    } 
     
 
    public function ManoJugador($cartas) { 
        $this->analizadorMano = new Algoritmo(); 
        $this->cartasOrd = $this->analizadorMano->ordenarCartas($cartas); 
        $this->escaleraReal = $this->analizadorMano->isEscaleraReal($this->cartasOrd); 
        $this->escaleraColor = $this->analizadorMano->isEscaleraColor($this->cartasOrd); 
        $this->poker = $this->analizadorMano->isPoker($this->cartasOrd); 
        $this->full = $this->analizadorMano->isFull($this->cartasOrd); 
        $this->color = $this->analizadorMano->isColor($this->cartasOrd); 
        $this->escalera = $this->analizadorMano->isEscalera($this->cartasOrd); 
        $this->trio = $this->analizadorMano->isTrio($this->cartasOrd); 
        $this->parejasODobles = $this->analizadorMano->isParejaODoble($this->cartasOrd); 
        $this->cartaAlta = $this->analizadorMano->cartaAlta($this->cartasOrd); 
    } 
 
} 
 
?>

Apolo_13 · #12 (**permalink**) 26/06/2015, 05:51

NIVEL 2 - A (mensaje 3)

La clase Algoritmo:

Código PHP:

  <?php

class Algoritmo {

    private $arrOrd;

    public function Algoritmo() {
        $this->arrOrd = array("2" => 2, "3" => 3, "4" => 4, "5" => 5, "6" => 6, "7" => 7, "8" => 8, "9" => 9, "10" => 10, "j" => 11, "q" => 12, "k" => 13, "a" => 14);
    }

    public function isEscaleraReal($carts) {
        $result = array();
        $isEscaleraColor = $this->isEscaleraColor($carts);

        if ($isEscaleraColor['bool']) {
            $result['color'] = $isEscaleraColor['color'];
            if ($isEscaleraColor['min'] == 10 && $isEscaleraColor['max'] == 14) {
                $result['bool'] = true;
            } else {
                $result['bool'] = false;
            }
        } else {
            $result['bool'] = false;
        }
        return $result;
    }

    public function isEscaleraColor($carts) {
        $result = array();

        $isEscalera = $this->isEscalera($carts);
        $isColor = $this->isColor($carts);

        $result['min'] = $isEscalera['min'];
        $result['max'] = $isEscalera['max'];

        if ($isEscalera['bool'] && $isColor['bool']) {
            $result['color'] = $isColor['color'];
            $result['bool'] = true;
        } else {
            $result['bool'] = false;
        }
        return $result;
    }

    public function isPoker($carts) {
        $result = array();
        $cartsAgrupadas = $this->agruparCartas($carts);

        //$exist = array_search('2', $cartsAgrupadas);
        $exist = array_keys($cartsAgrupadas, '4');
        if (count($exist) == 0) {
            $result['bool'] = false;
        } else {
            $result['bool'] = true;
            $result['val'] = $this->arrOrd[$exist[0]];
        }
        return $result;
    }

    public function isFull($carts) { 
        $result = array();

        $exist1 = $this->isTrio($carts);
        $exist2 = $this->isParejaODoble($carts);
        if ($exist2['bool'] == true && $exist2['modo'] == "normal" && $exist1['bool']) {
            $result['bool'] = true;
            $result['val'] = array(array("trio", $exist1['val']), array("pareja", $exist2['val']));
        } else {
            $result['bool'] = false;
        }
        return $result;
    }

    public function isColor($carts) {
        $result = array();
        $color = true;
        for ($i = 0; $i < (count($carts) - 1) && $color; $i++) {
            if ($carts[$i]->getPalo() != $carts[$i + 1]->getPalo()) {
                $color = false;
            }
        }
        if ($color) {
            $result['color'] = $carts[0]->getPalo();
            $result['val'] = $this->arrOrd[$carts[count($carts) - 1]->getValor()];
            $result['bool'] = true;
        } else {
            $result['bool'] = false;
        }
        return $result;
    }

    public function isEscalera($carts) {
        $result = array();
        $result['max'] = $this->arrOrd[$carts[count($carts) - 1]->getValor()];
        $result['min'] = $this->arrOrd[$carts[0]->getValor()]; //para calcular si es escalera real
        $escalera = true;
        for ($i = 0; $i < (count($carts) - 1) && $escalera; $i++) {
            if (($this->arrOrd[$carts[$i]->getValor()] + 1) != $this->arrOrd[$carts[$i + 1]->getValor()]) {
                if (($this->arrOrd[$carts[$i + 1]->getValor()] == 14) && ($this->arrOrd[$carts[$i]->getValor()] == 5)) {
                    $escalera = true;
                } else {
                    $escalera = false;
                }
            }
        }
        if ($escalera) {
            $result['bool'] = true;
            if ($result['max'] == 14 && $result['min'] == 2) {
                $result['min'] = $result['max'];
                $result['max'] = 5;
            }
        } else {
            if ($result['max'] == 5 && $result['min'] == 14) {
                $result['bool'] = true;
            } else {
                $result['bool'] = false;
            }
        }
        return $result;
    }

    public function isTrio($carts) {
        $result = array();
        $cartsAgrupadas = $this->agruparCartas($carts);

        //$exist = array_search('2', $cartsAgrupadas);
        $exist = array_keys($cartsAgrupadas, '3');
        if (count($exist) == 0) {
            $result['bool'] = false;
        } else {
            $result['bool'] = true;
            $result['val'] = $this->arrOrd[$exist[0]];
        }
        return $result;
    }

    public function isParejaODoble($carts) {
        $result = array();
        $cartsAgrupadas = $this->agruparCartas($carts);

        $exist = array_keys($cartsAgrupadas, '2');
        if (count($exist) == 2) {
            $result['bool'] = true;
            $result['val'] = array($this->arrOrd[$exist[0]], $this->arrOrd[$exist[1]]);
            $result['modo'] = "dobles";
            $aux = $this->cartaAlta($carts, $result['val']);
            $result['max'] = $aux['val'];
        } elseif (count($exist) == 1) {
            $result['bool'] = true;
            $result['val'] = $this->arrOrd[$exist[0]];
            $result['modo'] = "normal";
            $aux = $this->cartaAlta($carts, $result['val']);
            $result['max'] = $aux['val'];
        } else {
            $result['bool'] = false;
        }
        return $result;
    }

    public function cartaAlta($carts, $excluir = null) {
        $result = array();
        $masAlta = null;
        foreach ($carts as $val) {
            if ($excluir != null) {
                if (is_array($excluir)) {
                    if ($this->arrOrd[$val->getValor()] != $excluir[0] && $this->arrOrd[$val->getValor()] != $excluir[1]) {
                        if ($masAlta == null) {
                            $masAlta = $val->getValor();
                        } else {
                            if ($this->arrOrd[$val->getValor()] > $this->arrOrd[$masAlta]) {
                                $poner = true;
                                foreach($excluir as $exc) {
                                    if($val->getValor() == $exc) {
                                        $poner = false;
                                    }
                                }
                                if($poner) {
                                    $masAlta = $val->getValor();
                                }
                            }
                        }
                    }
                } else {
                    if ($this->arrOrd[$val->getValor()] != $excluir) {
                        if ($masAlta == null) {
                            $masAlta = $val->getValor();
                        } else {
                            if ($this->arrOrd[$val->getValor()] > $this->arrOrd[$masAlta]) {
                                $masAlta = $val->getValor();
                            }
                        }
                    }
                }
            } else {
                if ($masAlta == null) {
                    $masAlta = $val->getValor();
                } else {
                    if ($this->arrOrd[$val->getValor()] > $this->arrOrd[$masAlta]) {
                        $masAlta = $val->getValor();
                    }
                }
            }
        }
        $result['val'] = $masAlta;
        return $result;
    }

    private function agruparCartas($carts) {
        $result = array();
        $result['2'] = 0;
        $result['3'] = 0;
        $result['4'] = 0;
        $result['5'] = 0;
        $result['6'] = 0;
        $result['7'] = 0;
        $result['8'] = 0;
        $result['9'] = 0;
        $result['10'] = 0;
        $result['j'] = 0;
        $result['q'] = 0;
        $result['k'] = 0;
        $result['a'] = 0;
        for ($i = 0; $i < count($carts); $i++) {
            switch ($carts[$i]->getValor()) {
                case "2":
                    $result['2'] += 1;
                    break;
                case "3":
                    $result['3'] += 1;
                    break;
                case "4":
                    $result['4'] += 1;
                    break;
                case "5":
                    $result['5'] += 1;
                    break;
                case "6":
                    $result['6'] += 1;
                    break;
                case "7":
                    $result['7'] += 1;
                    break;
                case "8":
                    $result['8'] += 1;
                    break;
                case "9":
                    $result['9'] += 1;
                    break;
                case "10":
                    $result['10'] += 1;
                    break;
                case "j":
                    $result['j'] += 1;
                    break;
                case "q":
                    $result['q'] += 1;
                    break;
                case "k":
                    $result['k'] += 1;
                    break;
                case "a":
                    $result['a'] += 1;
                    break;
                default:
                    break;
            }
        }
        return $result;
    }

    public function ordenarCartas($cartas) {
        $cards = array();
        $resultado = array();
        foreach ($cartas as $key => $value) {
            $cards[$key] = $this->arrOrd[$value->getValor()];
        }
        asort($cards);
        foreach ($cards as $cla => $val) {
            $resultado[] = $cartas[$cla];
        }
        return $resultado;
    }

}

?>

NSD · #13 (**permalink**) 28/06/2015, 11:33

NIVEL 3

Este es el tercer nivel de la maratón. ¡En marcha!

A.- En este nivel se deberá recrear el clásico juego "Piedra-Papel-Tijera", el usuario elegirá su jugada y el servidor elegirá la suya aleatoriamente, luego informara quien es el ganador o si hubo empate.
Para superar este desafió, solo es necesario resolver el "Modo clásico".
A continuación, se muestra la pantalla visual y el lugar donde deberá estar ubicado el código PHP, recuerde publicar solo el código PHP no toda la plantilla visual ya que esta es la misma para todos los concursantes.

Código HTML:

Ver original<!DOCTYPE html>
 <html>
     <head>
         <title>PHP MARATON SCRIPT V1 - NIVEL 3 A</title>
     </head>
     <body>
         <?php 
            // Su código aqui...
         ?>
         
         <h3>Modo Clasico</h3>
         <form method="post">
             <ul>
                <li><input type="radio" name="jugada" value="0"> Piedra</li>
                <li><input type="radio" name="jugada" value="1"> Papel</li>
                <li><input type="radio" name="jugada" value="2"> Tijera</li>
             </ul>
             <input type="hidden" name="modo" value="0">
             <input type="submit" value="¡JUGAR!">
         </form>
         
         <h3>Modo Experto</h3>
         <form method="post">
             <ul>
                <li><input type="radio" name="jugada" value="0"> Piedra</li>
                <li><input type="radio" name="jugada" value="1"> Papel</li>
                <li><input type="radio" name="jugada" value="2"> Tijera</li>
                <li><input type="radio" name="jugada" value="3"> Demonio</li>
                <li><input type="radio" name="jugada" value="4"> Dragon</li>
                <li><input type="radio" name="jugada" value="5"> Agua</li>
                <li><input type="radio" name="jugada" value="6"> Aire</li>
                <li><input type="radio" name="jugada" value="7"> Linterna</li>
                <li><input type="radio" name="jugada" value="8"> Esponja</li>
                <li><input type="radio" name="jugada" value="9"> Lobo</li>
                <li><input type="radio" name="jugada" value="10"> Arbol</li>
                <li><input type="radio" name="jugada" value="11"> Humano</li>
                <li><input type="radio" name="jugada" value="12"> Serpiente</li>
                <li><input type="radio" name="jugada" value="13"> Revolver</li>
                <li><input type="radio" name="jugada" value="14"> Fuego</li>
             </ul>
             <input type="hidden" name="modo" value="1">
             <input type="submit" value="¡JUGAR!">
         </form>
     </body>
 </html>

CONDICIÓN DE MERITO:
El algoritmo debe ser genérico, es decir, debe servir para resolver tanto el "Modo clásico" como el "Modo experto".
Considere para el "Modo experto" el siguiente gráfico:

LINEAS DE CODIGO ESTIMADAS: <40

B.- En este desafió, se deberá programar un algoritmo que genere una tabla de enfrentamientos, recibiendo un array con una cantidad impar de valores de tipo string, y que devuelva otro array donde las claves sean los valores del array ingresados y el valor de cada una sea otro array que contenga a los string a los cuales derrota (determinados aleatoriamente), recuerde que cada elemento debe derrotar a la mitad de los demas elementos y ser derrotado por la otra mitad.

Un ejemplo de todas las soluciones posibles para 3 elementos:

Código PHP:

Ver originalenfrentamientos(["Piedra", "Papel", "Tijera"]);
// Posibles respuestas:
// ["Piedra" => ["Tijera"], "Tijera" => ["Papel"], "Papel" => ["Piedra"]]
// ["Piedra" => ["Papel"], "Tijera" => ["Piedra"], "Papel" => ["Tijera"]]

CONDICIÓN DE MERITO:
Permitir que el algoritmo reciba un segundo parámetro opcional, que defina algunas pre-condiciones de las soluciones, es decir, algunos elementos que se deben cumplir si o si.
Ej:

Código PHP:

Ver originalenfrentamientos(["Piedra", "Papel", "Tijera"], ["Piedra" => ["Tijera"]]);
// Siempre retorna esta combinación, ya que es la única posible que cumple los requisitos:
// ["Piedra" => ["Tijera"], "Tijera" => ["Papel"], "Papel" => ["Piedra"]]

NOTA: Asuma que los pre-requisitos son validos y que existe al menos una combinación que los satisface. También asuma que el numero de elementos del primer array es impar.

LINEAS DE CODIGO ESTIMADAS: <30 (<60 CON MERITO)

NIVEL 4

Este es el cuarto nivel de la maratón. ¡En marcha!

A.- Cuando un grupo de amigos se reune a jugar al futbol, es comun definir los equipos mediante eleccion directa por turnos, los dos directores hacen el clasico "Pan y Queso" para ver quien elije primero y luego cada uno elije un jugador, no obstante, el ganador del "Pan y Queso" puede en un turno dado permitir al otro que elija primero, esto se conoce como "Galantear". Como sabemos, en el futbol siempre gana el equipo que tiene los jugadores con mayor habilidad (

) por lo tanto, la tarea a realizar en este desafio, consiste en determinar cuantas veces el ganador del "Pan y Queso" puede "Galantear" a su adversario asegurandose la victoria del encuentro.
- Programe una funcion llamada "galantear" que reciba un array con las puntuaciones de cada jugador.
- Considere que siempre hay una cantidad par de jugadores.
- Considere que ambos directores siempre elijen primero a los de mayor habilidad.
- Debe retornar la cantidad de veces que el ganador puede "Galantear" a su adversario sin riesgo de perder el partido.
- Si no es posible ganar el partido, debe retornar -1

CONDICIÓN DE MERITO:
La funcion debe aceptar un segundo array opcional (inicialmente vacio), recibido por referencia, donde almacenara las puntuaciones de los jugadores que conformaran al equipo del ganador de "Pan y Queso".

Algunos tests:

Código PHP:

Ver originalgalantear([10,10,10,10]) // -1
galantear([7,8,2,10,1,4]) // 1
galantear([7,8,2,10,1,3]) // 2
galantear([60,95,100,65]) // 0
 
// Siendo $equipo = [];
galantear([10,10,10,10], $equipo) // -1, $equipo = [10,10]
galantear([7,8,2,10,1,4], $equipo) // 1, $equipo = [10,7,1]
galantear([7,8,2,10,1,3], $equipo) // 2, $equipo = [8,7,1]
galantear([60,95,100,65], $equipo) // 0, $equipo = [100,65]

LINEAS DE CODIGO ESTIMADAS: <25

B.- En una determinada ciudad, hay muchas lineas de trenes que se entrecruzan. En un momento del dia dado, sale un tren de cada una de estas lineas, pero claro, si todos salen al mismo tiempo y las vías se cruzan ¡Chocarian!, por lo tanto se implemento un sistema de salida de trenes por turnos, su tarea para este desafio consiste en determinar la menor cantidad de turnos necesarios para que no se produzca ningun choque.
- Programe una funcion llamada trenes, que reciba un array ordenado con el numero de anden al que se dirige cada tren.
- La cantidad de trenes es variable.
- Deber retornar el numero minimo de turnos de salida.
- Considere que hay 1 anden por tren.
- Considere que no hay dos trenes que se dirijan al mismo anden.
- Las vias de tren tienen la topologia que se muestra en la imagen siguiente, el array que recibira la funcion como parametro es la serie de numeros de la derecha, en el caso particular de esta imagen de ejemplo seria: [5,3,4,1,2], los andenes a la izquierda estan numerados de forma consecutiva creciente.

CONDICIÓN DE MERITO:
La funcion debe aceptar un segundo array opcional (inicialmente vacio), recibido por referencia, donde almacenara para cada turno, que trenes deben salir.
En caso de haber mas de una combinacion posible, se puede mostrar cualquiera de ellas.

Algunos tests:

Código PHP:

Ver originaltrenes([4,5,2,3,1]) // 3
trenes([1,2,3]) // 1
 
// Siendo $turnos = [];
trenes([4,5,2,3,1], $turnos) // 3, $turnos = [[4,5],[2,3],[1]]
trenes([1,2,3], $turnos) // 1, $turnos = [[1,2,3]]

LINEAS DE CODIGO ESTIMADAS: <35

Eleazan · #14 (**permalink**) 07/07/2015, 09:38

Nivel 1-A

Código PHP:

Ver original<?php
$letters = array("a", "o", "u", "H", "l", "m", "n", "d");
 
$output = fopen('php://output', 'w');
fwrite($output, $letters[3].$letters[1].$letters[4].$letters[0]." ".$letters[5].$letters[2].$letters[6].$letters[7].$letters[1]."\n");
fclose($output);
?>

Eleazan · #15 (**permalink**) 07/07/2015, 14:52

Nivel 1-B

Código PHP:

  <?php 
$pagina = isset($_GET['pagina']) ? $_GET['pagina'] : 0; 
$nombre = isset($_GET['nombre']) ? $_GET['nombre'] : ''; 
 
if($nombre == '') $pagina = 0; 
 
$pantallas = str_replace( 
                array(".php", '<input type="text"', "-NOMBRE-"), 
                array( ".php?nombre=".$nombre."&pagina=".($pagina+1), '<input type="hidden" name="pagina" value="'.($pagina+1).'"><input type="text"', $nombre), 
                $pantallas 
                ); 
 
 
echo $pantallas[$pagina]; 
 
?>

NSD · #16 (**permalink**) 12/07/2015, 12:38

NIVEL 5

Este es el quinto nivel de la maratón. ¡En marcha!

A.- En este nivel se deberá crear un algoritmo de encriptado.
El algoritmo que se les pide desarrollar, recibira 3 parametros:
- Un string, compuesto solo por letras minusculas, de la "a" a la "z" inclusive, de al menos 2 caracteres, que es el string original que se quiere encriptar.
- Un array compuesto por 4 numeros diferentes, ordenados de forma creciente, todos distintos y menores o iguales que la longitud del string del primer parametro.
- Un numero opcional, mayor que 0, por defecto 1, que indica el nivel de encriptacion.

El algoritmo funciona asi:
0) Tantas veces como indique el parametro "nivel de encriptacion" repetir los siguientes pasos:
1) Se obtienen 2 substring del string original, basandose en las posiciones indicadas en el array del segundo parametro.
2) A cada uno de esos substring, se los "da vuelta", es decir, se hace la reversa de la cadena.
3) A cada caracter de cada uno de esos substring se le resta 1 a su valor ascii, considere un alfabeto circular, donde la "a" se convierte en la "z".
4) Se intercambian los dos substring dentro del string original.

Un ejemplo:
encriptar("estedesafioesincreible", [2,6,8,18], 2);
1) Obtener los dos substring: "tede" y "fioesincre"
2) Darlos vuelta: "edet" y "ercniseoif"
3) Restar 1 al valor ascii: "dcds" y "dqbmhrdthe"
4) Intercambiar en el string original: "esdqbmhrdthesadcdsible"
5) Repetir el paso 1 al 4 otra vez, tomando ahora como string de entrada a: "esdqbmhrdthesadcdsible"

CONDICIÓN DE MERITO:
Programar otro algoritmo, llamado desencriptar que reciba los mismos tipos de parametros que "encriptar" pero que realice el proceso inverso.

LINEAS DE CODIGO ESTIMADAS: <50

B.- En este nivel se deberá crear un webservice para una sala de chat publica.
Considere la siguiente pantalla visual:

Código HTML:

Ver original<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
        <title>Chat Webservice</title>
        <script>
            ChatWs = function(params) {
                this.comet = this.comet.bind(this);
 
                this.messages = params.messages;
                this.form = params.form;
                this.ws = params.ws;
                this.stack = new FormData();
                this.stack.length = 0;
                this.id = 0;
 
                this.form.addEventListener("submit", function(evt) {
                    evt.preventDefault();
                    this.stack.append('stack[' + this.stack.length + '][nick]', this.form.elements.nick.value);
                    this.stack.append('stack[' + this.stack.length + '][mensaje]', this.form.elements.mensaje.value);
                    this.stack.length++;
                    this.form.elements.mensaje.value = "";
                }.bind(this));
 
                this.comet();
            }
 
            ChatWs.prototype = {
                "comet" : function() {
                    var request = new XMLHttpRequest();
                    request.open("POST", this.ws);
                    request.onreadystatechange = function(chatws) {
                        if(this.readyState == 4) {
                            if(this.status == 200) {
                                var response;
                                try {
                                    response = JSON.parse(this.responseText);
                                } catch (e) {
                                    console.error(this.responseText);
                                    console.error(e);
                                } finally {
                                    var nro;
                                    for(nro = 0; nro<response.mensajes.length; nro++)
                                        chatws.messages.appendChild(document.createElement("li")).innerHTML = response.mensajes[nro];
                                    chatws.id = response.id;
                                }
                            }
                            
                            setTimeout(chatws.comet, 2000);
                        }
                    }.bind(request, this);
                    
                    this.stack.append("id", this.id);
                    request.send(this.stack);
                    this.stack = new FormData();
                    this.stack.length = 0;
                }
            };
        </script>
    </head>
    <body>
        <h1>Chat Ws</h1>
        <ul id="messages-list"></ul>
        <form id="chat-form">
            <label>
                Nick:
                <input type="text" name="nick">
            </label>
            <label>
                Mensaje:
                <input type="text" name="mensaje">
            </label>
            <input type="submit" value="enviar">
        </form>
        <script>
            new ChatWs({
                "messages" : document.getElementById("messages-list"),
                "form" : document.getElementById("chat-form"),
                "ws" : "chat-ws.php"
            });
        </script>
    </body>
</html>

y la siguiente plantilla PHP, llamado el archivo como "chat-ws.php":

Código PHP:

Ver original<?php
    $archivo = "chat-ws.txt";
 
    function chat($stack, &$id, $archivo) {
        $nuevos_mensajes = [];
 
        // Su codigo aqui...
        
        return $nuevos_mensajes;
    }
 
    echo json_encode(["mensajes" => chat($_POST["stack"], $_POST["id"], $archivo), "id" => $_POST["id"]]);

su tarea sera programar el contenido de la funcion "chat" teniendo en cuenta las siguientes condiciones:
- El parametro $stack, es un array bidimencional, donde cada cada elemento tiene las propiedades "nick" y "mensaje".
- El parametro $id, recibido por referencia, es el ultimo mensaje que el cliente conoce.
- El parametro $archivo contiene el nombre de un archivo txt donde se almacenan los mensajes.
- En el archivo txt donde se guardan los mensajes, solo puede haber un mensaje por linea, el numero de linea se comportara entonces como "Clave Primaria autoincrementada".
- Al invocarse la funcion, se deben agregar al archivo tantas lineas como mensajes alla en $stack.
- La funcion debe retornar un array, con todos los mensajes no leidos por el cliente, es decir, todos aquellos mensajes cuyo numero de linea sea mayor al valor del parametro $id.
- La funcion debe de actualizar el valor de $id con la cantidad de lineas final del archivo.
- El chat debe funcionar de forma fluida y correctamente (sin repetir mensajes ni saltearse alguno) sin importar la cantidad de personas conectadas al chat.
- Cada mensaje nuevo devuelto, debe contener el nick del usuario en negrita (usar la etiqueta strong de html5) y el texto del mensaje en letra normal.

CONDICIÓN DE MERITO:
El algoritmo debe ser robusto y eficiente, al punto tal que pueda manejar millones de lineas de mensajes y decenas de usuarios simultáneos sin saturar los recursos del servidor.
Considere en este caso, que la longitud maxima para $nuevos_mensajes es de 50.

LINEAS DE CODIGO ESTIMADAS: <50

rodrypaladin · #17 (**permalink**) 31/12/2015, 21:15

Nivel 1 - A

Intentando no repetir las ideas de los otros foreros, aunque lo complique mucho cumple! XD

Código PHP:

Ver original//declaramos letras
$let = "abcdefghijklmnopqrstuvwxyz";
$let .= "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
//declaramos arrays de las posiciones
$word1 = array(33,14,11,0,);
$word2 = array(12,20,13,3,14);
 
//imprimimos 1º palabra
for($i=0; $i<count($word1);$i++) {
echo $let[$word1[$i]];
}
 
//imprimimos separacion
echo " ";
 
//imprimimos 2º palabra
for($j=0; $j<count($word2);$j++) {
echo $let[$word2[$j]];
}