Dado um número n (0 <= n <= 2642245), verifique se n e n ³ têm o mesmo conjunto de dígitos e produza um valor de verdade ou falsey de acordo.

Por exemplo, vamos verificar o número 100.

100 ³ é 1000000.

O conjunto de dígitos em 100 é {0, 1}.

O conjunto de dígitos em 1000000 é {0, 1}.

Portanto, 100 deve fornecer um valor verdadeiro.

Casos de teste

0 -> True
1 -> True
10 -> True
107624 -> True
251894 -> True
251895 -> False
102343 -> False

Lembre-se, isso é código-golfe , então o código com o menor número de bytes vence.

OEIS A029795

Python 3, 36 32 bytes

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

Eu acho que isso só funciona no Python 3.5 e posterior. Quatro bytes se foram, graças ao Copper.

05AB1E , 6 bytes

05AB1E usa a codificação CP-1252 .

3mê¹êQ

Experimente online!

Explicação

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

Cria o conjunto via bits. Retorna 0para o mesmo conjunto, qualquer outra coisa para conjuntos diferentes.

Ungolfed:

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 ( -plsinalizador) = 25 21 18 34 33 bytes

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

Usando:

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

Saída: 1\nou 0\n.

Thanx para @Dada por 3 bytes, Gabriel Benamy por 1 byte e @Zaid para relatórios de erros.

Mathematica, 34 bytes

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

Implementação direta (função sem nome de um argumento inteiro).

Geléia , 8 bytes

,3*\D‘ṬE

Experimente online! ou verifique todos os casos de teste .

Como 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^!

Suíte de teste.

Explicação

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

Obrigado ao Downgoat por 3 bytes! Você pode salvar um byte convertendo para o ES7 e usando em n**3vez de n*n*n.

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

Simples o suficiente.

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;};

Os lambda devem usar especificamente o ulongtipo:

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

Agradeço a @Corak e @Dennis_E por salvar alguns bytes e @TimmyD por encontrar um problema com minha solução original. Agradeço ao @SaxxonPike por apontar o problema ulong / long / decimal / etc (que na verdade também me salvou alguns bytes).

Há também uma solução de 109 bytes usando o HashSets, semelhante às respostas Java aqui, mas vou manter a minha solução original para a minha pontuação.

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

Chamado assim:

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

Saídas:

true
true
true
true
true
false
false

Uma resposta muito Java 8-y, usando um lambda, bem como fluxos, incluindo algumas conversões sofisticadas de número para string.

Infelizmente, precisamos usar em BigInteger.pow(3)vez de Math.pow(a,3)usar Math.pow usando dobras não precisas, que retornam valores incorretos com números grandes (começando com 2103869).

BATER, 69, 59 bytes

ATUALIZAR

Outra boa maneira de fazer isso no bash é usar tr (62 bytes, mas provavelmente pode ser espremido um pouco mais)

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

EDIT: Mais algumas otimizações (Thx! @Manatwork)

Golfe

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

Teste

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 sucesso (código de saída) 1 - para falha (código de saída)

função de código de máquina x86-64, 40 bytes.

Ou 37 bytes, se 0 vs. diferente de zero for permitido como "verdade", como strcmp.

Graças à resposta C de Karl Napf para a idéia de bitmap, que o x86 pode fazer de maneira muito eficiente com o BTS .

Assinatura da função:, _Bool cube_digits_same(uint64_t n);usando o x86-64 System V ABI. ( nem RDI, valor de retorno booleano (0 ou 1) em AL).

_Boolé definido pela ISO C11 e normalmente é usado #include <stdbool.h>para definir boolcom a mesma semântica que o C ++ bool.

Potencial de economia:

• 3 bytes: retornando a condição inversa (diferente de zero, se houver alguma diferença). Ou do asm inline: retornando uma condição de flag (possível com o gcc6)
• 1 byte: se pudéssemos derrotar o EBX (isso daria a essa função uma convenção de chamada não padrão). (poderia fazer isso de inline asm)
• 1 byte: a instrução RET (do inline asm)

Tudo isso é possível se esse fosse um fragmento inline-asm em vez de uma função, o que tornaria 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 a menor maneira de repetir uma vez. Também observei apenas a repetição do loop (sem prefixos REX e um registro de bitmap diferente), mas isso é um pouco maior. Eu também tentei usar PUSH RSI e usar test spl, 0xf/ jzpara fazer loop uma vez (uma vez que a ABI exige que o RSP seja 16B alinhado antes de CALL, então um empurrão o alinha e outro desalinha novamente). Não há test r32, imm8codificação; portanto, a menor maneira foi com uma instrução 4B TEST (incluindo um prefixo REX) para testar apenas o byte baixo do RSP contra um imm8. Mesmo tamanho que LEA + LOOP, mas com instruções extras de PUSH / POP necessárias.

Testado para todos os n na faixa de teste, em comparação à implementação C do stablebox (já que ele usa um algoritmo diferente). Nos dois casos de resultados diferentes para os quais eu olhei, meu código estava correto e o do stablebox estava errado. Eu acho que meu código está correto para todos os 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);
    }
}

