Figura y suelo

32

figura y suelo
Fuente: Wikipedia

Para este desafío, debe escribir dos programas que se parezcan a la figura y al fondo de la imagen de arriba, de modo que uno imprima figurey el otro imprima ground. Específicamente:

  1. Escriba un programa que no tome entrada e imprima la cadena figure. Los únicos caracteres de espacio en blanco permitidos en su programa son espacios (punto de código 0x20) y líneas nuevas (retornos de carro, 0x0D, avances de línea, 0x0A o una combinación de ambos).
  2. Ignorando las nuevas líneas, el número de caracteres de espacio (punto de código 0x20) y los caracteres que no son de espacio tiene que ser el mismo. Por ejemplo, este sería un programa válido (en un lenguaje hipotético):

    ab c 
       d
    e f
    

    Tenga en cuenta que hay un espacio final en la primera línea.

  3. Si se cambia el n º carácter de espacio con el n º no está en blanco, el programa debe imprimir grounden su lugar. Para el ejemplo anterior, el programa se vería así:

      a b
    cde 
     f 
    

    Tenga en cuenta que hay espacios finales en la segunda y tercera línea.

Tanto la figura como las soluciones básicas deben ser programas completos en el mismo lenguaje que se impriman en STDOUT. Puede imprimir una sola línea final opcional en cualquier caso. Puede generar cualquier cosa que desee STDERR, siempre que STDOUT sea correcto.

Puede usar cualquier lenguaje de programación , pero tenga en cuenta que estas lagunas están prohibidas de forma predeterminada.

Este es el , por lo que gana la respuesta válida más corta, medida en bytes .

Script de ayuda

Puede usar este script CJam para convertir entre una figura y un programa básico . Simplemente pegue uno de los dos en el campo Entrada y ejecute el programa. También le indicará si el número de espacios y no espacios no coincide.

Tabla de clasificación

Martin Ender
fuente

Respuestas:

20

Jalea , 20 bytes

Figura

“¦ĠȮ“©ụd» Ṃ         

Nueve espacios finales. Pruébalo en línea!

Suelo

         “ ¦ĠȮ“©ụd»Ṃ

Sin espacios finales. Pruébalo en línea!

Cómo funciona

Primero, tenga en cuenta que los espacios no son átomos, por lo que los caracteres de espacio fuera de los literales de cadena no afectan el programa de ninguna manera.

Los literales de cadena usan la compresión de cadena basada en diccionario incorporada de Jelly para producir las palabras deseadas. Un literal de cadena comprimido comienza con , termina con »y se usa internamente para crear una matriz de cadenas.

En el programa de figuras , “¦ĠȮ“©ụd»produce el par de cuerdas ("figura", "tierra") , y el átomo selecciona el mínimo lexicográfico, es decir, "figura" .

En el programa de tierra, “ ¦ĠȮ“©ụd»produce el par de cadenas ("logicallyAbacs", "ground") en su lugar. El mínimo lexicográfico es ahora "terreno" , que selecciona debidamente.

En ambos casos, el intérprete imprime automáticamente el último valor de retorno, es decir, el mínimo seleccionado, en STDOUT.

Dennis
fuente
14

Python 2, 53 bytes

Reemplazar ·con espacio en ambas respuestas:

····················
print'······figureground'[6:12]#

Impresiones figure.

print'figureground'[
······6:12]#····················

Impresiones ground.

Lynn
fuente
14

05AB1E , 15 14 bytes

Figura

 'ŠÂ,'í¶      

Pruébalo en línea!

Suelo

'       ŠÂ,'í¶

Pruébalo en línea!

Utiliza la codificación CP-1252 . Tenga en cuenta los espacios finales. En el programa Figura , es un programa normal sin errores. Descomprime las siguientes palabras:

'ŠÂ  ->  figure
'í¶  ->  ground

La coma imprime pops e imprime el figure palabra con una nueva línea. Como se ha impreso algo, la parte superior de la pila ya no se imprime.

En el programa Ground , hay algunos errores que son convenientes en este caso. La siguiente parte:

