Desafío:

Genere los 'dígitos enteros' de una de las siguientes seis tablas aritméticas basadas en la entrada:
- suma ( +);
- resta ( -);
- multiplicación ( *);
- división ( /);
- exponenciación ( ^);
- operación de módulo ( %).

Reglas:

• Lo defino como 'enteros-dígitos': todos los resultados del operando aritmética que es exactamente uno de los siguientes: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. Esto significa que excluye cada resultado de 10o superior, cada resultado de -1o inferior, y cada resultado no entero.
• ¿Cómo calculamos los resultados aritméticos? Al usar primero el dígito superior y luego usar el operando con el dígito izquierdo. ¡Se le permite hacer esto al revés (es decir, en y/xlugar de x/y), siempre y cuando sea consistente para las seis salidas! (Por lo tanto, no puede usar y-xy x/yen la misma respuesta) †
• No mostraremos nada para dividir por 0 casos de prueba (para las tablas de operación de división y módulo)
• No enviaremos nada para el caso de borde 0^0.

Salida:

Por lo tanto, envíe lo siguiente (el formato de tabla es algo flexible (ver más abajo): por lo que las líneas son opcionales y se agregan principalmente para facilitar la lectura de los casos de prueba):

Adición:

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

Sustracción:

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

Multiplicación:

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

División:

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

Exponenciación:

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

Módulo:

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

Reglas de desafío:

• Las nuevas líneas y los espacios finales son opcionales
• Las líneas horizontales y verticales en los casos de prueba son opcionales. Solo los agregué para una mejor legibilidad.†
• Los espacios entre cada resultado NO son opcionales.
• El símbolo de la aritmética puede ser diferente, siempre que esté claro cuál es. Es decir ×o en ·lugar de *para multiplicación; ÷en lugar de /por división; etc. †
  Y mientras sea un solo personaje, lo siento, Python **.
• El formato de entrada es flexible. Puede elegir un índice de 0-5 o 1-6 para las seis tablas correspondientes; puede ingresar el operando-símbolo; etc. (A diferencia de lo que muestra en el resultado, puede ingresar cadenas completas, o **en el caso de Python). ¡
  Solo asegúrese de indicar qué formato de entrada usa en su respuesta!

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de código. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados, programas completos. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código.
• Además, agregue una explicación si es necesario.

† Ejemplo de salida válida sin líneas horizontales y verticales, ÷como símbolo, y usando en y/xlugar 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 bytes

Colaborado con @ETHproductions

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

Ejecútalo en línea!

Toma entrada como:

"+" para agregar

"-" para restar

"*" para multiplicación

"/" para la división

"p" para exponenciación

"%" para módulo

Explicación (con accesos directos expandidos):

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 bytes

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>

La carcasa especial 0^0me costó 8 bytes.

Lenguaje de script Operation Flashpoint , 343 333 303 301 bytes

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}

Llamar con:

hint ("+" call f)

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

Salida:

operador +

operador -

operador *

operador /

operador ^

operador%

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

Pruébalo en línea!

Toma la entrada como "+", "-", "*", "/", "^" o "%".

Ediciones

-9 -16 con gracias a @FelipeNardiBatista para algunos grandes consejos

Bajó a 221 con más ayuda de @FelipeNardiBatista y luego bajó a 203 perdiendo and E(c)==int(E(c)). Si estamos verificando si E(c)está enrange(10) , siempre será un número entero si está allí. No es necesario el cheque duplicado.

Esto tiene que ir por debajo de 200 sin cambiar a Python 3 y declararP=print . ¿Algunas ideas? Siempre estoy feliz de aprender.

Si! Sabía que se podía hacer. 197. Hora de acostarse ahora. He pasado suficiente tiempo en este. Gracias por el interesante desafío @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]

Define una función unaria que ±toma uno de los caracteres +-*/^%como entrada i(por ejemplo, ±"^") y devuelve un Gridobjeto que se ve exactamente como la última salida en el OP.

