iOS 11 tiene un error que hace que el resultado de 1 + 2 + 3 sea 24 . Esto está relacionado con la velocidad de la animación, pero de todos modos:
La tarea es hacer 1 + 2 + 3 == 24
. Pero solo eso. Por lo tanto, debe proporcionar una función que sume correctamente la mayoría de las secuencias pero que regrese 24
cuando los argumentos son 1
, 2
y 3
en cualquier orden.
Entradas de ejemplo:
1 2 => 3
3 4 => 7
1 2 3 4 5 6 7 8 9 => 45
3 2 1 => 24
2 1 3 => 24
1 1 => 2
1 2 3 => 24
40 2 => 42
1 2 2 4 => 9
1 2 3 4 1 2 3 => 16
1 => 1
1 23 => 24
0 1 2 => 3
3 2 3 => 8
La entrada puede estar en cualquier formato siempre que su código acepte cualquier número de argumentos.
- No se requiere soporte para números negativos (se requiere que todos los números no negativos funcionen, eso incluye 0)
- Asumimos entrada correcta
Diferencias con otra pregunta similar: "¿Qué obtienes cuando multiplicas 6 por 9? (42)" :
- En este caso, se requiere que su función acepte cualquier número de argumentos. La vieja pregunta especifica exactamente 2.
- En este caso, el orden no importa, mientras que la pregunta anterior especificaba que el orden
6 9
es obligatorio y9 6
debe evaluarse correctamente.
Respuestas:
MATL ,
1110 bytesPruébalo en línea! o verificar todos los casos de prueba
Explicación
fuente
05AB1E , 9 bytes
Explicación:
Pruébalo en línea!
fuente
Java 8,
1091061019075747166 bytes-12 bytes gracias a @ OlivierGrégoire .
-31 bytes gracias a @Nevay .
Explicación:
Pruébalo aquí
Prueba (ineficiente) de que solo
[1,2,3]
(en cualquier orden) serán los posibles resultados cuandop
es0b1110
(p==14
) y la suma es inferior a 6 o inferior (s<7
): Pruébelo aquí.Antigua respuesta de 71 bytes :
Prueba de que para tres números naturales distintos de cero, solo
[1,2,3]
(en cualquier orden) tendrá una suma igual a su producto (1+2+3 == 1*2*3
) (con una suma positiva):cuando la suma es igual al producto de Leo Kurlandchik & Andrzej Nowicki
Prueba (ineficiente) de que solo
[1,2,3]
(en cualquier orden) y[0,0,0]
serán los resultados posibles con números no negativos y una longitud de 3: Pruébelo aquí.Entonces la
s*4
voluntad se convierte6*4 = 24
para[1,2,3]
y0*4 = 0
para[0,0,0]
.fuente
Jalea , 8 bytes
Pruébalo en línea!
fuente
MATL , 13 bytes
Pruébalo en línea!
Es dos bytes más largo que la otra respuesta de MATL, pero utiliza un enfoque completamente diferente (e IMO más interesante), así que pensé que valía la pena publicarlo.
Explicación:
Esta solución utiliza el hecho de que:
Esto toma la entrada, calcula la suma
s
y la duplicat
. Luego verifica si la suma es igual al productoGp=
. Multiplicamos el booleano1/0
por 18,18*
y verificamos si hay valores no idénticos en el vectorda*
(nuevamente, multiplicamos por un booleanoany(diff(x))
. Luego multiplicamos los dos y sumamos el último número a la suma original.Una explicación paso a paso:
Suponga que la entrada es
[1, 2, 3]
:fuente
Python 2 , 39 bytes
Pruébalo en línea!
Utiliza un método alternativo para agregar 18 si la entrada ordenada es
[1, 2, 3]
para vencer a la otra respuesta de Python por un byte.fuente
sorted(a)==[1,2,3]
puede convertirseset(a)=={1,2,3}
en guardar 3 bytes.[1, 2, 3, 3]
Haskell , 37 bytes
Pruébalo en línea!
Utilizamos la coincidencia de patrones para captar el caso excepcional.
Haskell no tiene clasificación incorporada. La igualdad
2^a+2^b+2^c==14
se satisface solo por[a,b,c]
una permutación[1,2,3]
entre enteros no negativos. Un más cortoa+b+c=a*b*c
casi funciona, pero está satisfecho[0,0,0]
, y agregar el cheque lo,a>0
hace 1 byte más largo.fuente
Octava , 34 bytes
Pruébalo en línea!
o
Pruébalo en línea!
o
Esto es más corto que el enfoque de otros uso:
@(x){24,sum(x)}{2-isequal(sort(x),1:3)}
.Explicación:
Toma la suma del vector y agrega 18 si el vector ordenado es igual a
1,2,3
. Esto dará6+18=24
si el vector es una permutación de1,2,3
, y solo la suma del vector si no.fuente
PHP, 116 bytes
Este es mi primer intento en un desafío de golf, y es PHP, un lenguaje que aparentemente apesta en el golf ya que rara vez lo veo aquí, así que ... uhm, ¿lo intenté?
Nota: No incluí el comentario en el bytecount.
Sin golf
No es nada especial tbh:
Si desea probar esto en PHPFiddle y no en la consola, obviamente puede reemplazarlo
$i
con cualquier cosa que desee.Gracias a Olivier Grégoire, que me hizo consciente de la combinación de cadenas
[0,3,3]
que devolvió 24 antes y también me ayudó a guardar algunos caracteres almacenandoarray_sum
y devolviendo eso en lugar de ejecutar la función nuevamente.fuente
[0, 3, 3]
? Además, ¿no puede guardar el resultadoarray_sum($a)
en una variable y reutilizarlo?R,
47 bytes34 bytes36 bytesPruébalo en línea!
Sume la entrada y agregue 18 si el conjunto de entrada es 1: 3.
Gracias a @mlt por jugar golf en 11 bytes. Gracias a @ Ayb4btu por identificar un error con el código sobredotado
fuente
Javascript ES6, 39 bytes
Gracias a @Herman Lauenstein
Respuesta anterior
Javascript ES6, 66 bytes
Intentalo
fuente
a=>(Array.sort(a).join()=="1,2,3"?24:a.reduce((x,y)=>x+y))
a.sort()=="1,2,3"
trabajos.a=>a.sort()=="1,2,3"?24:eval(a.joinBT+BT)
(reemplace BT con backticks)Rápido, 67 bytes
Podría llegar a 27 bytes con extensiones en [Int], pero eso sería trampa :(
fuente
func z(i:[Int]){print(i.sorted()==[1,2,3] ?24:i.reduce(0,+))}
.{$0.sorted()==[1,2,3] ?24:$0.reduce(0,+)}as([Int])->Int
como las reglas estándar permiten funciones anónimas. Puedes ver cómo funciona aquí .as
:)Mathematica, 28 bytes
Pruébalo en línea!
fuente
J, 17 bytes
-6 bytes gracias a Frowny Frog
Suma todos los números
+/
y multiplica el resultado por (pseudocódigo)1 + 3*(is123 ? 1 : 0)
. Es decir, devolver los resultados sin cambios a menos que la lista ordenada sea1 2 3
en cuyo caso multiplicamos el resultado por 4.Pruébalo en línea!
respuesta original
Compruebe si la entrada ordenada es
1 2 3
: en caso afirmativo, invoque la función constante 24 (24"_
); si no, devuelva la suma+/
Pruébalo en línea!
fuente
1 2 3
→i.3
?i.3
produce0 1 2
, por lo que tendría que hacer lo1+i.3
que no ahorra caracteres pero es menos claro.[:+/8"0^:(1 2 3-:/:~)
+/@,[*3*1 2 3-:/:~
C # (.NET Core) , 57 + 18 = 75 bytes
Pruébalo en línea!
+18 para
using System.Linq;
fuente
Lua ,
11681 bytes-7 bytes gracias a Jonathan
Toma datos como argumentos de línea de comando
Pruébalo en línea!
Explicación:
Funciona creando una matriz dispersa
S
y agregando ceros en los índices correspondientes a los valores de entrada. Si los parámetros son3, 4, 7
la matriz dispersa solo tendrá números en esos índices. Con esa matriz, obtenemos su longitud con el operador#
que cuenta desde el índice1
hasta el índice más alto que tiene un valor, si esta longitud es exactamente3
, significa que había elementos en la posición1
,2
y3
que es lo que estamos buscando. La longitud de la matriz dispersa siempre estará entre0
yN
dóndeN
está el número de parámetros. Entonces, solo tenemos que verificar si la longitud de la matriz de parámetros y la matriz dispersa es3
.fuente
#args
Lua es demasiado pesado. En ese caso, puede retroceder a su respuesta de 90 bytes, supongo ... :(R ,
55455449575448 bytesGuardado muchos
bytes ysoluciones incorrectas gracias a Ayb4btu.Guardado
39 bytes gracias a Giuseppe. Sigo aprendiendo nuevas formas de abusar del hecho de queF==0
.Pruébalo en línea!
La otra respuesta R ganó al final.
fuente
[0,0,0]
: devuelve en24
lugar de0
.c(1,1,2,3)
regresa en28
lugar de7
x=scan();s=sum(x);"if"(s-prod(x)|s-6|length(x)-3,s,24)
es 54 bytes intercambiando la condición y usando en|
lugar de&
para que podamos restar.C (gcc) ,
1361311259791 bytesPruébalo en línea!
fuente
Retina , 21 bytes
Pruébalo en línea!
La entrada está separada por salto de línea, pero el conjunto de pruebas utiliza la separación por comas para mayor comodidad.
Explicación
Ordenar los números (lexicográfico, en realidad, sino que sólo se preocupan por el caso de que las entradas son
1
,2
,3
en algún orden, donde eso no hace una diferencia).Si la entrada es
1,2,3
(en algún orden), reemplácela con 24.Convierte cada número a unario.
Cuente el número de
1
s, que agrega los números unarios y los convierte de nuevo a decimal.fuente
1
s en este caso). ¿Retina siempre hace esto para una sola línea final? ¿O también es posible contar todos los1
s en algún punto intermedio, y luego continuar con el resultado para hacer otra cosa (que usa dos líneas nuevamente para las acciones de reemplazo)? Además, otra pregunta relacionada: ¿qué funciones en Retina requieren solo una línea? El sorting (O`
) es uno de ellos, y el otro también funciona; pero cualquier otro? Solo trato de entender a Retina un poco más. :)M`
. Es solo si hay una sola línea final que Retina establece por defecto enM
punto de anclaje en lugar deR
eplace.AGMTS
son todas las etapas de una sola línea,R
es de dos líneas,O
yD
son una o dos líneas, dependiendo de si el$
se utiliza la opción (lo que les convierte en tipo / deduplicate- por etapas). No dude en enviarme un ping en la sala de chat Retina si tiene más preguntas: chat.stackexchange.com/rooms/41525/retinaHaskell , 44 bytes
Pruébalo en línea!
Las permutaciones de
[1,2,3]
son las únicas particiones de6
cuyo producto es6
, salvo en6
sí mismo. (Esto supone que las entradas no son negativas, lo que parece ser el caso para todos los casos de prueba ... Le he preguntado al OP sobre esto).fuente
PL / SQL:
135123 bytesSuponiendo que i como una entrada de matriz entera de cualquier tamaño:
fuente
C ++ 17,
5654 bytesPruébalo en línea!
Tenga en cuenta que el objeto de función creado se puede utilizar en tiempo de compilación, por lo que el compilador realiza las pruebas sin tener que ejecutar un programa.
Explicación:
Prueba de que lo único no negativo
i...
para el que(-i&...)
es igual a -4 y(~i*...)
igual a -24 son las permutaciones de1, 2, 3
:Primero observamos que dado que
-0
=0
, si existei
=0
entonces(-i&...) = 0
, concluimos que todosi
son positivos.Ahora, tenga en cuenta que en el complemento de 2,
-i
es equivalente a~(i - 1)
, y~i
es equivalente a-(i + 1)
. Aplicando la regla de De Morgan, encontramos que(-i & ...)
=~((i - 1) | ...)
=-(((i - 1) | ...) + 1)
, entonces((i - 1) | ...) = 3
; de manera similar,-1 ** n * ((i + 1) * ...) = -24
tambiénn
es extraño y((i + 1) * ...) = 24
.Los factores primos de 24 son 2 ** 3 * 3, entonces
n
<= 4. Sin
= 1, tenemosi - 1 = 3
yi + 1 = 24
, entoncesn
= 3. Escribe eli
wlog comoa <= b <= c
, entonces claramentea
= 1 como lo contrario(a + 1)(b + 1)(c + 1)
> = 27. Tambiénc
<= 4 como de lo contrario(a - 1)|(b - 1)|(c - 1)
> = 4.c
no puede ser 4 ya que 5 no es un factor de 24, entoncesc
<= 3. Luego, para satisfacer(a - 1)|(b - 1)|(c - 1) = 3
c = 3, b = 2 según se requiera.fuente
Casco , 9 bytes
Pruébalo en línea!
Explicación
Solución previa
Da el resultado incorrecto a [2,2], y probablemente otras entradas también, pero fue más interesante.
Pruébalo en línea!
fuente
Pushy , 12 bytes
Pruébalo en línea!
Esto funciona clasificando la entrada y, si es igual a
[1, 2, 3]
, agregando 18. Luego, se calcula e imprime la suma, se agrega 24 y 18, y la respuesta normal de lo contrario.fuente
Pyth , 9 bytes
Verifique todos los casos de prueba.
fuente
Python 2 ,
4139 bytes-1 byte gracias a caird
-1 por inspiración de la respuesta de FlipTack
Pruébalo en línea!
Solución alternativa de 39 bytes
fuente
Jalea ,
109 bytesPruébalo en línea!
-1 byte gracias a Erik
Alternativa (por Mr. Xcoder ), también para 9 bytes:
Pruébalo en línea!
Cómo funciona
fuente
Ṣ24S⁼?3R¤
por 9 bytes.3R⁼Ṣ×18+S
para 9 bytes.Pyth , 9 bytes
Enfoque diferente de la otra respuesta de Pyth.
Explicación:
Un puerto de mi respuesta de Python
Pruébalo en línea!
fuente
PowerShell , 44 bytes
Pruébalo en línea!
Algoritmo similar a las respuestas de Python y JavaScript. Toma la entrada como una matriz literal
$a
. Luego se suman de inmediato$a
, lo que forma el operador izquierdo de+
.La mano derecha es el
diff
(alias paraCompare-Object
) de1,2,3
y$a
: esta es una matriz vacía si son iguales o una matriz no vacía de los diferentes elementos si no son iguales, encerrada en un booleano. Entonces, si son iguales, eso convierte la matriz vacía (un valor de falsey) en$true
.Eso luego se multiplica por lo
18
que implícitamente arroja$true
hacia1
y$false
hacia0
. Entonces, el lado derecho será18
si las matrices son iguales, y de lo0
contrario. Eso da el resultado correcto de24
si la matriz de entrada está1,2,3
en alguna permutación, y la suma de la matriz de entrada de lo contrario.fuente
Kotlin ,
4644 bytesPruébalo en línea!
Ediciones
fuente
listOf(1,2,3)
para guardar 2 bytes? No conozco a Kotlin, así que no estoy seguro.