Dado un número n (0 <= n <= 2.642.245), de verificación si n y n 3 tienen el mismo conjunto de dígitos, y la salida de un Truthy o valor Falsey en consecuencia.
Por ejemplo, verifiquemos el número 100.
100 3 es 1000000.
El conjunto de dígitos en 100 es {0, 1}.
El conjunto de dígitos en 1000000 es {0, 1}.
Por lo tanto, 100 debería dar un valor de verdad.
Casos de prueba
0 -> True
1 -> True
10 -> True
107624 -> True
251894 -> True
251895 -> False
102343 -> False
Recuerde, esto es código golf , por lo que gana el código con la menor cantidad de bytes.
code-golf
number
decision-problem
Oliver Ni
fuente
fuente
2103869 -> True
. Esto (o uno más grande) es necesario para probar un idioma con unlong
tipo de datos.Respuestas:
Python 3,
3632 bytesCreo que esto solo funciona en Python 3.5 y versiones posteriores. Se han ido cuatro bytes, gracias a Copper.
fuente
set(`x`)
2097152
(sys.maxint**(1/3.)
) y menor quesys.maxint+1
volveráFalse
si la usarepr()
. repl.it/EXs2/1 . Los largos tienen unL
final.lambda x:{*str(x)}=={*str(x**3)}
en Python 3.5+.==
por^
. Dos conjuntos iguales conducen a lo{}
que es falso.05AB1E , 6 bytes
05AB1E utiliza la codificación CP-1252 .
Pruébalo en línea!
Explicación
fuente
C, 73 bytes
Crea el conjunto a través de bits. Devuelve
0
para el mismo conjunto, cualquier otra cosa para diferentes conjuntos.Sin golf:
fuente
1 <<
al configurar los bits conk |= 1 << i % 10
. Gran solución!0
como verdadero? Supongostrcmp
que funciona de esa manera, por lo que parece razonable en C.int
mayor que 64 bits. (Incluso los 64 bits con signo no son suficientes, pero los 64 bits sin signo sí lo son). Por lo tanto, no hay implementaciones reales de C que yo sepa de dónde esto satisface los requisitos de la pregunta. (Funciona correctamente conunsigned long long
, o solounsigned long
en implementaciones donde ese es un tipo de 64 bits). GNU C define__int128_t
en máquinas de 64 bits (sin encabezados) ...Perl, 31 + 2 (
-pl
bandera) =2521183433 bytesUtilizando:
Salida:
1\n
o0\n
.Gracias a @Dada por 3 bytes, Gabriel Benamy por 1 byte y @Zaid por informes de errores.
fuente
perl -pe '$_=$_**3!~/[^$_]/'
10
:(-l
bandera necesaria&&
a a*
para guardar un byteMathematica, 34 bytes
Implementación directa (función sin nombre de un argumento entero).
fuente
Jalea , 8 bytes
Pruébalo en línea! o verificar todos los casos de prueba .
Cómo funciona
fuente
CJam, 8 bytes
Banco de pruebas.
Explicación
fuente
JavaScript ES6,
5551 bytes¡Gracias a Downgoat por 3 bytes! Puede guardar un byte convirtiéndolo a ES7 y usando en
n**3
lugar den*n*n
.Suficientemente simple.
fuente
==
no funciona incluso en matrices.n*n*n
an**3
, pero supongo que podría ser ES7 y no ES6.2103869
y el problema requiere explícitamente soluciones para trabajar2642245
.C #,
241208205201193233222220212203177159 bytes (109 alternativo)Los lambda deben usar específicamente el
ulong
tipo:Gracias a @Corak y @Dennis_E por guardar algunos bytes, y @TimmyD por encontrar un problema con mi solución original. Gracias a @SaxxonPike por señalar el problema ulong / long / decimal / etc (que en realidad también me ahorró algunos bytes).
También hay una solución de 109 bytes que usa HashSets, similar a las respuestas de Java aquí, pero voy a mantener mi solución original para mi puntaje.
fuente
p<0
lugar dep==1
?n=>{Func<string,int[]>x=s=>{var a=new int[10];foreach(var c in s)a[int.Parse(c+"")]++;return a;};var i=x(n);var j=x((long)Math.Pow(int.Parse(n),3)+"");for(var k=0;k<10;)if(i[k]>0^j[k++]>0)return 0>1;return 1>0;};
int.Parse(c+"")
conc-'0'
long
lugar deulong
y este caso de prueba usa el MSB.)Java 8, 154 caracteres
Llamado así:
Salidas:
Una respuesta muy Java 8-y, usando un lambda, así como secuencias que incluyen algunas sofisticadas conversiones de número a cadena.
Desafortunadamente, necesitamos usar en
BigInteger.pow(3)
lugar deMath.pow(a,3)
debido a que Math.pow usa dobles no precisos, que devuelven valores incorrectos con números grandes (comenzando con2103869
).fuente
static Y y
cosa es una sintaxis de inicialización extraña, ¿se asigna automáticamentey.n
porque la interfaz tiene exactamente un miembro?@FunctionalInterface
anotación (interfaz con un solo método, consulte javadoc) que hace que lambdas funcione en lugar de la instanciación de tipo anónimo habitual.Y y = new Y() { @Override public boolean n(int x) { return Arrays.equals((a+"").chars().distinct().sorted().toArray(),(new BigInteger(a+"").pow(3)+"").chars().distinct().sorted().toArray()); } }
y elstatic
modificador solo está ahí para permitir llamadasy.n(int)
desde el método principal estático.GOLPETAZO,
6959 bytesACTUALIZAR
Otra buena manera de hacer esto en bash es usar tr (62 bytes, pero probablemente se puede exprimir un poco más)
EDITAR: Algunas optimizaciones más (Thx! @Manatwork)
Golfed
Prueba
0 - para éxito (código de salida) 1 - para falla (código de salida)
fuente
T <<< 11
. Dirá que los conjuntos de dígitos son los mismos solo porque 11 ** 3 == 1331 contiene los dígitos que no están presentes en el número original dos veces.-w
explícitamente afold
. Siuniq
se usa sin opciones,sort -u
puede reemplazarlo. Y alimente la segunda llamada S con here-string. Y creo que no hay necesidad de citar la fórmula pasadabc
.cmp
lugar dediff
y guardar 1 byte.Función de código de máquina x86-64, 40 bytes.
O 37 bytes si se permite 0 frente a cero como "verdadero", como strcmp.
Gracias a la respuesta C de Karl Napf para la idea de mapa de bits, que x86 puede hacer de manera muy eficiente con BTS .
Firma de la función:,
_Bool cube_digits_same(uint64_t n);
utilizando el x86-64 System V ABI. (n
en RDI, valor de retorno booleano (0 o 1) en AL)._Bool
está definido por ISO C11, y generalmente se usa#include <stdbool.h>
para definirbool
con la misma semántica que C ++bool
.Posibles ahorros:
Todo esto es posible si se tratara de un fragmento inline-asm en lugar de una función, lo que lo convertiría en 35 bytes para inline-asm .
LOOP parece ser la forma más pequeña de repetir una vez. También miré solo repetir el ciclo (sin prefijos REX y un registro de mapa de bits diferente), pero eso es un poco más grande. También intenté usar PUSH RSI y usar
test spl, 0xf
/jz
to loop una vez (ya que el ABI requiere que RSP esté alineado 16B antes de CALL, por lo que un impulso lo alinea y otro lo desalinea nuevamente). No haytest r32, imm8
codificación, por lo que la forma más pequeña fue con una instrucción 4B TEST (incluido un prefijo REX) para probar solo el byte bajo de RSP contra un imm8. Mismo tamaño que LEA + LOOP, pero con instrucciones adicionales PUSH / POP requeridas.Probado para todos los n en el rango de prueba, frente a la implementación C de steadybox (ya que utiliza un algoritmo diferente). En los dos casos de resultados diferentes que miré, mi código era correcto y el de steadybox estaba equivocado. Creo que mi código es correcto para todos los n.
Las únicas líneas impresas tienen c = 1 asm = 0: falsos positivos para el algoritmo C.
También se probó con una
uint64_t
versión de la implementación C de Karl del mismo algoritmo, y los resultados coinciden con todas las entradas.fuente
objdump -drwC -Mintel
en el archivo de objeto y copiar comentarios). Es un lenguaje donde la optimización para el tamaño del código es realmente útil en la vida real. (Pero incluso entonces, solo en casos raros como cargadores de arranque o demostraciones. Por lo general, solo vale la pena guardar el tamaño del código cuando no daña el rendimiento en el caso ya almacenado en caché, pero es útil para evitar cuellos de botella de decodificación + errores de caché)Haskell, 47 bytes
Muy lento. Prueba con
c<-['0'..'9']
.Prueba cada carácter para su inclusión en la representación de cadena de
n
, y hace una lista de los incluidos. Hace lo mismo paran^3
y comprueba si las listas son iguales.fuente
nub
(obtener elementos únicos) ysort
, pero ambos requieren una larga importaciónimport Data.List
. Aun así, se acerca mucho a las 48 bytes:import Data.List;q=sort.nub.show;f n=q n==q(n^3)
.nub
conserva el orden por primera aparición, es decirnub [3,1,3,2,1,2] == [3,1,2]
. No se convierte a un tipo de conjunto (no hay ninguno), pero proporciona una lista.Dyalog APL , 10 bytes
⍕≡
es la representación de texto del argumento idéntica a⍕∪
la unión de la representación del texto del argumento y(⍕*∘3)
la representación de texto del argumento en cubos?TryAPL en línea!
Nota: para números grandes, establezca
⎕PP←34 ⋄ ⎕FR←1287
(34 dígitos significativos, flotantes de 128 bits)fuente
Clojure, 35 bytes
fuente
Java 7,
185178 caracteresLlamar como:
Salida:
(Nunca estoy seguro si tengo que contar las importaciones y las definiciones de métodos también ... Lo he visto de cualquier manera. Sin embargo, el código en sí solo tendría 141 bytes de longitud).
fuente
static
sin embargo.static
.Jalea , 8 bytes
Pruébalo en línea!
Explicación:
fuente
*3ṢQ⁼ṢQ$
funciona según lo previsto, ya que el rápido$
agrupa los dos átomos a su izquierda en una cadena monádica.Pyth, 10 bytes
Debido a que no tenemos suficiente variedad con las respuestas de Pyth, ¡agreguemos no una, sino dos más! Ambos son de 10 bytes y se han probado con
106239
una entrada de muestra (que algunas otras respuestas fallaron).Explicación:
Pruebe la primera respuesta con un conjunto de pruebas en línea.
Segunda respuesta:
Explicación:
Pruebe la segunda respuesta con un conjunto de pruebas en línea.
fuente
Kotlin: 46/88/96 bytes
La pregunta no especifica de dónde proviene la entrada, así que aquí están las 3 fuentes de entrada habituales.
Función: 46 bytes.
main () usando el primer argumento del programa: 88 bytes
fun main(a:Array<String>){val i=a[0].toLong();println("$i".toSet()=="${i*i*i}".toSet())}
main () usando entrada estándar: 96 bytes
fun main(a:Array<String>){val i=readLine()!!.toLong();println("$i".toSet()=="${i*i*i}".toSet())}
fuente
Haskell,
5452 bytesGracias @Laikoni por guardar dos bytes.
fuente
a%b=all(
elema)b
como una función y luego llamar conb%a&&a%b
debería ahorrar dos bytes.JavaScript (ES6), 44 bytes
Puerto de la excelente respuesta C de @ KarlNapf. ES7 guarda un byte a través de
n**3
. Solo funciona hasta 208063 debido a la precisión numérica limitada de JavaScript; Si solo necesita que funcione hasta 1290, puede guardar otro byte.fuente
Perl 6 , 22 bytes
Expandido:
El operador de diferencia de conjunto simétrico 「⊖」 devuelve un conjunto vacío si ambos lados son conjuntos equivalentes (convierte automáticamente una lista en un conjunto). En ese punto, lo único que queda por hacer es invertirlo lógicamente.
fuente
$_
con solo.
C ++, 82 bytes
La función t (a) devuelve la respuesta. Utiliza un int como conjunto. Impreso muy bien:
fuente
#include<set>
yusing namespace std;
en el código de golf y el conteo de bytes#include<set>
lugar dealgorithm
R,
657970 bytesToma
n
de stdin, dividen
y dividen^3
en un solo dígito, y compara los dos conjuntos. Utiliza elgmp
paquete para manejar enteros grandes (gracias a Billywob por señalar esa deficiencia). Ahora se usasubstring
para cortarn
yn^3
, gracias a @MickyT por la sugerencia. (Versiones anteriores utilizadasscan
ygsub
de una manera hacky).fuente
n
) a menos que use algún tipo de paquete BigInt. Consulte?.Machine
para obtener detalles sobre el número entero más grande y flotante, etc. Para ver esta comparación, por ejemplo,2600001^3
en R a wolframalphagmp
paquete podría resolver este problema.gmp::as.bigz()
para manejar enteros grandes.s=substring;setequal(s(n<-gmp::as.bigz(scan()),p<-1:1e4,p),s(n^3,p,p))
substring
podría usarse de esa manera (solo lo he usado alguna vezsubstr
). La respuesta ha sido editada para incorporar su sugerencia ahora.C ++ 14, 93 bytes
El puerto de mi respuesta C , funciona para números grandes (llamada con
L
sufijo).fuente
Haskell, 47 bytes
Ejemplo de uso:
f 102343
->False
.Utiliza conjuntos del
Data.Set
módulo. La función auxiliars
convierte un número en su representación de cadena y luego crea un conjunto de caracteres.fuente
s$n^3
?(s n==s) (n^3)
que da un error de tipo.Brachylog , 11 bytes
Pruébalo en línea!
Gracias a @DestructibleWatermelon por señalar un problema con mi respuesta original.
Explicación
fuente
PowerShell v2 +,
9493 bytes(Nueva línea para mayor claridad, no incluida en el bytecount)
La primera línea se define
f
comofilter
(lo suficientemente similar a una función para nuestros propósitos aquí como para no entrar en detalles) que toma información$n
y hace lo siguiente:La segunda línea toma la entrada
$args
, realizaf
en ella y verifica si es-eq
realf
realizarla en$x
cubos. Tenga en cuenta el[bigint]
reparto explícito , de lo contrario, obtendremos el resultado en notación científica, lo que obviamente no funcionará.El resultado booleano se deja en la tubería y la salida es implícita.
Guardado un byte gracias a @ConnorLSW
fuente
"$n"[0..99]
lugar de[char[]]"$n"
guardar un byte, ya que el mayor número con el que tendrá que lidiar es de solo 20 caracteres de longitud.char[]
conversión normal , el resto de su código es tan bueno como podría obtenerlo, si hubiera una forma abreviada de comparar matrices, podría usa algo como("$n"[0..99]|group).Name
ahorrar cargas, perocompare
no es exactamente rápido y fácil jugar al golf.Groovy, 35
51caracteres / bytesMe entristeció no ver a Groovy incluido, así que aquí está mi intento original de 51 bytes:
def x(def n){"$n".toSet()=="${n.power(3)}".toSet()}
Reescrito como un cierre anónimo de 35 bytes y con
**
exponenciación, gracias a manatwork:{"$it".toSet()=="${it**3}".toSet()}
Algunos casos de prueba para la función original:
Un cierre llamada
c
podría ser llamado como esto:println c.call(107624)
. El cierre anónimo de 35 bytes podría llamarse así:println ({"$it".toSet()=="${it**3}".toSet()}(107624))
Salidas:
Tenga en cuenta: aprendí que algo como el golf de código existe en este momento, ¡así que espero haberlo hecho bien!
fuente
def c={"$it".toSet()=="${it.power(3)}".toSet()}
**
operador para exponenciación.x(107624)
conc.call(107624)
**
lo reduce a hermosos 35 caracteres / bytes:{"$it".toSet()=="${it**3}".toSet()}
Ruby, 48 bytes
fuente