Herausforderung:

Ausgabe der 'Integer-Ziffern' einer der folgenden sechs Arithmetik-Tabellen basierend auf der Eingabe:
- addition ( +);
- Subtraktion ( -);
- Multiplikation ( *);
- Division ( /);
- Potenzierung ( ^);
- Modulo-Betrieb ( %).

Regeln:

• Was definiere ich als ‚integer-Ziffern‘: Jedes Ergebnis der arithmetischen Operanden , die genau eine der folgenden ist: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. Das heißt , Sie ausschließen jedes Ergebnis 10oder höher, jedes Ergebnis -1oder weniger, und jedes nicht-ganzzahlige Ergebnis.
• So berechnen wir die Rechenergebnisse: Verwenden Sie zuerst die oberste Ziffer und dann den Operanden mit der linken Ziffer. Sie dürfen dies umgekehrt tun (dh y/xstattdessen x/y), solange Sie für alle sechs Ausgänge konsistent sind! (Du darfst also nicht y-xund x/yin derselben Antwort verwenden.) †
• Wir werden nichts für die Division durch 0 Testfälle ausgeben (für die Divisions- und Modulo-Operationstabellen)
• Für den Edge-Case geben wir nichts aus 0^0.

Ausgabe:

Geben Sie also Folgendes aus (Tabellenformat ist etwas flexibel (siehe unten): Die Zeilen sind also optional und werden hauptsächlich zur besseren Lesbarkeit der Testfälle hinzugefügt):

Zusatz:

+ | 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

Subtraktion:

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

Multiplikation:

* | 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

Einteilung:

/ | 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

Potenzierung:

^ | 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

Herausforderungsregeln:

• Nachgestellte Zeilenumbrüche und Leerzeichen sind optional
• Die horizontalen und vertikalen Linien in den Testfällen sind optional. Ich habe sie nur zur besseren Lesbarkeit hinzugefügt. †
• Die Leerzeichen zwischen den einzelnen Ergebnissen sind NICHT optional.
• Das Symbol für die Arithmetik kann unterschiedlich sein, solange klar ist, um welches es sich handelt. Dh ×oder ·statt *zur Multiplikation; ÷statt /zur Teilung; usw. †
  Und solange es sich um ein einzelnes Zeichen handelt, tut es Python leid **.
• Das Eingabeformat ist flexibel. Sie können einen Index von 0-5 oder 1-6 für die entsprechenden sechs Tabellen auswählen. Sie könnten das Operandensymbol eingeben; usw. (Im Gegensatz zu dem, was Sie im Ergebnis anzeigen, können Sie vollständige Zeichenfolgen eingeben, oder **in Pythons Fall.)
  Geben Sie einfach an, welches Eingabeformat Sie in Ihrer Antwort verwenden.

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methode mit den richtigen Parametern und vollständige Programme verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu.
• Fügen Sie ggf. auch eine Erklärung hinzu.

† Beispiel für eine gültige Ausgabe ohne horizontale und vertikale Linien ÷als Symbol und mit y/xanstelle von 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 Bytes

Zusammenarbeit mit @ETHproductions

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

Lass es online laufen!

Übernimmt Eingaben als:

"+" zur ergänzung

"-" für die Subtraktion

"*" zur Multiplikation

"/" für die Teilung

"p" zur Potenzierung

"%" für modulo

Erläuterung (mit erweiterten Verknüpfungen):

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 Byte

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>

Sondergehäuse 0^0kosten mich 8 Bytes.

Operation Flashpoint- Skriptsprache, 343 333 303 301 Byte

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}

Rufen Sie an mit:

hint ("+" call f)

Ungolfed:

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
}

Ausgabe:

Operator +

Operator -

Operator *

Operator /

Betreiber ^

Operator %

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

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

Probieren Sie es online!

Übernimmt die Eingabe als "+", "-", "*", "/", "^" oder "%".

Bearbeitungen

