Dato un numero n (0 <= n <= 2642245), controlla se n e n ³ hanno lo stesso insieme di cifre e genera un valore di verità o falsità di conseguenza.

Ad esempio, controlliamo il numero 100.

100 ³ è 1000000.

L'insieme di cifre in 100 è {0, 1}.

Il set di cifre in 1000000 è {0, 1}.

Pertanto, 100 dovrebbe dare un valore veritiero.

Casi test

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

Ricorda, questo è code-golf , quindi vince il codice con il minor numero di byte.

OEIS A029795

Python 3, 36 32 byte

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

Penso che questo funzioni solo in Python 3.5 e versioni successive. Sono passati quattro byte, grazie a Copper.

05AB1E , 6 byte

05AB1E utilizza la codifica CP-1252 .

3mê¹êQ

Provalo online!

Spiegazione

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

C, 73 byte

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 l'insieme tramite bit. Restituisce 0per lo stesso set, qualsiasi altra cosa per set diversi.

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

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

usando:

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

Uscita: 1\no 0\n.

Grazie a @Dada per 3 byte, Gabriel Benamy per 1 byte e @Zaid per segnalazioni di bug.

Mathematica, 34 byte

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

Implementazione diretta (funzione senza nome di un argomento intero).

Gelatina , 8 byte

,3*\D‘ṬE

Provalo online! o verifica tutti i casi di test .

Come funziona

,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 byte

l_~3#s^!

Suite di test.

Spiegazione

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 byte

Grazie a Downgoat per 3 byte! È possibile salvare un byte convertendolo in ES7 e utilizzando n**3invece di n*n*n.

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

Abbastanza semplice.

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

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

I lambda devono usare specificamente il ulongtipo:

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

Grazie a @Corak e @Dennis_E per aver salvato alcuni byte e @TimmyD per aver trovato un problema con la mia soluzione originale. Grazie a @SaxxonPike per aver segnalato il problema ulong / long / decimal / etc (che in realtà mi ha anche salvato alcuni byte).

Esiste anche una soluzione a 109 byte che utilizza Hashset, simile alle risposte Java qui, ma mi atterrò alla mia soluzione originale per il mio punteggio.

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

Java 8, 154 caratteri

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

Chiamato così:

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

Uscite:

true
true
true
true
true
false
false

Una risposta Java a 8 anni, utilizzando un lambda e flussi che includono alcune conversioni da numero a stringa fantasiose.

Purtroppo dobbiamo usare BigInteger.pow(3)invece che a Math.pow(a,3)causa di Math.pow usando doppi non precisi, che restituiscono valori errati con numeri grandi (a partire da 2103869).

BASH, 69, 59 byte

AGGIORNARE

Un altro bel modo per farlo in bash è usare tr (62 byte, ma probabilmente può essere compresso un po 'di più)

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

EDIT: alcune altre ottimizzazioni (Thx! @Manatwork)

golfed

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

Test

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 - per successo (codice di uscita) 1 - per errore (codice di uscita)

funzione codice macchina x86-64, 40 byte.

O 37 byte se 0 rispetto a zero è consentito come "verità", come strcmp.

Grazie alla risposta C di Karl Napf per l'idea bitmap, che x86 può fare in modo molto efficiente con BTS .

Firma della funzione:, _Bool cube_digits_same(uint64_t n);utilizzando l'ABI System V x86-64. ( nin RDI, valore di ritorno booleano (0 o 1) in AL).

_Boolè definito da ISO C11 ed è in genere utilizzato #include <stdbool.h>per definire boolcon la stessa semantica di C ++ bool.

Potenziali risparmi:

• 3 byte: restituzione della condizione inversa (diversa da zero se c'è una differenza). O da inline asm: restituire una condizione di bandiera (che è possibile con gcc6)
• 1 byte: se potessimo ostruire EBX (farlo darebbe a questa funzione una convenzione di chiamata non standard). (potrebbe farlo da inline asm)
• 1 byte: l'istruzione RET (da inline asm)

Tutti questi sono possibili se questo fosse un frammento inline-asm invece di una funzione, che lo renderebbe 35 byte per 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 sembra il modo più piccolo di ripetere una volta. Ho anche guardato solo ripetendo il ciclo (senza prefissi REX e un registro bitmap diverso), ma è leggermente più grande. Ho anche provato a usare PUSH RSI e usare test spl, 0xf/ jzper eseguire il loop una volta (poiché l'ABI richiede che RSP sia allineato di 16B prima di CHIAMATA, quindi una spinta la allinea e un'altra disallinea di nuovo). Non c'è test r32, imm8codifica, quindi il modo più piccolo era con un'istruzione TEST 4B (incluso un prefisso REX) per testare solo il byte basso di RSP su un imm8. Stesse dimensioni di LEA + LOOP, ma con istruzioni PUSH / POP extra richieste.

Testato per tutte le n nell'intervallo di test, rispetto all'implementazione C di steadybox (poiché utilizza un algoritmo diverso). Nei due casi di risultati diversi che ho visto, il mio codice era corretto e quello di steadybox era sbagliato. Penso che il mio codice sia corretto per tutti 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);
    }
}

Le uniche righe stampate hanno c = 1 asm = 0: falsi positivi per l'algoritmo C.

