Biorąc pod uwagę liczbę n (0 <= n <= 2642245), sprawdź, czy n i n ³ mają ten sam zestaw cyfr, i odpowiednio wypisz wartość prawdy lub fałszu.

Na przykład sprawdźmy liczbę 100.

100 ³ to 1000000.

Zestaw cyfr w 100 to {0, 1}.

Zestaw cyfr w 1000000 to {0, 1}.

Dlatego 100 powinno dać prawdziwą wartość.

Przypadki testowe

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

Pamiętaj, to jest kodowanie w golfa , więc wygrywa kod z najmniejszą liczbą bajtów.

OEIS A029795

Python 3, 36 32 bajtów

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

Myślę, że działa to tylko w Pythonie 3.5 i nowszych. Cztery bajty zniknęły dzięki Copper.

05AB1E , 6 bajtów

05AB1E wykorzystuje kodowanie CP-1252 .

3mê¹êQ

Wypróbuj online!

Wyjaśnienie

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

C, 73 bajty

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

Tworzy zestaw za pomocą bitów. Zwraca ten 0sam zestaw, wszystko inne dla różnych zestawów.

Nie golfowany:

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 ( -plflaga) = 25 21 18 34 33 bajtów

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

Za pomocą:

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

Wyjście: 1\nlub 0\n.

Dzięki za @Dada za 3 bajty, Gabriel Benamy za 1 bajt i @Zaid za zgłoszenia błędów.

Mathematica, 34 bajty

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

Implementacja bezpośrednia (nienazwana funkcja jednego argumentu całkowitego).

Galaretka , 8 bajtów

,3*\D‘ṬE

Wypróbuj online! lub zweryfikuj wszystkie przypadki testowe .

Jak to działa

,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 bajtów

l_~3#s^!

Zestaw testowy.

Wyjaśnienie

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 bajtów

Dzięki Downgoat za 3 bajty! Możesz zapisać bajt, konwertując na ES7 i używając n**3zamiast n*n*n.

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

Wystarczająco proste.

C #, 241 208 205 201 193 233 222 220 212 203 177 159 bajtów (109 na przemian)

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

Lambda muszą w szczególności używać ulongtypu:

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

Dzięki @Corak i @Dennis_E za zapisanie niektórych bajtów oraz @TimmyD za znalezienie problemu z moim oryginalnym rozwiązaniem. Dzięki @SaxxonPike za wskazanie problemu długiego / długiego / dziesiętnego / etc (który faktycznie zaoszczędził mi również trochę bajtów).

Istnieje również 109-bajtowe rozwiązanie wykorzystujące HashSets, podobne do odpowiedzi w Javie tutaj, ale zamierzam trzymać się mojego oryginalnego rozwiązania dla mojego wyniku.

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

Java 8, 154 znaków

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

Nazywany tak:

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

Wyjścia:

true
true
true
true
true
false
false

Bardzo 8-letnia odpowiedź w języku Java, wykorzystująca zarówno lambda, jak i strumienie, w tym niektóre fantazyjne konwersje liczb na ciągi.

Niestety musimy użyć BigInteger.pow(3)zamiast Math.pow(a,3)Math.pow z użyciem nieprecyzyjnych podwójnych, które zwracają niepoprawne wartości z dużymi liczbami (zaczynając od 2103869).

GRZMOTNĄĆ, 69, 59 bajtów

AKTUALIZACJA

Innym dobrym sposobem na zrobienie tego w bashu jest użycie tr (62 bajtów, ale prawdopodobnie może być ściśnięty nieco więcej)

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

EDYCJA: Jeszcze więcej optymalizacji (Thx! @Manatwork)

Grał w golfa

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 - dla sukcesu (kod wyjścia) 1 - dla niepowodzenia (kod wyjścia)

funkcja kodu maszynowego x86-64, 40 bajtów.

Lub 37 bajtów, jeśli 0 kontra niezerowe jest dozwolone jako „prawda”, np. Strcmp.

Dzięki odpowiedzi C Karla Napfa na pomysł na mapę bitową, który x86 może bardzo skutecznie zrobić z BTS .

