¿N y n ^ 3 tienen el mismo conjunto de dígitos?

52

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 , por lo que gana el código con la menor cantidad de bytes.

OEIS A029795

Oliver Ni
fuente
28
Caso de prueba propuesto: 106239
Dennis
8
Caso de prueba: 2103869 -> True. Esto (o uno más grande) es necesario para probar un idioma con un longtipo de datos.
mbomb007
55
Lástima que el máximo es demasiado grande para el lenguaje sin un tipo entero de 64 bits.
edc65
17
Creo que deberías ser explícito sobre la base ... en binario es un poco la mitad de la diversión :-D
The Vee
77
@ ZoltánSchmidt 106239 es el número entero positivo más pequeño n tal que - 1199090390129919 - no contiene todos los dígitos de n . Algunas respuestas solo verificaban si n contenía todos los dígitos de y, por lo tanto, obtenía el resultado incorrecto para 106239 .
Dennis

Respuestas:

28

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.

0WJYxW9FMN
fuente
8
En python 2 puede usar backtics como acceso directo para repr (), ahorrando 6 bytes. set(`x`)
DenDenDo
99
@DenDenDo Cualquier entrada mayor que 2097152( sys.maxint**(1/3.)) y menor que sys.maxint+1volverá Falsesi la usa repr(). repl.it/EXs2/1 . Los largos tienen un Lfinal.
mbomb007
99
No probado, pero probablemente puedas hacerlo lambda x:{*str(x)}=={*str(x**3)}en Python 3.5+.
Cobre
1
@BenHoyt Es más conciso que usar print (...) y input (). Hacer que sea una función es más corto que hacer un programa completo.
0WJYxW9FMN
1
Como la pregunta dice que devolver un valor verdadero o falso es suficiente, puede reemplazarlo ==por ^. Dos conjuntos iguales conducen a lo {}que es falso.
RemcoGerlich
19

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
Emigna
fuente
1
@PuzomorCroatia: 05AB1E usa la codificación CP-1252 , por lo que todos estos caracteres son de 1 byte cada uno. Es bastante común que los idiomas de golf usen páginas de códigos con más caracteres imprimibles que UTF-8 o, alternativamente, creen su propia página de códigos.
Emigna
77
Gracias por la respuesta. Lamentablemente, al intentar editar mi comentario, lo eliminé. Sólo para dejar las cosas claras a todo el mundo, le pregunté acerca de la codificación de caracteres en idiomas de golf de código
Puzomor Croacia
14

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);
}
Karl Napf
fuente
Falta el código no protegido 1 <<al configurar los bits con k |= 1 << i % 10. Gran solución!
1Darco1
1
Usé esta idea de mapa de bits para hacer una función de código de máquina x86-64 de 39 bytes :)
Peter Cordes
¿Se nos permite considerarlo 0como verdadero? Supongo strcmpque funciona de esa manera, por lo que parece razonable en C.
Peter Cordes
1
Esto solo funciona para todo el rango de entradas requerido por la pregunta si es intmayor 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 con unsigned long long, o solo unsigned longen implementaciones donde ese es un tipo de 64 bits). GNU C define __int128_ten máquinas de 64 bits (sin encabezados) ...
Peter Cordes
8

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.

Denis Ibaev
fuente
1
¡Buena respuesta! Todavía puede guardar algunos (3) bytes:perl -pe '$_=$_**3!~/[^$_]/'
Dada
@Zaid Thanx. Fijo.
Denis Ibaev
Ahora da como resultado falso para 10:(
Zaid
@Zaid Sip. -lbandera necesaria
Denis Ibaev
2
Cambie el &&a a *para guardar un byte
Gabriel Benamy
7

Mathematica, 34 bytes

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

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

Greg Martin
fuente
7

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.
Dennis
fuente
6

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.
Martin Ender
fuente
6

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.

Conor O'Brien
fuente
es terrible que no haya una mejor manera de comparar conjuntos para la equivalencia
njzk2
1
@ njzk2 Bueno, yo diría que la mayor tragedia es que ==no funciona incluso en matrices.
Conor O'Brien
Puede guardar un byte cambiando n*n*na n**3, pero supongo que podría ser ES7 y no ES6.
Robert Hickman
1
@Downgoat ¡Gracias, eso me inspiró a guardar más bytes!
Conor O'Brien el
3
Esto falla 2103869y el problema requiere explícitamente soluciones para trabajar 2642245.
user5090812
6

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+""));};
Yodle
fuente
¿Puedes comprobar en p<0lugar de p==1?
Yytsi
@TuukkaX Habría hecho eso, pero la forma en que estoy determinando los conjuntos ahora es usando la misma matriz de enteros, incrementando el índice apropiado para ambas cadenas, por lo que un valor de 0 o 2 está bien, pero si alguno es 1, Debería devolver falso.
Yodle
Ahorre muy poco extrayendo la creación y el llenado de las matrices en una lambda separada: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;};
Corak
Puede reemplazar int.Parse(c+"")conc-'0'
Dennis_E
Falla el caso de prueba 2103869. Me encontré con el mismo problema. (No importa, descubrí por qué. Había usado un en longlugar de ulongy este caso de prueba usa el MSB.)
SaxxonPike
6

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

