Bloque de dígitos

18

Imprima / imprima este bloque de texto:

1234567890
2468013579
3691470258
4815926037
5049382716
6172839405
7306295184
8520741963
9753108642
0987654321

Los formatos aceptables incluyen:

  • Nuevas líneas / espacios en blanco
  • Lista de cadenas
  • Lista de listas de personajes.
  • Lista de listas de enteros

Sin embargo, la lista de enteros no es aceptable porque la última línea no es un entero.

Este es el código de golf . La respuesta más corta en bytes gana. Se aplican lagunas estándar .

code-golf math kolmogorov-complexity Monja permeable
fuente

Respuestas:

20

Mathematica, 33 bytes

Mod[1##,11]~Mod~10&~Array~{10,10}

Pruébalo en línea! (Usando matemáticas).

La celda en el índice basado en 1 (x,y)tiene valor((x*y) % 11) % 10

Martin Ender
fuente
11

Python 2 , 48 46 bytes

n=10
while n:print('00987654321'*n)[n::n];n-=1

Pruébalo en línea!

mdahmoune
fuente
66
¡Bienvenido a PPCG, y sorprendente primera respuesta! Esperamos que se quede y contribuya más :-)
ETHproductions
@ETHproductions thanx :)))
mdahmoune
5

MATL , 12 11 bytes

Salvó un byte gracias a Luis. Sigo olvidando que &es un atajo para duplicar y transponer.

10:&*11\10\

Pruébalo en línea!

Usando el algoritmo de @ Martin: x*y % 11 % 10

Explicación:

10            % Pust 10 to the stack. Stack: 1
  :           % 1-based range. Stack: [1 2 3 ... 10]
   &          % Duplicate range. Stack: [1 2 3 ... 10],[1 2 3 ... 10]
              % Transpose last range. Stack [1 2 3 ... 10],[1;2;3 ...10]
    *         % Multiply with broadcasting. Stack: [1 2 3 ...;2 4 6...] (10-by-10 array)
     11       % Push 11 to the stack. Stack [1 2 3 ...;2 4 6 ...], 11
       \      % Modulus. 
        10    % Push 10 to the stack.
          \   % Modulus
              % Implicit display

Mismo bytecount:

10t:&*11\w\
Stewie Griffin
fuente
Puede guardar un byte reemplazando t!*por&*
Luis Mendo
1
@LuisMendo retrocede dos veces si tiene una barra invertida al final del fragmento de código en los comentarios.
Martin Ender
@MartinEnder Gracias! Nunca recuerdo cómo funciona eso, así que fui por el camino fácil :-)
Luis Mendo
@LuisMendo, sí, es un poco confuso con publicaciones y comentarios que usan una sintaxis diferente.
Martin Ender
Gracias @LuisMendo! Eso no está en los documentos, ¿verdad?
Stewie Griffin
2

Retina , 59 bytes

El recuento de bytes asume la codificación ISO 8859-1.


10$*
1
,1$`
,1+
$_¶
(?<=(¶?.+)+)1
$#1$*
1{10}1?

,(1*)
$.1

Pruébalo en línea!

Explicación

Otra implementación del algoritmo ...% 11% 10 . La parte divertida de hacerlo con una expresión regular es que podemos ocuparnos de ambos cálculos de módulo a la vez.


10$*

Inicialice la cadena a diez 1s.

1
,1$`

Reemplace cada una de ellas con una coma, una y el prefijo delante de esa. Esto da ,1,11,...,1111111111, es decir, un rango unario.

,1+
$_¶

Ahora reemplace cada uno de los elementos de rango con la cadena completa seguida de un salto de línea. Esto nos da una cuadrícula de 10x10 de números unarios que indica la columna actual.

(?<=(¶?.+)+)1
$#1$*

Haga coincidir cada uno 1y determine en qué fila está repitiendo el grupo uno tantas veces. Reemplace el 1con ese 1s. Esto multiplica los valores en cada fila por el índice basado en 1 de la fila.

1{10}1?

Ahora hagamos mod 11, mod 10 en un solo paso. Para hacer el mod 11 , normalmente solo eliminaríamos todo 1{11}de la cadena para dejar el resto. Y luego lo eliminaríamos 1{10}después de eso. Pero si solo eliminamos diez 1s más otro si es posible, la codicia del motor regex hará el mod 11 para nosotros el mayor tiempo posible, y si no, intentará al menos el mod 10 .

,(1*)
$.1

Finalmente, simplemente convertimos cada número a decimal reemplazándolo por su longitud.

Martin Ender
fuente
2

05AB1E , 14 bytes

11GTLN*11%T%})

Pruébalo en línea!

Utiliza el algoritmo de Martin, como siempre.

Erik el Outgolfer
fuente
Oh, hay un algoritmo para ese patrón. Eso explica por qué estoy 30 bytes por encima de la respuesta promedio.
Magic Octopus Urn
2

Haskell, 43 bytes

