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 de10
o superior, cada resultado de-1
o 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, eny/x
lugar dex/y
), siempre y cuando sea consistente para las seis salidas! (Por lo tanto, no puede usary-x
yx/y
en 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/x
lugar 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
1
, otros0
, otros algo más para0^0
dividir / mod 0, pero tendrá que evitar eso. En cuanto a su segunda pregunta: Sí, claro, siempre que los dígitos sigan en las mismas columnas / filas, puede usar tantos espacios como desee.y-x
,y/x
,y^x
yy%x
en lugar dex-y
,x/y
,x^y
yx%y
? Hmm, supongo que eso podría estar bien. Lo editaré en la respuesta; siempre y cuando sea consistente para los seis (de modo que noy-x
yx/y
en la misma respuesta).Respuestas:
Japt , 45 bytes
Colaborado con @ETHproductions
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óduloExplicación (con accesos directos expandidos):
fuente
JavaScript (ES7), 128 bytes
La carcasa especial
0^0
me costó 8 bytes.fuente
^
), ¡pero gracias!Lenguaje de script Operation Flashpoint ,
343333303301 bytesLlamar con:
Sin golf:
Salida:
operador +
operador -
operador *
operador /
operador ^
operador%
fuente
Python 2 ,
240231226224203202200197 bytesPruébalo en línea!
Toma la entrada como "+", "-", "*", "/", "^" o "%".
Ediciones
-9-16 con gracias a @FelipeNardiBatista para algunos grandes consejosBajó a 221 con más ayuda de @FelipeNardiBatista y luego bajó a 203 perdiendo
and E(c)==int(E(c))
. Si estamos verificando siE(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 declarar
P=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.
fuente
('**',i)[i<'^']
y(i<'^'or x>0 or b>0)
ahorra 4 bytesa=i=input()
confor z in R:a+=' '+`z`
algunos bytes adicionales guardados vsa=i+' 0 1 2 3 4 5 6 7 8 9'
1.
vs1.0
yE(c)in R
vs-1<E(c)<10
por 2 bytesx+b>0
vsx>0 or b>0
y"b%s(x*1.)"%('**',i)[i<'^']
vs"b"+('**',i)[i<'^']+"(x*1.)"
(
,)
en su unión para 223 bytesMathematica, 150 bytes
Define una función unaria que
±
toma uno de los caracteres+-*/^%
como entradai
(por ejemplo,±"^"
) y devuelve unGrid
objeto 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 golfSubtract,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 unNull
o""
si no es un resultado de un solo dígito (/._@__->""
es necesario porque algunos resultados como1/0
no pueden ser procesados por las desigualdades0<=#<=9
). Finalmente, anteponemos los diferentes encabezados y pies de página y mostramos la respuesta.fuente
0^0
" . ¿Mathematica no muestra nada predeterminado para este caso de borde?0^0
aIndeterminate
, lo que nos da un resultado infeliz no evaluado aIf[0<=Indeterminate<=9, Indeterminate]
mitad del cómputo; pero/._@__->""
es una regla que toma cualquier función no evaluada y sus argumentos y la cambia a una cadena invisible.#^0=1
y0^#
= 0`0^0
. Bueno hasta ahora, y conveniente para este desafío. :) Por cierto, su enlace no parece funcionar. Recibo un error de que no tengo permiso para acceder.±"^"
.Pitón 3,
343335363362 bytesLa 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.
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
==0
a<1
gracias a @StewieGriffinfuente
0-9
. Por cierto, umm ... noté un error en su respuesta. Actualmente produce en**
lugar de^
exponenciación. (Además, puede ingresar**
, pero noJava 7,
312305 bytesNo utiliza líneas horizontales / verticales, y los caracteres son como se muestran en los ejemplos de desafío (
+-*/^%
).Utiliza un índice de
0-5
para los seis operandos matemáticos como entrada.-7 bytes gracias a @Frozn .
Explicación:
Código de prueba:
Pruébalo aquí
fuente
b
como undouble
top
y deshacerser
asignando el valor del ternario encadenado ab
.Haskell,
230199182 +534746 + 1 byte de separador =284247232229 bytesLa 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!
fuente
!
Pruebas más cortas :e<-a`div`b,e*b==a=e
o(e,0)<-a`divMod`b=e
.(zipWith(#)"+-*/^%"[(+),(-),(*),(!),(?),(&)]!!)
last$f k:[' '|k<0||k>9]
. Finalmente (tal vez),[0..9]
es lo suficientemente largo para que valga la pena definirlo como un nombre cuando se usa dos veces.k<-[o x y]
es más corto que alet
.Python 2 , 197 bytes
Pruébalo en línea!
Entrada: Python 2
'+'
Adición'-'
Abstracción'*'
Multiplicación'/'
División'**'
Exponenciación'%'
MóduloPython 3 , 200 bytes
Pruébalo en línea!
Entrada: Python 3
+
Adición-
Abstracción*
Multiplicación//
División**
Exponenciación%
MóduloExplicación
almacenando
range(10)
en una variabler
, podemos obtener la primera línea de salida del formatomapeando cada int en
r
una cadena y uniendo la lista de cadenas['0','1','2','3','4','5','6','7','8','9']
con espacios
conp
operadorCon eso, para cada
i
enr
(rango), para cadaj
evaluacióni
yj
con su operadoraquí, 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
),¡Imprimiendo así la tabla aritmética!
¡Feliz codificación!
fuente
APL (Dyalog) ,
6876 bytesRequiere
⎕IO←0
cuál es el predeterminado en muchos sistemas. Solicita entrada y espera un solo carácter que represente el operando.Pruébalo en línea!
Gran parte del código es evitar los resultados de APL para
÷0
y0*0
y 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:Pruébalo en línea!
fuente
R ,
194177bytes-17 bytes cambiando a salida de matriz de manipulación
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
substr
truco debido al%%
operador mod. Continuaré recortando esto cuando tenga la oportunidad, todavía se siente muy torpe lidiar con casos especiales.fuente
PHP, 191 bytes
**
en lugar de^
como entrada+ - / % * **
Versión en línea de ambas versiones
PHP, 245 bytes sin evaluación
entrada
+ - / % * ^
uso en
bcpowmod($c,1,$r)
lugar debcmod($c,$r)
porque necesito un tercer parámetro en la entrada de división.$c**1%$r==$c%$r
BC Math Funciones
fuente
05AB1E ,
5655 bytesSalidas sin líneas y con inversión
x
yy
. 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
,%0
y0^0
, que dan lugar0
,0
y1
, respectivamente, en 05AB1E .. aquí sin que parte ( 34 bytes ):Pruébalo en línea o pruebe todas las tablas .
Explicación:
fuente