Если задано число n (0 <= n <= 2642245), проверьте, имеют ли n и n ³ одинаковый набор цифр, и выведите соответственно значение truey или false.

Например, давайте проверим число 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для того же набора, что-нибудь еще для разных наборов.

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\nили 0\n.

Спасибо @Dada за 3 байта, Габриэлю Бенами за 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;};

Лямбда должна специально использовать 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).

BASH, 6959 байт

ОБНОВИТЬ

Другой хороший способ сделать это в bash - использовать tr (62 байта, но, вероятно, его можно сжать немного больше)

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

РЕДАКТИРОВАТЬ: Еще несколько оптимизаций (Thx! @Manatwork)

Golfed

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 за идею растрового изображения, которую 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 (это дало бы этой функции нестандартное соглашение о вызовах). (может сделать это из встроенного ассема)
• 1 байт: инструкция RET (из встроенного asm)

Все это возможно, если бы это был фрагмент inline-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 против imm8. Тот же размер, что и LEA + LOOP, но с дополнительными инструкциями PUSH / POP.

Проверено для всех n в тестовом диапазоне, по сравнению с реализацией Си от устойчивой среды (поскольку она использует другой алгоритм). В двух случаях, когда я смотрел на разные результаты, мой код был верным, а версионный - неверным. Я думаю, что мой код правильный для всех 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вариант версии того же алгоритма, реализованный Карлом С, и результаты совпадают для всех входных данных.

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

Порт @ KarlNapf отличный ответ C. ES7 сохраняет байты через n**3. Работает только до 208063 из-за ограниченной числовой точности JavaScript; если вам нужно, чтобы он работал до 1290, вы можете сохранить еще один байт.

Perl 6 , 22 байта

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

Expanded:

{ # 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 difference 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от стандартного устройства ввода, расколов 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превращает число в его строковое представление, а затем создает набор из символов.

Брахилог , 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(достаточно похожая на функцию для наших целей, чтобы не вдаваться в подробности), которая принимает входные данные $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-байтовое анонимное закрытие и **для возведения в степень, благодаря manatwork:

{"$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

Пожалуйста, обратите внимание: я узнал, что нечто вроде Code Golf существует только сейчас, так что, надеюсь, я понял это правильно!

Рубин, 48 байтов

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