Bueno, resumirlo realmente.
Escriba un programa o función que tome una lista no vacía de enteros decimales (0-9) y genere un "triángulo" de dígitos apuntando hacia abajo con la lista de entrada en la parte superior donde cada dígito después de la primera línea es la suma de los dos dígitos encima de él módulo 10.
Por ejemplo, la entrada [7, 5, 0, 9]
tiene salida
7 5 0 9
2 5 9
7 4
1
porque 2
es (7 + 5) mod 10
, 5
es (5 + 0) mod 10
, 9
es (0 + 9) mod 10
, etc. todo el camino hacia el 1
ser (7 + 4) mod 10
.
Si la lista tiene solo un elemento, la salida coincide con la entrada; Por ejemplo, una entrada de [4]
producirá
4
Aquí hay algunos ejemplos adicionales:
[0]
0
[1, 2]
1 2
3
[8, 7]
8 7
5
[0, 0]
0 0
0
[1, 4, 2]
1 4 2
5 6
1
[0, 1, 0]
0 1 0
1 1
2
[1, 0, 0, 0]
1 0 0 0
1 0 0
1 0
1
[1, 2, 3, 4]
1 2 3 4
3 5 7
8 2
0
[1, 2, 3, 5, 8]
1 2 3 5 8
3 5 8 3
8 3 1
1 4
5
[9, 2, 4, 5, 3, 2, 2]
9 2 4 5 3 2 2
1 6 9 8 5 4
7 5 7 3 9
2 2 0 2
4 2 2
6 4
0
Tenga en cuenta que en la salida:
- La primera línea no tiene espacios iniciales.
- Cada línea posterior tiene un espacio inicial más que la línea anterior.
- Los dígitos están separados por un solo espacio.
- Cada línea puede tener hasta un espacio final.
- Puede haber una sola línea final opcional.
- Debe usar los caracteres para dígitos decimales normales (0 a 9).
El código más corto en bytes gana. Tiebreaker es la respuesta anterior.
Respuestas:
BrainF ** k,
396391 bytesNo pude resistir la tentación de hacer esto. Al menos el triángulo tiene el lado puntiagudo hacia abajo.
La entrada viene como una cadena de caracteres numéricos seguidos de una nueva línea nueva.
La salida contendrá un solo espacio final en cada línea.
Ejemplos:
Explicación
Dado que es bastante difícil explicar el código desde una perspectiva funcional, podemos verlo desde la perspectiva del estado de la cinta en varios momentos. La idea central aquí es que el triángulo que generamos se inicializa como una matriz muy compacta (para BF, de todos modos) que se reduce en tamaño en 1 cada iteración de un bucle. Otro pensamiento importante es que usamos
255
para indicar un "marcador de posición" que podemos buscar en la cinta.Inicialización
Este es el paso más fácil. Al comienzo del programa, ejecutamos lo siguiente:
Esto fuerza a la cinta al siguiente estado (donde
>N<
indica la ubicación del puntero en la cinta)El primer número aquí es una ubicación de "búfer". No lo vamos a utilizar a largo plazo, pero es útil para simplificar las pequeñas operaciones y para copiar datos.
El segundo número es el número de espacios que generaremos al comienzo de cada línea, comenzando después de la primera línea. La primera línea no tendrá espacios iniciales.
El tercer número es el carácter de espacio que mostramos.
El cuarto número es un marcador de posición 255, por lo que podemos volver a esta posición con relativa facilidad.
Entrada
Desde esta posición, leeremos todos los personajes. Al final de este paso, esperamos estar en la siguiente situación:
Donde
a b c d e f ...
indica la cadena de caracteres numéricos que se ingresó (no la nueva línea).Logramos esto con lo siguiente:
Hay algunos matices en esto. En primer lugar, mostraremos cada carácter a medida que los obtengamos, y luego mostraremos un espacio después. En segundo lugar, no queremos copiar el valor ASCII en la cinta, queremos copiar el dígito numérico real. Tercero, queremos detenernos cuando lleguemos a una nueva línea y dejarnos en un buen lugar en ese momento.
Digamos que nuestra entrada es
6723
. Luego, al leer el primero6
, nuestra cinta se ve así:Verificamos que este valor no sea igual a
10
(una nueva línea ASCII) con,----------[++++++++++
. Luego imprimimos el valor y continuamos restando simultáneamente 48 del valor de entrada y sumando 32 al valor al lado (>>++++++++[-<++++<------>>]<
), dejándonos aquí:Observe cómo a lo largo de este proceso podemos suponer que todos los dígitos a la derecha de nuestra entrada son 0; esto significa que no estamos en peligro de arruinar ningún estado anterior si usamos valores a la derecha para calcular
6 * 8
y4 * 8
.Ahora sacamos el carácter de espacio que acabamos de generar y tomamos una nueva entrada, eliminando el espacio que calculamos allí. Eventualmente, la entrada será terminada por una nueva línea y el ciclo saldrá, dejando un lugar
255
donde la nueva línea habría estado (,----------]-
). Este es el segundo carácter de marcador de posición que utilizaremos para navegar por la cinta. En este punto de nuestro escenario, nuestra cinta es exactamente esto:Cálculo
La forma en que esto funciona es que la lista de dígitos entre nuestros
255
marcadores de posición se reducirá en uno cada iteración del bucle. Cuando solo le queda 1 dígito, hemos terminado y deberíamos detenernos de inmediato (tenga en cuenta que, en este punto, cada dígito de esa lista ya se ha generado, por lo que no tenemos que preocuparnos por volver a generarlo).Ahora utilizamos este truco para navegar hasta el primer
255
marcador de posición:<+[-<+]-
. Esto efectivamente busca en la cinta a la izquierda un255
, sin cambiar nada en el medio. Ahora que hemos movido el puntero, podemos verificar nuestra condición de salida: si solo hay un dígito en la lista, entonces se mantendrán los dos espacios de la celda a la derecha255
. Por lo tanto, verificamos eso y comenzamos un ciclo:>>+[-<<
El primer paso en nuestro bucle es generar una nueva línea. Entonces nos movemos a la primera celda (nuestra celda de búfer), le agregamos 10 y salimos. El siguiente paso es generar todos los caracteres de espacio iniciales. Después de generarlos, incrementamos nuestra cuenta para el número de espacios iniciales. Estos pasos se logran de la siguiente manera:
Lo que nos deja en este estado:
Nuestro siguiente paso es copiar el primer valor de la lista, más allá del segundo marcador de posición
255
:Esencialmente hacemos esto saltando de un lado a otro entre nuestros marcadores de posición
255
, dejándonos aquí:Ahora comenzamos un ciclo, iterando por el resto de la lista, deteniéndonos cuando tocamos
255
:>+[-<
En este punto, el dígito a nuestra izquierda inmediata siempre es 0. Entonces, como los amamos, colocamos un marcador
255
de posición allí para que podamos volver a nuestro lugar en la lista. El siguiente paso es mover el segundo lugar de la lista a las ubicaciones que rodean a donde movimos el primer lugar, más allá del segundo marcador de posición255
. Estos pasos se logran de la siguiente manera:Dejándonos aquí:
[ 0 2 32 255 255 >0< 2 3 255 7 6 7 0 ]
ahora, tanto el6
y7
se han movido a una ubicación donde puede ocurrir el cálculo. Necesitamos dos copias del7
porque el siguiente número de la lista también lo necesitará. El7
inmediatamente posterior al255
sirve para este propósito, mientras que el otro7
será consumido por el cálculo.Primero, agregamos los dos dígitos:
Dejándonos aquí:
La siguiente combinación de pasos es la más complicada. Necesitamos ver si el número al que apuntamos es mayor que 10, y si es así, restamos
10
. En realidad, lo que hacemos es restarle 10 y ver si llega0
a algún punto de la resta. Si es así, agregamos10
nuevamente más tarde. Al final de esto, deberíamos tener la suma módulo 10.En este punto, hemos logrado el objetivo. ¡Tenemos la suma módulo 10! Además, ya sea que el número sea mayor que 10, terminaremos aquí:
Nuestros próximos objetivos son generar esta nueva suma, seguirla con un espacio e inyectarla nuevamente en nuestra lista. Hacemos todo esto con nuestras técnicas anteriores de
255
salto y adición48
a nuestra suma, por lo que no lo cubriré en detalle.Y estamos aquí:
[ 0 2 32 255 3 255 2 3 255 7 0 0 51 >32< ]
observe cómo colocamos un255
marcador de posición adicional después de nuestro recién inyectado3
para que no perdamos lugar en la lista. En este punto, hemos generado nuestra suma y su espacio, por lo que debemos limpiar y volver a un estado en el que la próxima iteración de este bucle vaya a funcionar. Necesitamos limpiar nuestro51
y32
celdas , mover la7
una vez a la derecha y navegar a nuestro marcador de posición de lista para que podamos comenzar de nuevo.Ahora estamos aquí:
[ 0 2 32 255 3 >0< 2 3 255 0 7 0 ... ]
que es exactamente donde queremos estar para nuestra próxima iteración. ¡Así que verifique 255 y siga adelante! (
>+]
)Cuando nos retiremos del ciclo, tendremos una lista completamente nueva, compuesta de las sumas de la lista anterior. La primera vez, se verá así:
Ahora queremos repetir todo el proceso en nuestra nueva lista, ¡así que dejamos
255
caer a la izquierda y comenzamos de nuevo! Necesitamos hacer un poco de limpieza>>[-]<<
y luego quitar nuestro marcador de posición<-
. Después de eso, estamos exactamente en el mismo lugar donde estábamos después de la entrada, por lo que podemos hacer las mismas verificaciones: ¡<+[-<+]->>+
y boom! ¡Tenemos nuestro circuito completo! Todo lo que necesitamos es el corchete de cierre, y cuando termina todo lo que ya hemos de salida, por lo que hemos terminado:]
.fuente
Jalea ,
201918 bytesPruébalo en línea!
Fondo
Generar los números es sencillo en Jelly. La salida es un poco más complicada.
Jelly tiene un átomo de cuadrícula incorporado (
G
) que muestra una lista 2D con nuevas líneas entre filas y espacios entre columnas. Tomamos la matriz 2D de números (generados con cada fila invertida) y la transponemos con el valor de relleno@
. Después de revertir la matriz resultante y transponer nuevamente, la aplicaciónG
produce lo siguiente.Para obtener la forma triangular deseada, todo lo que tenemos que hacer es eliminar el valor de relleno.
Cómo funciona
fuente
Pyth - 18 bytes
Test Suite .
fuente
Python 3.5,
747271 bytesLa entrada es una lista de enteros (p
f([1,2,3,5,8])
. Ej. ), La salida es STDOUT. El%10
hecho de quemap
devuelva unmap
objeto en Python 3 es un poco molesto, lo que significa que no podemos hacer nadamap(lambda*x:sum(x)%10,L,L[1:])
similar.La función falla, pero para entonces la salida se habría completado. Gracias a @xsot por -1 byte al encontrar un buen lugar para pegar el
print
.fuente
f=lambda L,*S:f([sum(x)%10for x in zip(L,L[1:print(*S,*L)]or 1)],'',*S)
None
!print
devuelve algo? No sé de laprint
función que regresa.print
función de Python que regresa, sí, regresaNone
al completarseNone
cortar?05AB1E ,
201917 bytesCódigo:
Explicación:
Utiliza la codificación CP-1252 . Pruébalo en línea! .
fuente
MATL,
3230292827262524 bytes1 Byte guardado gracias a @Luis
Pruébalo en línea!
Versión modificada para todos los casos de prueba.
Explicación
fuente
V
permitir especificaciones de formato. Puede guardar 1 byte usando enZ"
lugar deO
: vea este enlace (estoy teniendo problemas con el formato en el comentario)D
cual se usan esos números de espacio único por defecto.En realidad, 43 bytes
Pruébalo en línea!
Este programa imprime una nueva línea final después de la salida.
Explicación:
fuente
Mathematica, 67 Bytes
Ejemplo:
fuente
CJam, 25 bytes
Pruébalo en línea!
Explicación
Esto utiliza un truco bastante bueno para generar el diseño del triángulo.
fuente
JavaScript (ES6) 147 bytes
fuente
Julia,
6059 bytesBasado en la respuesta de @ Sp3000 . La función
\
acepta una matriz como entrada y devuelve una cadena.Pruébalo en línea!
fuente
Pyke, 21 bytes
Pruébalo aquí!
Me gustaría pensar que este método es un poco diferente.
fuente
Perl 6 ,
65 63 6261 bytesExplicación:
Ejemplo:
fuente
TSQL,
198194191 bytesAl usar GOTO en lugar de uno de WHILE, pude jugar golf a 3 personajes
Golfed
Pruébelo en línea (usando un script antiguo con 2 * MIENTRAS)
fuente
Java 7,
230215213 bytesEsto terminó siendo un poco más de lo que pensaba ... Tal vez se pueda jugar un poco más al golf, ya que creo que me equivoqué un poco ...
Algunos bytes guardados gracias a @GiacomoGarabello .
Ungolfed y código de prueba:
Pruébalo aquí
Salida:
fuente
void p(String s){System.out.print(s);}
y reemplace la impresión estándar. Para elprintln
usop("\n")
. Mueva elint i
yint j
cerca delint c=0;
(int c=0,i,j;
) y mueva elprint(a[i]+" ")
interior de lafor
condición para que pueda quitar los corchetes para un total de -11<T>void p(T s){System.out.print(s);}
lugar devoid p(String s){System.out.print(s);}
.C # 6,
125 +31125 + 18 = 143 bytesEl +18 es para
using System.Linq;
Gracias a @TheLethalCoder por guardar 13 bytes, al señalar una declaración de uso innecesario
fuente
JavaScript (ES6), 77 bytes
fuente
C, 138 bytes
Golfed
Sin golf
fuente
C #, 167 bytes
De hecho, estoy bastante orgulloso de esta solución, las expresiones lambda son muy divertidas una vez que las dominas
aquí sin pretensiones para nuevas mejoras:
pruébalo aquí
fuente
List<int> a
->int[] a
,int x=a.Count
->int x=a.Length
,.ToList()
->ToArray()
Haskell, 139 bytes
Toma la entrada como argumento, las salidas a STDOUT.
Versión sin golf:
fuente
Python 3, 97 bytes
Imprime una línea nueva final.
Cómo funciona
Pruébalo en Ideone
fuente
J, 44 bytes
Basado en esta solución .
fuente
Javascript (usando una biblioteca externa) (198 bytes)
Enlace a lib: https://github.com/mvegh1/Enumerable/
Explicación del código: ¡Fue fácil usar la biblioteca! No gana en bytes, pero el código no es demasiado detallado y fácil de leer. Por lo tanto, la entrada "n 'es una matriz de enteros. Cárguelo en la biblioteca, almacenado en la variable" a "." B "es la cadena de retorno, almacene la cadena unida con" "como delimitador en b. C es el iteración actual, use esto para determinar el número de espacios para insertar. NOTA: Esto solo parece funcionar bien cuando la entrada es de 0 a 9. Luego, mientras es verdadero, repita un cierto conjunto de código. Ese código es para crear un lote adyacente conjuntos de la "a" actual enumerable, es decir, si tenemos [1,2,3,4,5,6] obtenemos [1,2], [2,3], [3,4], ... [ 6] ... luego filtre eso para que solo tengamos los lotes de tamaño 2. Luego lo asignamos a una colección de las sumas de los lotes% 10. Si a está vacío, hemos terminado, de lo contrario, agregamos la nueva línea a nuestro regreso. Finalmente regreso ...
La imagen viene en unos minutos.
fuente