Dado un número n (0 <= n <= 2.642.245), de verificación si n y n ³ 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 ³ 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.

OEIS A029795

Python 3, 36 32 bytes

lambda x:{*str(x)}=={*str(x**3)}

Creo que esto solo funciona en Python 3.5 y versiones posteriores. Se han ido cuatro bytes, gracias a Copper.

05AB1E , 6 bytes

05AB1E utiliza la codificación CP-1252 .

3mê¹êQ

Pruébalo en línea!

Explicación

3m       # input^3
  ê      # sorted with duplicates removed
     Q   # is equal to
   ¹ê    # input sorted with duplicates removed

C, 73 bytes

k;b(i){k=0;while(i)k|=1<<i%10,i/=10;return k;}f(n){return b(n)-b(n*n*n);}

Crea el conjunto a través de bits. Devuelve 0para el mismo conjunto, cualquier otra cosa para diferentes conjuntos.

Sin golf:

k;
b(i){
  k=0;
  while(i)
    k|=1<<i%10,
    i/=10;
  return k;
}

f(n){
  return b(n)-b(n*n*n);
}

Perl, 31 + 2 ( -plbandera) = 25 21 18 34 33 bytes

$_=($==$_**3)!~/[^$_]/*!/[^$=]/

Utilizando:

perl -ple '$_=($==$_**3)!~/[^$_]/*!/[^$=]/' <<< 251894

Salida: 1\no 0\n.

Gracias a @Dada por 3 bytes, Gabriel Benamy por 1 byte y @Zaid por informes de errores.

Mathematica, 34 bytes

f=Union@*IntegerDigits;f@#==f[#^3]&

Implementación directa (función sin nombre de un argumento entero).

Jalea , 8 bytes

,3*\D‘ṬE

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo funciona

,3*\D‘ṬE  Main link. Argument: n

,3        Pair; yield [n, 3].
  *\      Cumulative reduce by exponentation. Yields [n, n³].
    D     Decimal; yield the digit arrays of n and n³.
     ‘    Increment, mapping 0 ... 9 to 1 ... 10.
      Ṭ   Untruth (vectorizes); map digit array [a, b, c, ...] to the smallest
          of zeroes with ones at indices a, b, c, ...
       E  Test the results for equality.

CJam, 8 bytes

l_~3#s^!

Banco de pruebas.

Explicación

l   e# Read input.
_~  e# Duplicate and evaluate.
3#  e# Raise to third power.
s   e# Convert back to string.
^   e# Symmetric set difference. Gives an empty list iff the two sets
    e# are equal.
!   e# Logical NOT.

JavaScript ES6, 55 51 bytes

¡Gracias a Downgoat por 3 bytes! Puede guardar un byte convirtiéndolo a ES7 y usando en n**3lugar de n*n*n.

n=>(f=s=>[...new Set(s+[])].sort()+[])(n)==f(n*n*n)

Suficientemente simple.

C #, 241 208 205 201 193 233 222 220 212 203 177 159 bytes (109 alternativo)

I=>{x=s=>{var a=new int[10];foreach(var h in s+"")a[h-'0']++;return a;};var i=x(I);var j=x(I*I*I);for(var k=0;k<10;)if(i[k]>0^j[k++]>0)return 0>1;return 1>0;};

Los lambda deben usar específicamente el ulongtipo:

System.Func<ulong, bool> b; // = I=>{...};
System.Func<ulong, int[]> x; // inner lambda

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.

using System.Collections.Generic;I=>{return new HashSet<char>(I+"").SetEquals(new HashSet<char>(I*I*I+""));};

Java 8, 154 caracteres

a->java.util.Arrays.equals((a+"").chars().distinct().sorted().toArray(),(new java.math.BigInteger(a+"").pow(3)+"").chars().distinct().sorted().toArray());

Llamado así:

interface Y {
    boolean n(int x);
}

static Y y = a->java.util.Arrays.equals((a+"").chars().distinct().sorted().toArray(),(new java.math.BigInteger(a+"").pow(3)+"").chars().distinct().sorted().toArray());

public static void main(String[] args) {
    System.out.println(y.n(0));
    System.out.println(y.n(1));
    System.out.println(y.n(10));
    System.out.println(y.n(107624));
    System.out.println(y.n(251894));
    System.out.println(y.n(251895));
    System.out.println(y.n(102343));
}

Salidas:

true
true
true
true
true
false
false

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 de Math.pow(a,3)debido a que Math.pow usa dobles no precisos, que devuelven valores incorrectos con números grandes (comenzando con 2103869).

GOLPETAZO, 6959 bytes

ACTUALIZAR

Otra buena manera de hacer esto en bash es usar tr (62 bytes, pero probablemente se puede exprimir un poco más)

T() { m=`bc<<<$1^3`;[ -z "`tr -d $m <<<$1;tr -d $1 <<<$m`" ];}

EDITAR: Algunas optimizaciones más (Thx! @Manatwork)

Golfed

T() { S(){ fold -1|sort -u;};bc<<<$1^3|S|diff - <(S<<<$1);}

Prueba

TEST() {
 T $1 >/dev/null; echo $?
}

TEST 0
0
TEST 1
0
TEST 11
1
TEST 10
0
TEST 107624
0
TEST 251894
0
TEST 251895
1
TEST 102343
1
TEST 106239
1

0 - para éxito (código de salida) 1 - para falla (código de salida)

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. ( nen RDI, valor de retorno booleano (0 o 1) en AL).

_Boolestá definido por ISO C11, y generalmente se usa #include <stdbool.h>para definir boolcon la misma semántica que C ++ bool.

Posibles ahorros:

• 3 bytes: devuelve la condición inversa (distinta de cero si hay una diferencia). O desde asm en línea: devolver una condición de marca (que es posible con gcc6)
• 1 byte: si pudiéramos clobber EBX (hacerlo le daría a esta función una convención de llamada no estándar). (podría hacer eso desde inm asm)
• 1 byte: la instrucción RET (desde inm asm)

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 .

0000000000000000 <cube_digits_same>:
   0:   89 f8           mov    eax,edi
   2:   48 f7 e7        mul    rdi          # can't avoid a REX prefix: 2642245^2 doesn't fit in 32 bits
   5:   48 f7 e7        mul    rdi          # rax = n^3, rdx=0
   8:   44 8d 52 0a     lea    r10d,[rdx+0xa]  # EBX would save a REX prefix, but it's call-preserved in this ABI.
   c:   8d 4a 02        lea    ecx,[rdx+0x2]

000000000000000f <cube_digits_same.repeat>:
   f:   31 f6           xor    esi,esi

0000000000000011 <cube_digits_same.cube_digits>:
  11:   31 d2           xor    edx,edx
  13:   49 f7 f2        div    r10         ; rax = quotient.  rdx=LSB digit
  16:   0f ab d6        bts    esi,edx     ; esi |= 1<<edx
  19:   48 85 c0        test   rax,rax     ; Can't skip the REX: (2^16 * 10)^3 / 10 has all-zero in the low 32.
  1c:   75 f3           jne    11 <cube_digits_same.cube_digits>

                                         ; 1st iter:                 2nd iter:                both:
  1e:   96              xchg   esi,eax   ; eax=n^3 bitmap            eax=n bitmap             esi=0
  1f:   97              xchg   edi,eax   ; edi=n^3 bitmap, eax=n     edi=n bmp, eax=n^3 bmp
  20:   e2 ed           loop   f <cube_digits_same.repeat>

  22:   39 f8           cmp    eax,edi
  24:   0f 94 d0        sete   al
                  ;; The ABI says it's legal to leave garbage in the high bytes of RAX for narrow return values
                  ;; so leaving the high 2 bits of the bitmap in AH is fine.
  27:   c3              ret    
0x28: end of function.

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/ jzto 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 hay test r32, imm8codificació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.

_Bool cube_digits_same(unsigned long long n);

#include <stdio.h>
#include <stdbool.h>
int main()
{
    for(unsigned n=0 ; n<= 2642245 ; n++) {
        bool c = f(n);
        bool asm_result = cube_digits_same(n);
        if (c!=asm_result)
            printf("%u problem: c=%d asm=%d\n", n, (int)c, (int)asm_result);
    }
}

Las únicas líneas impresas tienen c = 1 asm = 0: falsos positivos para el algoritmo C.

También se probó con una uint64_tversión de la implementación C de Karl del mismo algoritmo, y los resultados coinciden con todas las entradas.

Haskell, 47 bytes

n%p=[c|c<-['0'..],elem c$show$n^p]
f n=n%1==n%3

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 para n^3y comprueba si las listas son iguales.

Dyalog APL , 10 bytes

⍕≡⍕∪(⍕*∘3)

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

Clojure, 35 bytes

#(=(set(str %))(set(str(* % % %))))

Java 7, 185 178 caracteres

import java.util.*;
boolean a(int n){return new HashSet(Arrays.asList((n+"").split(""))).equals(new HashSet(Arrays.asList((new java.math.BigInteger(n+"").pow(3)+"").split(""))));}

Llamar como:

public static void main(String [] args) {
    System.out.println(0 + " -> " + a(0));
    System.out.println(1 + " -> " + a(1));
    System.out.println(10 + " -> " + a(10));
    System.out.println(107624 + " -> " + a(107624));
    System.out.println(2103869 + " -> " + a(2103869));
    System.out.println(251894 + " -> " + a(251894));
    System.out.println(251895 + " -> " + a(251895));
    System.out.println(102343 + " -> " + a(102343));
    System.out.println(106239 + " -> " + a(106239));
}

Salida:

0 -> true
1 -> true
10 -> true
107624 -> true
2103869 -> true
251894 -> true
251895 -> false
102343 -> false
106239 -> false

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

Jalea , 8 bytes

*3ṢQ⁼ṢQ$

Pruébalo en línea!

Explicación:

       $    # As a monadic (single argument) link:
    ⁼       # Return true if the following are equal
     ṢQ     # The unique sorted elements of 'n'
  ṢQ        # and The unique sorted elements
*3          # of 'n^3'

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 106239una entrada de muestra (que algunas otras respuestas fallaron).

!s.++Q,`**

Explicación:

!s.++Q,`**QQQQ   Implicit input filling
        **QQQ    Q ^ 3
       `         repr(Q^3)
      ,      Q   [repr(Q^3),Q]
    +Q           [Q,repr(Q^3),Q]
  .+             Deltas ([Digits in Q but not in Q^3, digits in Q^3 but not in Q])
!s               Are both empty?

Pruebe la primera respuesta con un conjunto de pruebas en línea.

Segunda respuesta:

qFmS{`d,**

Explicación:

qFmS{`d,**QQQQ   Implicit input filling
        **QQQ    Q ^ 3
       ,     Q   [Q^3, Q]
  m              map over each element d of [Q^3, Q]:
     `d           the element's string representation
    {             with duplicates removed
   S              and sorted
qF               Fold over equality (are the two the same?)

Pruebe la segunda respuesta con un conjunto de pruebas en línea.

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.

fun f(i:Long)="$i".toSet()=="${i*i*i}".toSet()

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

Haskell, 54 52 bytes

Gracias @Laikoni por guardar dos bytes.

(%)=all.flip elem
k n|[a,b]<-show<$>[n,n^3]=b%a&&a%b

JavaScript (ES6), 44 bytes

g=n=>n<1?0:g(n/10)|1<<n%10
n=>g(n)==g(n*n*n)

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.

Perl 6 , 22 bytes

{!(.comb⊖$_³.comb)}

Expandido:

{ # bare block lambda with implicit parameter ｢$_｣
  !(
    .comb # get a list of the graphemes ( digits )

    ⊖ # Symmetric Set difference

    $_³.comb # cube and get a list of the graphemes
  )
}

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.

C ++, 82 bytes

t(int a){int b=a*a*a,c,d;while(a|b)c|=1<<a%10,a/=10,d|=1<<b%10,b/=10;return c==d;}

La función t (a) devuelve la respuesta. Utiliza un int como conjunto. Impreso muy bien:

t(int a)
{
    int b = a*a*a, c, d;
    while(a|b) c|=1 << a%10, a/=10, d|=1 << b%10, b/=10;
    return c==d;
}

R, 65 79 70 bytes

Toma nde stdin, divide ny divide n^3en un solo dígito, y compara los dos conjuntos. Utiliza el gmppaquete para manejar enteros grandes (gracias a Billywob por señalar esa deficiencia). Ahora se usa substringpara cortar ny n^3, gracias a @MickyT por la sugerencia. (Versiones anteriores utilizadas scany gsubde una manera hacky).

s=substring
setequal(s(n<-gmp::as.bigz(scan()),p<-1:1e2,p),s(n^3,p,p))

C ++ 14, 93 bytes

int b(auto i){int k=0;while(i)k|=1<<i%10,i/=10;return k;}int f(auto n){return b(n)-b(n*n*n);}

El puerto de mi respuesta C , funciona para números grandes (llamada con Lsufijo).

Haskell, 47 bytes

import Data.Set
s=fromList.show
f n=s n==s(n^3)

Ejemplo de uso: f 102343-> False.

Utiliza conjuntos del Data.Setmódulo. La función auxiliar sconvierte un número en su representación de cadena y luego crea un conjunto de caracteres.

Brachylog , 11 bytes

doI,?:3^doI

Pruébalo en línea!

Gracias a @DestructibleWatermelon por señalar un problema con mi respuesta original.

Explicación

(?)doI,           I is the Input sorted with no duplicates
       ?:3^       Compute Input^3
           doI    Input^3 sorted with no duplicates is I

PowerShell v2 +, 94 93 bytes

filter f($n){-join("$n"[0..99]|sort|select -u)}
(f($x=$args[0]))-eq(f("[bigint]$x*$x*$x"|iex))

(Nueva línea para mayor claridad, no incluida en el bytecount)

La primera línea se define fcomo filter(lo suficientemente similar a una función para nuestros propósitos aquí como para no entrar en detalles) que toma información $ny hace lo siguiente:

filter f($n){-join("$n"[0..99]|sort|select -u)}
       f($n)                                    # Input
                   "$n"                         # Cast as string
                       [0..99]                  # Index as char-array
                              |sort             # Sorted alphabetically
                                   |select -u   # Only select the -Unique elements
             -join(                          )  # Join those back together into a string
                                                 # Implicit return

La segunda línea toma la entrada $args, realiza fen ella y verifica si es -eqreal frealizarla en $xcubos. 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.

PS C:\Tools\Scripts\golfing> 0,1,10,107624,251894,251895,102343,106239,2103869|%{"$_ --> "+(.\do-n-n3-same-digits.ps1 $_)}
0 --> True
1 --> True
10 --> True
107624 --> True
251894 --> True
251895 --> False
102343 --> False
106239 --> False
2103869 --> True

Guardado un byte gracias a @ConnorLSW

Groovy, 35 51 caracteres / bytes

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

println x(0)
println x(1)
println x(10)
println x(107624)
println x(251894)
println x(251895)
println x(102343)

Un cierre llamada cpodrí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:

true
true
true
true
true
false
false

Tenga en cuenta: aprendí que algo como el golf de código existe en este momento, ¡así que espero haberlo hecho bien!

Ruby, 48 bytes

->n{(f=->x{x.to_s.chars.uniq.sort})[n]==f[n**3]}