数値n（0 <= n <= 2642245）が与えられた場合、nとn ³が同じ数字のセットを持っているかどうかを確認し、それに応じて真偽値を出力します。

たとえば、100という数字を確認しましょう。

100 ³は1000000です。

100の数字のセットは{0、1}です。

1000000の数字のセットは{0、1}です。

したがって、100は真実の値を与える必要があります。

テストケース

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

これはcode-golfであるため、バイト数が最も少ないコードが優先されることに注意してください。

OEIS A029795

Pythonの3、36の、32バイト

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

これはPython 3.5以降でのみ機能すると思います。カッパーのおかげで、4バイトがなくなっています。

05AB1E、6バイト

05AB1EはCP-1252エンコードを使用します。

3mê¹êQ

オンラインでお試しください！

説明

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

C、73バイト

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

ビットを介してセットを作成します。0同じセットに対して返されますが、異なるセットに対しては何でも返します。

ゴルフをしていない：

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（-plフラグ）= 25 21 18 34 33バイト

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

を使用して：

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

出力：1\nまたは0\n。

3バイトの@ Dada、1バイトのGabriel Benamy、バグレポートの@Zaidに感謝します。

Mathematica、34バイト

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

直接実装（1つの整数引数の名前のない関数）。

ゼリー、8 バイト

,3*\D‘ṬE

オンラインでお試しください！または、すべてのテストケースを確認します。

使い方

,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バイト

l_~3#s^!

テストスイート。

説明

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バイト

3バイトのDowngoatに感謝します！ES7に変換してのn**3代わりにを使用すると、バイトを保存できますn*n*n。

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

簡単です。

C位、241 208 205 201 193 233 222 220 212 203 177 159バイト（109の代替）

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

ラムダは具体的にulong型を使用する必要があります。

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

いくつかのバイトを保存してくれた@Corakと@Dennis_E、そして私の元のソリューションで問題を見つけてくれた@TimmyDに感謝します。@ long / long / decimal / etcの問題を指摘してくれた@SaxxonPikeに感謝します（実際に数バイトも節約されました）。

HashSetsを使用する109バイトのソリューションもあります。これは、Javaの回答と似ていますが、スコアについては元のソリューションに固執します。

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

Java 8、154文字

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

このように呼び出されます：

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

出力：

true
true
true
true
true
false
false

ラムダといくつかの派手な数字から文字列への変換を含むストリームを使用した、非常にJava 8-yの回答。

残念ながら、Math.powが非正確なdouble を使用するBigInteger.pow(3)代わりに使用する必要がありますMath.pow(a,3)。このdoubleは、（）で始まる大きな数値で不正な値を返します2103869。

BASH、 69、59バイト

更新

bashでこれを行う別の良い方法は、tr（62バイトですが、おそらくもう少し絞ることができます）を使用することです

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

編集：さらにいくつかの最適化（Thx！@manatwork）

ゴルフ

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

テスト

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-成功の場合（終了コード）1-失敗の場合（終了コード）

x86-64マシンコード関数、40バイト。

または、strcmpのように「真」として0対非ゼロが許可されている場合は37バイト。

ビットマップのアイデアに対するKarl NapfのCの回答のおかげで、x86はBTSで非常に効率的に実行できます。

関数シグネチャ：_Bool cube_digits_same(uint64_t n);、x86-64 System V ABIを使用。（nRDIでは、ALのブール戻り値（0または1））。

_BoolISO C11で定義されており、通常はC ++と同じセマンティクスで#include <stdbool.h>定義するために使用されます。boolbool

潜在的な節約：

• 3バイト：逆条件を返します（違いがある場合はゼロ以外）。またはインラインasmから：フラグ条件を返します（gcc6で可能）
• 1バイト：EBXを上書きできる場合（そうすると、この関数に非標準の呼び出し規則が与えられます）。（インラインasmから実行できます）
• 1バイト：RET命令（インラインasmから）

これが関数ではなくインラインasmフラグメントである場合、これらはすべて可能です。これにより、inline-asmで35バイトになります。

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.

ループは、1回繰り返す最小の方法のようです。また、ループの繰り返し（REXプレフィックスなし、異なるビットマップレジスタなし）を検討しましたが、それはわずかに大きくなります。また、PUSH RSIを使用し、test spl, 0xf/ jzを使用して1回ループしました（ABIではRSPがCALLの前に16Bアラインされる必要があるため、1回押すとアラインし、もう1つはミスアラインします）。test r32, imm8エンコードがないため、最小の方法は4B TEST命令（REXプレフィックスを含む）を使用して、imm8に対してRSPの下位バイトのみをテストすることでした。LEA + LOOPと同じサイズですが、追加のPUSH / POP命令が必要です。

