Bloco de dígitos

18

Saída / impressão deste bloco de texto:

1234567890
2468013579
3691470258
4815926037
5049382716
6172839405
7306295184
8520741963
9753108642
0987654321

Os formatos aceitáveis ​​incluem:

  • Trailing newlines / espaço em branco
  • Lista de strings
  • Lista de listas de caracteres
  • Lista de listas de números inteiros

No entanto, a lista de números inteiros não é aceitável porque a última linha não é um número inteiro.

Isso é código-golfe . A resposta mais curta em bytes vence. Aplicam-se brechas padrão .

code-golf math kolmogorov-complexity Freira Furada
fonte

Respostas:

20

Mathematica, 33 bytes

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

Experimente online! (Usando matemática.)

A célula no índice baseado em 1 (x,y)tem valor((x*y) % 11) % 10

Martin Ender
fonte
11

Python 2 , 48 46 bytes

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

Experimente online!

mdahmoune
fonte
6
Bem-vindo ao PPCG, e incrível primeira resposta! Esperamos que você fique por aqui e contribua com mais :-)
ETHproductions
@ETHproductions thanx :)))
mdahmoune
7

Geléia , 7 bytes

⁵×þ`%‘%

Experimente online!

Usa o algoritmo de Martin.

Erik, o Outgolfer
fonte
5

MATL , 12 11 bytes

Guardou um byte graças a Luis. Eu continuo esquecendo que &é um atalho para duplicar e transpor.

10:&*11\10\

Experimente online!

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

Explicação:

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

O mesmo bytecount:

10t:&*11\w\
Stewie Griffin
fonte
Você pode salvar um byte substituindo t!*por&*
Luis Mendo
1
@LuisMendo backticks duplos, se você tiver uma barra invertida no final do snippet de código nos comentários.
Martin Ender
@MartinEnder Thanks! Eu nunca me lembro como isso funciona, então eu fui para o caminho mais fácil :-)
Luis Mendo
@LuisMendo sim, é um pouco confuso com postagens e comentários usando sintaxe diferente.
Martin Ender
Obrigado @LuisMendo! Isso não está na documentação, está?
Stewie Griffin
2

Retina , 59 bytes

A contagem de bytes assume a codificação ISO 8859-1.


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

,(1*)
$.1

Experimente online!

Explicação

Outra implementação do ...% 11% 10 . A parte divertida de fazer isso com um regex é que podemos cuidar dos dois cálculos de módulo de uma só vez.


10$*

Inicialize a string para dez 1s.

1
,1$`

Substitua cada uma delas por vírgula, uma e o prefixo na frente dessa. Isso dá ,1,11,...,1111111111, ou seja, um alcance unário.

,1+
$_¶

Agora substitua cada um dos elementos do intervalo pela sequência inteira seguida por um avanço de linha. Isso nos fornece uma grade de 10x10 de números unários, indicando a coluna atual.

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

Combine cada um 1e determine em qual linha está repetindo o grupo um várias vezes. Substitua 1por tantos 1s. Isso multiplica os valores em cada linha pelo índice baseado em 1 da linha.

1{10}1?

Agora vamos fazer o mod 11, o mod 10 em uma etapa. Para fazer o mod 11 , normalmente removíamos tudo 1{11}da string a ser deixada com o restante. E depois removeríamos 1{10}depois disso. Mas se apenas removermos dez 1s mais outro, se possível, a ganância do mecanismo de expressão regular fará o mod 11 por nós o máximo de tempo possível; caso contrário, tentará pelo menos o mod 10 .

,(1*)
$.1

Finalmente, apenas convertemos cada número em decimal, substituindo-o pelo seu comprimento.

Martin Ender
fonte
2

05AB1E , 14 bytes

11GTLN*11%T%})

Experimente online!

Usa o algoritmo de Martin, como de costume.

Erik, o Outgolfer
fonte
Oh, existe um algoritmo para esse padrão. Isso explica por que estou 30 bytes acima da resposta média.
Magic Octopus Urn
2

Haskell, 43 bytes

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

Javascript (ES6), 70 64 56 bytes

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

Economizou 4 bytes graças a Shaggy e 8 bytes graças a Arnauld.

Lucas
fonte
1
66 bytes: _=>[...a=Array(10)].map((_,x)=>[...a].map((_,y)=>(x+1)*++y%11%10)). Você me salvar 4 bytes, eu te salvar 4 bytes :)
Shaggy
Muito obrigado. Também fixa um bug, então eu raspei mais 2 bytes de sua solução ;-)
Lucas
1
Você pode salvar 5 bytes usando o terceiro parâmetro do retorno de chamada no primeiro map()e mais 3 bytes usando em 1e9+''vez de Array(10). Isso leva a _=>[...1e9+''].map((_,x,a)=>a.map((_,y)=>-~x*++y%11%10)).
Arnauld
@ Arnauld: Obrigado pelo 1e9truque. Eu não conhecia esse. Pensei em usar o terceiro argumento, mas por algum motivo não o usei.
Luke
Recentemente, compilei uma lista de truques semelhantes aqui .
precisa
2

Japonês , 16 12 11 bytes

Acontece que esta foi a minha resposta 200 (não excluída) aqui :)

Parece que esta é a mesma fórmula que Martin viu .

Aõ
£®*X%B%A

