Étant donné un nombre n (0 <= n <= 2642245), vérifiez si n et n ³ ont le même ensemble de chiffres et émettez une valeur de vérité ou de falsey en conséquence.

Par exemple, vérifions le nombre 100.

100 ³ est 1000000.

L'ensemble des chiffres de 100 est {0, 1}.

L'ensemble des chiffres dans 1000000 est {0, 1}.

Par conséquent, 100 devrait donner une valeur de vérité.

Cas de test

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

Rappelez-vous que c'est du code-golf , donc le code avec le moins d'octets gagne.

OEIS A029795

Python 3, 36 32 octets

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

Je pense que cela ne fonctionne que dans Python 3.5 et versions ultérieures. Quatre octets ont disparu, grâce à Copper.

05AB1E , 6 octets

05AB1E utilise le codage CP-1252 .

3mê¹êQ

Essayez-le en ligne!

Explication

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

C, 73 octets

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

Crée l'ensemble via des bits. Retourne 0pour le même ensemble, rien pour les autres ensembles.

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

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

En utilisant:

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

Sortie: 1\nou 0\n.

Merci à @ Dada pour 3 octets, à Gabriel Benamy pour 1 octet et à @Zaid pour les rapports de bogues.

Mathematica, 34 octets

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

Implémentation directe (fonction non nommée d'un argument entier).

Gelée , 8 octets

,3*\D‘ṬE

Essayez-le en ligne! ou vérifier tous les cas de test .

Comment ça fonctionne

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

l_~3#s^!

Suite de tests.

Explication

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 octets

Merci à Downgoat pour 3 octets! Vous pouvez enregistrer un octet en convertissant à ES7 et en utilisant à la n**3place de n*n*n.

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

Assez simple.

C #, 241 208 205 201 193 233 222 220 212 203 177 159 octets (109 en remplacement)

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

Le lambda doit utiliser spécifiquement le ulongtype:

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

Merci à @Corak et @Dennis_E pour la sauvegarde de quelques octets et à @TimmyD pour avoir trouvé un problème avec ma solution d'origine. Merci à @SaxxonPike d’avoir signalé le problème ulong / long / decimal / etc (qui m’a également fait économiser des octets).

Il existe également une solution de 109 octets utilisant HashSets, similaire aux réponses Java ici, mais je vais m'en tenir à ma solution originale pour mon score.

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

Java 8, 154 caractères

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

Appelé comme ça:

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

Les sorties:

true
true
true
true
true
false
false

Une réponse très Java 8-y, utilisant un lambda ainsi que des flux incluant des conversions de nombre à chaînes fantaisistes.

Malheureusement, nous devons utiliser à la BigInteger.pow(3)place de Math.pow(a,3)Math.pow des doubles non précis, qui renvoient des valeurs incorrectes avec des nombres élevés (commençant par 2103869).

FRAPPER, 69, 59 octets

MISE À JOUR

Une autre façon de faire cela en bash est d’utiliser tr (62 octets, mais peut probablement être un peu plus pressé)

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

EDIT: Quelques optimisations supplémentaires (Thx! @Manatwork)

Golfé

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

Tester

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 - en cas de succès (code de sortie) 1 - en cas d'échec (code de sortie)

Fonction de code machine x86-64, 40 octets.

Ou 37 octets si 0 ou non-zéro est autorisé comme "vérité", comme strcmp.

Grâce à la réponse C de Karl Napf pour l’idée bitmap, ce que x86 peut faire de manière très efficace avec BTS .

Signature de fonction:, _Bool cube_digits_same(uint64_t n);à l’aide de l’ABI System V x86-64. ( nen RDI, valeur de retour booléen (0 ou 1 en AL)).

_Boolest défini par ISO C11 et est généralement utilisé #include <stdbool.h>pour définir boolavec la même sémantique que C ++ bool.

Potentiel d'économies:

• 3 octets: retour de la condition inverse (différent de zéro s'il y a une différence). Ou depuis inline asm: retour d'une condition de drapeau (ce qui est possible avec gcc6)
• 1 octet: Si nous pouvions supprimer EBX (cela donnerait à cette fonction une convention d'appel non standard). (pourrait le faire depuis inline asm)
• 1 octet: l'instruction RET (de inline asm)

Tout cela est possible s'il s'agissait d'un fragment inline-asm au lieu d'une fonction, ce qui en ferait 35 octets pour 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 semble être le moyen le plus simple de répéter une fois. J'ai aussi regardé simplement répéter la boucle (sans les préfixes REX et un registre bitmap différent), mais c'est légèrement plus grand. J'ai également essayé d'utiliser PUSH RSI et d'utiliser test spl, 0xf/ jzto en boucle une fois (étant donné que l'ABI exige que RSP soit 16B aligné avant CALL, une poussée l'aligne et une autre l'aligne à nouveau). Il n'y a pas d' test r32, imm8encodage, le plus petit moyen était donc d'utiliser une instruction 4B TEST (incluant un préfixe REX) pour tester uniquement l'octet de poids faible de RSP par rapport à un imm8. Même taille que LEA + LOOP, mais avec les instructions supplémentaires PUSH / POP requises.

Testé pour tous les n de la plage de test, par rapport à la mise en œuvre C de steadybox (car elle utilise un algorithme différent). Dans les deux cas de résultats différents que j'ai examinés, mon code était correct et celui de steadybox, celui qui était incorrect. Je pense que mon code est correct pour tout 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);
    }
}

