Bir sayısı göz önüne alındığında , N (0 <= N ise <= 2.642.245), kontrol , n ve n, ³ bir truthy veya Falsey değeri de buna uygun aynı basamak kümesini ve çıkış bulunmaktadır.

Örneğin, 100 sayısını kontrol edelim.

100 ³ , 1000000'dür.

100'deki rakam kümesi {0, 1} 'dir.

1000000’deki rakam kümesi {0, 1} 'dir.

Bu nedenle, 100 gerçeğe uygun bir değer vermelidir.

Test durumları

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

Unutmayın, bu kod golf , bu yüzden en az bayt olan kod kazanır.

OEIS A029795

Python 3, 36 32 bayt

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

Bunun sadece Python 3.5 ve sonrasında çalıştığını düşünüyorum. Copper sayesinde dört bayt gitti.

05AB1E , 6 bayt

05AB1E, CP-1252 kodlamasını kullanır .

3mê¹êQ

Çevrimiçi deneyin!

açıklama

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

C, 73 bayt

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

Seti bitler üzerinden oluşturur. İade 0aynı kümesi için, farklı setleri için başka bir şey.

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

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

Kullanımı:

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

Çıktı: 1\nveya 0\n.

3 bayt için @Dada, 1 bayt için Gabriel Benamy, ve hata raporları için @ Zaid Thanx.

Mathematica, 34 bayt

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

Doğrudan uygulama (bir tamsayı argümanının adsız işlevi).

Jöle , 8 bayt

,3*\D‘ṬE

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Nasıl çalışır

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

l_~3#s^!

Test odası.

açıklama

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 bayt

3 bayt için Downgoat'a teşekkürler! ES7'ye dönüştürerek ve n**3yerine kullanarak bir bayt kaydedebilirsiniz n*n*n.

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

Yeterince basit.

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

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'nın özellikle aşağıdakileri kullanması gerekir ulong:

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

Bazı baytları kaydetmek için @Corak ve @Dennis_E ve orijinal çözümümle ilgili bir sorun bulmak için @TimmyD sayesinde. @SaxxonPike'a ulong / long / decimal / etc problemini (ki bu da bana biraz bayt kazandırdı) gösterdiği için teşekkür ederiz.

Ayrıca burada Java cevaplarına benzer şekilde HashSets kullanarak 109 baytlık bir çözüm var, ancak puanım için orijinal çözümüme bağlı kalacağım.

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

Java 8, 154 karakter

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

Böyle denir:

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

Çıktılar:

true
true
true
true
true
false
false

Çok sayıda Java 8-y cevabı, bir lambda ve bazı süslü sayıdan dizeye dönüşümler içeren akışları kullanan bir cevap.

Ne yazık ki , büyük sayılarla yanlış değerler döndüren (başlangıçtan başlayarak ) kesin olmayan çiftler kullanarak Math.pow BigInteger.pow(3)yerine kullanmak zorundayız .Math.pow(a,3)2103869

BASH, 69, 59 bayt

GÜNCELLEME

Bunu bash yapmak için başka bir güzel yol tr (62 byte, ancak muhtemelen biraz daha sıkılmış olabilir) kullanmaktır

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

EDIT: Bazı daha fazla optimizasyon (Thx! @Manatwork)

golfed

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

Ölçek

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 - başarı için (çıkış kodu) 1 - başarısızlık için (çıkış kodu)

x86-64 makine kodu işlevi, 40 bayt.

Veya 0'a karşılık sıfır olmayana strcmp gibi "truthy" olarak izin verilirse 37 bayt.

Karl Napf'ın C'si sayesinde, x86'nın BTS ile çok verimli bir şekilde yapabileceği bitmap fikrine cevap .

