Мой друг и я работали в лаборатории в нашем классе AP Computer Science и решили написать одну из проблем, так как у нас все еще оставалась свободная половина класса, когда мы закончили. Вот вопрос:

Учитывая число n, делится ли n на каждую из его цифр?

Например, 128 пройдет этот тест - он делится на 1,2 и 8. Любые числа с нулем автоматически дисквалифицируют число. Хотя вы можете использовать другие языки и публиковать решения с ними, если хотите, нам больше всего интересно узнать, насколько компактные люди могут создавать программы на Java, поскольку это язык, который мы используем в классе. Пока у нас обоих 51. Вот мой текущий код:

public boolean dividesSelf(int n){for(int p=n;n%10>0;)n/=p%(n%10)>0?.1:10;return n<1;}
// 51 characters

// Breakdown:
// for(int p=n;         Saves one semicolon to put declaration into for loop
// n%10>0;)             Basic check-for-zero
// n/=                  Pretty simple, discarding one number off of n at a time
// p%(n%10)>0?          If p (the given value) is not divisible by n%10 (the current digit)...
// .1:10;               Divide by .1 (multiply by 10) so it fails the check next iteration. If it is divisible, divide by 10 to truncate the last digit
// return n<1           If the number was fully divisible, every digit would be truncated, and n would be 0. Else, there would still be non-zero digits.

Требования

Подпись метода может быть любой, какой вы захотите. Просто посчитайте тело функции. Убедитесь, что метод возвращает логическое значение и передает только один числовой параметр (не строку).