'<space>

empuja un carácter de espacio en la parte superior de la pila. La Šgira la pila, que tiene una aridad 3 . Solo hay un elemento en la pila y no hay entrada, por lo que esto da una excepción, limpiando la pila. El Âbifurca la parte superior de la pila, pero esto tiene la misma historia que el operador de rotación. Entonces, básicamente, el ,comando no imprime nada.

Eso significa que el programa aún generará la parte superior de la pila que es 'í¶. Resultando en ground.

Adnan
fuente
9

Retina , 31 bytes

Figura:

El |       
figura
 tierra
      

Suelo:

 figura

El |       
suelo

Figura y tierra . Ambos programas requieren que STDIN se deje vacío para ser programas válidos de figura o tierra.

FryAmTheEggman
fuente
9

Pyth, 30 bytes

Figura

"figure" "ground              

14 espacios finales.

Prueba

Suelo

Sin espacios finales

        "       figure""ground

Prueba

Cómo funciona

Muy útil, un espacio suprime la impresión en Pyth, mientras que los literales de cadena sin cierre " están implícitamente cerrados.

Por lo tanto, el primer programa consta de dos cadenas, "figure"y "ground ". La primera cadena se imprime implícitamente, y la impresión de la segunda se suprime, lo que significa que solo figurese imprime.

El segundo programa consta de dos cadenas " figure"y "ground". La impresión de la primera se suprime, y la segunda se imprime implícitamente, lo que significa que solo groundse imprime.

TheBikingViking
fuente
6

MATL , 37 bytes

Primer programa

'figure'         
%x'ground'         

Cada línea tiene 9 espacios finales.

Pruébalo en línea!

Segundo programa

    'figure'%
      x'ground'

No hay espacios de rastreo aquí.

Pruébalo en línea!

Explicación

Nada terriblemente elegante ...

  • MATL ignora los espacios y las nuevas líneas entre las declaraciones.
  • % es el símbolo de comentario, que ignora el resto de la línea.
  • x elimina la parte superior de la pila.
  • La pila se imprime implícitamente al final del programa.
Luis Mendo
fuente
6

Java, 180 bytes

Reemplazar .con espacio.

Imprime "figura":

class
A{public
static
void
main(String[]a){System.out.println(
//"ground"
//
.....
........
......
....
...................................
..
........
..........
....
"figure");}}

Imprime "suelo":

.....
........
......
....
...................................
..........
..
class
A{public
static
void
main(String[]a){System.out.println(
//
"ground"
//"figure"
);}}
............
Arnaud
fuente
5

Befunge, 54 bytes

FiguraPruébelo en línea! )

#v "erugif" v>
      : #, _ @>         
"dnuorg"

Diez espacios finales en la segunda línea.

GroundPruébelo en línea! )

  # v "erugif" v 
>: #, _ @> "dnuorg"
        

Un espacio final en la primera línea y ocho espacios en la tercera línea.

James Holderness
fuente
4

Mathematica, 50 34 bytes

Utiliza un entorno REPL. (Agregar un Print[]contenedor con un número igual de espacios aumentaría el número de bytes en 14.) Los dos programas son

01figure+0 1ground                

(con 16 espacios finales) y

          0       1figure+01ground

La clave aquí es que Mathematica trata la concatenación de dígitos sin espacios como un solo número, pero los espacios intermedios se interpretan como una multiplicación vecina, al igual que la concatenación de números y nombres de variables arbitrarias. Entonces la primera expresión se evalúa como 1*figure+0*1*ground, que es figure; la segunda expresión se evalúa como 0*1*figure+1*ground, que es ground.

Greg Martin
fuente
4

PHP, 44 42 bytes

figura: (16 espacios finales, 5 espacios entre la figura &;)

echo''?ground:figure     ;                 

tierra: (20 espacios principales)

                     echo' '?ground:figure;

Bastante simple en realidad, funciona porque ''es falsey y ' 'es sincero. Usar como:

php -r "echo''?ground:figure     ;                "
php -r "                    echo' '?ground:figure;"

