给定数字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及更高版本。多亏了Copper，四个字节已经消失了。

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。

感谢@Dada表示3个字节，Gabriel Benamy表示1个字节，@ Zaid表示错误报告。

Mathematica，34个字节

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

直接实现（一个整数参数的未命名函数）。

果冻，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字节

感谢Downgoat提供3个字节！您可以通过转换为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;};

Lambda必须专门使用以下ulong类型：

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

感谢@Corak和@Dennis_E保存了一些字节，并感谢@TimmyD发现了我原来的解决方案中的问题。感谢@SaxxonPike指出ulong / long / decimal / etc问题（实际上还为我节省了一些字节）。

还有一个使用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答案，使用lambda以及包括一些奇特的数字到字符串转换的流。

不幸的是BigInteger.pow(3)，Math.pow(a,3)由于Math.pow使用了不精确的双精度数，因此我们需要使用，而不是使用大精度的双精度数（以开头2103869）。

重击 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字节。

或37个字节（如果允许0到非零）是“真实的”，如strcmp。

多亏了Karl Napf的C回答了位图的思想，该x86可以非常有效地使用BTS进行操作。

功能签名：_Bool cube_digits_same(uint64_t n);，使用x86-64 System V ABI。（n在RDI中，布尔返回值（在AL中为0或1））。

_Bool由ISO C11定义，通常用于#include <stdbool.h>定义bool与C ++相同的语义bool。

潜在的节省：

• 3个字节：返回相反的条件（如果存在差异，则为非零）。或从内联asm：返回标志条件（使用gcc6可能）
• 1个字节：如果我们可以破坏EBX（这样做会使该函数具有非标准的调用约定）。（可以从嵌入式asm做到这一点）
• 1个字节：RET指令（从内联asm）

如果这是一个inline-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.

LOOP似乎是重复一次的最小方法。我也看过只是重复循环（没有REX前缀和不同的位图寄存器），但是稍微大一点。我还尝试使用PUSH RSI，并使用test spl, 0xf/ jz循环一次（因为ABI要求RSP在CALL之前是16B对齐的，因此一按即可将其对齐，而另一按则将其重新对齐）。没有test r32, imm8编码，因此最小的方法是使用4B TEST指令（包括REX前缀）来针对imm8测试RSP的低字节。与LEA + LOOP相同，但需要额外的PUSH / POP指令。

针对steadybox的C实现对测试范围内的所有n进行了测试（因为它使用了不同的算法）。在我看到的两种不同结果的情况下，我的代码是正确的，而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同一算法的Karl 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) 立方参数的文本表示形式？

在线尝试APL！

注意：对于大数字，请设置⎕PP←34 ⋄ ⎕FR←1287（34个有效数字，128位浮点数）

Clojure，35个字节

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

Java 7、185178个字符

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答案的了解不够多，因此我们不添加一个，而是再添加两个！两者均为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?

使用在线测试套件尝试第一个答案。

第二个答案：

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

使用在线测试套件尝试第二个答案。

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保存了两个字节。

(%)=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字节

需要n从stdin，分裂n和n^3成个位数，和两组进行比较。使用该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

第二行接受输入$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而节省了一个字节

Groovy，35个51字符/字节

我很遗憾没有看到Groovy，所以这是我最初的51字节尝试：

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

**多亏了manatwork，将其重写为一个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

请注意：我了解到像代码高尔夫这样的东西现在已经存在，所以希望我没错！

Ruby，48个字节

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