As únicas linhas impressas têm c = 1 asm = 0: falso-positivos para o algoritmo C.

Também testado contra uma uint64_tversão da implementação C de Karl do mesmo algoritmo, e os resultados correspondem a todas as entradas.

Haskell, 47 bytes

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

Muito devagar. Teste com c<-['0'..'9'].

Testa cada caractere para inclusão na representação de string de ne faz uma lista dos incluídos. Igualmente faz n^3e verifica se as listas são iguais.

Dyalog APL , 10 bytes

⍕≡⍕∪(⍕*∘3)

⍕≡ é a representação de texto do argumento idêntica à

⍕∪ a união da representação de texto do argumento e

(⍕*∘3) a representação de texto do argumento em cubos?

TryAPL online!

Nota: Para números grandes, defina ⎕PP←34 ⋄ ⎕FR←1287(34 dígitos significativos, flutuações 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(""))));}

Ligue 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));
}

Resultado:

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

(Eu nunca tenho certeza se preciso contar também as importações e as definições de métodos ... vi de qualquer maneira. O código em si teria apenas 141 bytes de comprimento.)

Gelatina , 8 bytes

*3ṢQ⁼ṢQ$

Experimente online!

Explicação:

       $    # 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'

Pitão, 10 bytes

Como não temos variedade suficiente com as respostas Pyth, vamos adicionar não uma, mas mais duas! Ambos são 10 bytes e foram testados 106239como uma amostra de entrada (com falha em algumas outras respostas).

!s.++Q,`**

Explicação:

!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?

Experimente a primeira resposta usando uma suíte de testes online.

Segunda resposta:

qFmS{`d,**

Explicação:

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

Tente a segunda resposta usando uma suíte de testes online.

Kotlin: 46/88/96 bytes

A pergunta não especifica de onde a entrada vem, então aqui estão as 3 fontes de entrada usuais.

Função: 46 bytes

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

main () usando o argumento do primeiro programa: 88 bytes

fun main(a:Array<String>){val i=a[0].toLong();println("$i".toSet()=="${i*i*i}".toSet())}

main () usando entrada padrão: 96 bytes

fun main(a:Array<String>){val i=readLine()!!.toLong();println("$i".toSet()=="${i*i*i}".toSet())}

Haskell, 54 52 bytes

Obrigado @Laikoni por salvar dois 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)

Porto da excelente resposta C de @ KarlNapf. O ES7 salva um byte via n**3. Funciona apenas até 208063 devido à precisão numérica limitada do JavaScript; se você precisar apenas trabalhar até 1290, poderá salvar outro 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
  )
}

O operador Diferença do conjunto simétrico returns ⊖ ｣ retorna um conjunto vazio se os dois lados forem conjuntos equivalentes (transforma automaticamente uma lista em um conjunto). Nesse ponto, a única coisa que resta a fazer é invertê-lo logicamente.

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;}

A função t (a) retorna a resposta. Usa um int como um conjunto. Impresso bem:

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 ne n^3em dígitos únicos e compara os dois conjuntos. Usa o gmppacote para lidar com números inteiros grandes (obrigado a Billywob por apontar essa falha). Agora, use o substringcut-up ne n^3, graças a @MickyT, pela sugestão. (Versões anteriores usadas scane de gsubmaneira 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);}

Porta da minha resposta C , funciona para grandes números (ligue com Lsufixo).

Haskell, 47 bytes

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

Exemplo de uso: f 102343-> False.

Usa conjuntos do Data.Setmódulo. A função auxiliar stransforma um número em sua representação de sequência e, em seguida, define os caracteres.

Braquilog , 11 bytes

doI,?:3^doI

Experimente online!

Obrigado a @DestructibleWatermelon por apontar um problema com a minha resposta original.

Explicação

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

(Nova linha para maior clareza, não incluída no bytecount)

A primeira linha define fcomo um filter(similar-ish o suficiente para uma função para nossos propósitos aqui, não entrar em detalhes) que recebe entrada $ne faz o seguinte:

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

A segunda linha pega a entrada $args, executa fnela e verifica se é -eqnecessário fexecutar em $xcubos. Observe o [bigint]elenco explícito , necessário, caso contrário, obteremos o resultado de volta em notação científica, que obviamente não funcionará.

O resultado booleano é deixado no pipeline e a saída é 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

Guardou um byte graças a @ConnorLSW

Groovy, 35 51 caracteres / bytes

Fiquei triste por não ter incluído o Groovy, então aqui está minha tentativa original de 51 bytes:

def x(def n){"$n".toSet()=="${n.power(3)}".toSet()}

Reescrito como um fechamento anônimo de 35 bytes e com **exponenciação, graças ao manatwork:

{"$it".toSet()=="${it**3}".toSet()}

Alguns casos de teste para a função original:

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

Um fechamento chamado cpoderia ser chamado assim: println c.call(107624). O fechamento anônimo de 35 bytes poderia ser chamado assim:println ({"$it".toSet()=="${it**3}".toSet()}(107624))

Saídas:

true
true
true
true
true
false
false

Por favor note: eu aprendi que algo como código golf existe agora, então espero que eu entendi direito!

Ruby, 48 bytes

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