Bei einer gegebenen Zahl n (0 <= n <= 2642245) prüfen Sie, ob n und n ³ den gleichen Satz von Ziffern haben, und geben Sie dementsprechend einen Wahrheits- oder Falschwert aus.

Lassen Sie uns zum Beispiel die Zahl 100 überprüfen.

100 ³ ist 1000000.

Die Ziffernfolge in 100 lautet {0, 1}.

Der Ziffernsatz in 1000000 ist {0, 1}.

Daher sollten 100 einen wahrheitsgemäßen Wert angeben.

Testfälle

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

Denken Sie daran, das ist Code-Golf , also gewinnt der Code mit den wenigsten Bytes.

OEIS A029795

Python 3, 36 32 Bytes

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

Ich denke, das funktioniert nur in Python 3.5 und höher. Dank Copper sind vier Bytes vergangen.

05AB1E , 6 Bytes

05AB1E verwendet die CP-1252- Codierung.

3mê¹êQ

Probieren Sie es online!

Erläuterung

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

Erzeugt den Satz über Bits. Gibt 0für den gleichen Satz zurück, alles andere für verschiedene Sätze.

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

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

Verwenden von:

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

Ausgabe: 1\noder 0\n.

Vielen Dank an @Dada für 3 Bytes, Gabriel Benamy für 1 Byte und @Zaid für Fehlermeldungen.

Mathematica, 34 Bytes

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

Direkte Implementierung (unbenannte Funktion eines Integer-Arguments).

Gelee , 8 Bytes

,3*\D‘ṬE

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

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

Testsuite.

Erläuterung

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

Danke an Downgoat für 3 Bytes! Sie können ein Byte speichern, indem Sie auf ES7 konvertieren und n**3anstelle von verwenden n*n*n.

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

Einfach genug.

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

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

Die Lambdas müssen speziell den ulongTyp verwenden:

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

Vielen Dank an @Corak und @Dennis_E für das Speichern einiger Bytes und an @TimmyD für das Finden eines Problems mit meiner ursprünglichen Lösung. Vielen Dank an @SaxxonPike für den Hinweis auf das ulong / long / decimal / etc-Problem (das mir tatsächlich auch einige Bytes erspart hat).

Es gibt auch eine 109-Byte- Lösung mit HashSets, ähnlich den Java-Antworten hier, aber ich bleibe bei meiner ursprünglichen Lösung für meine Punktzahl.

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

Java 8, 154 Zeichen

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

So genannt:

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

Ausgänge:

true
true
true
true
true
false
false

Eine sehr Java-8-y-Antwort, die sowohl ein Lambda als auch Streams verwendet, einschließlich einiger ausgefallener Konvertierungen von Zahl zu Zeichenfolge.

Leider müssen wir BigInteger.pow(3)anstelle von Math.pow(a,3)Math.pow nicht präzise Doubles verwenden, die falsche Werte mit großen Zahlen zurückgeben (beginnend mit 2103869).

BASH, 6959 Bytes

AKTUALISIEREN

Eine andere gute Möglichkeit, dies in bash zu tun, ist die Verwendung von tr (62 Bytes, kann aber wahrscheinlich ein bisschen mehr zusammengedrückt werden).

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

BEARBEITEN: Einige weitere Optimierungen (Thx! @Manatwork)

Golf gespielt

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

Prüfung

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 - für Erfolg (Exit-Code) 1 - für Misserfolg (Exit-Code)

x86-64-Maschinencodefunktion, 40 Byte.

Oder 37 Bytes, wenn 0 gegen Nicht-Null als "wahr" zulässig ist, wie strcmp.

Vielen Dank an Karl Napfs C-Antwort für die Bitmap-Idee, die x86 mit BTS sehr effizient umsetzen kann .

Funktionssignatur: _Bool cube_digits_same(uint64_t n);unter Verwendung der x86-64-System-V-ABI. ( nin RDI boolescher Rückgabewert (0 oder 1) in AL).

_Boolwird von ISO C11 definiert und wird normalerweise verwendet #include <stdbool.h>, um boolmit derselben Semantik wie C ++ zu definieren bool.