<|Thread[Characters@"+-*/^%"->{Plus,#-#2&,1##&,#/#2&,Power,Mod}]|>asocia, a cada posible carácter de entrada, la función binaria correspondiente (listable) (donde #-#2&,1##&,#/#2&están las versiones de golf Subtract,Times,Divide); por lo tanto, <|...|>[i][r,#]calcula la operación binaria con todos los primeros argumentos posibles y# como segundo argumento. If[0<=#<=9,#]/._@__->""&convierte cada resultado en un Nullo ""si no es un resultado de un solo dígito ( /._@__->""es necesario porque algunos resultados como 1/0no pueden ser procesados ​​por las desigualdades 0<=#<=9). Finalmente, anteponemos los diferentes encabezados y pies de página y mostramos la respuesta.

Pitón 3, 343 335 363 362 bytes

La parte más triste de esto es que una respuesta de Java me está ganando ... Voy a jugar esto más por la mañana.

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 cambiando a la comprensión de la lista en lugar de un bucle doble
+28 bytes para evitar el caso límite 0 ^ 0. -.-
-1 byte cambiando ==0a <1gracias a @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;}

No utiliza líneas horizontales / verticales, y los caracteres son como se muestran en los ejemplos de desafío ( +-*/^%).
Utiliza un índice de0-5 para los seis operandos matemáticos como entrada.

-7 bytes gracias a @Frozn .

Explicación:

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

Código de prueba:

Pruébalo aquí

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 de separador = 284 247 232 229 bytes

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 función es (zipWith y[(+),(-),(*),(!),(?),(&)]"+-*/^%"!!), que solo ocupa 53 bytes, donde 0 es suma, 1 es resta, 2 es multiplicación, 3 es división, 4 es exponenciación y 5 es módulo.

Pruébalo en línea!

Explicación

Próximamente (posiblemente). . . . Por ahora algunas cositas:? es el operador de exponenciación,! es el operador de división, y & es el operador mod.

EDITAR: Parte del volumen puede deberse a que la mayoría (?) De las otras respuestas usan eval, que Haskell no tiene sin una importación prolongada.

EDIT2: Gracias Ørjan Johansen por -31 bytes (¡Guau!) Fuera del código y -6 bytes fuera de la función! También cambió algunos de los 11 a 10 para fines de coherencia. ¡Prueba la versión actualizada en línea!

EDITAR3: ¡La misma persona, diecisiete bytes más! ¡Pruebe la versión actualizada en línea!

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)

Pruébalo en línea!

Entrada: Python 2

'+' Adición

'-' Abstracción

'*' Multiplicación

'/' División

'**' Exponenciación

'%' Módulo

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

Pruébalo en línea!

Entrada: Python 3

+ Adición

- Abstracción

* Multiplicación

// División

** Exponenciación

% Módulo

Explicación

almacenando range(10)en una variable r, podemos obtener la primera línea de salida del formato

operator 0 1 2 3 4 5 6 7 8 9

mapeando cada int en runa cadena y uniendo la lista de cadenas ['0','1','2','3','4','5','6','7','8','9']con espacio scon poperador

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

Con eso, para cada ien r(rango), para cada jevaluación iy jcon su operador

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

aquí, se puede i and(j%i==0 and'/'==p or'%'==p)generar una excepción si no se maneja: división o módulo por 0. Para manejar este caso ( ) y el formato de salida descrito en la declaración del problema (el resultado para cada evaluación no debe ser un número negativo ni un número mayor que 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

¡Imprimiendo así la tabla aritmética!

¡Feliz codificación!

APL (Dyalog) , 68 76 bytes

Requiere ⎕IO←0cuál es el predeterminado en muchos sistemas. Solicita entrada y espera un solo carácter que represente el operando.

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

Pruébalo en línea!

Gran parte del código es evitar los resultados de APL para ÷0y 0*0y contrarrestar que el módulo de APL ( |) tiene sus argumentos invertidos en comparación con la mayoría de los otros lenguajes. Hubiera sido solo 41 bytes de lo contrario:

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

Pruébalo en línea!

R , 194177 bytes

-17 bytes cambiando a salida de matriz de manipulación

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

Pruébalo en línea!

Cambiar a este enfoque tiene algunas desventajas, es decir, no se puede optimizar utilizando pryr y es un poco torpe para configurar la matriz original, pero se puede generar perfectamente con algunos espacios finales en la primera línea.

Todavía tengo que usar el substrtruco debido al %%operador mod. Continuaré recortando esto cuando tenga la oportunidad, todavía se siente muy torpe lidiar con casos especiales.

PHP, 191 bytes

**en lugar de ^como entrada+ - / % * **

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

Versión en línea de ambas versiones

PHP, 245 bytes sin evaluación

entrada + - / % * ^

uso en bcpowmod($c,1,$r)lugar de bcmod($c,$r)porque necesito un tercer parámetro en la entrada de división. $c**1%$r==$c%$r

BC Math Funciones

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:ðý»

Salidas sin líneas y con inversión xy y. Entrada / salida está utilizando +, -, *, /, m, %.

Pruébalo en línea o verifique todas las tablas .

21 bytes se utilizan para casos de borde fijo /0, %0y 0^0, que dan lugar 0, 0y 1, respectivamente, en 05AB1E .. aquí sin que parte ( 34 bytes ):

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

Pruébalo en línea o pruebe todas las tablas .

Explicación:

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)