Défi:

Sortez les «chiffres entiers» de l'une des six tables arithmétiques suivantes en fonction de l'entrée:
- addition ( +);
- soustraction ( -);
- multiplication ( *);
- division ( /);
- exponentiation ( ^);
- fonctionnement modulo ( %).

Règles:

• Qu'est-ce que je définis comme « integer-chiffres »: Tous les résultats de l'opérande arithmétique qui est exactement un des éléments suivants: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. Cela signifie que vous excluez chaque résultat de 10ou supérieur, chaque résultat de -1ou inférieur et chaque résultat non entier.
• Comment calculer les résultats arithmétiques: en utilisant d'abord le chiffre du haut, puis en utilisant l'opérande avec le chiffre de gauche. Vous êtes autorisé à le faire vice-versa (c'est-à-dire y/xau lieu de x/y), tant que vous êtes cohérent pour les six sorties! (Vous n'êtes donc pas autorisé à utiliser y-xet x/ydans la même réponse.) †
• Nous ne publierons rien pour les cas de test de division par 0 (pour les tables d'opérations de division et de module)
• Nous ne publierons rien pour le cas de bord 0^0.

Production:

Sortez donc les éléments suivants (le format du tableau est quelque peu flexible (voir ci-dessous): les lignes sont donc facultatives et principalement ajoutées pour la lisibilité des cas de test):

Une addition:

+ | 0 1 2 3 4 5 6 7 8 9
-----------------------
0 | 0 1 2 3 4 5 6 7 8 9
1 | 1 2 3 4 5 6 7 8 9
2 | 2 3 4 5 6 7 8 9
3 | 3 4 5 6 7 8 9
4 | 4 5 6 7 8 9
5 | 5 6 7 8 9
6 | 6 7 8 9
7 | 7 8 9
8 | 8 9
9 | 9

Soustraction:

- | 0 1 2 3 4 5 6 7 8 9
-----------------------
0 | 0 1 2 3 4 5 6 7 8 9
1 |   0 1 2 3 4 5 6 7 8
2 |     0 1 2 3 4 5 6 7
3 |       0 1 2 3 4 5 6
4 |         0 1 2 3 4 5
5 |           0 1 2 3 4
6 |             0 1 2 3
7 |               0 1 2
8 |                 0 1
9 |                   0

Multiplication:

* | 0 1 2 3 4 5 6 7 8 9
-----------------------
0 | 0 0 0 0 0 0 0 0 0 0
1 | 0 1 2 3 4 5 6 7 8 9
2 | 0 2 4 6 8
3 | 0 3 6 9
4 | 0 4 8
5 | 0 5
6 | 0 6
7 | 0 7
8 | 0 8
9 | 0 9

Division:

/ | 0 1 2 3 4 5 6 7 8 9
-----------------------
0 | 
1 | 0 1 2 3 4 5 6 7 8 9
2 | 0   1   2   3   4
3 | 0     1     2     3
4 | 0       1       2
5 | 0         1
6 | 0           1
7 | 0             1
8 | 0               1
9 | 0                 1

Exponentiation:

^ | 0 1 2 3 4 5 6 7 8 9
-----------------------
0 |   1 1 1 1 1 1 1 1 1
1 | 0 1 2 3 4 5 6 7 8 9
2 | 0 1 4 9
3 | 0 1 8
4 | 0 1
5 | 0 1
6 | 0 1
7 | 0 1
8 | 0 1
9 | 0 1

Modulo:

% | 0 1 2 3 4 5 6 7 8 9
-----------------------
0 | 
1 | 0 0 0 0 0 0 0 0 0 0
2 | 0 1 0 1 0 1 0 1 0 1
3 | 0 1 2 0 1 2 0 1 2 0
4 | 0 1 2 3 0 1 2 3 0 1
5 | 0 1 2 3 4 0 1 2 3 4
6 | 0 1 2 3 4 5 0 1 2 3
7 | 0 1 2 3 4 5 6 0 1 2
8 | 0 1 2 3 4 5 6 7 0 1
9 | 0 1 2 3 4 5 6 7 8 0

Règles du défi:

• Les nouvelles lignes et les espaces de fin sont facultatifs
• Les lignes horizontales et verticales dans les cas de test sont facultatives. Je les ai seulement ajoutés pour une meilleure lisibilité. †
• Les espaces entre chaque résultat ne sont PAS facultatifs.
• Le symbole de l'arithmétique peut être différent, tant qu'il est clair de savoir lequel il s'agit. C'est-à-dire ×ou ·au lieu de *pour la multiplication; ÷au lieu de /pour la division; etc. †
  Et tant qu'il s'agit d'un seul caractère, alors désolé Python **.
• Le format d'entrée est flexible. Vous pouvez choisir un index de 0-5 ou 1-6 pour les six tables correspondantes; vous pouvez saisir l'opérande-symbole; etc. (Contrairement à ce que vous affichez dans le résultat, vous êtes autorisé à saisir des chaînes complètes, ou **dans le cas de Python.)
  Assurez-vous simplement d'indiquer le format d'entrée que vous utilisez dans votre réponse!

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés, des programmes complets. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• Veuillez également ajouter une explication si nécessaire.

† Exemple de sortie valide sans lignes horizontales et verticales, ÷comme symbole, et utilisant à la y/xplace de x/y:

÷ 0 1 2 3 4 5 6 7 8 9
0   0 0 0 0 0 0 0 0 0
1   1
2   2 1
3   3   1
4   4 2   1
5   5       1
6   6 3 2     1
7   7           1
8   8 4   2       1
9   9   3           1

Japt , 45 octets

Collaboration avec @ETHproductions

AÆAÇU¥'p«Z«XªOvZ+U+X)+P r"..+"SÃuXÃuAo uU)m¸·

Exécutez-le en ligne!

Prend l'entrée comme:

"+" pour addition

"-" pour la soustraction

"*" pour la multiplication

"/" pour la division

"p" pour l'exponentiation

"%" pour modulo

Explication (avec des raccourcis étendus):

AÆ  AÇ  U¥ 'p«  Z«  Xª OvZ+U+X)+P r"..+"SÃ uXÃ uAo uU)m¸  ·
AoX{AoZ{U=='p&&!Z&&!X||OvZ+U+X)+P r"..+"S} uX} uAo uU)mqS qR

A                                                             // By default, 10 is assigned to A
 o                                                            // Create a range from [0...9]
  X{                                         }                // Iterate through the range, X becomes the iterative item
    Ao                                                        //   Create another range [0...9]
      Z{                                 }                    //   Iterate through the range, Z becomes the iterative item
                                                              //     Take:
        U=='p                                                 //       U (input) =="p"
             &&!Z                                             //       && Z != 0
                 &&!X                                         //       && X != 0
                     ||                                       //     If any of these turned out false, instead take
                       Ov                                     //       Japt Eval:
                         Z+U+X                                //         Z{Input}X
                              )+P                             //     Whichever it was, convert to a string
                                  r"..+"S                     //     Replace all strings of length 2 or more with " "
                                                              //     (this makes sure the result !== "false" and has length 1)
                                           uX                 //   Insert X (the row number) into the front of the row
                                               u              // Insert at the beginning the first row:
                                                Ao            //   [0...9]
                                                   uU)        //   with the input inserted at the beginning
                                                      mqS     // Join each item in the final array with " "
                                                          qR  // Join the final array with "\n"

JavaScript (ES7), 128 octets

f=
c=>[...c+`0123456789`].map((r,_,a)=>a.map(l=>l==c?r:r==c?l:/^\d$/.test(l=c<`^`?eval(l+c+r):l|c?l**r:l/r)?l:` `).join` `).join`
`

<select onchange=o.textContent=f(this.value)><option>><option>+<option>-<option>*<option>/<option>%<option>^<option>&<option>,<option>.</select><pre id=o>

Le boîtier spécial 0^0m'a coûté 8 octets.

Langage de script Operation Flashpoint , 343 333 303 301 octets

f={o=_this;s=o+" 0 1 2 3 4 5 6 7 8 9\n";i=0;while{i<10}do{j=0;s=s+format["%1",i];if(i<1&&(o=="/"||o=="%"||o=="^"))then{if(o=="^")then{if(j<1)then{s=s+"  ";j=1}}else{s=s+"\n1";i=1}};while{j<10}do{r=call format["%1%2%3",j,o,i];if(r>9||r<0||r%1>0)then{r=" "};s=s+format[" %1",r];j=j+1};s=s+"\n";i=i+1};s}

Appeler avec:

hint ("+" call f)

Non golfé:

f=
{
    o=_this;
    s=o+" 0 1 2 3 4 5 6 7 8 9\n";
    i=0;
    while{i<10}do
    {
        j=0;
        s=s+format["%1",i];
        if(i<1&&(o=="/"||o=="%"||o=="^"))then
        {
            if(o=="^")then{if(j<1)then{s=s+"  ";j=1}}
            else{s=s+"\n1";i=1}
        };
        while{j<10}do
        {
            r=call format["%1%2%3",j,o,i];
            if(r>9||r<0||r%1>0)then{r=" "};
            s=s+format[" %1",r];
            j=j+1
        };
        s=s+"\n";
        i=i+1
    };
    s
}

Production:

opérateur +

opérateur -

opérateur *

opérateur /

opérateur ^

opérateur%

Python 2 , 240 231 226 224 203 202 200 197 octets

a=i=input()
R=range(10)
for z in R:a+=' '+`z`
print a
for x in R:
 try:
	d=`x`
	for b in R:c=eval("b%s(x*1.)"%('**',i)[i<'^']);d+=' '+(' ',`int(c)`)[(i<'^'or x+b>0)and c in R]
 except:pass
 print d

Essayez-le en ligne!

Prend l'entrée comme "+", "-", "*", "/", "^" ou "%".

Modifications

-9 -16 avec grâce à @FelipeNardiBatista pour quelques grands conseils

Jusqu'à 221 avec plus d'aide de @FelipeNardiBatista, puis jusqu'à 203 en perdant and E(c)==int(E(c)). Si nous vérifions si E(c)est range(10)dedans, ce sera toujours un entier s'il est là. Pas besoin de vérifier les doublons.

Cela doit descendre en dessous de 200 sans passer à Python 3 et déclarer P=print. Des idées? Je suis toujours content d'apprendre.

Oui! Je savais que cela pouvait être fait. 197. Il est temps de se coucher maintenant. J'ai passé assez de temps sur celui-ci. Merci pour le défi intéressant @KevinCruijssen.

Mathematica, 150 octets

r=0~Range~9;p=Prepend;±i_:=Grid@p[p[If[0<=#<=9,#]/._@__->""&/@<|Thread[Characters@"+-*/^%"->{Plus,#-#2&,1##&,#/#2&,Power,Mod}]|>[i][r,#],#]&/@r,r~p~i]

Définit une fonction unaire ±prenant un des caractères +-*/^%comme entrée i(donc par exemple ±"^") et renvoyant un Gridobjet qui ressemble exactement à la dernière sortie de l'OP.

<|Thread[Characters@"+-*/^%"->{Plus,#-#2&,1##&,#/#2&,Power,Mod}]|>associe, à chaque caractère d'entrée possible, la fonction binaire correspondante (listable) (où #-#2&,1##&,#/#2&sont les versions golfées de Subtract,Times,Divide); <|...|>[i][r,#]calcule donc l'opération binaire avec tous les premiers arguments possibles et #comme deuxième argument. If[0<=#<=9,#]/._@__->""&convertit chaque résultat en un Nullou ""si ce n'est pas un résultat à un chiffre ( /._@__->""est nécessaire car certains résultats comme 1/0ne peuvent pas être traités par les inégalités 0<=#<=9). Enfin, nous ajoutons les différents en-têtes et pieds de page et affichons la réponse.

Python 3, 343 335 363 362 octets

La partie la plus triste à ce sujet est qu'une réponse Java me bat ... Je jouerai plus au golf le matin.

o=input()
r=range(10)
g=[['']*10 for i in r]
for x in r:
 for y in r:exec('if"/"!=o and(o!="%"or x)and(o!="**"or x or y):k=str(y'+o+'x);g[x][y]=k')
if'/'==o:
 for x in r:
  for y in r:
   if x and y%x<1:g[x][y]=str(round(y/x))
if'**'==o:o='^'
print('\n'.join([' '.join([o]+list(map(str,r)))]+[' '.join([str(q)]+[' 'if len(x)!=1else x for x in g[q]])for q in r]))

ReplIT

-8 octets en passant à la compréhension de liste plutôt qu'à une double boucle
+28 octets pour éviter le cas de bord 0 ^ 0. -.-
-1 octet en passant ==0à <1grâce à @StewieGriffin

Java 7, 312 305 octets

String c(int o){String r=("+-*/^%".charAt(o))+" 0 1 2 3 4 5 6 7 8 9\n";for(int i=0,j,p;i<10;i++){r+=i+" ";for(j=0;j<10;r+=p<0|p>9?"  ":p+" ")p=p(o,i,j++);r+="\n";}return r;}int p(int o,int a,double b){b=o<1?b+a:o<2?b-a:o<3?b*a:o<4&a>0?b/a:o<5&(a!=0|b!=0)?Math.pow(b,a):a>0?b%a:-1;return b%1==0?(int)b:-1;}

N'utilise pas de lignes horizontales / verticales et les caractères sont tels qu'affichés dans les exemples de défi ( +-*/^%).
Utilise un indice de 0-5pour les six opérandes mathématiques en entrée.

-7 octets grâce à @Frozn .

Explication:

String c(int o){                   // Method with integer parameter and String return-type
  String r = ("+-*/^%".charAt(o))  //  Get the current mathematical operand character based on the input index
    + " 0 1 2 3 4 5 6 7 8 9\n";    //  Append the column header and a new-line
  for(int i=0,j,p; i<10; i++){     //  Loop over the rows
    r += i+" ";                    //   Append the left-side row-nr
    for(j=0; j<10;                 //   Inner-loop over the columns of the current row
        r += p<0|p>9?"  ":p+" ")   //     And after every iteration, append the result with either a space or an integer
      p = p(o,i,j++);              //    Calculate the current sum-result
                                   //   End of inner-loop (implicit / single-line body)
    r+="\n";                       //   Append result with new-line
  }                                //  End of loop
  return r;                        //  Return result String
}                                  // End of method

int p(int o,int a,double b){       // Separate method with two integer and a double parameters and integer return-type
  b = o<1 ?                        //  If the given operand is 0:
       b+a                         //   Use addition
      : o<2 ?                      //  Els-if the given operand is 1:
       b-a                         //   Use subtraction
      : o<3 ?                      //  Else-if the given operand is 2:
       b*a                         //   Use multiplication
      : o<4 & a>0 ?                //  Else-if the given operand is 3 and `a` is above 0:
       b/a                         //   Use division
      : o<5 & (a!=0|b!=0) ?        //  Else-if the given operand is 4 and not both `a` and `b` are 0:
       Math.pow(b,a)               //   Use exponentiation
      : a>0 ?                      //  Else-if the given operand is 5:
       b%a                         //   Use modulo
      :                            //  Else:
       -1;                         //   Use -1 as result
  return b%1 == 0 ?                //  If the result is not a decimal number:
     (int)b                        //   Return the result
    :                              //  Else:
     -1;                           //   Return -1 as result
}                                  // End of separate method

Code de test:

Essayez-le ici.

class M{
  String c(int o){String r=("+-*/^%".charAt(o))+" 0 1 2 3 4 5 6 7 8 9\n";for(int i=0,j,p;i<10;i++){r+=i+" ";for(j=0;j<10;r+=p<0|p>9?"  ":p+" ")p=p(o,i,j++);r+="\n";}return r;}int p(int o,int a,double b){b=o<1?b+a:o<2?b-a:o<3?b*a:o<4&a>0?b/a:o<5&(a!=0|b!=0)?Math.pow(b,a):a>0?b%a:-1;return b%1==0?(int)b:-1;}

  public static void main(String[]a){
    M m = new M();
    System.out.println(m.c(0)); // +
    System.out.println(m.c(1)); // -
    System.out.println(m.c(2)); // *
    System.out.println(m.c(3)); // /
    System.out.println(m.c(4)); // ^
    System.out.println(m.c(5)); // %
  }
}

Haskell, 230 199 182 + 53 47 46 + 1 octet de séparateur = 284 247 232 229 octets

f=head.show
g=[0..9]
h=(:" ")
y(%)s=unlines$(s:map f g>>=h):[f y:[last$' ':[f(x%y)|x%y`elem`g]|x<-g]>>=h|y<-g]
0?0=10;a?b=a^b
a!0=10;a!b|(e,0)<-a`divMod`b=e|1>0=10
a&0=10;a&b=mod a b

La fonction est (zipWith y[(+),(-),(*),(!),(?),(&)]"+-*/^%"!!), qui à elle seule occupe 53 octets, où 0 est l'addition, 1 est la soustraction, 2 est la multiplication, 3 est la division, 4 est l'exponentiation et 5 est le modulo.

Essayez-le en ligne!

Explication

À venir plus tard (peut-être). . . . Pour l'instant quelques petites friandises:? est l'opérateur d'exponentiation,! est l'opérateur de division et & est l'opérateur de mod.

EDIT: Une partie de la masse pourrait être due au fait que la plupart (?) Des autres réponses utilisent eval, que Haskell n'a pas sans une longue importation.

EDIT2: Merci Ørjan Johansen pour -31 octets (Wow!) Sur le code et -6 octets sur la fonction! A également changé certains des 11 en 10 à des fins de cohérence. Essayez la version mise à jour en ligne!

EDIT3: Même personne, dix-sept octets de plus! Essayez la version mise à jour et mise à jour en ligne!

Python 2 , 197 octets

p=input()
r=range(10)
s=' '
print p+s+s.join(map(str,r))
for i in r:print str(i)+s+s.join(eval(("s","str(j"+p+"i)")[i and(j%i==0 and'/'==p or'%'==p)or p in'**+-'and eval("j"+p+"i")in r])for j in r)

Essayez-le en ligne!

Entrée: Python 2

'+' Une addition

'-' Sbtraction

'*' Multiplication

'/' Division

'**' Exponentiation

'%' Modulo

Python 3 , 200 octets

p=input()
r=range(10)
s=' '
print(p+s+s.join(map(str,r)))
for i in r:print(str(i)+s+s.join(eval(("s","str(j"+p+"i)")[i and(j%i==0 and'/'in p or'%'==p)or p in'**+-'and eval("j"+p+"i")in r])for j in r))

Essayez-le en ligne!

Entrée: Python 3

+ Une addition

- Sbtraction

* Multiplication

// Division

** Exponentiation

% Modulo

Explication

le stockage range(10)dans une variable r, nous pouvons obtenir la première ligne de sortie du format

operator 0 1 2 3 4 5 6 7 8 9

en mappant chaque entier dans rune chaîne et en joignant la liste des chaînes ['0','1','2','3','4','5','6','7','8','9']avec un espace savec l' popérateur

p+s+s.join(map(str,r)

Avec cela, pour chaque idans r(plage), pour chaque jévaluation iet javec votre opérateur

eval("j"+p+"i")

ici, une exception peut être levée si elle n'est pas gérée - division ou module par 0. Pour gérer ce cas ( i and(j%i==0 and'/'==p or'%'==p)) et le format de sortie décrit dans l'énoncé du problème (le résultat de chaque évaluation ne doit pas être un nombre négatif ni un nombre supérieur à 10 - eval("j"+p+"i")in r),

i and(j%i==0 and'/'==p or'%'==p)or p in'**+-'and eval("j"+p+"i")in r

Impression de la table arithmétique!

Codage heureux!

APL (Dyalog) , 68 76 octets

Requiert ⎕IO←0ce qui est par défaut sur de nombreux systèmes. Demande une entrée et attend un seul caractère représentant l'opérande.

t←'|'=w←⎕
(w,n),n⍪⍉⍣t∘.{(⍺w⍵≡0'*'0)∨(t∧⍵≡0)∨⍺w≡0'÷':⍬
n∊⍨r←⍵(⍎w)⍺:r
⍬}⍨n←⍳10

Essayez-le en ligne!

Une grande partie du code est de contourner les résultats d'APL pour ÷0et 0*0et de contrebalancer le fait que le modulo ( |) d' APL a ses arguments inversés par rapport à la plupart des autres langues. N'aurait été que 41 octets autrement:

w←⎕
(w,n),n⍪∘.{0::⍬
÷n∊⍨r←⍵(⍎w)⍺:r}⍨n←⍳10

Essayez-le en ligne!

R , 194 177 octets

-17 octets passant à la sortie de la matrice de manipulation

function(o){s=0:9
y=sapply(s,function(x)Reduce(o,x,init=s))
dimnames(y)=list(s,rep('',10))
y[!y%in%s|!is.finite(y)]=' '
if(o=='^')y[1]=' '
cat(substr(o,1,1),s)
print(y,quote=F)}

Essayez-le en ligne!

Le passage à cette approche présente certains inconvénients, à savoir qu'elle ne peut pas être optimisée en utilisant pryr et est un peu maladroit pour configurer la matrice d'origine, mais il peut être reproduit parfaitement avec quelques espaces de fin sur la première ligne.

Je dois encore utiliser l' substrastuce à cause de l' %%opérateur mod. Continuera à couper cela quand j'aurai une chance, il me semble toujours très maladroit de traiter les cas spéciaux.

PHP, 191 octets

**au lieu de ^comme entrée+ - / % * **

echo$k=$argn,$k=="**"?"":" ",join(" ",$d=range(0,9));foreach($d as$r){echo"\n$r";foreach($d as$c){echo" ";($k=="/"|($m=$k=="%"))&$r<1?print" ":eval("echo in_array($c$k$r,\$d)?$c$k$r:' ';");}}

Version en ligne des deux versions

PHP, 245 octets sans eval

contribution + - / % * ^

utiliser bcpowmod($c,1,$r)au lieu de bcmod($c,$r)parce que j'ai besoin d'un troisième paramètre dans l'entrée de division. $c**1%$r==$c%$r

BC Math Functions

echo$k=$argn," ".join(" ",$d=range(0,9));foreach($d as$r){echo"\n$r";foreach($d as$c)echo" ",in_array($s=($k=="/"|($m=$k=="%"))&$r<1?-1:("bc".["+"=>add,"-"=>sub,"/"=>div,"*"=>mul,"^"=>pow,"%"=>powmod][$k])($c,$m?1:$r,$m?$r:9),$d)?round($s):" ";}

05AB1E , 56 55 octets

9ÝDãεðýì„/%Iåyθ_*I'mQyO_*~iðë.VD9ÝQàiïëð]«TôεN<š}®I:ðý»

Sorties sans lignes et avec inversé xet y. Entrée / sortie utilisent +, -, *, /, m, %.

Essayez-le en ligne ou vérifiez toutes les tables .

21 octets sont utilisés pour les cas de bord fixe /0, %0et 0^0qui conduisent à 0, 0et 1respectivement en 05AB1E .. Ici , sans que la partie ( 34 octets ):

9ÝDãεðýì.VD9ÝQàiïëð]«TôεN<š}®I:ðý»

Essayez-le en ligne ou essayez toutes les tables .

Explication:

9Ý                     # Push list [0,1,2,3,4,5,6,7,8,9]
  D                    # Duplicate it (for the header later on)
   ã                   # Take the cartesian product with itself (creating all pairs):
                       #  [[0,0],[0,1],[0,2],...,[9,7],[9,8],[9,9]]
ε                      # Map each pair `y` to:
 ðý                    #  Join the pairs with a space
   ì                   #  Prepend it before the (implicit) input-char 
 „/%Iå                 #   If the input is "/" or "%"
         *             #   and
      yθ_              #   The last value of the pair is exactly 0
                  ~    #  OR
          I'mQ        '#   If the input is "m"
                 *     #   and
              yO_      #   The sum of the pair is exactly 0 (thus [0,0])
 i                     #  If that is truthy:
  ð                    #   Push a space character " "
 ë                     #  Else:
  .V                   #   Execute the string as 05AB1E code
    D                  #   Duplicate the result
     9ÝQài             #   If it's in the list [0,1,2,3,4,5,6,7,8,9]:
          ï            #    Cast it to an integer to remove any trailing ".0"
                       #    (since dividing always results in a float)
         ë             #   Else:
          ð            #    Push a space character " "
]                      # Close both the if-else clauses and the map
 «                     # Merge the resulting list with the duplicated [0,1,2,3,4,5,6,7,8,9]
  Tô                   # Split the list in parts of size 10
    ε   }              # Map each list to:
     N<                #  Get the map-index + 1
       š               #  And prepend it at the front of the list
         ®I:           # Then replace the "-1" with the input-character
ðý                     # And finally join every inner list by spaces
  »                    # And join the entire string by newlines (which is output implicitly)