İşlev imzası:, _Bool cube_digits_same(uint64_t n);x86-64 System V ABI kullanılarak. ( nRDI'da, boolean dönüş değeri (0 veya 1) AL cinsinden).

_BoolISO C11 ile tanımlanır ve tipik olarak C ++ ile aynı anlambilimiyle #include <stdbool.h>tanımlamak için kullanılır .boolbool

Potansiyel tasarruflar:

• 3 bayt: Ters koşulu döndürür (fark varsa sıfır olmayan). Veya satır içi asm'den: bayrak koşulu döndürmek (gcc6 ile mümkün)
• 1 byte: EBX'i engelleyebilseydik (böyle yaparsa bu fonksiyon standart olmayan bir çağrı kuralı olurdu). (satır içi asm bunu yapabilir)
• 1 bayt: RET komutu (satır içi asm'dan)

Bunların tümü, bir işlev yerine satır içi bir bölüm olsaydı , satır içi asm için 35 bayt yapabilecekse mümkün .

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 bir kez tekrar etmenin en küçük yolu gibi görünüyor. Ayrıca sadece döngüyü tekrarlamaya baktım (REX önekleri ve farklı bir bitmap kaydı olmadan), ama bu biraz daha büyük. Ayrıca PUSH RSI'yı kullanmayı ve test spl, 0xf/ jzdöngüsünü bir kez kullanmayı da denedim (ABI, RSP'nin CALL'den önce 16B hizalı olmasını gerektirdiğinden, bir itme onu hizalar, diğeri yeniden hizalar). test r32, imm8Kodlama yok , bu yüzden en küçük yol 4B TEST komutuyla (REX öneki dahil) bir imm8'e karşı RSP'nin sadece düşük baytını test etmekti. LEA + LOOP ile aynı boyutta, ancak ekstra PUSH / POP talimatları gerekli.

Steadybox'ın C uygulamasını (test farklı bir algoritma kullandığı için) vs. Baktığım farklı sonuçlardan iki tanesinde kodum doğruydu ve sabit kutu yanlıştı. Kodumun herkes için doğru olduğunu düşünüyorum.

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

Yazdırılan tek satırlar c = 1 asm = 0: C algoritması için yanlış pozitifler.

Ayrıca uint64_taynı algoritmanın Karl'ın C uygulamasının bir versiyonuna karşı test edildi ve sonuçlar tüm girdiler için uygun.

Haskell, 47 bayt

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

Çok yavaş. İle test et c<-['0'..'9'].

Her karakteri string temsili içerisine dahil etmek için test eder ve içerdiklerinin nbir listesini yapar. Aynı şekilde n^3listeler ve listelerin eşit olup olmadığını kontrol eder.

Dyalog APL , 10 bayt

⍕≡⍕∪(⍕*∘3)

⍕≡ bağımsız değişkeninin metin gösterimi aynı

⍕∪ Argümanın metin gösterimi birliği ve

(⍕*∘3) cubed argümanının metin gösterimi?

TryAPL çevrimiçi!

Not: Büyük sayılar için, ⎕PP←34 ⋄ ⎕FR←1287(34 önemli basamak, 128 bit yüzer) ayarlayın

Clojure, 35 bayt

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

Java 7, 185 178 karakter

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

Çağrı yap:

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

Çıktı:

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

(İthalatları ve yöntem tanımlarını da saymam gerekip gerekmediğinden asla emin değilim. Her iki şekilde de gördüm.

Jöle , 8 bayt

*3ṢQ⁼ṢQ$

Çevrimiçi deneyin!

Açıklama:

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

Çünkü Pyth cevaplarıyla yeteri kadar çeşitliliğimiz yok, bir tane değil iki tane daha ekleyelim! Her ikisi de 10 bayttır ve 106239örnek girdi olarak test edilmiştir (bazı cevaplar başarısız oldu).

!s.++Q,`**

Açıklama:

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

Çevrimiçi bir test takımı kullanarak ilk yanıtı deneyin.

İkinci cevap:

qFmS{`d,**

Açıklama:

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

Çevrimiçi bir test takımı kullanarak ikinci cevabı deneyin.

Kotlin: 46/88/96 bayt

Soru, girişin nereden geldiğini belirtmiyor, işte normal 3 giriş kaynağı.

İşlev: 46 bayt

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

main () ilk program değişkenini kullanarak: 88 bayt

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

main () standart girdi kullanarak: 96 bayt

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

Haskell, 54 52 bayt

İki bayt kaydettiğiniz için teşekkürler @Likonik.

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

JavaScript (ES6), 44 bayt

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

@ KarlNapf'ın mükemmel C cevabı limanı. ES7 yoluyla bir bayt kaydeder n**3. JavaScript'in sınırlı sayısal kesinliği nedeniyle yalnızca 208063'e kadar çalışır; sadece 1290'a kadar çalışması için ihtiyacınız varsa, başka bir bayttan tasarruf edebilirsiniz.

Perl 6 , 22 bayt

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

Expanded:

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

Simetrik Seti fark ｢⊖｣ operatör boş döner Set her iki taraf eşdeğer Setleri (otomatik Set içine bir liste çıkıyor) ise. Bu noktada yapılacak tek şey mantıksal olarak tersine çevirmek.

C ++, 82 bayt

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

T (a) işlevi cevabı verir. Küme olarak int kullanır. Güzel yazdırılır:

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 bayt

Alır nStdin, gelen böler nve n^3tek haneli içine ve iki set karşılaştırır. gmpBüyük tamsayıları işlemek için paketi kullanır (bu eksikliğe işaret ettiği için Billywob'a teşekkürler). Şimdi kullandığı substringkesmeye nve n^3öneri için @MickyT sayende. (Önceki sürümlerde kullanılan scanve gsubhack bir şekilde.)

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

C ++ 14, 93 bayt

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

C cevabımın limanı, büyük sayılar için çalışıyor ( Lsonek ile arama ).

Haskell, 47 bayt

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

Kullanım örneği: f 102343-> False.

Data.SetModülden setleri kullanır . Yardımcı işlev s, sayıyı dize olarak gösterir ve karakterlerden oluşan bir küme yapar.

Brachylog , 11 bayt

doI,?:3^doI

Çevrimiçi deneyin!

Orijinal cevabımla ilgili bir sorunu işaret ettiği için @DrucructibleWatermelon'a teşekkürler.

açıklama

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

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

(Netlik için Newline, bytecount'a dahil değil)

İlk satır, girdi alan ve aşağıdakileri yapan ( buradaki amaçlarımıza spesifikasyonlara girmeyen bir fonksiyona benzer fbir eşittir) olarak tanımlanır :filter$n

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

İkinci satır girdiyi alır, üzerinde işlem $argsyapar fve küp şeklinde gerçekleştirilmesinin -eqnormal olup olmadığını kontrol eder . Açıkça belirtilen alçıya dikkat edin, aksi takdirde sonucu kesinlikle işe yaramayacak olan bilimsel gösterimde geri alırız.f$x[bigint]

Boolean sonucu, boru hattında bırakılır ve çıktı kesindir.

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

@ConnorLSW sayesinde bir bayt kaydedildi

Groovy, 35 51 chars / bytes tarafından

Groovy'nin dahil olmadığını göremediğim için üzgündüm, işte orijinal 51 bayt denemem:

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

**Manatwork sayesinde, 35 baytlık isimsiz bir kapatma olarak ve üstel olarak yeniden yazılmıştır:

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

Orijinal işlev için bazı test durumları:

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

Bir adlandırılmış kapatma cböyle adlandırılabilir: println c.call(107624). Anonim 35 baytlık kapatma şöyle söylenebilir:println ({"$it".toSet()=="${it**3}".toSet()}(107624))

Çıktılar:

true
true
true
true
true
false
false

Lütfen dikkat: Şu anda kod golf gibi bir şeyin var olduğunu öğrendim, umarım bunu hak ettim!

Ruby, 48 bayt

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