l=[1..10]
f=[[x*i`mod`11`mod`10|i<-l]|x<-l]
siracusa
fuente
2

Javascript (ES6), 70 64 56 bytes

_=>[...1e9+''].map((_,a,b)=>b.map((_,c)=>-~a*++c%1‌​1%10))

Guardado 4 bytes gracias a Shaggy y 8 bytes gracias a Arnauld.

Luke
fuente
1
66 Bytes: _=>[...a=Array(10)].map((_,x)=>[...a].map((_,y)=>(x+1)*++y%11%10)). Me ahorras 4 bytes, te guardo 4 bytes :)
Shaggy
Muchas gracias. También solucionó un error, por lo que reduje otros 2 bytes de su solución ;-)
Luke
1
Puede guardar 5 bytes usando el tercer parámetro de la devolución de llamada en el primero map()y 3 bytes más usando en 1e9+''lugar de Array(10). Eso lleva a _=>[...1e9+''].map((_,x,a)=>a.map((_,y)=>-~x*++y%11%10)).
Arnauld
@Arnauld: Gracias por el 1e9truco. No lo sabía. Pensé en usar el tercer argumento, pero por alguna razón no lo usé.
Lucas
Recientemente he compilado una lista de trucos similares aquí .
Arnauld
2

Japt , 16 12 11 bytes

Resulta que esta fue mi respuesta 200 (sin borrar) aquí :)

Parece que esta es la misma fórmula que Martin vio .

Aõ
£®*X%B%A

Pruébalo ( -Rmarca solo con fines de visualización)

  • 4 bytes guardados gracias a Luke señalando que devolver una matriz de matrices estaba permitido.

Explicación

Aõ    :Generate an array of integers from 1 to 10, inclusive.
£     :Map over each element in the array, returning...
®     :Another map of the same array, which...
*X    :Multiplies the current element of the inner function by the current element of the outer function...
%B    :Modulus 11...
%A    :Modulus 10.
      :Implicit output of resulting 2D array
Lanudo
fuente
Derrótame ... Puedes soltar los dos últimos personajes, y en su lugar usar la -Rbandera
Luke
1
Aún mejor, suelta los últimos cuatro caracteres. Parece que eso está permitido ...
Luke
Sí, parece que tienes razón, gracias, @Luke :)
Shaggy
1

Java 8, 84 bytes

o->{String r="";for(int x=0,y;++x<11;r+="\n")for(y=0;++y<11;r+=x*y%11%10);return r;}

Utiliza el mismo algoritmo que la respuesta de Mathematica de @MartinEnder : 1-indexado x*y%11%10.

Explicación:

Pruébalo aquí

o->{                     // Unused Object parameter and String return-type
  String r="";           //  Result-String
  for(int x=0,y;++x<11;  //  Loop (1) from 1 to 11 (exclusive)
      r+="\n")           //    And append a new-line after every iteration
    for(y=0;++y<11;      //   Inner loop (2) from 1 to 11 (exclusive)
      r+=x*y%11%10       //    And append the result-String with `x*y%11%10`
    );                   //   End of inner loop (2)
                         //  End of loop (1) (implicit / single-line body)
  return r;              //  Return result-String
}                        // End of method
Kevin Cruijssen
fuente
1

Python 2 , 58 52 bytes

-6 bytes gracias a offcialaimm.

Utiliza el algoritmo de Martin, que no entiendo cómo se le ocurrió tan rápido. o0

r=range(1,11)
print[[x*y%11%10for y in r]for x in r]

Pruébalo en línea!

totalmente humano
fuente
1
Taquigrafía r=range(1,11)ahorra 6 bytes
officialaimm
2
Parte de la razón por la que descubrí la fórmula tan rápidamente es esta cuestión matemática .
Martin Ender
1

Pyth, 13 bytes

mme%*kd11STST

Pruébalo aquí

-1 gracias a KarlKastor .

¡Duuuuuuupe!

Erik el Outgolfer
fuente
Ahorre un byte si lo usa en elugar de% T
KarlKastor
@KarlKastor ... y lo estaba recordando ._.
Erik the Outgolfer
1

R , 19 bytes

1:10%o%1:10%%11%%10

Pruébalo en línea!

El bit de código R que parece menos "R" que haya escrito. Utiliza el mismo algoritmo que la respuesta de Martin Ender (y casi todas las otras respuestas también). x %o% yes el mismo que outer(x, y).

user2390246
fuente
1

Carbón , 30 29 19 bytes

Ｆχ«ＦχＩ﹪﹪×⁺¹ι⁺¹κ¹¹χ⸿

Pruébalo en línea!

Utiliza la fórmula de Martin .

  • 10 bytes guardados gracias a Neil, lo que demuestra una vez más que todavía tengo mucho que aprender ...