Podpis funkcji: _Bool cube_digits_same(uint64_t n);przy użyciu ABI x86-64 System V. ( nw RDI: logiczna wartość zwracana (0 lub 1) w AL).

_Booljest zdefiniowany przez ISO C11 i jest zwykle używany #include <stdbool.h>do definiowania boolprzy użyciu tej samej semantyki co C ++ bool.

Potencjalne oszczędności:

• 3 bajty: Zwracanie warunku odwrotnego (niezerowego, jeśli występuje różnica). Lub z wbudowanego asm: zwracanie warunku flagi (co jest możliwe w gcc6)
• 1 bajt: Gdybyśmy mogli zablokować EBX (zrobienie tego nadałoby tej funkcji niestandardową konwencję wywoływania). (może to zrobić z wbudowanego asm)
• 1 bajt: instrukcja RET (z wbudowanego asm)

Wszystkie te są możliwe, jeśli byłby to fragment wbudowanego asm zamiast funkcji, co dałoby 35 bajtów dla wbudowanego 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.

PĘTLA wydaje się najmniejszym sposobem powtórzenia raz. Patrzyłem również na powtórzenie pętli (bez prefiksów REX i innego rejestru bitmap), ale to nieco większe. Próbowałem także użyć PUSH RSI i użyć test spl, 0xf/ jzdo zapętlenia raz (ponieważ ABI wymaga, aby RSP był wyrównany 16B przed CALL, więc jeden push wyrównuje go, a drugi ponownie wyrównuje). Nie ma test r32, imm8kodowania, więc najmniejszym sposobem była instrukcja 4B TEST (w tym prefiks REX), aby przetestować tylko niski bajt RSP na imm8. Taki sam rozmiar jak LEA + PĘTLA, ale wymagane są dodatkowe instrukcje PUSH / POP.

Przetestowano dla wszystkich nw zakresie testowym vs. implementacja C steadyboksa (ponieważ używa innego algorytmu). W dwóch przypadkach różnych wyników, na które patrzyłem, mój kod był poprawny, a kod steadyboksa był niepoprawny. Myślę, że mój kod jest poprawny dla wszystkich 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);
    }
}

Jedyne drukowane linie mają c = 1 asm = 0: fałszywie dodatnie dla algorytmu C.

Przetestowano również pod kątem uint64_timplementacji tego samego algorytmu w wersji C Karla, a wyniki są zgodne dla wszystkich danych wejściowych.

Haskell, 47 bajtów

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

Bardzo wolno. Przetestuj za pomocą c<-['0'..'9'].

Testuje każdy znak pod kątem włączenia do reprezentacji ciągu ni tworzy listę tych zawartych. Podobnie n^3sprawdza i sprawdza, czy listy są równe.

Dyalog APL , 10 bajtów

⍕≡⍕∪(⍕*∘3)

⍕≡ to reprezentacja tekstowa argumentu identyczna z

⍕∪ związek reprezentacji tekstu argumentu i

(⍕*∘3) tekstowa reprezentacja argumentu w kostce?

Wypróbuj APL online!

Uwaga: W przypadku dużych liczb ustaw ⎕PP←34 ⋄ ⎕FR←1287(34 cyfry znaczące, 128-bitowe zmiennoprzecinkowe)

Clojure, 35 bajtów

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

Java 7, 185 178 znaków

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

Zadzwoń jako:

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

Wynik:

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

(Nigdy nie jestem pewien, czy muszę liczyć również import i definicje metod ... Widziałem obie strony. Sam kod miałby jednak tylko 141 bajtów).

Galaretka , 8 bajtów

*3ṢQ⁼ṢQ$

Wypróbuj online!

Wyjaśnienie:

       $    # 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 bajtów

Ponieważ nie mamy wystarczającej różnorodności z pytaniami, dodajmy nie jedną, ale dwie kolejne! Oba mają 10 bajtów i zostały przetestowane 106239jako przykładowe dane wejściowe (których niektóre inne odpowiedzi zawiodły).

!s.++Q,`**

Wyjaśnienie:

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

Wypróbuj pierwszą odpowiedź za pomocą internetowego zestawu testów.

Druga odpowiedź:

qFmS{`d,**