Hypino
fuente
Esa static Y ycosa es una sintaxis de inicialización extraña, ¿se asigna automáticamente y.nporque la interfaz tiene exactamente un miembro?
gato
Yo creo que sí. Para ser honesto, soy nuevo en Java 8 ya que mi lugar de trabajo todavía está en 7, pero así es como lo percibo.
Hypino
El compilador agrega automáticamente la @FunctionalInterfaceanotació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.
1Darco1
Esto es esencialmente igual a 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 el staticmodificador solo está ahí para permitir llamadas y.n(int)desde el método principal estático.
1Darco1
1
No importa, solo lea la meta publicación sobre esto y parece que la comunidad está de acuerdo. Supongo que puedo ver por qué. Voy a actualizar.
Hypino
6

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)

zepelín
fuente
Me temo que la teoría básica está completamente equivocada aquí. Tratar 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.
manatwork
Sí, tienes razón, ¡arreglado! Gracias !
zeppelin
Ok, pero ahora quedan algunos espacios adicionales en el código. No estoy seguro de por qué agregaste -wexplícitamente a fold. Si uniqse usa sin opciones, sort -upuede reemplazarlo. Y alimente la segunda llamada S con here-string. Y creo que no hay necesidad de citar la fórmula pasada bc.
manatwork el
@manatwork, thx, arreglé el argumento de plegado, eliminé espacios e hice que el segundo argumento diff usara un documento aquí. Ahora también canalizo el primer argumento en diff , y eliminé las comillas superfluas alrededor de la expresión bc . > uniq se usa sin opciones, sort -u puede reemplazarlo. Eso es solo un remanente de la versión anterior (era uniq -u )). Gracias !
zeppelin
1
@zeppelin: puede usar en cmplugar de diffy guardar 1 byte.
Ipor Sircer
6

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.

Peter Cordes
fuente
Código de golf en código de máquina ? Eso es verdadero dominio!
chx
@chx: Realmente está en lenguaje ensamblador, optimizando el tamaño del código. No escribo los bytes hexadecimales directamente, solo sé (o verifico) qué tamaño tiene cada instrucción. (Lo que publiqué es de ensamblar con yasm y luego ejecutar objdump -drwC -Mintelen 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é)
Peter Cordes
@chx: pero sí, jugar al golf en el asm me hace sentir como un rudo, gracias por notar :) Mira mis otras respuestas, aquí y en SO :)
Peter Cordes
Soy un sombrero muy viejo en la asamblea (1987, Z80 fue el primero) pero nunca hubiera pensado entrar en el código de golf con eso. Hubiera pensado imposible.
chx
@chx: solo juego golf de vez en cuando, generalmente solo cuando veo una en Hot Network Questions que parece razonable para asm. Por lo general, cosas con números, no cadenas. Sin embargo, algunas otras personas practican golf en el asm. No había pensado en hacerlo hasta que vi la respuesta de golf de código máquina de otra persona. Podría haber sido este el que me dio una idea del hecho de que puede contar bytes de código de máquina en lugar de caracteres de fuente asm para respuestas asm. anatolyg ha publicado algunos, incluso sobre esta pregunta.
Peter Cordes
5

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.

xnor
fuente
¿Haskell no tiene literales establecidos o una función que devuelve los elementos únicos de una lista?
gato
2
@cat No. Haskell tiene nub(obtener elementos únicos) y sort, pero ambos requieren una larga importación import 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).
xnor
¿Por qué la necesidad de ordenar ...?
gato
1
@cat nubconserva el orden por primera aparición, es decir nub [3,1,3,2,1,2] == [3,1,2]. No se convierte a un tipo de conjunto (no hay ninguno), pero proporciona una lista.
xnor
Oh, nunca me di cuenta de que Haskell no tiene un tipo de colección desordenada primitiva, eso tiene sentido
cat
5

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)

Adán
fuente
1
¿Asume que los dígitos únicos en n ^ 3 no pueden ser menos que los de n?
ngn
¿Puedes probar la existencia de un contraejemplo?
Adám
1
106239, ver comentarios en la parte superior
ngn
5

