숫자 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

파이썬 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]&

직접 구현 (하나의 정수 인수의 이름없는 함수).

젤리 , 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.

자바 스크립트 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에게 감사드립니다. ulong / long / decimal / etc 문제를 지적 해 주신 @SaxxonPike에게 감사합니다 (실제로 몇 바이트를 절약했습니다).

여기에 Java 답변과 비슷한 HashSets를 사용 하는 109 바이트 솔루션이 있지만 내 점수에 대한 원래 솔루션을 고수 할 것입니다.

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 답변.

불행히도 우리는 정확하지 않은 double을 사용하는 Math.pow BigInteger.pow(3)대신에 사용해야 합니다 .Math.pow(a,3)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 바이트.

또는 0과 0이 아닌 값이 strcmp와 같이 "truthy"로 허용되는 경우 37 바이트입니다.

비트 맵 아이디어에 대한 Karl Napf의 C 답변 덕분에 x86은 BTS로 매우 효율적으로 작업 할 수 있습니다 .

기능 서명 : _Bool cube_digits_same(uint64_t n);, x86-64 System V ABI 사용. ( nRDI에서 부울 리턴 값 (0 또는 1)은 AL).

_Bool는 ISO C11에 의해 정의되며 일반적 으로 C ++과 동일한 의미로 #include <stdbool.h>정의 bool하는 데 사용됩니다 bool.

잠재적 절감 :

• 3 바이트 : 역 조건 반환 (차가있는 경우 0이 아님). 또는 인라인 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.

루프는 한 번 반복하는 가장 작은 방법 인 것 같습니다. 또한 루프 (REX 접두사와 다른 비트 맵 레지스터가없는)를 반복하는 것을 보았지만 약간 더 큽니다. 또한 PUSH RSI를 사용하고 test spl, 0xf/ jz를 한 번 반복 하여 시도했습니다 (ABI는 RSP가 CALL 전에 16B로 정렬되어야하므로 한 번 누르면 정렬하고 다시 한 번 잘못 정렬하므로). 아무 없다 test r32, imm8인코딩되므로 작은 방법은 IMM8 RSP에 대해 단지 낮은 바이트를 테스트하기 위해 (a REX 접두사 포함)도 4b TEST 명령으로했다. 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 구현 버전에 대해 테스트 했으며 모든 입력에 대해 결과가 일치합니다.

하스켈, 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 비트 부동 소수점)으로 설정하십시오.

클로저, 35 바이트

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

자바 (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?)

온라인 테스트 스위트를 사용하여 두 번째 답변을 시도하십시오.

코 틀린 : 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())}

하스켈, 54 52 바이트

2 바이트를 절약 해 준 @Laikoni에게 감사합니다.

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

자바 스크립트 (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까지만 작동해야하는 경우 다른 바이트를 저장할 수 있습니다.

펄 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표준 입력, 스플릿에서 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접미사로 전화)에 작동합니다 .

하스켈, 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))

(바이트 수에 포함되지 않은 명확성을위한 줄 바꿈)

첫 번째 줄은 정의 fA와 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 덕분에 바이트를 절약했습니다.

그루비, 35 51 문자 / 바이트

Groovy가 포함되어 있지 않은 것이 슬 sad습니다. 따라서 원래의 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

참고 : 코드 골프와 같은 것이 현재 존재한다는 것을 알았으므로 희망이 있습니다.

루비, 48 바이트

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