editar: 2 bytes retrospectivamente obvios guardados gracias a Martin Ender

usuario59178
fuente
3

Haskell, 96 94 88 82 77 bytes

Primer programa, impresiones "figure":

main              =          putStr$idid"ground"
idid    _          ="figure"

Segundo programa, impresiones "ground":

    main=putStr$id id"ground"                   
    idid _="figure"         

Llama a una de dos funciones constantes con nombres diferentes

Angs
fuente
3

Haskell 88 65 bytes

main=putStr
...........--
.."figure"..........
--"ground"........

y

...........
main=putStr..
--........"figure"--
.........."ground"

.indica un espacio Solo un comentario de línea (-> --) malabares.

nimi
fuente
3

Python 2, 52 bytes

........................
print"figure"
an
d
"ground"

.s indican espacios. Las últimas tres líneas se dividen por error sin tener unSyntaxError que impida que el código se ejecute en primer lugar.

La versión terrestre solo usa and para hacer que se imprima la segunda cadena.


Intentos alternativos (más largos):

.......
print(#"ground")#
"figure")...................


print"figure"""and"ground"
.............
.............
Sp3000
fuente
3

JavaScript (ES6), 56 bytes

alert('figure'
                //&&'ground'
           )
              
alert('figure'//            
&&'ground') 

La figura no tiene espacios finales.

Neil
fuente
Cuento 56 bytes para cada programa, a menos que las nuevas líneas no cuenten. Dudo que se acorte más.
ETHproductions
@ETHproductions Ugh, eso es lo que sucede cuando cuentas bytes manualmente :-(
Neil
2

Carril , 56 bytes

Figura

$'main'
 -[figure]o                
-          [ground]o

Hay 16 espacios finales en la segunda línea. El programa termina con un error.

Pruébalo en línea!

Suelo

       
$ 'main' - [figura] o
 - [tierra] o         

Hay 7 espacios en la primera línea y 9 espacios finales en la última línea. Este programa también termina con un error.

Pruébalo en línea!

Explicación

Rail busca una línea que comience con (notación regex) \$.*'main'para encontrar un punto de entrada. El tren (puntero de instrucción) comienza desde el $sureste en movimiento. Las cosas que el tren no puede alcanzar pueden ignorarse por completo para el programa. Esto incluye cualquier cosa en la misma línea que el punto de entrada. Dado que, el -sureste del $inmediatamente gira el tren hacia el este, ambos programas simplemente se reducen a:

 -[figure]o
 -[ground]o

[...]denota un literal de cadena y lo oimprime. Normalmente, necesita un #para finalizar el riel, pero si lo omite, el programa termina de todos modos (pero se queja en STDERR de que el tren se estrelló).

Martin Ender
fuente
2

> <> , 39 bytes

Utilizando ·para representar espacios.

Figura

v·
"·dnuo
e·
r·
u·
g··
i··
f···
"·
>·o·

Pruébalo en línea!

Suelo

·v
·"····
·d
·n
·u
·oe
·ru
·gif
·"
·>·o

Pruébalo en línea!

Ambos programas terminan con un error.

Explicación

Al escribir el código verticalmente, pude reutilizar el gy el rentre ambas soluciones, así como las comillas y el >y opara el bucle de salida.

En ambos casos, el único bit que se ejecuta es la columna debajo de v, que empuja las letras de la palabra requerida en la pila en orden inverso. Luego, >redirige el puntero de instrucciones hacia la derecha, donde recorre el ociclo e imprime los caracteres hasta que la pila esté vacía.

Martin Ender
fuente
Empecé a trabajar en mi propia versión> <>, luego me encontré con la tuya. Realmente me gusta la idea de que el tuyo trabaje verticalmente (el mío es muy 'normal').
Pelícano
@ Tealpelican No se me ocurrió esto hasta que resolví la respuesta de Fisión. Antes de eso, mi mejor solución> <> era 42 bytes: !__|"druong">o<"figure"(donde _hay espacios, y los espacios restantes simplemente van al final de la línea).
Martin Ender
Mi versión actual más corta es esta: ## "de nr uu og ri GF"> o! ~ ~! <## ¡Qué divertido es también 42 bytes también! Mis versiones anteriores tenían comprobación de errores, pero solo podían reducirse a 53 bytes.
Teal pelican
2

Fisión , 37 bytes

Utilizando ·para representar espacios.

Figura

D·
"···
f··
i··
g·
u·
r·
e·ound
"·
;·

Pruébalo en línea!

Suelo

·D
·"fi
·gu
·re
·o
·u
·n
·d····
·"
·;

Pruébalo en línea!

Explicación

Funciona básicamente igual que mi respuesta> <> (aunque en realidad encontré esta primero). Las únicas diferencias son que "imprime los caracteres inmediatamente en Fission, es por eso que las palabras no se escriben al revés y por qué solo necesitamos terminar el programa ;al final.

Martin Ender
fuente
1

reticular, 46 bytes

                      "ground""figure"" "?$$o;

Pruébalo en línea! Esto imprime ground.

"ground""figure"""?$$o                 ;      

Pruébalo en línea! Esto imprime figure.

suelo

Código relevante:

"ground""figure"" "?$$o;
................          push these two strings
                " "?$     pop " " off (since " " is truthy, `?` executes `$`)
                     $    pop TOS ("figure")
                      o;  output and terminate

figura

Código relevante:

"ground""figure"""?$$o;
................         push these two strings
                ""?$     doesn't activate
                    $    pop ""
                     o;  output and terminate
Conor O'Brien
fuente
1

Brian y Chuck , 55 53 bytes

Figura

erugif?dnuorg             
}<.<.<.<.<.<.             