Teste ( -Rsinalize apenas para fins de visualização)

  • 4 bytes salvos graças a Luke, apontando que o retorno de uma matriz de matrizes era permitido.

Explicação

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
Shaggy
fonte
Me derrote ... Você pode soltar os dois últimos caracteres e usar a -Rbandeira
Luke
1
Melhor ainda, solte os últimos quatro caracteres. Parece que é permitido ...
Lucas
Sim, parece que você está bem, obrigado, @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;}

Usa o mesmo algoritmo da resposta do Mathematica do @MartinEnder : 1-indexado x*y%11%10.

Explicação:

Experimente aqui.

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
fonte
1

Python 2 , 58 52 bytes

-6 bytes graças a offcialaimm.

Utiliza o algoritmo de Martin, que não entendo como ele o criou tão rápido. o0

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

Experimente online!

totalmente humano
fonte
1
Taquigrafia r=range(1,11)salva 6 bytes
officialaimm
2
Parte da razão pela qual descobri a fórmula tão rapidamente é essa questão matemática .
Martin Ender
1

Pitão, 13 bytes

mme%*kd11STST

Experimente aqui

-1 graças a KarlKastor .

Vamos duuuuuuupe!

Erik, o Outgolfer
fonte
Salve um byte se você usar em evez de% T
KarlKastor 26/06
@KarlKastor ... e eu estava lembrando disso ._.
Erik the Outgolfer
1

R , 19 bytes

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

Experimente online!

O mínimo de código R com aparência de "R" que eu já escrevi. Usa o mesmo algoritmo da resposta de Martin Ender (e quase todas as outras respostas também). x %o% yé o mesmo que outer(x, y).

user2390246
fonte
1

Carvão , 30 29 19 bytes

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

Experimente online!

Usa a fórmula de Martin .

  • 10 bytes salvos graças a Neil, provando mais uma vez que ainda tenho muito a aprender ...
Charlie
fonte
Você não precisa se arrastar se, »enquanto você pode usar, em ωvez de ””salvar um monte de bytes, use ⸿como ele se torna Ｆχ«ＦχＩ﹪﹪×⁺¹ι⁺¹κ¹¹χ⸿. (Antes que eu sabia sobre o ⸿que eu teria sugerido Ｊ⁰ιque ainda teria salvou um número de bytes.)
Neil
@ Neil O ⸿operador é o reverso, o que ele faz no final do seu código sem argumentos? Está documentado?
Charlie
1
Não, ⮌é o operador Reverso, ⸿é o move cursor to start of next linecaractere (como mas pode estar em uma sequência separada).
Neil
0

C (gcc) , 70 bytes

f(x,y){for(x=0;x++<10;puts(""))for(y=0;y++<10;putchar(x*y%11%10+48));}

Experimente online!

Giacomo Garabello
fonte
0

QBIC , 17 bytes

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

Obviamente, isso usa o método de Martin. É traduzido para esse código QBasic .

Explicação

[|               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
fonte
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;}

O mesmo algoritmo da maioria das outras respostas e essencialmente a porta C # da resposta do @Kevins Java.

TheLethalCoder
fonte
0

GolfScript , 37 24 bytes

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

Experimente online!

-13, graças a um truque inteligente sugerido por Martin Ender .

Erik, o Outgolfer
fonte
se você transformá-lo em um programa completo ( {-> ;, }-> `), você pode pelo menos largar o primeiro [.
Martin Ender
É muito mais curto usar um loop aninhado simples em vez da técnica de zip:{){\)*11%10%}+10,/n}10,/
Martin Ender
@MartinEnder Umm ... você parece estar usando demais /. ;)
Erik the Outgolfer
@MartinEnder Oh, eu vejo o que você fez ... você usou int blk +-> {int space contents-of-blk}.
Erik the Outgolfer
@MartinEnder ok Eu implementei seu +truque ... embora eu tenha alterado um pouco o código #
Erik the Outgolfer
0

Pyke, 13 bytes

TS F~u0+*i>i%

Experimente aqui!

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
fonte
0

PHP , 54 bytes

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

Experimente online!

PHP , 56 bytes

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

Experimente online!

Jörg Hülsermann
fonte
1
Você pode soltar os colchetes ().
Christoph
-2 bytes:for(;<0>$y++||10>$x+=$y=print"\n";)echo($x+1)*$y%11%10;
Titus
... oufor($x=1;11>++$y||11>$x+=$y=print"\n";)echo$x*$y%11%10;
Tito
0

TECO, 45 bytes

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

Uma implementação (bastante) direta da resposta de Rod's Python.

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!

O uso de inserções terminadas com <ESC> e um caractere de controle para o comando ^ T economizaria outros três cinco bytes, à custa da legibilidade.

O uso da fórmula mod-11 / mod-10 de Martin na verdade aumenta em 43 bytes usando os controles para ^ A e ^ T, principalmente porque o TECO não possui um operador mod.

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

O Mod 11 é feito de maneira contínua, incrementando o número em qn em -11 sempre que excede 10. A qn\r0a^Tsequência insere o número no buffer de edição como dígitos decimais, reverte o último dígito, recupera-o do buffer e digita-o, essencialmente fazendo mod-10.

Eu esperava que fosse mais curto. Ah bem.

JoeT
fonte