テスト範囲内のすべてのnに対してテスト済み、対ステディボックスのC実装（異なるアルゴリズムを使用しているため）。私が見た結果が異なる2つのケースでは、コードは正しく、steadyboxのコードは間違っていました。私のコードはすべての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);
    }
}

印刷される唯一の行には、c = 1 asm = 0：Cアルゴリズムの偽陽性があります。

またuint64_t、同じアルゴリズムのカールのC実装のバージョンに対してテストされ、結果はすべての入力に一致します。

Haskell、47バイト

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

非常に遅い。でテストしc<-['0'..'9']ます。

の文字列表現に含まれているすべての文字をテストし、含まれている文字nのリストを作成します。n^3リストが等しいかどうかについても同様にチェックします。

Dyalog APL、10 バイト

⍕≡⍕∪(⍕*∘3)

⍕≡ 引数のテキスト表現は次と同じです

⍕∪ 引数のテキスト表現の結合

(⍕*∘3) キューブ化された引数のテキスト表現？

TryAPLオンライン！

注：大きな数値の場合、設定⎕PP←34 ⋄ ⎕FR←1287（有効数字34、浮動小数点数128）

Clojure、35バイト

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

Java 7、185 178文字

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

として電話をかける：

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

出力：

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

（インポートとメソッド定義もカウントする必要があるかどうかはわかりません。どちらの方法も見ました。コード自体の長さはたった141バイトです。）

ゼリー、8バイト

*3ṢQ⁼ṢQ$

オンラインでお試しください！

説明：

       $    # 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バイト

Pythの答えには十分な多様性がないため、1つではなく、さらに2つ追加しましょう。どちらも10バイトであり106239、サンプル入力としてテストされています（他のいくつかの答えは失敗しました）。

!s.++Q,`**

説明：

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

オンラインテストスイートを使用して最初の回答をお試しください。

2番目の答え：

qFmS{`d,**

説明：

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

オンラインテストスイートを使用して2番目の答えを試してください。

Kotlin：46/88/96バイト

質問は、入力がどこから来たのかを特定しないので、ここに通常の3つの入力ソースがあります。

機能：46バイト

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

main（）最初のプログラム引数を使用：88バイト

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

標準入力を使用するmain（）：96バイト

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

Haskell、54 52バイト

@Laikoniに2バイトの保存をありがとう。

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

JavaScript（ES6）、44バイト

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

@KarlNapfの優れたC回答のポート。ES7はを介してバイトを保存しますn**3。JavaScriptの数値精度が制限されているため、最大208063までしか機能しません。最大1290までしか機能しない場合は、別のバイトを保存できます。

Perl 6、22バイト

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

拡張：

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

対称差集合は、 ｢⊖｣オペレータは空の戻りセットの双方が同等のセット（自動的に設定にリストをオン）である場合。その時点で残っているのは、論理的に反転することだけです。

C ++、82バイト

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）は答えを返します。intをセットとして使用します。きれいに印刷：

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バイト

取りnSTDIN、分割からnとn^3一桁にし、2つのセットを比較します。gmpパッケージを使用して大きな整数を処理します（その欠点を指摘してくれたBillywobに感謝します）。今使ってsubstringカットアップするnとn^3、提案のための@MickyTに感謝。（以前のバージョンを使用scanし、gsubハックのように）。

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

C ++ 14、93バイト

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回答のポートは、大きな数字（Lサフィックス付きの呼び出し）で動作します。

Haskell、47バイト

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

使用例：f 102343- > False。

Data.Setモジュールのセットを使用します。ヘルパー関数sは、数字を文字列表現に変換し、文字からセットを作成します。

Brachylog、11バイト

doI,?:3^doI

オンラインでお試しください！

私の元の答えの問題を指摘してくれた@DestructibleWatermelonに感謝します。

説明

(?)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バイト

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

（明確にするために改行、バイトカウントには含まれません）

最初の行はf、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

2行目は入力を受け取り$args、fそれ-eqをf実行し、$xキューブで実行するのが適切かどうかを確認します。明示的な[bigint]キャストに注意してください。そうしないと、科学表記法で結果が返されますが、これは明らかに機能しません。

ブール結果はパイプラインに残り、出力は暗黙的です。

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のおかげで1バイト節約

Groovy、35 51文字/バイト

Groovyが含まれていないのが残念だったので、51バイトのオリジナルの試みを以下に示します。

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

**マナトワークのおかげで、35バイトの匿名クロージャーとして、べき乗のために書き直されました。

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

元の関数のいくつかのテストケース：

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

名前付きクロージャーcは次のように呼び出すことができますprintln c.call(107624)。匿名の35バイトのクロージャーは、次のように呼び出すことができます。println ({"$it".toSet()=="${it**3}".toSet()}(107624))

出力：

true
true
true
true
true
false
false

ご注意：コードゴルフのようなものが今あることを知ったので、うまくいけばうまくいきました！

ルビー、48バイト

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