Imprima / imprima este bloque de texto:
1234567890
2468013579
3691470258
4815926037
5049382716
6172839405
7306295184
8520741963
9753108642
0987654321
Los formatos aceptables incluyen:
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 .
Respuestas:
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
Salvó un byte gracias a Luis. Sigo olvidando que &es un atajo para duplicar y transponer.
10:&*11\10\
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\
t!*por&*
10|11|∘.×⍨⍳10Un puerto de mi respuesta de Mathematica .
∘.×⍨ ⍝ Multiplication table of...
⍳10 ⍝ The list from 1 to 10.
11| ⍝ mod 11.
10| ⍝ mod 10.El recuento de bytes asume la codificación ISO 8859-1.
10$*
1
,1$`
,1+
$_¶
(?<=(¶?.+)+)1
$#1$*
1{10}1?
,(1*)
$.1
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.
_=>[...1e9+''].map((_,a,b)=>b.map((_,c)=>-~a*++c%11%10))
Guardado 4 bytes gracias a Shaggy y 8 bytes gracias a Arnauld.
_=>[...a=Array(10)].map((_,x)=>[...a].map((_,y)=>(x+1)*++y%11%10)). Me ahorras 4 bytes, te guardo 4 bytes :)
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)).
1e9truco. No lo sabía. Pensé en usar el tercer argumento, pero por alguna razón no lo usé.
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)
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
-Rbandera
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:
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-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]r=range(1,11)ahorra 6 bytes
elugar de% T
1:10%o%1:10%%11%%10El 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).
Ｆχ«ＦχＩ﹪﹪×⁺¹ι⁺¹κ¹¹χ⸿
Utiliza la fórmula de Martin .
»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).
⸿es el operador inverso, ¿qué hace al final de su código sin argumentos? ¿Está documentado?
⮌es el operador inverso, ⸿es el move cursor to start of next linecarácter (como ¶pero puede estar en una cadena separada).
f(x,y){for(x=0;x++<10;puts(""))for(y=0;y++<10;putchar(x*y%11%10+48));}[|?[|?a*b%11%z';
Esto, por supuesto, utiliza el método de Martin. Se traduce a este código QBasic .
[| 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
_=>{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 .
12345678902468013579369147025848159260375049382716
.*
$&$&
O$^50>`.
.{10}
$&¶
10,{){\)*11%10%}+10,%}%`
-13 gracias a un ingenioso truco que sugirió Martin Ender .
{-> ;, }-> `), al menos puede soltar el primero [.
{){\)*11%10%}+10,/n}10,/
/. ;)
int blk +-> {int space contents-of-blk}.
+truco ... aunque modifiqué un poco tu código
10$*T
M!&`T+
m`$
;110$*T10$*
1
09876543210
m`(?<=^\1;\1{0,9}(T+))T
C
(?<!C.{108})\S
TS F~u0+*i>i%
TS - [1, 2, 3, 4, 5, 6, 7, 8, 9]
F~u0+*i>i% - for i in ^:
~u0+ - "01234567890"
* - ^ * i
i> - ^[i:]
i% - ^[::i]
for(;9>=$y++||9>=$x+=$y=print"
";)echo($x+1)*$y%11%10;for(;$x++<=9;print"
")for($y=0;$y++<=9;)echo$x*$y%11%10;().
for(;<0>$y++||10>$x+=$y=print"\n";)echo($x+1)*$y%11%10;
for($x=1;11>++$y||11>$x+=$y=print"\n";)echo$x*$y%11%10;
1":(10|11|*&>:)"0/~@(i.@9:)
Utiliza el mismo truco que en la respuesta de Mathematica de Martin Ender .
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.