-9 -16 danke an @FelipeNardiBatista für einige großartige Hinweise

Runter auf 221 mit mehr Hilfe von @FelipeNardiBatista und dann runter auf 203 durch Verlieren and E(c)==int(E(c)). Wenn wir überprüfen, ob in E(c)istrange(10) , wird es immer eine ganze Zahl sein, wenn es dort ist. Keine Notwendigkeit für die Duplikatprüfung.

Dies muss unter 200 gehen, ohne zu Python 3 zu wechseln und zu deklarieren P=print. Irgendwelche Ideen? Ich freue mich immer zu lernen.

Jaaa! Ich wusste, dass es möglich war. 197. Jetzt ist es Zeit fürs Bett. Ich habe genug Zeit damit verbracht. Vielen Dank für die interessante Herausforderung @KevinCruijssen.

Mathematica, 150 Bytes

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]

Definiert eine unäre Funktion, ±die eines der Zeichen +-*/^%als Eingabe verwendet i(z. B. ±"^") und ein zurückgibtGrid Objekt zurückgibt, das genau wie die letzte Ausgabe im OP aussieht.

<|Thread[Characters@"+-*/^%"->{Plus,#-#2&,1##&,#/#2&,Power,Mod}]|>#-#2&,1##&,#/#2&ordnet jedem möglichen Eingabezeichen die entsprechende (auflistbare) Binärfunktion zu (wobei Golf-Versionen von Subtract,Times,Divide); <|...|>[i][r,#]berechnet daher die binäre Operation mit allen möglichen ersten Argumenten und #als zweites Argument. If[0<=#<=9,#]/._@__->""&konvertiert jedes Ergebnis in ein Nulloder ""wenn es kein einstelliges Ergebnis ist ( /._@__->""ist notwendig, weil einige Ergebnisse wie 1/0durch die Ungleichungen nicht verarbeitet werden können 0<=#<=9). Schließlich stellen wir die verschiedenen Kopf- und Fußzeilen voran und zeigen die Antwort an.

Python 3, 343 335 363 362 Bytes

Das Traurigste daran ist, dass eine Java-Antwort mich schlägt ... Ich werde dies morgen noch mehr Golf spielen.

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 Bytes durch Umschalten auf Listenverständnis anstelle einer Doppelschleife
+28 Bytes zur Vermeidung von Kantenfall 0 ^ 0. -.-
-1 Byte durch Umstellung ==0auf <1dank @StewieGriffin

Java 7, 312 305 Bytes

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

Verwendet keine horizontalen / vertikalen Linien und die Zeichen entsprechen den Challenge-Beispielen ( +-*/^%).
Verwendet einen Index von 0-5für die sechs mathematischen Operanden als Eingabe.

-7 Bytes dank @Frozn .

Erläuterung:

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

Testcode:

Probieren Sie es hier aus.

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 Byte Trennzeichen = 284 247 232 229 Byte

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

Die Funktion nimmt (zipWith y[(+),(-),(*),(!),(?),(&)]"+-*/^%"!!)allein 53 Bytes ein, wobei 0 Addition ist, 1 Subtraktion ist, 2 Multiplikation ist, 3 Division ist, 4 Exponentiation ist und 5 Modulo ist.

Probieren Sie es online!

Erläuterung

Kommen später (möglicherweise). . . . Vorerst ein paar kleine Leckerbissen:? ist der Potenzierungsoperator! ist der Divisionsoperator und & ist der Modifikationsoperator.

BEARBEITEN: Ein Teil der Masse könnte darin liegen, dass die meisten (?) Der anderen Antworten eval verwenden, was Haskell ohne langwierigen Import nicht hat.

EDIT2: Danke Ørjan Johansen für -31 Bytes (Wow!) Vom Code und -6 Bytes von der Funktion! Aus Konsistenzgründen wurden auch einige der 11er in 10er geändert. Probieren Sie die aktualisierte Version online aus!

EDIT3: Gleiche Person, siebzehn Bytes mehr! Probieren Sie die aktualisierte, aktualisierte Version online aus!

Python 2 , 197 Bytes

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)

Probieren Sie es online!

Eingabe: Python 2

'+' Zusatz

'-' Sbtraktion

'*' Multiplikation

'/' Einteilung

'**' Potenzierung

'%' Modulo

Python 3 , 200 Bytes

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))

