รับตัวเลข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

โปรดจำไว้ว่านี่คือรหัสกอล์ฟดังนั้นโค้ดที่มีจำนวนไบต์น้อยที่สุดจะเป็นผู้ชนะ

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สำหรับชุดเดียวกันสิ่งอื่นสำหรับชุดอื่น

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 ( -plธง) = 25 21 18 34 33 ไบต์

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

โดยใช้:

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

ขาออกหรือ1\n0\n

Thanx ถึง @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**3n*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 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 สำหรับการค้นหาปัญหาด้วยโซลูชันดั้งเดิมของฉัน ขอบคุณ @SaxxonPike สำหรับการชี้ให้เห็นถึงปัญหา ulong / long / decimal / etc (ซึ่งจริง ๆ แล้วฉันก็ช่วยประหยัดไบต์ด้วย)

นอกจากนี้ยังมีวิธีการแก้ปัญหา109 ไบต์โดยใช้ HashSets คล้ายกับคำตอบของ 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 ที่มีการใช้แลมบ์ดาและสตรีมรวมถึงการแปลงตัวเลขเป็นสตริง

น่าเสียดายที่เราต้องใช้BigInteger.pow(3)แทนMath.pow(a,3)เนื่องจาก Math.pow ใช้คู่ที่ไม่แม่นยำซึ่งส่งคืนค่าที่ไม่ถูกต้องด้วยตัวเลขจำนวนมาก (เริ่มต้นด้วย2103869)

ทุบตี, 69, 59 ไบต์

UPDATE

อีกวิธีที่ดีในการทำเช่นนี้ในการทุบตีคือการใช้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

ขอบคุณสำหรับคำตอบ C คาร์ล Napf สำหรับความคิดบิตแมปซึ่ง x86 สามารถทำได้อย่างมีประสิทธิภาพมากกับบีทีเอส

ฟังก์ชั่นลายเซ็น: _Bool cube_digits_same(uint64_t n);ใช้ x86-64 System V ABI ( nใน RDI, ค่าบูลีนส่งคืน (0 หรือ 1) ใน AL)

_Boolจะถูกกำหนดโดย ISO C11 และมักจะถูกใช้โดย#include <stdbool.h>การกำหนดboolที่มีความหมายเช่นเดียวกับภาษา C bool++

การประหยัดที่มีศักยภาพ:

• 3 ไบต์: การกลับเงื่อนไขผกผัน (ไม่ใช่ศูนย์หากมีความแตกต่าง) หรือจาก inline asm: ส่งคืนเงื่อนไขแฟล็ก (ซึ่งเป็นไปได้กับ gcc6)
• 1 ไบต์: ถ้าเราสามารถปิดกั้น EBX (การทำเช่นนั้นจะทำให้ฟังก์ชั่นนี้เป็นแบบแผนการโทรที่ไม่ได้มาตรฐาน) (สามารถทำได้จาก inline asm)
• 1 ไบต์: คำสั่ง RET (จาก inline asm)

ทั้งหมดเหล่านี้เป็นไปได้ที่ว่านี้เป็นส่วนอินไลน์ 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/ jzto loop หนึ่งครั้ง (เนื่องจาก ABI ต้องการให้ RSP อยู่ในแนว 16B ก่อน CALL ดังนั้นการกดหนึ่งครั้งจะจัดแนวและอีกแนวหนึ่งอีกครั้ง) ไม่มีการtest r32, imm8เข้ารหัสดังนั้นวิธีที่เล็กที่สุดคือพร้อมกับคำสั่ง 4B TEST (รวมถึงคำนำหน้า REX) เพื่อทดสอบไบต์ที่ต่ำของ RSP เทียบกับ imm8 ขนาดเดียวกับ LEA + LOOP แต่ต้องใช้คำสั่ง PUSH / POP เพิ่มเติม

ทดสอบสำหรับ n ทั้งหมดในช่วงทดสอบเทียบกับการใช้งาน C ของ steadybox (เนื่องจากใช้อัลกอริทึมที่แตกต่างกัน) ในสองกรณีของผลลัพธ์ที่แตกต่างกันที่ฉันดูรหัสของฉันถูกต้องและกล่องเก็บของผิด ฉันคิดว่ารหัสของฉันถูกต้องสำหรับทุกคน

_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: false-positives สำหรับอัลกอริทึม C

ทดสอบกับuint64_tเวอร์ชันของการใช้ C ของ Karl ในอัลกอริทึมเดียวกันและผลลัพธ์ตรงกับอินพุตทั้งหมด

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) แสดงข้อความของการโต้แย้ง cubed?

ลองใช้ออนไลน์!

หมายเหตุ:สำหรับตัวเลขขนาดใหญ่ให้ตั้งค่า⎕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 ไม่หลากหลายพอลองเพิ่มอีกหนึ่งข้อ แต่เพิ่มอีกสองข้อ! ทั้งสองมีขนาด 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)

คำตอบที่ยอดเยี่ยมของ C @ Port of @ KarlNapf ES7 n**3ประหยัดไบต์ผ่าน ใช้งานได้ถึง 208063 เนื่องจากความแม่นยำของตัวเลขที่ จำกัด ของ JavaScript หากคุณต้องการใช้งานได้ถึง 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 102343False

ใช้ชุดจาก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))

(ขึ้นบรรทัดใหม่เพื่อความชัดเจนไม่รวมอยู่ใน bytecount)

บรรทัดแรกกำหนดfเป็นfilter(คล้าย - ish เพียงพอกับฟังก์ชั่นสำหรับวัตถุประสงค์ของเราที่นี่เพื่อไม่ไปลงในเฉพาะ) ที่รับอินพุต$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กับมันและตรวจสอบว่าเป็น-equal เพื่อ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()}

เขียนใหม่เป็นการปิดนิรนามแบบ 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]}