Код должен быть в состоянии пройти все эти случаи (чтобы оставаться верным направлениям исходного вопроса, учитываются только логические значения true и false, если язык поддерживает логические значения. Если и только если ваш язык не имеет логических переменных, вы может представлять false с 0 и true с любым ненулевым целым числом (предпочтительно 1 или -1):

128 -> true
 12 -> true
120 -> false
122 -> true
 13 -> false
 32 -> false
 22 -> true
 42 -> false
212 -> true
213 -> false
162 -> true
204 -> false

Кроме того, мы не учитывали пробелы, поэтому не стесняйтесь делать то же самое, если только пробелы не важны для работы программы (так что переводы строки в Java не учитываются, а только один пробел между intи x=1считается). Удачи !

Perl 6, 13

sub golf($_) {
   $_%%.comb.all
}

Использует неявную переменную $_- $_ %% .comb.allэквивалентно $_ %% all($_.comb). %%является оператором «делится», и combбез дополнительного аргумента возвращает список символов в строке. Например, если аргумент равен 123, то функция оценивает

123 %% all(123.comb)

который

123 %% all(1, 2, 3)

автоматическое продвижение нитей делает это

all(123 %% 1, 123 %% 2, 123 %% 3)

который

all(True, False, True)

который является ложным в логическом контексте, потому что это соединение «все», и, очевидно, не все его элементы верны.

Должна быть возможность принудительно возвращать возвращаемое значение Boolи скрывать соединение от вызывающих, создавая сигнатуру функции sub golf($_ --> Bool()), но приведения в сигнатурах функций в Rakudo пока не работают. Возвращаемое значение по-прежнему правильно true или false, просто нет Trueили False.

C # и System.Linq - 26/40

По правилам, не считая самого объявления метода.

bool dividesSelf(int i) { 
    return(i+"").All(d=>i%(d-48d)<1);
}

Еще раз продемонстрировав, что C # - лучший выбор, когда рассматривается Java ... Я шучу, шучу!

К сожалению, эта функция (и многие другие ответы) не даст правильных результатов для отрицательного ввода. Мы можем это исправить, но решение теряет большую часть своего очарования (и увеличивается до 46 символов в длину):

return(i+"").All(d=>d>48&&i%(d-48)==0||d==45);

Изменить : сбрил один персонаж с предложением Тима.

Изменить : с введением членов с выражением тела в C # 6, мы можем сократить это дальше, вырезав return:

bool dividesSelf(int i) =>
    (i+"").All(d=>i%(d-48d)<1);

в общей сложности 26 символов (по моему мнению, =>их не следует включать больше, чем было бы в скобках). Версия, обрабатывающая отрицательные числа, может быть сокращена аналогичным образом.

APL ( 13 11)

{0∧.=⍵|⍨⍎¨⍕⍵}

Объяснение:

• ⍎¨⍕⍵: оценить каждый символ в строковом представлении ⍵
• ⍵|⍨: для каждого из них найдите модуль и ⍵
• 0∧.=: посмотреть, все ли равны 0

Testcases:

      N,[.5] {0∧.=⍵|⍨⍎¨⍕⍵} ¨ N←128 12 120 122 13 32 22 42 212 213 162 204
128 12 120 122 13 32 22 42 212 213 162 204
  1  1   0   1  0  0  1  0   1   0   1   0

Python 2: 43 символа

f=lambda n:any(n%(int(d)or.3)for d in`n`)<1

Проверяет, есть ли у числа ненулевые остатки по модулю его цифр, и выводит отрицание этого. Нулевые цифры обрабатываются странно: поскольку вычисления %0вызывают ошибку, цифры 0заменяются на .3, что, как представляется, всегда дает ненулевой результат из-за неточностей с плавающей запятой.

Тело функции составляет 32 символа.

Perl - 27 байт

sub dividesSelf{
    $_=pop;s/./!$&||$_%$&/ger<1
}

Не считая подписи функции, как указано в инструкции.

Пример использования:

use Data::Dump qw(dump);
for $i (128, 12, 120, 122, 13, 32, 22, 42, 212, 213, 162, 204) {
  printf "%3d -> %s\n", $i, dump(dividesSelf $i);
}

Пример вывода:

128 -> 1
 12 -> 1
120 -> ""
122 -> 1
 13 -> ""
 32 -> ""
 22 -> 1
 42 -> ""
212 -> 1
213 -> ""
162 -> 1
204 -> ""

Решение проблемы: «Только логические значения true и false учитываются. Значения Truthy / Falsey не учитываются».

use Data::Dump qw(dump);
dump(1 == 1);
dump(0 == 1);

Выходы:

1
""

«True» и «False» определяются как 1и "".

Ошибка:
как справедливо указывает Брэд Гилберт , Perl определяет true как скаляр, который одновременно является целым числом 1и строкой "1", и false как скаляр, который одновременно является целым числом 0и строкой "".

CJam, 11 10 байт

{
    _Ab:df%:+!
}:F;

Это определяет функцию с именем Fи отбрасывает блок из стека.

Попробуйте онлайн.

Контрольные примеры

$ cjam <(echo '{_Ab:df%:+!}:F;[128 12 120 122 13 32 22 42 212 213 162 204]{F}%p')
[1 1 0 1 0 0 1 0 1 0 1 0]

Как это устроено

_      " Copy the integer on the stack.                                          ";
Ab     " Push the array of its digits in base 10.                                ";
:d     " Cast each digit to Double.                                              ";
f%     " Take the integer on the stack modulus each of its digits.               ";
:+     " Add the results.                                                        ";
!      " Push the logical NOT of the sum.                                        ";

JavaScript ES6, 39 32 28 байт

v=>[...""+v].every(x=>v%x<1)

Спасибо core1024 за предложение заменить (""+v).split("")с [...""+v], и openorclose для предполагая использование everyфункции.

Ответ в настоящее время не содержит ни одного бита моего кода: O

Предыдущее решение

v=>[...""+v].filter(x=>v%x|!+x)==""

==""не является допустимым способом проверить, является ли массив пустым, поскольку [""]==""возвращает true, но массив гарантированно содержит непустую строку, поэтому он работает здесь.

Остальные являются стандартным сокращением типов преобразования в JavaScript.

Java 8, 46 байт (тело метода)

Использование преобразования Джероена Мостерта в двойной трюк.

public static boolean dividesSelf(int n) {
    return(""+n).chars().allMatch(x->n%(x-48d)<1);
}

Pyth, 12 байт

!f|!vT%vzvTz

Это фильтрует символы в строке как наличие нуля ( !vT) или не разделяет input ( %vzvT), а затем принимает логическое значение не результирующего списка.

Попробуй это здесь.

Ruby, 44 байта (тело функции: 37)

Вероятно, есть потенциал, чтобы дальше играть в гольф.

f=->n{n.to_s.chars.all?{|x|x>?0&&n%x.hex<1}}

Ввод через функцию f. Пример использования:

f[128] # => true
f[12]  # => true
f[120] # => false
...

Python - 59 50 49 47 байт

f=lambda n:all(c>'0'and 0==n%int(c)for c in`n`)

Я уверен, что есть более быстрый способ ... о хорошо.

Редактировать - Спасибо FryAmTheEggman за советы по игре в гольф.

Редактировать 2 - FryAmTheEggman, возможно, также написал это на данный момент, ой

Редактировать 3 - Руки вверх, если вы даже не знали, что генэкспы были чем-то особенным. ...Просто я?

Pyth 11

!f%Q|vT.3`Q

Это объединяет ответы @ isaacg и @ xnor . Он отфильтровывает цифры из входных данных, проверяя значение input % (eval(current_digit) or .3). Затем он проверяет, является ли полученная строка пустой или нет.

Наткнулся на еще пару вариантов такой же длины:

!f%Q|T.3jQT
!f|!T%QTjQT

Попробуйте онлайн.

Bash + coreutils, 44 байта

Полное определение функции:

f()((`tr 0-9 \10<<<$1``sed "s/./||$1%&/g"<<<$1`))

Я не уверен, как это оценить, поскольку обычно функции оболочки используют один набор {}или ()содержат тело функции. Я обнаружил, что здесь также можно использовать double, (())чтобы содержать тело функции, которое вызывает арифметическое расширение, которое мне здесь и нужно. Итак, пока я считаю только одну пару из этих скобок - дальнейшее обсуждение этого приветствуется.

Выход:

$ for i in 128 12 120 122 13 32 22 42 212 213 162 204; do f $i; printf "%d " $?; done
1 1 0 1 0 0 1 0 1 0 1 0 $
$

J - 14 символов

Тело функции - это часть после =:. Если мы хотим минимизировать количество символов для всей функции, это 15 символов */@(0=,.&.":|]).

f=:0*/@:=,.&.":|]

,.&.":кратчайший путь в J, чтобы развернуть как число в список его десятичных цифр: преобразовать в строку, разделить цифры и преобразовать каждую цифру обратно в число. ,.&.":|]принимает входной номер ( ]) по модулю ( |) эти цифры. 0*/@:=возвращает true, если все результаты были 0, иначе выдает false.

   f 162
1
   f every 204 212 213
0 1 0

Java - 121 102 97 79 78 байт

Я просто знаю, что это будет забито позже. Ну что ж.

boolean b(int a){int m=10,j,t=1;for(;m<a*10;m*=10){j=10*(a%m)/m;if(j==0||a%j>0)t=0;}return t>0;}

Я вернусь.

Хаскелл - 100 54 38

f x=all(\y->y>'0'&&x`mod`read[y]<1)$show x

Все еще учусь, критику оценили

CJam, 15 байтов

{_Abf{_g{%}*}:|!}

Это блок, наиболее близкий к функции в CJam. Я только считаю тело (т.е. опускаю скобки). Вы можете использовать его следующим образом:

128{_Abf{_g{%}*}:|!}~

Или, если вы хотите проверить серию входов, вы можете сделать

[128 12 120 122 13 32 22 42 212 213 162 204]{{_Abf{_g{%}*}:|!}~}%

Блок оставляет 0(ложно) или 1(верно) в стеке, чтобы указать результат. (CJam не имеет логического типа.)

Проверьте это здесь.

Объяснение:

_               "Duplicate input.";
 Ab             "Get base-10 digits.";
   f{      }    "This maps the block onto the list of digits, supplying the input each time.";
     _g         "Duplicate digit, get signum S (0 or 1).";
       { }*     "Repeat this block S times.";
        %       "Take input modulo digit.";
                "This leaves an array of zeroes for divisible digits, non-zeroes
                 for non-divisible digits, and non-zero junk for zeroes.";
            :|  "Fold OR onto this list. One could also sum the list with :+";
              ! "Logical NOT. Turns 0 into 1, and non-zero values into 0.";

Альтернатива, также 15 байтов

{:XAb{X\_X)?%},!}

объяснение

:X              "Store input in X.";
  Ab            "Get base-10 digits.";
    {       },  "Filter this list by the result of the block.";
     X\         "Push another copy of X, swap with digit.";
       _        "Duplicate digit.";
        X)      "Push X+1.";
          ?     "Select digit itself or X+1, depending on whether digit is 0 or not.";
           %    "Take modulo. X%(X+1) will always be nonzero for positive integers.";
              ! "Logical NOT. Turns an empty list into 1 and a non-empty list into 0.";

CJam, 15 байтов

{_Abf{_{%}1?}1b!}

{}это самая близкая вещь к функции в CJam. Я просто считаю тело функции

Используйте это так:

128{_Abf{_{%}1?}1b!}~

Получить либо 1(если число делится), либо 0(если число не делится на его цифры).

Попробуйте онлайн здесь

объяснение

_Ab                "Copy the number and split it to its digits";
   f{      }       "For each digit, run this code block on the number";
     _{%}1?        "If the digit is 0, put 1, otherwise perform number modulus digit";
            1b     "We now have an array of modulus corresponding to each digit. Sum it up";
              !    "Negate the sum. If all digits were divisible, sum of modules will be"
                   "0, thus answer should be 1 and vice versa";

C89, 43 байта

unsigned char d(int n, int c) {
        int a=n%10;return!n||a&&!(c%a)&&d(n/10,c);
}

C89 не имеет логического типа. Надеюсь, что это работает. Также я использовал второй параметр, чтобы передать копию оригинального числа через стек, но определение может быть любым. Чтобы получить правильный результат, вам просто нужно вызвать функцию с одинаковым значением для обоих параметров ( d(128, 128)).

РЕДАКТИРОВАТЬ: применены предложенные изменения от анонимного пользователя

C11 - 44 байта в теле функции

Другая версия C, не рекурсивная и без исключения с плавающей запятой.

bool digit_multiple(int i)
{
    for(int n=i;i%10&&n%(i%10)<1;i/=10);return!i;
}

Это также будет работать в C ++, Java и большинстве других C-подобных языков.

Отредактировано, чтобы включить улучшение комментария primo.

Юлия 32 25 23

Улучшено использование цифр

Также исправляет проблему с отрицательными числами

selfDivides(x)=sum(x%digits(x).^1.)==0

Старый метод

Все цифры делятся, если сумма всех остатков равна 0. Как и у других, есть проблема с отрицательными числами.

selfDivides(x)=sum(x.%(Float64["$x"...]-48))==0

Выход

[selfDivides(x) for x in [128,12,120,122,13,32,22,42,212,213,162,204]]
12-element Array{Any,1}:
  true
  true
 false
  true
 false
 false
  true
 false
  true
 false
  true
 false

Улучшенный метод также обрабатывает BigInt

selfDivides(BigInt(11111111111111111111111111111111111111112))
true

тем не мение

selfDivides(BigInt(11111111111111111111111111111111111111113))
false

потому что

BigInt(11111111111111111111111111111111111111113) %3
1

C / C ++, 58 байт (44 в теле)

Вызывает неопределенное поведение (см. Комментарии)

int d(int i){int j=i;while(i&&!(j%(i%10)))i/=10;return!i;}

trueи false являются 1 и 0, но вы можете добавить один символ подписи возвращать bool.

И для удовольствия, рекурсивная версия, которая меньше, если вы разрешаете вызовы вида r(128,128)

Изменить : теперь запрещено по правилам:

int r(int i,int j){return!i||!(j%(i%10))&&r(i/10,j);}

R: 72 67 65

Функция

f<-function(a)!(anyNA(a%%(d=as.double(strsplit(paste0(a),"")[[1]])))|sum(a%%d))

Спасибо @AlexA и @plannapus за экономию

Тестовый забег

i=c(128,12,120,122,13,32,22,42,212,213,162,204)
for(a in i){print(f(a))}
[1] TRUE
[1] TRUE
[1] FALSE
[1] TRUE
[1] FALSE
[1] FALSE
[1] TRUE
[1] FALSE
[1] TRUE
[1] FALSE
[1] TRUE
[1] FALSE

GNU Awk: 53 символа

Подсчитанная часть:

for(;++i<=split($1,a,//);)r=r||!a[i]||v%a[i];return!r

Вся функция:

function self_divisible(v, i, r)
{
    for (; ++i <= split($1, a, //); )
        r = r || ! a[i] || v % a[i]

    return ! r
}

Поскольку Awk не имеет логических значений, возвращает 1 для true и 0 для false.

JavaScript (ES6) 30

Функция с одним числовым параметром. Используя% и вычитание, нет необходимости в специальном случае '0', потому что 0% 0 - это NaN в JavaScript.

Редактировать Сохранено 1 символ thx DocMax

F=n=>[for(d of t=n+'')t-=n%d]&&t==n 

Просто ради забавы, нарушая правило о неисчислении подписи функции, 4

Check=(n,t=n+'',q=[for(d of t)n-=t%d])=>t==n

Тест в консоли FireFox / FireBug

console.log([128, 12, 120, 122, 13, 32, 22, 42, 212, 213, 162, 204]
.map(x=>+x + ' -> ' + F(x)).join('\n'))

Выход

128 -> true
12 -> true
120 -> false
122 -> true
13 -> false
32 -> false
22 -> true
42 -> false
212 -> true
213 -> false
162 -> true
204 -> false

PHP: 85 байт (64 байта на теле)

Чтобы эта функция работала, просто передайте строку или число.

0 правильно вернет false.

Код:

function f($n,$i=0){for($n.='';$n[$i]&&$t=!($n%$n[$i++]););return$t&&$i==strlen($n);}

Пожалуйста, НЕ УСТАНАВЛИВАЙТЕ 2-Й ПАРАМЕТР!

Javascript: 76 байт (61 байт на теле)

Это переписать предыдущую функцию.

Не сильно изменилось между обеими версиями.

Вот код:

function f(n){for(i=0,n+='';n[i]/1&&(t=!(n%n[i++])););return t&&i==n.length}

Полиглот: Javascript + PHP 187 217 байты (76 84 байта без шаблона):

Почему я это сделал?

Из-за причины и, возможно, потому что я могу!

Просто игнорируйте ошибку на PHP: все равно работает!
Больше не нужно, это было исправлено путем удаления 3 байтов.

Вот этот шедевр:

if('\0'=="\0"){function strlen($s){return $s['length'];}}
function toString(){return'';}
function f($n){for($i=0,$n=$n.toString();$n[$i]/1&&($t=!($n%$n[$i++])););return $t&&$i==strlen($n);}

Вы можете запустить этот код как на своей консоли, так и на интерпретаторе PHP!

Старая версия:

if('\0'=="\0"){function strlen($s){return $s['length'];}}
function s($s){return('\0'=="\0")?$s+'':str_replace('','',$s);}
function f($n,$i){for($i=0,$n=s($n);$n[$i]/1&&($t=!($n%$n[$i++])););return $t&&$i==strlen($n);}

Октава, 33 (39, включая настройку функций)

Использование числового преобразования в матрицу:

f=@(a)sum(mod(a./(num2str(a)-48),1))==0

Разделите число поэлементно на матрицу X, где X получается путем преобразования числа в строку и вычитания 48, чтобы снова перейти от значений ASCII к числам. Возьмите по модулю 1, чтобы получить десятичную часть каждого деления, подтвердите, что все они равны нулю (если они равны NaN из-за / 0, сумма будет равна NaN и, следовательно, не равна нулю).

Пример ввода с использованием www.octave-online.net:

f=@(a)sum(mod(a./(num2str(a)-48),1))==0
for j=[128,12,120,122,13,32,22,42,212,213,162,204]
f(j)
end

Выход:

ans =  1
ans =  1
ans = 0
ans =  1
ans = 0
ans = 0
ans =  1
ans = 0
ans =  1
ans = 0
ans =  1
ans = 0

MATLAB - 39 символов

function [b] = dividesSelf(i)
b=all(~mod(i,sscanf(num2str(i),'%1d')))
end

BASH - 117 знаков

f(){ [[ $1 =~ 0 ]]&& return 0 || r=;n=$1;for((i=0;i<${#n};i++));do r=$(($r+${n}%${n:$i:1}));done;return $(($r==0));}

тесты

for N in 128 12 120 122 13 32 22 42 212 213 162 204; do
  f $N
  echo "${N} ->  $?"
done

128 ->  1
12 ->  1
120 ->  0
122 ->  1
13 ->  0
32 ->  0
22 ->  1
42 ->  0
212 ->  1
213 ->  0
162 ->  1
204 ->  0

PHP - 74 71 64 символов

Golfed:

function t($n){while($n>1){if(!($b=$n%10)||($n%$b)){return 0;}$n/=10;}return 1;}

Меньше гольфа

function t($n){
    while($n>1){
        if( !($b=$n%10) || ($n%$b) )
            { return 0; }
        $n/=10;
    }
    return 1;
}

Результаты теста:

(Код)

$ans = array(128,12,120,122,13,32,22,42,212,213,162,204);
foreach($ans as $a)
{ echo "$a -> ".(t($a)?"True":"False").PHP_EOL; }

(Выход)

128 -> True
12 -> True
120 -> False
122 -> True
13 -> False
32 -> True
22 -> True
42 -> True
212 -> True
213 -> True
162 -> False
204 -> False