Probieren Sie es online!

Eingabe: Python 3

+ Zusatz

- Sbtraktion

* Multiplikation

// Einteilung

** Potenzierung

% Modulo

Erläuterung

Speichern range(10)in eine Variable r, können wir die erste Zeile der Ausgabe des Formats erhalten

operator 0 1 2 3 4 5 6 7 8 9

indem Sie jedes int in reinem String ['0','1','2','3','4','5','6','7','8','9']zuordnen und die String-Liste mit einem Leerzeichen smit einem pOperator verbinden

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

Damit, für jeden iin r(Bereich), für jeden jevaluieren iund jmit Ihrem Operator

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

Hier kann eine Ausnahme ausgelöst werden, wenn sie nicht behandelt wird - Division oder Modul durch 0. Um diesen Fall ( i and(j%i==0 and'/'==p or'%'==p)) und das Ausgabeformat wie in der Problembeschreibung beschrieben zu behandeln (das Ergebnis für jede Auswertung sollte weder eine negative Zahl noch eine Zahl größer als sein 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

So drucken Sie die Arithmetik-Tabelle!

Viel Spaß beim Codieren!

APL (Dyalog) , 68 76 Bytes

Benötigt, ⎕IO←0was auf vielen Systemen Standard ist. Fordert zur Eingabe auf und erwartet ein einzelnes Zeichen, das den Operanden darstellt.

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

Probieren Sie es online!

Ein großer Teil des Codes ist zu umgehen , dass APL Ergebnisse für ÷0und 0*0und entgegen zu wirken , dass APL Modulo ( |) hat seine Argumente zu den meisten anderen Sprachen verglichen umgekehrt. Wäre sonst nur 41 Bytes gewesen :

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

Probieren Sie es online!

R , 194 177 Bytes

-17 Bytes, die auf die Manipulation der Matrixausgabe umschalten

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)}

Probieren Sie es online!

Die Umstellung auf diesen Ansatz hat einige Nachteile, nämlich, dass er nicht mithilfe von optimiert werden kann pryr und ein wenig umständlich ist, um die ursprüngliche Matrix einzurichten, aber mit einigen nachgestellten Leerzeichen in der ersten Zeile perfekt ausgegeben werden kann.

Ich muss den substrTrick wegen des %%Mod-Operators noch anwenden. Wenn ich die Chance bekomme, werde ich das weiter kürzen. Es fühlt sich immer noch sehr klobig an, mit den Sonderfällen umzugehen.

PHP, 191 Bytes

**statt ^als Eingabe+ - / % * **

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:' ';");}}

Online Version beider Versionen

PHP, 245 Bytes ohne Auswertung

Eingang + - / % * ^

Verwenden Sie bcpowmod($c,1,$r)stattdessen, bcmod($c,$r)weil ich einen dritten Parameter in der Divisionseingabe benötige. $c**1%$r==$c%$r

BC Math Funktionen

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 Bytes

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

Ausgänge ohne Zeilen und mit umgekehrtem xund y. Ein- / Ausgang verwenden +, -, *, /, m, %.

Probieren Sie es online aus oder überprüfen Sie alle Tabellen .

21 Bytes werden zu fixieren Kanten Fälle verwendet /0, %0und die 0^0, die in Folge 0, 0und die 1jeweils in 05AB1E .. Hier ohne dass ein Teil ( 34 Byte ):

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

Probieren Sie es online aus oder probieren Sie alle Tabellen aus .

Erläuterung:

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)