Charlie
fuente
No necesita el seguimiento de »s y, si bien puede usarlo en ωlugar de hacerlo ””, puede guardar una gran cantidad de bytes al usarlo ⸿como se convierte en esto Ｆχ«ＦχＩ﹪﹪×⁺¹ι⁺¹κ¹¹χ⸿. (Antes de darme cuenta ⸿, habría sugerido Ｊ⁰ιqué habría ahorrado una cantidad de bytes).
Neil
@Neil The ⸿es el operador inverso, ¿qué hace al final de su código sin argumentos? ¿Está documentado?
Charlie
1
No, ⮌es el operador inverso, ⸿es el move cursor to start of next linecarácter (como pero puede estar en una cadena separada).
Neil
0

QBIC , 17 bytes

[|?[|?a*b%11%z';

Esto, por supuesto, utiliza el método de Martin. Se traduce a este código QBasic .

Explicación

[|               FOR A = 1 to 10 ([ starts a FOR loop, | delimits the list of arguments; 
                 a FOR loop with 0 args loops from 1 to 10 by default with increment 1.
  ?              PRINT a newline
   [|            Start a second FOR loop from 1-10, iterator b
     ?           PRINT
      a*b%11%z   the result of Martin's formula.
              '; and suppress newlines/tabs/spaces
Steenbergh
fuente
0

C #, 81 bytes

_=>{var r="";for(int x=0,y;++x<11;r+="\n")for(y=0;++y<11;r+=x*y%11%10);return r;}

Mismo algoritmo que la mayoría de las otras respuestas y esencialmente el puerto C # de la respuesta Java @Kevins .

TheLethalCoder
fuente
0

GolfScript , 37 24 bytes

10,{){\)*11%10%}+10,%}%`

Pruébalo en línea!

-13 gracias a un ingenioso truco que sugirió Martin Ender .

Erik el Outgolfer
fuente
si lo convierte en un programa completo ( {-> ;, }-> `), al menos puede soltar el primero [.
Martin Ender
Sin embargo, es mucho más corto usar un bucle anidado simple en lugar de la técnica zip:{){\)*11%10%}+10,/n}10,/
Martin Ender
@ MartinEnder Umm ... parece que estás usando demasiado /. ;)
Erik the Outgolfer
@MartinEnder Oh, veo lo que hiciste ... que usaste int blk +-> {int space contents-of-blk}.
Erik the Outgolfer
@MartinEnder ok, he implementado tu +truco ... aunque modifiqué un poco tu código
Erik the Outgolfer
0

Pyke, 13 bytes

TS F~u0+*i>i%

Pruébalo aquí!

TS            -  [1, 2, 3, 4, 5, 6, 7, 8, 9]
   F~u0+*i>i% - for i in ^:
    ~u0+      -     "01234567890"
        *     -    ^ * i
         i>   -   ^[i:]
           i% -  ^[::i]
Azul
fuente
0

PHP , 54 bytes

for(;9>=$y++||9>=$x+=$y=print"
";)echo($x+1)*$y%11%10;

Pruébalo en línea!

PHP , 56 bytes

for(;$x++<=9;print"
")for($y=0;$y++<=9;)echo$x*$y%11%10;

Pruébalo en línea!

Jörg Hülsermann
fuente
1
Puedes soltar los corchetes ().
Christoph
-2 bytes:for(;<0>$y++||10>$x+=$y=print"\n";)echo($x+1)*$y%11%10;
Titus
... ofor($x=1;11>++$y||11>$x+=$y=print"\n";)echo$x*$y%11%10;
Titus
0

TECO, 45 bytes

1un@i/
/10<@i/01234567890/jl10<qnc0a^t>jtl%n>

Una implementación (bastante) directa de la respuesta Python de Rod.

1un           !initialize register n to 1!
@i/<nl>/      !insert a newline!
10<           !loop for 10 rows!
@i/01234567890/  !insert the mysterious string of digits!
j             !move point to start of buffer!
l             !move forward past the newline!
10<           !loop for 10 digits on a line!
qnc           !move point forward by n characters!
0a^t          !print the character at point!
>             !end inner loop!
j             !move point to start of buffer!
t             !print (empty) line!
l             !move to start of digit string!
%n            !increment register n (for next line)!
>             !end outer loop!

El uso de insertos terminados en <ESC> y un carácter de control para el comando ^ T salvaría tres cinco bytes, a expensas de la legibilidad.

El uso de la fórmula de Martin mod-11 / mod-10 en realidad lo hace más largo a 43 bytes usando controles para ^ A y ^ T, principalmente porque TECO no tiene un operador de mod.

0ur10<%run10<qn-10"g-11%n'qn\r0a^Tqr%n>^a
^A>

Mod 11 se realiza de manera continua incrementando el número en qn en -11 cada vez que excede 10. El qn\r0a^T secuencia inserta el número en el búfer de edición como dígitos decimales, invierte más allá del último dígito, lo recupera del búfer y lo escribe, esencialmente haciendo mod-10.

Esperaba que fuera más corto. Oh bien.

JoeT
fuente