Hay 13 espacios finales en cada línea.

Pruébalo en línea!

Suelo

             erugif?dnuorg
             }<.<.<.<.<.<.

Pruébalo en línea!

Explicación

Ah, ha pasado un tiempo desde la última vez que usé a Brian y Chuck. Como breve recordatorio, Brian y Chuck son dos instancias parecidas a Brainfuck, que usan el código fuente de los demás como cinta. Solo Chuck puede usar el comando de impresión ., ?cambia entre las dos instancias condicionalmente y }es algo así como [>]en Brainfuck. Los comandos desconocidos simplemente se ignoran.

Como los espacios al comienzo de los programas se ignoran, los dos programas son casi idénticos. La única diferencia proviene del hecho de que después del comando de cambio ?, el puntero de instrucción se mueve antes de ejecutar el siguiente comando. Por lo tanto, el primer comando en la cinta de Chuck siempre se omite. Entonces, la única diferencia real es que el programa terrestre ejecuta }mientras que el programa de figura no. Así es como funciona el código:

?   Switch control to Chuck.
}   GROUND PROGRAM ONLY: Move the tape head on Brian to the end of the tape.
<.  Move the tape head left and print the character there.
... Do the same another five times to print the remainder of the string.
Martin Ender
fuente
0

WinDbg, 74 bytes

Suelo

                      ea2000000"      groundfigure";;;da       2000006  L6

Figura

ea2000000"groundfigure          ";;;da                  2000006       L6  

La figura tiene 2 espacios finales. Siento que al menos 2 o 4 bytes deberían ser golfable ...

Funciona escribiendo una cadena en la memoria y mostrando 6 caracteres de ella. Los caracteres en la cadena se reorganizan para que los caracteres mostrados cambien entre los programas:

* Ground:
ea 2000000 "      groundfigure";     * Write string "      groundfigure" starting at 2000000
;                                    * No-op
;                                    * No-op
da 2000006 L6                        * Print 6 ascii chars, from 2000006, ie- ground

* Figure:
ea 2000000 "groundfigure          "; * Write string "groundfigure          " to memory
;                                    * No-op
;                                    * No-op
da 2000006 L6                        * Print 6 ascii chars, ie- figure

Salida:

0:000>                       ea2000000"      groundfigure";;;da       2000006  L6
02000006  "ground"
0:000> ea2000000"groundfigure          ";;;da                  2000006       L6  
02000006  "figure"
Leche
fuente