Bloc de chiffres

18

Sortez / imprimez ce bloc de texte:

1234567890
2468013579
3691470258
4815926037
5049382716
6172839405
7306295184
8520741963
9753108642
0987654321

Les formats acceptables comprennent:

  • Traits de fin de ligne / espaces blancs
  • Liste des chaînes
  • Liste des listes de personnages
  • Liste des listes d'entiers

Cependant, la liste des nombres entiers n'est pas acceptable car la dernière ligne n'est pas un nombre entier.

C'est du code-golf . La réponse la plus courte en octets l'emporte. Des échappatoires standard s'appliquent.

code-golf math kolmogorov-complexity Leaky Nun
la source

Réponses:

20

Mathematica, 33 octets

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

Essayez-le en ligne! (Utilisation des mathématiques.)

La cellule à l'index basé sur 1 (x,y)a une valeur((x*y) % 11) % 10

Martin Ender
la source
11

Python 2 , 48 46 octets

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

Essayez-le en ligne!

mdahmoune
la source
6
Bienvenue chez PPCG, et première réponse étonnante! Nous espérons que vous resterez et contribuerez davantage :-)
ETHproductions
@ETHproductions thanx :)))
mdahmoune
5

MATL , 12 11 octets

Enregistré un octet grâce à Luis. J'oublie toujours que &c'est un raccourci pour la duplication et la transposition.

10:&*11\10\

Essayez-le en ligne!

En utilisant l'algorithme de @ Martin: x*y % 11 % 10

Explication:

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

Même bytecount:

10t:&*11\w\
Stewie Griffin
la source
Vous pouvez enregistrer un octet en le remplaçant t!*par&*
Luis Mendo
1
@LuisMendo double backticks si vous avez une barre oblique inverse à la fin de l'extrait de code dans les commentaires.
Martin Ender
@MartinEnder Merci! Je ne me souviens jamais comment cela fonctionne, alors je suis allé pour le plus simple :-)
Luis Mendo
@LuisMendo ouais c'est un peu déroutant avec des publications et des commentaires utilisant une syntaxe différente.
Martin Ender
Merci @LuisMendo! Ce n'est pas dans les documents, n'est-ce pas?
Stewie Griffin
2

Rétine , 59 octets

Le nombre d'octets suppose un codage ISO 8859-1.


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

,(1*)
$.1

Essayez-le en ligne!

Explication

Une autre implémentation de l' algorithme ...% 11% 10 . La partie amusante de le faire avec une expression régulière est que nous pouvons prendre en charge les deux calculs modulo à la fois.


10$*

Initialisez la chaîne à dix 1s.

