我和我的朋友正在AP计算机科学课程的一个实验室里工作，并决定将一个问题编码为一个高尔夫，因为完成后我们仍然有一半的课程免费。这是问题：

给定数字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值计算，如果语言支持布尔值，当且仅当你的语言没有布尔变量，你可以用0表示false，用任何非零整数（最好是1或-1）表示true：

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，不是Trueor False。

C＃和System.Linq-26/40

根据规则，不计算方法声明本身。

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

再次说明，在考虑Java时，C＃是最佳选择。

不幸的是，此功能（以及许多其他答案）对于负输入不会产生正确的结果。我们可以解决此问题，但是解决方案失去了很多魅力（长度增加到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个字符（我认为，=>不应该包含大括号，而应包括在内）。处理负数的版本可以类似地缩短。

杀伤人员地雷（13 11）

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

说明：

• ⍎¨⍕⍵：评估字符串表示形式中的每个字符 ⍵
• ⍵|⍨：对于每一个，找到它的模，然后 ⍵
• 0∧.=：查看所有这些值是否等于 0

测试用例：

      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才计数。真值/ falsey值不计算在内。”

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

输出：

1
""

“ True”和“ False”定义为1和""。

勘误：
作为吉尔伯特正确地指出，perl的定义真实作为标量，它是两个整数1和字符串"1"同时，和假作为标量，它是两个整数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字节（方法体）

使用Jeroen Mostert的转换为双重技巧。

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

Pyth，12个字节

!f|!vT%vzvTz

这将过滤字符串中的字符以使其为零（!vT）或不对输入进行除法（%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-如果您甚至不知道genexps是一件事情，请举起手来。...只有我？

腐霉病 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*/@:=如果所有结果均为0，则返回true，否则返回false。

   f 162
1
   f every 204 212 213
0 1 0

爪哇- 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 tor true和0表示false。

JavaScript（ES6）30

具有一个数字参数的函数。使用％和减法，不需要特殊情况'0'，因为0％0在JavaScript中是NaN。

编辑已保存的1个字符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);}

请不要设置第二个参数！

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以获得每个除法的小数部分，确认所有这些均为零（如果由于/ 0而为NaN，则总和为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

重击-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个字符

打高尔夫球：

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