Esta tarea forma parte del primer empuje de programación periódica Premier Puzzle .
Obtiene una jerarquía de elementos en el siguiente formato:
2
Hat
1
Gloves
que deben colocarse en cajas, así:
.------------.
| Hat |
| .--------. |
| | Gloves | |
| '--------' |
'------------'
En el formato de entrada, los números comienzan un cuadro con tantos elementos como el número especifica. La primera caja tiene dos elementos (el Sombrero y la caja que contiene los Guantes), la segunda solo contiene un elemento: los guantes.
Como se puede ver, las cajas también pueden vivir dentro de las cajas. Y siempre son redondeados ... más o menos (las esquinas puntiagudas son un riesgo de herida y no quisiéramos eso).
A continuación, se encuentran los detalles desagradables para aquellos que desean utilizar cada pequeño margen de maniobra que brinda la especificación. Eso sí, no leer las especificaciones no es excusa para enviar soluciones incorrectas. Hay un script de prueba y algunos casos de prueba al final.
Especificación
Las cajas se construyen a partir de los siguientes caracteres:
|
(U + 007C) se utiliza para construir los bordes verticales.-
(U + 002D) se utiliza para construir los bordes horizontales.'
(U + 0027) son las esquinas inferiores redondas..
(U + 002E) son las esquinas superiores redondas.
Por lo tanto, una caja se ve así:
.--. | | '--'
Tenga en cuenta que, si bien Unicode también tiene esquinas redondeadas y caracteres de dibujo de recuadro adecuados, esta tarea es solo en ASCII. Por mucho que amo a Unicode, me doy cuenta de que hay idiomas y entornos que no llegaron en la segunda a la última década.
Los cuadros pueden contener una secuencia de elementos que son texto u otros elementos. Los elementos individuales en un cuadro se representan de arriba a abajo. La secuencia A, B, C se presenta así:
.---. | A | | B | | C | '---'
Por supuesto, esto también se aplica a los cuadros anidados, que son un elemento similar al texto. Entonces la secuencia A, B, Box (C, Box (D, E)), F se representaría de la siguiente manera:
.-----------. | A | | B | | .-------. | | | C | | | | .---. | | | | | D | | | | | | E | | | | | '---' | | | '-------' | | F | '-----------'
Los cuadros ajustan su tamaño al contenido y los cuadros anidados siempre se extienden al tamaño de sus padres. Siempre hay un espacio antes y después del contenido, de modo que ni el texto ni los cuadros anidados estén demasiado cerca del borde del cuadro exterior. En resumen, lo siguiente está mal:
.---. |Box| '---'
Y lo siguiente es correcto:
.-----. | Box | '-----'
También se ve mucho mejor :-)
Los elementos de texto (ver Entrada a continuación) deben reproducirse exactamente.
Siempre hay un único cuadro de nivel superior (cf. XML). Sin embargo, un cuadro puede contener varios otros cuadros.
Entrada
La entrada se da en la entrada estándar; para una prueba más fácil, probablemente redirigido desde un archivo.
La entrada se da en línea, y cada línea representa un elemento de texto para colocar en el cuadro actual o abrir un nuevo cuadro.
Cada línea termina con un salto de línea.
Los elementos de texto están marcados por una línea que no consta de un número (ver más abajo). El texto usa caracteres alfabéticos, el espacio y la puntuación (
.,-'"?!()
). El texto no comenzará ni terminará con un espacio y siempre tendrá al menos un carácter.Un cuadro comienza con una sola línea con un número. El número indica el tamaño del cuadro, es decir, el número de elementos siguientes que se colocan en él:
2 A B
produce un cuadro con dos elementos de texto:
.---. | A | | B | '---'
Una caja siempre contendrá al menos un elemento.
El final de los cuadros no está marcado explícitamente con una línea; en su lugar, los cuadros se cierran implícitamente después de que se les coloca el número especificado de elementos.
Un cuadro siempre es un solo elemento, independientemente de cuántos elementos contenga. P.ej
3 A 4 a b c d B
producirá una caja con tres elementos, el segundo de los cuales es otra caja con cuatro elementos.
La anidación tampoco afecta el hecho de que una caja es solo un elemento.
Límites
El nivel máximo de anidación es cinco . Es decir, hay como máximo cinco cajas una dentro de la otra. Esto incluye el más externo.
Hay un máximo de diez artículos por caja.
Los elementos de texto tienen una longitud máxima de 100 caracteres.
Salida
- La salida es el cuadro representado que incluye todos los elementos que contienen y anidados según las reglas descritas anteriormente.
- La salida debe darse en la salida estándar y debe coincidir exactamente. No se permiten espacios en blanco iniciales o finales.
- Cada línea debe terminar con un salto de línea, incluida la última.
Condición ganadora
- El código más corto gana (es decir, obtiene la respuesta aceptada).
Entrada de muestra 1
3
This is some text!
Oh, more text?
Just text for now, as this is a trivial example.
Salida de muestra 1
.--------------------------------------------------.
| This is some text! |
| Oh, more text? |
| Just text for now, as this is a trivial example. |
'--------------------------------------------------'
Entrada de muestra 2
4
Extreme
nesting
3
of
boxes
4
might
lead
to
2
interesting
1
visuals.
Indeed!
Salida de muestra 2
.--------------------------.
| Extreme |
| nesting |
| .----------------------. |
| | of | |
| | boxes | |
| | .------------------. | |
| | | might | | |
| | | lead | | |
| | | to | | |
| | | .--------------. | | |
| | | | interesting | | | |
| | | | .----------. | | | |
| | | | | visuals. | | | | |
| | | | '----------' | | | |
| | | '--------------' | | |
| | '------------------' | |
| '----------------------' |
| Indeed! |
'--------------------------'
Entrada de muestra 3
1
1
1
1
1
Extreme nesting Part Two
Salida de muestra 3
.------------------------------------------.
| .--------------------------------------. |
| | .----------------------------------. | |
| | | .------------------------------. | | |
| | | | .--------------------------. | | | |
| | | | | Extreme nesting Part Two | | | | |
| | | | '--------------------------' | | | |
| | | '------------------------------' | | |
| | '----------------------------------' | |
| '--------------------------------------' |
'------------------------------------------'
Entrada de muestra 4
3
Foo
2
Bar
Baz
2
Gak
1
Another foo?
Salida de muestra 4
.----------------------.
| Foo |
| .------------------. |
| | Bar | |
| | Baz | |
| '------------------' |
| .------------------. |
| | Gak | |
| | .--------------. | |
| | | Another foo? | | |
| | '--------------' | |
| '------------------' |
'----------------------'
Script de prueba
Dado que obtener los detalles correctos puede ser difícil en ocasiones, nosotros ( Ventero y yo) hemos preparado un script de prueba con el que puede ejecutar su solución para verificar si es correcta. Está disponible como un script de PowerShell y un script de bash . Invocación es: <test-script> <program invocation>
.
ACTUALIZACIÓN: los scripts de prueba se han actualizado; hubo varios casos de prueba que no cumplieron con los límites que definí. El script de prueba de PowerShell no utilizó la comparación entre mayúsculas y minúsculas para verificar el resultado. Espero que todo esté bien ahora. El número de casos de prueba se redujo a 156, aunque el último ahora es bastante ... grande.
ACTUALIZACIÓN 2: cargué mi generador de casos de prueba . Escrito en C # , dirigido al tiempo de ejecución de .NET 2. Se ejecuta en mono. Puede ayudar a las personas a probar su implementación. Como peor caso definitivo dados los límites en la tarea, puede intentar:
nb.exe 1 10 10 5 100 100 | my invocation
que generará solo cuadros hasta el nivel más interno y utilizará tanto el número máximo de elementos por cuadro como la longitud máxima de elementos de texto. Sin embargo, no incluí este caso de prueba en el script de prueba, ya que es bastante grande y la salida aún más grande.
ACTUALIZACIÓN 3: Actualicé el script de prueba de PowerShell que era propenso a generar errores dependiendo de cómo estaban las terminaciones de línea en el script y qué terminaciones de línea imprimía la solución. Ahora debería ser agnóstico para ambos. Perdón de nuevo por la confusión.
Respuestas:
GolfScript, 125 caracteres
Usando un enfoque similar a la solución de Keith .
fuente
Python, 204 caracteres
P
devuelve una lista de triples, cada uno de los cuales es un prefijo / sufijo de línea (el sufijo es el reverso del prefijo), un texto de línea y un carácter de relleno de línea. Después de calcular todos los triples, se imprimen utilizando el número correcto de caracteres de relleno para que todas las líneas tengan la misma longitud.Versión sin golf:
fuente
P
eso.Ruby 1.9, 174 caracteres
Algo similar a la solución de Keith .
fuente
APL (78)
fuente
Python -
355314259 caracteresfuente
Rubí 1.9,
229228226223222fuente
C,
390366363 caracteresCompilar con
gcc -std=gnu99 -w file.c
Ni siquiera cerca de la versión de Keith, pero bueno, está bien.
fuente
160/160 passed
(me refería a una cadena de 100 caracteres, que de todos modos no está presente)FreeBSD 8.2-RELEASE #5: Sun Feb 27 10:40:25 CET 2011
congcc version 4.2.1 20070719 [FreeBSD]
el x64 aquí. Tomaré tu palabra para el 160, entonces :-). Y debería haber un caso de prueba con 100 caracteres, en realidad (Pruebas 143–147).pitón muy funcional, 460 caracteres
fuente
|
personajes no están espaciados correctamente. Es muy similar a mi solución de PythonHaskell, 297 caracteres
Mientras golf'd, el método es bastante sencillo. Solo los límites son memoria disponible.
fuente
C # -
1005 859 852782 caracteresNecesito echarle otro vistazo a esto, ya que estoy seguro de que se puede mejorar, pero este es mi tercer paso
inicial.Ungolf'd:
fuente
var a = 1, b = 2, c = 3;
. ¿No puedes hacer lo mismo en C?var
declaraciones implícitas como esa. Solo puedes combinar si tienen un tipo explícito como el que Joey mencionó usarstring b="",e=""
.PHP,
403388306 caracteresSin golf:
Tomé prestada la idea del prefijo de Keith (¿está permitido?), De lo contrario, esto es más o menos como el original. Todavía no podía estar por debajo de 300. Atrapado con esto. Adelante.
fuente
PHP,
806769721653619 caracteresVersión sin golf:
fuente
<?
principio para incluso ejecutarse. Entonces, aparentemente, está utilizando la longitud máxima de todos los elementos de texto en un caso de prueba como el ancho del cuadro más interno. Este código solo pasa 118 de los casos de prueba (probados en Linux y FreeBSD). No tengo idea de lo que hizo para la secuencia de comandos PowerShell que no iba a funcionar, aunque :-( Invocando como.powershell -noprofile -file test.ps1 php boxes.php
Debería funcionar, en realidad, pero no tengo PHP en mi máquina de Windows a prueba..Java -
681668 caracteresesencialmente el mismo método que el código Python de Keith Randall
Versión sin golf:
fuente
throws
.break;
)char
comparaciones mirando códigos ascii por más tiempo ... pero tengo que ir a prepararme para las vacacionesPerl -
200199 caracteresEl mismo algoritmo que el Python de Keith Randall (diseño agradable, Keith), pero un poco más compacto en esta versión de Perl.
fuente
$_@_@_
parece alguien persiguiendo el signo del dólarF # - 341 caracteres
Una versión F # de la solución de Keith. Las listas son inmutables por defecto, por lo que esta versión inserta toda la función recursiva en una lista, devuelve la lista, de la que se extraen los elementos usando el
for..do
bucle y ayield!
. No pude encontrar una manera de revertir el prefijo de forma concisa, así que simplemente adjunté el sufijo a los triples.Para su información, el método TryParse devuelve un doble
(bool,int)
.fuente
Clojure - 480 caracteres
Este es mi primer programa de Clojure, así como mi primer intento de golf de Clojure, por lo que, no hace falta decir que esto no debe tomarse como representante de las soluciones de Clojure en general. Estoy seguro de que podría acortarse significativamente, especialmente si el método de Keith Randall de analizar y construir las cajas de inmediato se implementó.
fuente
C # -
472 470 426 422398 caracteresfuente
goto
! Por cierto, puede omitir los paréntesis en torno a los argumentos lambdaz
yv
, reduciéndolo a 421.Scala - 475 caracteres
fuente
C #
1198 1156 1142 689 671634 caracteresfuente
\n
parece ser suficiente al final.Pip , 89 bytes (no competitivos)
(El lenguaje es más nuevo que el desafío. Además, no pude superar a APL).
El código es de 87 bytes, +2 para las
-rn
banderas.Pruébalo en línea!
La función
z
procesa el primer elemento de la lista de entrada (g
copiado en una variable globali
para que esté disponible dentro de las llamadas a funciones). Si este es un número n , se llama a sí mismo recursivamente n veces, rellena la lista de líneas resultante en un rectángulo completo, ajusta cada línea"| " " |"
y agrega.---.
y'---'
líneas antes de devolver la nueva lista. Si es una cadena, simplemente la convierte en una lista de un elemento y la devuelve. El resultado final se imprime separado por una nueva línea (-n
bandera). Más detalles disponibles bajo petición.fuente
Java (1369 caracteres, incluidos EOL)
No podría dejar esto sin una implementación de Java. Se supone que Java es más detallado que los slicks de Python y Ruby, así que busqué una solución elegante y recursiva.
La idea es un árbol (gráfico) de objetos (cadenas y cuadros), que se contienen entre sí a partir de un cuadro de "cabeza". A medida que analiza linealmente el archivo de entrada, agrega cadenas y cuadros al cuadro "actual" y mientras agrega la longitud máxima del contenedor se ajusta. Cuando un contenedor alcanza la cantidad de elementos predefinidos que puede retenerlo, retroceda al contenedor anterior. Al final del archivo de entrada, tiene un contenedor "head" que ya tiene un "maxLength" calculado, por lo que simplemente llama a su método print ().
Es realmente una solución agradable para escribir. Me gustó mucho la pregunta. Como mencioné anteriormente, busqué la elegancia de la solución, no el enfoque minimalista, lamentablemente Java no tiene la impresión de Python "-" * 4 para producir "----" :-)
Aquí está la versión sin golf:
fuente