Les seules lignes imprimées ont c = 1 asm = 0: faux positifs pour l'algorithme C.

Également testé sur une uint64_tversion de l'implémentation C de Karl du même algorithme, et les résultats correspondent pour toutes les entrées.

Haskell, 47 octets

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

Très lent. Testez avec c<-['0'..'9'].

Teste chaque caractère pour l'inclure dans la représentation sous forme de chaîne de n, et dresse une liste de ceux inclus. Fait de même pour n^3et vérifie si les listes sont égales.

Dyalog APL , 10 octets

⍕≡⍕∪(⍕*∘3)

⍕≡ est la représentation textuelle de l'argument identique à

⍕∪ l'union de la représentation textuelle de l'argument et

(⍕*∘3) la représentation textuelle de l'argument en cube?

TryAPL en ligne!

Remarque: Pour les grands nombres, définissez ⎕PP←34 ⋄ ⎕FR←1287(34 chiffres significatifs, float 128 bits)

Clojure, 35 octets

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

Java 7, 185 178 caractères

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

Appeler comme:

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

Sortie:

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

(Je ne suis jamais sûr de devoir compter également les importations et les définitions de méthodes ... je l'ai déjà vu de toute façon. Le code lui-même n'aurait toutefois qu'une longueur de 141 octets.)

Gelée , 8 octets

*3ṢQ⁼ṢQ$

Essayez-le en ligne!

Explication:

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

Parce que nous n’avons pas assez de variété avec les réponses Pyth, n’ajoutons pas une, mais deux autres! Les deux sont de 10 octets et ont été testés avec 106239un exemple d'entrée (auquel d'autres réponses ont échoué).

!s.++Q,`**

Explication:

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

Essayez la première réponse en utilisant une suite de tests en ligne.

Deuxième réponse:

qFmS{`d,**

Explication:

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

Essayez la deuxième réponse en utilisant une suite de tests en ligne.

Kotlin: 46/88/96 octets

La question ne précise pas d'où provient l'entrée, alors voici les 3 sources d'entrée habituelles.

Fonction: 46 octets

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

main () utilisant le premier argument du programme: 88 octets

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

main () utilisant l'entrée standard: 96 octets

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

Haskell, 54 52 octets

Merci @Laikoni pour la sauvegarde de deux octets.

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

JavaScript (ES6), 44 octets

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

Excellente réponse en C du port de @ KarlNapf. ES7 enregistre un octet via n**3. Ne fonctionne que jusqu'en 208063 en raison de la précision numérique limitée de JavaScript; si vous n’avez besoin que de travailler jusqu’à 1290, vous pouvez enregistrer un autre octet.

Perl 6 , 22 octets

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

Étendu:

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

L' opérateur Différence de jeux symétriques ⊖ ⊖ returns renvoie un jeu vide si les deux côtés sont des jeux équivalents (transforme automatiquement une liste en jeu). A ce stade, il ne reste plus qu'à l'inverser logiquement.

C ++, 82 octets

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 fonction t (a) renvoie la réponse. Utilise un int comme un ensemble. Bien imprimé:

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 octets

Prend nde stdin, divise net n^3en chiffres simples, et compare les deux ensembles. Utilise le gmppaquet pour gérer de grands nombres entiers (merci à Billywob pour avoir signalé cette lacune). Utilise maintenant substringpour couper net n^3, grâce à @MickyT pour la suggestion. ( Les versions précédentes scanet gsubd'une manière aki.)

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

C ++ 14, 93 octets

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

Port of my C answer , fonctionne pour les grands nombres (appel avec Lsuffixe).

Haskell, 47 octets

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

Exemple d'utilisation: f 102343-> False.

Utilise les ensembles du Data.Setmodule. La fonction d'assistance stransforme un nombre en représentation sous forme de chaîne et crée ensuite un jeu de caractères.

Brachylog , 11 octets

doI,?:3^doI

Essayez-le en ligne!

Merci à @DestructibleWatermelon pour avoir signalé un problème avec ma réponse initiale.

Explication

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

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

(Newline pour plus de clarté, non inclus dans bytecount)

La première ligne est définie fcomme un filter(assez similaire à une fonction pour que notre propos ici ne rentre pas dans les détails) qui prend en entrée $net effectue ce qui suit:

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 deuxième ligne prend l'entrée $args, l'exécute fet vérifie si elle -eqdoit être fexécutée au $xcube. Notez la [bigint]distribution explicite , sinon nous obtiendrons le résultat en notation scientifique, ce qui ne fonctionnera évidemment pas.

Le résultat booléen est laissé sur le pipeline et la sortie est implicite.

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

Enregistré un octet grâce à @ConnorLSW

Groovy, 35 51 caractères / octets

J'étais triste de ne pas voir Groovy inclus, alors voici ma tentative initiale de 51 octets:

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

Réécrit sous forme de fermeture anonyme de 35 octets et avec **une exponentiation, grâce à manatwork:

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

Quelques cas de test pour la fonction d'origine:

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

Une fermeture du nom cpourrait être appelé comme ceci: println c.call(107624). La fermeture anonyme de 35 octets pourrait s'appeler comme ceci:println ({"$it".toSet()=="${it**3}".toSet()}(107624))

Les sorties:

true
true
true
true
true
false
false

S'il vous plaît noter: j'ai appris que quelque chose comme le code de golf existe tout à l'heure, alors j'espère que j'ai raison!

Ruby, 48 octets

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