Einsparpotential:

• 3 Bytes: Rückgabe der inversen Bedingung (ungleich Null, wenn ein Unterschied besteht). Oder von inline asm: Rückgabe einer Flagbedingung (was mit gcc6 möglich ist)
• 1 Byte: Wenn wir EBX überlasten könnten (dies würde dieser Funktion eine nicht standardmäßige Aufrufkonvention geben). (könnte das von inline asm machen)
• 1 Byte: der RET-Befehl (von Inline-ASM)

All dies ist möglich, wenn dies ein Inline-Asm-Fragment anstelle einer Funktion wäre, was es für Inline-Asm zu 35 Bytes machen würde .

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 scheint die kleinste Möglichkeit zu sein, sich einmal zu wiederholen. Ich habe mir auch nur das Wiederholen der Schleife angesehen (ohne REX-Präfixe und ein anderes Bitmap-Register), aber das ist etwas größer. Ich habe auch versucht, PUSH RSI und test spl, 0xf/ jzzu verwenden, um eine Schleife auszuführen (da das ABI erfordert, dass RSP vor CALL auf 16B ausgerichtet ist, sodass es durch einen Tastendruck ausgerichtet und durch einen anderen erneut falsch ausgerichtet wird). Da es keine test r32, imm8Codierung gibt, bestand die kleinste Möglichkeit darin, mit einem 4B-TEST-Befehl (einschließlich eines REX-Präfix) nur das Low-Byte von RSP gegen ein imm8 zu testen. Gleiche Größe wie LEA + LOOP, jedoch mit zusätzlichen PUSH / POP-Anweisungen.

Getestet für alle n im Testbereich im Vergleich zur C-Implementierung von steadybox (da ein anderer Algorithmus verwendet wird). In den beiden von mir untersuchten Fällen mit unterschiedlichen Ergebnissen war mein Code korrekt und die von steadybox waren falsch. Ich denke, mein Code ist für alle n korrekt.

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

Die einzigen gedruckten Zeilen haben c = 1 asm = 0: falsch-positiv für den C-Algorithmus.

Wurde auch mit einer uint64_tVersion von Karls C-Implementierung desselben Algorithmus getestet und die Ergebnisse stimmen für alle Eingaben überein.

Haskell, 47 Bytes

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

Sehr langsam. Testen Sie mit c<-['0'..'9'].

Testet jedes Zeichen auf Einbeziehung in die Zeichenfolgendarstellung von nund erstellt eine Liste der enthaltenen Zeichen . Prüft ebenfalls für n^3und ob die Listen gleich sind.

Dyalog APL , 10 Bytes

⍕≡⍕∪(⍕*∘3)

⍕≡ ist die Textdarstellung des Arguments identisch mit

⍕∪ die Vereinigung der Textdarstellung des Arguments und

(⍕*∘3) die Textdarstellung des gewürfelten Arguments?

TryAPL online!

Hinweis: Setzen Sie für große Zahlen ⎕PP←34 ⋄ ⎕FR←1287(34 signifikante Stellen, 128-Bit-Gleitkommazahlen)

Clojure, 35 Bytes

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

Java 7, 185 178 Zeichen

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

Anrufen als:

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

Ausgabe:

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

(Ich bin mir nie sicher, ob ich auch Importe und Methodendefinitionen zählen muss ... Ich habe es so oder so gesehen. Der Code selbst wäre jedoch nur 141 Bytes lang.)

Gelee , 8 Bytes

*3ṢQ⁼ṢQ$

Probieren Sie es online!

Erläuterung:

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

Da wir mit Pyth-Antworten nicht genug Abwechslung haben, wollen wir nicht nur eine, sondern zwei weitere hinzufügen! Beide haben eine Größe von 10 Byte und wurden als Beispieleingabe getestet 106239(bei einigen anderen Antworten ist dies fehlgeschlagen).

!s.++Q,`**

Erläuterung:

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

Versuchen Sie die erste Antwort mit einer Online-Testsuite.

Zweite Antwort:

qFmS{`d,**