Testato anche contro una uint64_tversione dell'implementazione C di Karl dello stesso algoritmo e i risultati corrispondono per tutti gli input.

Haskell, 47 byte

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

Molto lento. Prova con c<-['0'..'9'].

Verifica ogni carattere per l'inclusione nella rappresentazione in formato stringa ne crea un elenco di quelli inclusi. Fa anche per n^3e controlla se le liste sono uguali.

Dyalog APL , 10 byte

⍕≡⍕∪(⍕*∘3)

⍕≡ la rappresentazione testuale dell'argomento è identica a

⍕∪ l'unione della rappresentazione testuale dell'argomento e

(⍕*∘3) la rappresentazione testuale dell'argomento al cubo?

ProvaAPL online!

Nota: per numeri grandi, impostare ⎕PP←34 ⋄ ⎕FR←1287(34 cifre significative, float a 128 bit)

Clojure, 35 byte

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

Java 7, 185 178 caratteri

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

Chiama come:

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

Produzione:

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

(Non sono mai sicuro se devo contare anche le importazioni e le definizioni dei metodi ... Ho visto in entrambi i casi. Il codice stesso sarebbe lungo solo 141 byte.)

Gelatina , 8 byte

*3ṢQ⁼ṢQ$

Provalo online!

Spiegazione:

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

Poiché non abbiamo abbastanza varietà con le risposte di Pyth, aggiungiamo non una, ma altre due! Entrambi sono 10 byte e sono stati testati 106239come input di esempio (con il quale alcune altre risposte hanno avuto esito negativo).

!s.++Q,`**

Spiegazione:

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

Prova la prima risposta utilizzando una suite di test online.

Seconda risposta:

qFmS{`d,**

Spiegazione:

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

Prova la seconda risposta utilizzando una suite di test online.

Kotlin: 46/88/96 byte

La domanda non specifica da dove proviene l'input, quindi ecco le solite 3 fonti di input.

Funzione: 46 byte

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

main () usando il primo argomento del programma: 88 byte

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

main () utilizzando l'input standard: 96 byte

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

Haskell, 54 52 byte

Grazie @Laikoni per aver salvato due byte.

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

JavaScript (ES6), 44 byte

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

Port of @ KarlNapf's eccellente risposta C. ES7 salva un byte tramite n**3. Funziona solo fino al 208063 a causa della precisione numerica limitata di JavaScript; se ne hai bisogno solo per funzionare fino a 1290, puoi salvare un altro byte.

Perl 6 , 22 byte

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

Allargato:

{ # 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
  )
}

La differenza Set simmetrico ｣⊖｣ restituisce un set vuoto se entrambi i lati sono set equivalenti (trasforma automaticamente un elenco in un set). A quel punto l'unica cosa che resta da fare è invertirla logicamente.

C ++, 82 byte

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 funzione t (a) restituisce la risposta. Utilizza un int come set. Stampato bene:

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 byte

Prende nda stdin, si divide ne n^3in cifre singole e confronta i due set. Utilizza il gmppacchetto per gestire numeri interi di grandi dimensioni (grazie a Billywob per aver sottolineato tale difetto). Ora usa substringper tagliare ne n^3, grazie a @MickyT per il suggerimento. (Versioni precedenti utilizzate scane gsubin modo confuso.)

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

C ++ 14, 93 byte

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 della mia risposta C , funziona per numeri grandi (chiama con il Lsuffisso).

Haskell, 47 byte

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

Esempio di utilizzo: f 102343-> False.

Utilizza i set dal Data.Setmodulo. La funzione helper strasforma un numero nella sua rappresentazione di stringa e crea un set di caratteri.

Brachylog , 11 byte

doI,?:3^doI

Provalo online!

Grazie a @DestructibleWatermelon per aver segnalato un problema con la mia risposta originale.

Spiegazione

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

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

(Newline per chiarezza, non incluso in bytecount)

La prima riga definisce fcome filter(abbastanza simile a una funzione per i nostri scopi qui per non andare nei dettagli) che accetta input $ne fa quanto segue:

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 seconda linea prende l'input $args, esegue fsu di esso, e verifica se è -equale per feseguita su $xcubetti. Nota il [bigint]cast esplicito , richiesto altrimenti avremo il risultato in notazione scientifica, che ovviamente non funzionerà.

Il risultato booleano viene lasciato sulla pipeline e l'output è implicito.

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

Salvataggio di un byte grazie a @ConnorLSW

Groovy, 35 51 caratteri / byte

Ero triste di non aver visto Groovy incluso, quindi ecco il mio tentativo originale di 51 byte:

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

Riscritto come una chiusura anonima da 35 byte e con **esponenziale, grazie a manatwork:

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

Alcuni casi di test per la funzione originale:

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

Una chiusura nominata c potrebbe essere chiamata in questo modo: println c.call(107624). La chiusura anonima a 35 byte potrebbe essere chiamata in questo modo:println ({"$it".toSet()=="${it**3}".toSet()}(107624))

Uscite:

true
true
true
true
true
false
false

Nota: ho imparato che esiste qualcosa come il code golf proprio ora, quindi spero di aver capito bene!

Rubino, 48 byte

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