Wyjaśnienie:

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

Wypróbuj drugą odpowiedź, korzystając z internetowego zestawu testów.

Kotlin: 46/88/96 bajtów

Pytanie nie określa, skąd pochodzi dane wejściowe, więc oto typowe 3 źródła danych wejściowych.

Funkcja: 46 bajtów

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

main () przy użyciu argumentu pierwszego programu: 88 bajtów

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

main () przy użyciu standardowego wejścia: 96 bajtów

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

Haskell, 54 52 bajty

Dzięki @Laikoni za zapisanie dwóch bajtów.

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

JavaScript (ES6), 44 bajty

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

Port doskonałej odpowiedzi C w KarlNapf. ES7 zapisuje bajt przez n**3. Działa tylko do 208063 z powodu ograniczonej precyzji liczbowej JavaScript; jeśli potrzebujesz go tylko do pracy do 1290, możesz zapisać kolejny bajt.

Perl 6 , 22 bajtów

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

Rozszerzony:

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

Różnica Symetryczny Zestaw ｢⊖｣ zwraca pusty Zestaw, jeśli obie strony są równoważnymi Zestawami (automatycznie zamienia listę w Zestaw). W tym momencie pozostaje tylko odwrócić to logicznie.

C ++, 82 bajty

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

Funkcja t (a) zwraca odpowiedź. Używa int jako zestawu. Ładnie wydrukowane:

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 bajtów

Bierze nze standardowego wejścia, rozdziela ni n^3do jednej cyfry i porównuje dwa zestawy. Używa gmppakietu do obsługi dużych liczb całkowitych (dzięki Billywob za wskazanie tej wady). Teraz używa substringcięcia ni n^3dzięki @MickyT za sugestię. (Poprzednie wersje używane scani gsubhacky).

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

C ++ 14, 93 bajty

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 mojej odpowiedzi C działa dla dużych liczb (połączenie z Lsufiksem).

Haskell, 47 bajtów

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

Przykład użycia: f 102343-> False.

Wykorzystuje zestawy z Data.Setmodułu. Funkcja pomocnika szamienia liczbę w jej ciąg znaków, a następnie tworzy zestaw znaków.

Brachylog , 11 bajtów

doI,?:3^doI

Wypróbuj online!

Dzięki @DestructibleWatermelon za wskazanie problemu z moją pierwotną odpowiedzią.

Wyjaśnienie

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

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

(Nowa linia dla przejrzystości, nieuwzględniona w bajtecount)

Pierwszy wiersz definiuje się fjako filter(wystarczająco podobna do funkcji dla naszych celów, aby nie wchodzić w szczegóły), który pobiera dane wejściowe $ni wykonuje następujące czynności:

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

Druga linia zajmuje wejście $args, wykonuje fna nim, i sprawdza, czy jest to -eqseksualnego, aby fprzeprowadzić na $xsześcienny. Zwróć uwagę na jawną [bigint]obsadę, wymaganą w przeciwnym razie uzyskamy wynik w notacji naukowej, co oczywiście nie zadziała.

Wynik boolowski jest pozostawiany w potoku, a dane wyjściowe są niejawne.

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

Zapisano bajt dzięki @ConnorLSW

Groovy, 35 51 znaków / bajtów

Smutno mi było nie widzieć Groovy, więc oto moja oryginalna 51-bajtowa próba:

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

Przepisany jako 35-bajtowe anonimowe zamknięcie i **do potęgowania, dzięki manatwork:

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

Niektóre przypadki testowe dla oryginalnej funkcji:

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

Nazwany zamknięcie cmożna nazwać tak: println c.call(107624). Anonimowe 35-bajtowe zamknięcie można nazwać tak:println ({"$it".toSet()=="${it**3}".toSet()}(107624))

Wyjścia:

true
true
true
true
true
false
false

Uwaga: dowiedziałem się, że istnieje coś takiego jak golf golfowy, więc mam nadzieję, że dobrze to zrozumiałem!

Rubinowy, 48 bajtów

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