1
,1$`

Remplacez chacun de ceux-ci par une virgule, un et le préfixe devant celui-ci. Cela donne ,1,11,...,1111111111, c'est-à-dire une plage unaire.

,1+
$_¶

Remplacez maintenant chacun des éléments de la plage par la chaîne entière suivie d'un saut de ligne. Cela nous donne une grille de 10x10 de nombres unaires indiquant la colonne actuelle.

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

Faites correspondre chacun d'eux 1et déterminez sur quelle ligne il se trouve en répétant le groupe plusieurs fois. Remplacez le 1par autant de 1s. Cela multiplie les valeurs de chaque ligne par l'index basé sur 1 de la ligne.

1{10}1?

Maintenant, faisons le mod 11, le mod 10 en une seule étape. Pour faire le mod 11 , nous retirons normalement tout 1{11}de la chaîne pour laisser les restes. Et puis nous supprimerions 1{10}après cela. Mais si nous supprimons simplement dix 1s plus un autre si possible, la gourmandise du moteur regex fera le mod 11 pour nous aussi longtemps que possible, et sinon, il essaiera au moins le mod 10 .

,(1*)
$.1

Enfin, nous convertissons simplement chaque nombre en décimal en le remplaçant par sa longueur.

Martin Ender
la source
2

05AB1E , 14 octets

11GTLN*11%T%})

Essayez-le en ligne!

Utilise l'algorithme de Martin, comme d'habitude.

Erik le Outgolfer
la source
Oh, il y a un algorithme pour ce modèle. Cela explique pourquoi je suis 30 octets au-dessus de la réponse moyenne.
Urne de poulpe magique
2

Haskell, 43 octets

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

Javascript (ES6), 70 64 56 octets

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

4 octets enregistrés grâce à Shaggy et 8 octets grâce à Arnauld.

Luc
la source
1
66 octets: _=>[...a=Array(10)].map((_,x)=>[...a].map((_,y)=>(x+1)*++y%11%10)). Vous me sauvez 4 octets, je vous sauve 4 octets :)
Shaggy
Merci beaucoup. Vous avez également corrigé un bug, j'ai donc rasé encore 2 octets de votre solution ;-)
Luke
1
Vous pouvez enregistrer 5 octets en utilisant le 3ème paramètre du rappel dans le premier map()et 3 autres octets en utilisant 1e9+''au lieu de Array(10). Cela mène à _=>[...1e9+''].map((_,x,a)=>a.map((_,y)=>-~x*++y%11%10)).
Arnauld
@Arnauld: Merci pour l' 1e9astuce. Je ne le connaissais pas. J'ai pensé à utiliser le troisième argument, mais pour une raison quelconque, je ne l'ai pas utilisé.
Luke
J'ai récemment compilé une liste d'astuces similaires ici .
Arnauld
2

Japt , 16 12 11 octets

Il s'avère que c'était ma réponse 200 (non supprimée) ici :)

On dirait que c'est la même formule que Martin a repérée .

Aõ
£®*X%B%A

Testez-le ( -Rindicateur à des fins de visualisation uniquement)

  • 4 octets enregistrés grâce à Luke soulignant que le retour d'un tableau de tableaux était autorisé.

Explication

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
Hirsute
la source
Battez-moi ... Vous pouvez laisser tomber les deux derniers personnages et utiliser le -Rdrapeau à la place
Luke
1
Encore mieux, laissez tomber les quatre derniers caractères. Il semble que ce soit permis ...
Luke
Ouaip, on dirait que tu as raison, merci, @Luke :)
Shaggy
1

Java 8, 84 octets

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

Utilise le même algorithme que la réponse Mathematica de @MartinEnder : 1 indexéx*y%11%10 .

Explication:

Essayez-le ici.

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
la source
1

Python 2 , 58 52 octets

-6 octets grâce à offcialaimm.

Utilise l'algorithme de Martin que je ne comprends pas comment il est arrivé si vite. o0

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

Essayez-le en ligne!

totalement humain
la source
1
Shorthand r=range(1,11)sauve 6 octets
officialaimm
2
Une partie de la raison pour laquelle j'ai repéré la formule si rapidement est ma question math.SE et le commentaire de orlp là-bas .
Martin Ender
1

Pyth, 13 octets

mme%*kd11STST

Essayez-le ici

-1 merci à KarlKastor .

Disons duuuuuuupe!

Erik le Outgolfer
la source
Économisez un octet si vous utilisez eau lieu de% T
KarlKastor
@KarlKastor ... et je m'en souvenais ._.
Erik the Outgolfer
1

R , 19 octets

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

Essayez-le en ligne!

Le bit de code R le moins "R" que j'aie jamais écrit. Utilise le même algorithme que la réponse de Martin Ender (et presque toutes les autres réponses également). x %o% yest le même que outer(x, y).

user2390246
la source
1

Fusain , 30 29 19 octets

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

Essayez-le en ligne!

Utilise la formule de Martin .

  • 10 octets économisés grâce à Neil, prouvant une fois de plus que j'ai encore tant à apprendre ...
Charlie
la source
Vous n'avez pas besoin de »s de fin et pendant que vous pouvez utiliser à la ωplace de ””vous pouvez enregistrer tout un tas d'octets en utilisant ⸿comme cela devient alors Ｆχ«ＦχＩ﹪﹪×⁺¹ι⁺¹κ¹¹χ⸿. (Avant que je sache, ⸿j'aurais suggéré Ｊ⁰ιce qui aurait encore permis d'économiser un certain nombre d'octets.)
Neil
@Neil The ⸿est l'opérateur inverse, que fait-il à la fin de votre code sans arguments? Est-ce documenté?
Charlie
1
Non, ⮌est l'opérateur inverse, ⸿est le move cursor to start of next linecaractère (comme mais peut être dans une chaîne distincte).
Neil
0

C (gcc) , 70 octets

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

Essayez-le en ligne!

Giacomo Garabello
la source
0

QBIC , 17 octets

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

Ceci, bien sûr, utilise la méthode de Martin. Cela se traduit par ce code QBasic .

Explication

[|               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
la source
0

C #, 81 octets

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

Même algorithme que la plupart des autres réponses et essentiellement le port C # de la réponse Java @Kevins .

TheLethalCoder
la source
0

GolfScript , 37 24 octets

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

Essayez-le en ligne!

-13 grâce à une astuce astucieuse suggérée par Martin Ender .

Erik le Outgolfer
la source
si vous le transformez en un programme complet ( {-> ;, }-> `), vous pouvez au moins supprimer le premier [.
Martin Ender
Il est cependant beaucoup plus court d'utiliser une simple boucle imbriquée au lieu de la technique zip:{){\)*11%10%}+10,/n}10,/
Martin Ender
@MartinEnder Umm ... vous semblez abuser /. ;)
Erik the Outgolfer
@MartinEnder Oh je vois ce que vous avez fait ... vous avez utilisé int blk +-> {int space contents-of-blk}.
Erik the Outgolfer le
@MartinEnder ok j'ai implémenté votre +astuce ... même si j'ai un peu modifié votre code
Erik the Outgolfer
0

Pyke, 13 octets

TS F~u0+*i>i%

Essayez-le ici!

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

PHP , 54 octets

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

Essayez-le en ligne!

PHP , 56 octets

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

Essayez-le en ligne!

Jörg Hülsermann
la source
1
Vous pouvez supprimer les crochets ().
Christoph
-2 octets: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;
Titus
0

TECO, 45 octets

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

Une implémentation (assez) simple de la réponse 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!

L'utilisation d'inserts terminés par <ESC> et d'un caractère de contrôle pour la commande ^ T économiserait encore trois cinq octets, au détriment de la lisibilité.

L'utilisation de la formule mod-11 / mod-10 de Martin l'allonge en fait à 43 octets en utilisant des contrôles pour ^ A et ^ T, principalement parce que TECO n'a pas d'opérateur mod.

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

Le module 11 se fait de manière continue en incrémentant le nombre dans qn de -11 chaque fois qu'il dépasse 10. Le qn\r0a^T séquence insère le nombre dans le tampon d'édition sous forme de chiffres décimaux, inverse le dernier chiffre, le récupère du tampon et le tape, faisant essentiellement mod-10.

Je m'attendais à ce qu'il soit plus court. Tant pis.

JoeT
la source