Erläuterung:

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

Versuchen Sie die zweite Antwort mit einer Online-Testsuite.

Kotlin: 46/88/96 Bytes

Die Frage gibt nicht an, woher die Eingabe stammt. Hier sind die üblichen 3 Eingabequellen.

Funktion: 46 Bytes

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

main () mit dem ersten Programmargument: 88 Bytes

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

main () mit Standardeingabe: 96 Bytes

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

Haskell, 54 52 Bytes

Danke @Laikoni für das Speichern von zwei Bytes.

(%)=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 @ KarlNapfs ausgezeichnete C-Antwort. ES7 speichert ein Byte über n**3. Funktioniert aufgrund der eingeschränkten numerischen Genauigkeit von JavaScript nur bis 208063; Wenn Sie es nur benötigen, um bis zu 1290 zu arbeiten, können Sie ein weiteres Byte speichern.

Perl 6 , 22 Bytes

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

Erweitert:

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

Der Operator Symmetric Set difference ｢ic ⊖ gibt ein leeres Set zurück, wenn beide Seiten äquivalente Sets sind (verwandelt eine Liste automatisch in ein Set). An diesem Punkt muss es nur noch logisch invertiert werden.

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

Die Funktion t (a) liefert die Antwort. Verwendet ein Int als Set. Schön gedruckt:

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

Nimmt nvon stdin, teilt nund n^3in einzelne Ziffern auf und vergleicht die beiden Sätze. Verwendet das gmpPaket, um große Ganzzahlen zu verarbeiten (danke an Billywob für den Hinweis auf dieses Manko). Jetzt verwendet substringzu zerschneiden nund n^3dank @MickyT für den Vorschlag. (Frühere Versionen verwendet scanund gsubauf eine hackige Weise.)

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

Port meiner C-Antwort , funktioniert für große Nummern (Anruf mit LSuffix).

Haskell, 47 Bytes

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

Anwendungsbeispiel: f 102343-> False.

Verwendet Sets aus dem Data.SetModul. Die Hilfsfunktion swandelt eine Zahl in eine Zeichenfolgendarstellung um und erstellt dann eine Menge aus den Zeichen.

Brachylog , 11 Bytes

doI,?:3^doI

Probieren Sie es online!

Vielen Dank an @DestructibleWatermelon für den Hinweis auf ein Problem mit meiner ursprünglichen Antwort.

Erläuterung

(?)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 bis 93 Byte

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

(Newline zur Verdeutlichung, nicht in bytecount enthalten)

Die erste Zeile definiert fals filter(ähnlich genug für eine Funktion, damit wir hier nicht auf Einzelheiten eingehen), die Eingaben nimmt $nund Folgendes ausführt:

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

Die zweite Zeile nimmt die Eingabe $args, führt fauf, und überprüft , ob es -equal zu fauf ausgeführt in $xWürfel geschnitten. Beachten Sie die explizite [bigint]Besetzung, ansonsten erhalten wir das Ergebnis in wissenschaftlicher Notation zurück, was offensichtlich nicht funktioniert.

Das boolesche Ergebnis verbleibt in der Pipeline, und die Ausgabe ist implizit.

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

Ein Byte dank @ConnorLSW gespeichert

Groovy, 35 51 Zeichen / Byte

Ich war traurig, Groovy nicht dabei zu haben, und hier ist mein ursprünglicher 51-Byte-Versuch:

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

Neu geschrieben als anonymer 35-Byte-Abschluss und mit **zur Potenzierung, dank manatwork:

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

Einige Testfälle für die ursprüngliche Funktion:

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

Eine benannte Schließung ckönnte wie folgt aufgerufen werden: println c.call(107624). Die anonyme 35-Byte-Schließung könnte folgendermaßen lauten:println ({"$it".toSet()=="${it**3}".toSet()}(107624))

Ausgänge:

true
true
true
true
true
false
false

Bitte beachten Sie: Ich habe gerade erfahren, dass es so etwas wie Codegolf gibt, also habe ich es hoffentlich richtig gemacht!

Ruby, 48 Bytes

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