Враховуючи число n (0 <= n <= 2642245), перевірте, чи n і n ³ мають однаковий набір цифр, і відповідно виведіть значення truthy або falsey.

Наприклад, давайте перевіримо число 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 та пізніших версіях. Чотири байти пішли завдяки міді.

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 байти, Габріелю Бенамі за 1 байт, а @Zaid за повідомлення про помилки.

Математика, 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 байт

Дякую Пуховику за 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;};

Лямбди повинні спеціально використовувати 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-у, використовуючи лямбда, а також потоки, включаючи певні перетворення числа на рядок.

На жаль, нам потрібно використовувати 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`" ];}

EDIT: Ще кілька оптимізацій (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 проти не нуля дозволено як "truthy", як strcmp.

Завдяки C відповіді Карла Напфа за раціональну ідею, яку x86 може зробити дуже ефективно з BTS .

Підпис функції: _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 байти: Повернення оберненої умови (ненульової, якщо є різниця). Або з вбудованого asm: повернення умови прапора (що можливо з gcc6)
• 1 байт: Якби ми могли сковувати EBX (це зробило б цю функцію нестандартною умовою виклику). (міг би зробити це з inline asm)
• 1 байт: інструкція RET (від вбудованого ASM)

Все це можливо, якби це був вбудований фрагмент asm замість функції, яка зробила б його 35 байтами для inline-asm .

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 вирівнювався 16B перед CALL, тому один натискання вирівнює його, а інший знову вирівнює). test r32, imm8Кодування немає , тому найменший спосіб полягав у інструкції 4B TEST (включаючи префікс REX), щоб перевірити лише низький байт RSP проти імунітету8. Той самий розмір, що і LEA + LOOP, але потрібні додаткові інструкції PUSH / POP.

Тестується для всіх n в тестовому діапазоні, порівняно з реалізацією C на постійній панелі (оскільки він використовує інший алгоритм). У двох випадках із різними результатами, які я розглянув, мій код був правильним, а стійка скринька помилялася. Я думаю, що мій код правильний для всіх 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і перевіряє, чи списки рівні.

Діалог APL , 10 байт

⍕≡⍕∪(⍕*∘3)

⍕≡ це подання тексту аргументу, ідентичне

⍕∪ об'єднання тексту аргументації аргументу та

(⍕*∘3) текстове подання кубового аргументу?

СпробуйтеAPL онлайн!

Примітка. Для великої кількості встановіть ⎕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?)

Спробуйте другу відповідь, використовуючи онлайн-тестовий набір.

Котлін: 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 відповідь Порта @ 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
  )
}

Оператор симетричного набору difference ⊖ ｣ повертає порожній набір, якщо обидві сторони еквівалентні Набори (автоматично перетворює список у набір). У той момент єдине, що залишається зробити, це перетворити його логічно.

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

Порт моєї відповіді на С , працює для великої кількості (дзвінок із Lсуфіксом).

Haskell, 47 байт

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

Приклад використання: f 102343-> False.

Використовує набори з Data.Setмодуля. Хелперна функція sперетворює число в його рядкове подання і чим робить набір символів.

Брахілог , 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на ньому, і перевіряє , чи є це -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

Зверніть увагу: я дізнався, що щось на кшталт кодового гольфу існує саме зараз, тому, сподіваюся, я все правильно зрозумів!

Рубін, 48 байт

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