Clojure, 35 bytes

#(=(set(str %))(set(str(* % % %))))
MattPutnam
fuente
5

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

QBrute
fuente
Las importaciones / usos son de hecho parte del recuento de bytes. Puede eliminar el static sin embargo.
Kevin Cruijssen
Bien gracias. Eliminado static.
QBrute
4

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'
DJMcMayhem
fuente
Esto no funciona con la entrada 100 .
Dennis
Entiendo por qué no, pero ¿por qué esto no funciona ?
DJMcMayhem
1
Porque Jelly se analiza estrictamente de izquierda a derecha, sin precedencia del operador. *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.
Dennis
4

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.

Steven H.
fuente
4

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

F. George
fuente
1
Bienvenido a PPCG! La entrada / salida se especifica implícitamente debido al código-golf . Puede ver los estándares de consenso de la comunidad aquí . Su recuento de funciones debería ser suficiente.
AdmBorkBork
4

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
Angs
fuente
1
Declarar a%b=all(elem a)bcomo una función y luego llamar con b%a&&a%bdebería ahorrar dos bytes.
Laikoni
4

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.

Neil
fuente
4

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.

Brad Gilbert b2gills
fuente
Puede reemplazar el $_con solo.
Jo King
4

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;
}
J. Antonio Perez
fuente
Debe incluir #include<set>y using namespace std;en el código de golf y el conteo de bytes
cat
@cat en #include<set>lugar dealgorithm
Karl Napf
@KarlNapf oh, pensé que todos los contenedores stdlib eran accesibles a través del algoritmo - muestra lo que sé sobre C ++ :)
cat
Me parece que la variable local de la función "c" no se inicializa sino que se usa c | = 1 ...
RosLuP
4

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))
rturnbull
fuente
Lamentablemente, esto no funcionará (para grandes n) a menos que use algún tipo de paquete BigInt. Consulte ?.Machinepara obtener detalles sobre el número entero más grande y flotante, etc. Para ver esta comparación, por ejemplo, 2600001^3en R a wolframalpha
Billywob
Nunca tuve que usarlo yo mismo, pero parece que el gmppaquete podría resolver este problema.
Billywob
Ah, buena captura! He actualizado la respuesta, ahora se usa gmp::as.bigz()para manejar enteros grandes.
rturnbull
podría utilizar el hecho de que la subcadena se convierte en un carácter para dividir el número, por ejemplos=substring;setequal(s(n<-gmp::as.bigz(scan()),p<-1:1e4,p),s(n^3,p,p))
MickyT
@MickyT ¡Fantástica sugerencia! No sabía que substringpodría usarse de esa manera (solo lo he usado alguna vez substr). La respuesta ha sido editada para incorporar su sugerencia ahora.
rturnbull
4

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

Karl Napf
fuente
3

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.

nimi
fuente
¿No puedes guardar un byte aquí usando s$n^3?
@ ais523: No, porque se traduce a lo (s n==s) (n^3)que da un error de tipo.
nimi
3

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
Fatalizar
fuente
Me gusta el gato sonriente en esto: 3
QBrute
3

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

AdmBorkBork
fuente
puede usar en "$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.
colsw
@ConnorLSW Ahí está ese truco de indexación nuevamente. Voy a necesitar recordar eso.
AdmBorkBork
siempre y cuando se garantice que está usando menos de 100 caracteres, es un ahorro bastante fácil sobre la 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).Nameahorrar cargas, pero compareno es exactamente rápido y fácil jugar al golf.
colsw
Eso es lo que obtengo por resolverlo sin mirar las respuestas ... Más o menos la misma respuesta ;-). Pero te perdiste algunas optimizaciones muy obvias ;-)
Joey
3

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!

Rado
fuente
¡Hola Rado y bienvenido a PPCG! ¡Esta es una gran primera respuesta, +1!
NoOneIsHere
Logré exprimirlo aún más a 47 caracteres / bytes usando un cierre, pero no puedo editar mi respuesta anterior debido a que soy nuevo aquí, así que aquí está:def c={"$it".toSet()=="${it.power(3)}".toSet()}
Rado
1
Las funciones anónimas son aceptables. Y use el **operador para exponenciación.
manatwork
Gracias @NoOneIsHere! Además, llamar al cierre para casos de prueba implicaría reemplazar x(107624)conc.call(107624)
Rado
Gracias @manatwork! Usando un cierre anónimo y **lo reduce a hermosos 35 caracteres / bytes:{"$it".toSet()=="${it**3}".toSet()}
Rado
2

Ruby, 48 bytes

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