可除性测试

39

任务

给定两个严格的正整数n和d作为输入，请确定n是否可被d 整除，即是否存在整数q使得n = qd。

您可以编写程序或函数，并使用我们的任何标准方法来接收输入和提供输出。

输出应该是真实值或虚假值；如果n可被d整除，则为真；否则为f。

您的代码只需要处理可以本机表示的整数，只要它适用于所有带符号的8位整数即可。但是，您的算法必须适用于任意大整数。

您可以使用任何编程语言，但是请注意，默认情况下，这些漏洞是禁止的。

这是代码高尔夫球，因此以字节为单位的最短有效答案为准。

测试用例

 n,  d    output

 1,  1    truthy
 2,  1    truthy
 6,  3    truthy
17, 17    truthy
22,  2    truthy
 1,  2    falsy
 2,  3    falsy
 2,  4    falsy
 3,  9    falsy
15, 16    falsy

排行榜

这篇文章底部的Stack Snippet会根据答案a）生成目录，a）作为每种语言最短解决方案的列表，b）作为整体排行榜。

为确保您的答案显示出来，请使用以下Markdown模板以标题开头。

## Language Name, N bytes

N您提交的文件大小在哪里。如果您提高了分数，则可以将旧分数保留在标题中，方法是将它们打掉。例如：

## Ruby, <s>104</s> <s>101</s> 96 bytes

如果要在标头中包含多个数字（例如，因为您的分数是两个文件的总和，或者您想单独列出解释器标志罚分），请确保实际分数是标头中的最后一个数字：

## Perl, 43 + 3 (-p flag) = 45 bytes

您还可以将语言名称设置为链接，然后该链接将显示在代码段中：

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

显示代码段

code-golf  math  arithmetic  decision-problem  division 
— 漏尼姑
source
此对话已转移至聊天。
— 丹尼斯

Answers:

29

Brain-Flak，72 70 64 62 58 46字节

{({}[()]{(<()>)}{}<({}[()]<({}())>)>)}{}{{}}{}

以除数和除数（按此顺序）作为输入，并打印除数（真实）或不打印任何内容。由于每个堆栈都有一个隐含的，无限数量的零，因此应将空输出视为虚假的。

尽管不是堆栈清洁的，但此解决方案仅使用单个堆栈。

在线尝试！

感谢@WheatWizard高尔夫球了2个字节！

这个怎么运作

                INPUT: a (dividend), b (divisor)
                INITIAL STACK: n = a, d = b, r = 0
                               An infinite amount of zeroes follows.

{               While n is non-zero:
  (
    {}              Pop n from the stack.
    [()]            Yield -1.
    {               While the top of the stack (initially, d) is non-zero:
      (<()>)          Push 0.
    }
    {}              Pop 0. This will remove d from the stack if d = 0, leaving r
                    on top. We can think of this as performing the assignment
                    (d, r) = (r, d) if d = 0.
    <
      (
        {}              Pop d.
        [()]            Yield -1.
        <
          (
            {}              Pop r.
            ()              Yield 1.
          )               Push r + 1.
        >               Yield 0.
      )               Push d + (-1) + 0 = d - 1.
    >               Yield 0.
  )               Push n + (-1) + 0 + 0 + 0 = n - 1.
}               Each iteration decrements n, swaps d and r if d = 0, decrements d,
                and increments r.
                FINAL VALUES: n = 0
                              d = b - r
                              r = a % b if a % b > 0 else b
{}              Pop n.
{               While the top of the stack is non-zero:
  {}              Pop it.
}               This pops d and r if d > 0 (and, thus, a % b > 0) or noting at all.
{}              Pop d or a 0, leaving r if r = b and, thus, a % b = 0.

模量计算，42字节

可以以简单的方式修改上面的完整程序以计算模量。

{({}[()]<({}[()]<({}())>)>{(<()>)}{})}{}{}

和以前一样，此方法不是堆栈清洁的，但仅使用单个堆栈。模数为0将使堆栈为空，这大致等于保留0 ; 每个堆栈包含无限零。

在线尝试！

这个怎么运作

比较除数测试器和模量计算器的两个循环。

{({}[()]{(<()>)}{}<({}[()]<({}())>)>)}
{({}[()]<({}[()]<({}())>)>{(<()>)}{})}

唯一的区别是的位置{(<()>)}{}，如果d = 0，它将交换d和r。为了计算模量，我们在递减d和递增r 之后执行此交换。

如果％b> 0，则此更改不会影响结果，但如果％b = 0，则它会留下（n，d，r）=（0，b，0） –而不是（n，d，r）= （0，0，b） –在堆栈上。

因此，为了获得模量，我们只需要弹出Ñ和d与{}{}。

堆栈清洁模量计算，64字节

42字节的模数算法不是堆栈干净的，因此不能按原样在所有程序中使用。以下版本从活动堆栈中弹出除数和除数（按此顺序），并推回模数。它没有其他副作用。

({}(<()>)){({}[()]<(({}()[({})])){{}(<({}({}))>)}{}>)}({}{}<{}>)

该解决方案主要基于@WheatWizard的以前的72字节记录，但是通过从不切换堆栈来节省6字节。

在线尝试！

这个怎么运作

             INPUT: a (dividend), b (divisor)
             INITIAL STACK: n = a, b

(
  {}         Pop and yield n = a.
  (<()>)       Push d = 0.
)              Push n + 0 = n.
             STACK: n, d = 0, b
{(           While n in non-zero:
  {}           Pop and yield n.
  [()]         Yield -1.
  <
   ((
     {}         Pop and yield d.
     ()         Yield 1.
     [({})]     Pop b, push it back on the stack, and yield -b.
   ))         Push d + 1 + -b = d + 1 - b twice.
   {          While/if d + 1 - b is non-zero, i.e., if d < b - 1
     {}         Pop d + 1 - b (second copy).
     (<(
       {}         Pop d + 1 - b (first copy).
       ({})       Pop b and push it back on the stack.
     )>)        Push d + 1 - b + b = d + 1, then 0.
   }          If the loop wasn't skipped entirely, pushing 0 breaks out.
              If d < b - 1, it essentially performs the assignment d = d + 1.
              However, if d = b - 1, we get d = d + 1 - b = b - 1 + 1 - b = 0.
              In all cases, we wind up with d = (d + 1) % b.
   {}         Pop 0.
  >         Yield 0.
)}        Push n + -1 + 0 = n - 1. Break if n - 1 = 0.
          STACK: n = 0, d = a % b, b
(
  {}        Pop and yield n = 0.
  {}        Pop and d = a % b.
  <{}>      Pop b, but yield 0.
)         Push 0 + a % b + 0 = a % b.
— 丹尼斯
source
20

x86_32机器码，8个字节

08048550 <div7>:
 8048550:   99                      cdq   
 8048551:   f7 f9                   idiv   %ecx
 8048553:   85 d2                   test   %edx,%edx
 8048555:   0f 94 c0                sete   %al

这是我第一个打高尔夫球的代码，所以希望我能遵守所有规则。

这首先调用cdq清除edx寄存器，然后对ecx寄存器执行带符号除法，该操作将余数存储在edx中。如果edx为零，则测试edx，edx行将设置零标志，如果edx不为零，则sete将0设置为false，如果edx为0，则将1设置为true。

这只是导致字节数增加的代码片段，但是为了进行测试，这是我用内联汇编编写的C代码，因为这种方式更容易处理I / O。

— 达维
source
2
欢迎使用PPCG，不错的第一答案！
— Leaky Nun
是否需要完整的程序？我正在根据这个答案格式化我的回答。谢谢你！我希望在汇编/机器代码方面变得更好，以便打出更多代码！
— 戴维
1
默认情况下，允许在汇编中指定寄存器中输入和输出：input，output。这是完全可以接受的提交。欢迎来到PPCG！
— Mego
太棒了！谢谢！
— 戴维
17

Hexagony，15，13，12 10个字节

大家最喜欢的六角形语言！：D

TL; DR使用魔术，无格式的解决方案来减少字节数：

?{?..>1'%<.@!'/
?{?!1\.'%<@.>
?{?\!1@'%\!(
?{?!1\@'%<

@MartinEnder的布局向导节省了2个字节。

@FryAmTheEggman通过更创造性地使用角落节省了1个字节

@MartinEnder和@FryAmTheEggman都提出了一个10字节的解决方案，该解决方案不会为错误的值打印任何内容。

我的解决方案（15）：

未格式化：

?{?..>1'%<.@!'/

格式：

  ? { ?
 . . > 1
' % < . @
 ! ' / .
  . . .

@马丁·恩德的解决方案（13）：

未格式化：

?{?!1\.'%<@.>

格式：

  ? { ?
 ! 1 \ .
' % < @ .
 > . . .
  . . .

说明：

首先，我们得到输入并取模数。

  ? { ?
 . . . .
' % . . .
 . . . .
  . . .

然后，它检查模量是否为0。如果是，则IP向左旋转60度，从镜子反射，将单元格设置为1并打印。

然后，IP继续到第四行。当它到达时>，它改为向右转（因为该单元格的值现在为1）。oob，然后回到右下角标题NW。IP击中<，沿着第一行，然后返回右上角以击中@，从而停止程序。

  . . .
 ! 1 \ .
. . < @ .
 > . . .
  . . .

如果模数为正，则IP向右旋转60度。一旦它走出右下角，由于Hexagony的包装规则，它会继续在左下角边缘。将'被重用，使IP去细胞与0它。然后，IP沿第四行传播，环绕到第二行，点击打印，然后反射到中<。通往的其余路径@相同。

  . . .
 ! . \ .
' . < @ .
 > . . .
  . . .

那是一些严肃的巫术。

@FryAmTheEggman的解决方案（12）：

未格式化：

?{?\!1@'%\!(

格式：

  ? { ?
 \ ! 1 @
' % \ ! (
 . . . .
  . . .

说明：

像其他解决方案一样，它获取输入并采用模数。

  ? { ?
 . . . .
' % . . .
 . . . .
  . . .

然后，IP被偏转到底角。如果模数为正，则它位于左上边缘。在?没有更多的输入，因此它设置单元为0。!然后打印0，@终止该程序。

  ? . .
 \ ! . @
. . \ . .
 . . . .
  . . .

当模数为0时，事情变得非常棘手。首先，将其递减，然后重置为0，然后设置为1，然后打印。然后，将1减为0。此后，程序将像开始时一样运行，直到尝试执行0%0。这使它抛出一个静默错误并退出。

  ? { ?
 . . 1 .
' % \ ! (
 . . . .
  . . .

我真的很喜欢静默错误技巧，但更简单的方法是将替换为(，/以便IP第一次通过，而@第二次通过。

协作解决方案（10）：

未格式化：

?{?!1\@'%<

格式：

  ? { ?
 ! 1 \ @
' % < . .
 . . . .
  . . .

该程序与所有其他程序一样开始，获取输入并进行修改。

如果输入为0，则IP命中时将向左转<。它被偏转为1!@，打印1并退出。

  . . .
 ! 1 \ @
. . < . .
 . . . .
  . . .

如果输入为正，则IP命中时将向右转<。它从拐角处退出，并沿着右上边缘碰到@而没有打印。

  . . ?
 . . . @
. . < . .
 . . . .
  . . .
— 蓝色
source
6
我认为您应该以不同的方式设置答案。在单个代码块中有四个答案，就好像您的字节数错误一样。
— mbomb007 '16
17

脑防弹 102，98， 96个字节

(({}<>))<>{({}[()])<>(({}[()])){{}(<({}[({})])>)}{}({}({}))<>}{}<>([{}]{}){<>(([()])())}({}{}())

真是的 毛。我可能会发布一个解释，但我自己几乎看不懂。这种语言伤害了我的大脑。

在线尝试！

感谢github用户@Wheatwizard提出了一个模数示例。我自己可能无法弄清楚！

另外，简短的答案在这里。

可能不正确的解释：

(({}<>))                    #Push this element onto the other stack
<>                          #Move back to stack one.
{                           #While the top element is non-zero:
 ({}[()])                   #  Decrement the number on top
 <>                         #  Move to the other stack
 (({}[()]))                 #  Push the top element minus one twice
 {                          #  While the top element is non-zero:
  {}                        #    Pop the top element
  (<          >)            #    Push a zero
        ({})                #    Push the second from top element
       [    ]               #    Evalue this second from top element as negative
    ({}      )              #    And push that negative plus the top element
 }
 {}                         #  Pop the top element
 ({}({}))                   #  Push the top element plus the second from the top, AND push the second from top
 <>                         #  Switch stacks
}

{}                          #Pop the stack
<>                          #Switch to the other stack
([{}]{})                    #And push the top element minus the second element.

其余的非常简单。

{              }            #While the top element is non-zero:
 <>                         #Move to the other stack
   (([()])  )               #Push a negative one
          ()                #AND push the previously pushed value + 1 (e.g. 0)

                 (      )   #Push:
                  {}{}      #The top two elements added together
                      ()    #Plus one
— DJMcMayhem
source
The rest is pretty straightforward.是的，似乎是这样。
— 暴民埃里克（Erik the Outgolfer）
如果将每个brainflak指令算作一个字节，则为24个字节。
— noɥʇʎԀʎzɐɹƆ
12

Javascript（ES6）17 12 11字节

a=>b=>a%b<1
  • 编辑：删除了5个字节，因为预期为“ a> 0”。
  • EDIT2：由于Downgoat删除了1个字节。
— ETH生产
source
使用curring保存一个字节：a => b =>
— Downgoat
那么我该如何执行呢？当我尝试在JS控制台中d=a=>b=>a%b<1紧随其后d(32,2)...时，我只是得到响应function b=>a%b<1
— WallyWest '16
@WallyWest这使用了currying，因此您需要输入d(32)(2)。因为d(32)给出了function b=>a%b<1，所以您必须用您的b值调用该函数
— Cyoce '16
9

Vim，11击键

C<C-r>=<C-r>"<C-Left>%<C-Right><1<cr>

对于仅处理字符串的语言来说还不错。：D

— DJMcMayhem
source
怎么<C-Left>办？无法测试，因为它会在Mac> _>上切换窗口
— Downgoat
1
@Downgoat您正在使用ctrl还是Command？无论哪种方式，它都等效于“ b”，除了它也可以在插入模式下工作。
— DJMcMayhem
要学究一点，它等同于B而不是b（并且Ctrl+ Right等同于W）-区别在于非单词字符，但是在这种情况下，它的作用完全相同：) vimdoc.sourceforge.net/htmldoc/motion。 html＃<C左 >
— Christian Rondeau
9

Mathematica- 17 13 3个字节

∣

感谢@MartinEnder节省了大量的字节！

— 伊西
source
那是什么角色
— Cyoce '16
@Cyoce我不知道它的Unicode代码（目前在电话上），但是它是的简短运算符Divisible[]。
— Yytsi's
@Cyoce我认为这是管道符号，也称为Shift +反斜杠。
— 帕维尔
@Pavel如果它是管道符号，则不会是三个字节。
— Cyoce '16
— numbermaniac
8

视网膜，12字节

^(1+)\1* \1$

用一元分隔输入，例如111111111111 1111检查12是否被4整除。打印1（true）或0（false）。

在线尝试！

FryAmTheEggman保存了两个字节。糟糕，改写我的答案，以正确的顺序接受论点。（然后Fry在评论中击败了我。正则表达式我很慢！）

— 林恩
source
为了解决这个问题，如果有必要，我认为^(1+)\1* \1$这是可行的。
— FryAmTheEggman
我想对于新规范，相反的输入顺序也很好。
— Martin Ender
8

批处理，20字节

@cmd/cset/a!(%1%%%2)

1成功输出，0失败输出。

— 尼尔
source
8

C＃，27 13 12字节

a=>b=>a%b<1;

感谢TuukkaX指出可以接受匿名lambda。感谢大卫·康拉德（David Conrad）为我指出了一些我甚至都不知道的咖喱。

简短而有趣，因为我们只处理整数，所以我们可以使用<1而不是==0保存整个字节。

— JustinM-恢复莫妮卡
source
我不知道，但我认为你可以使用lambda： (a,b)=>a%b<1;。+1。
— Yytsi '16
@TuukkaX，谢谢，我不确定，这似乎很骗人。
— JustinM-恢复莫妮卡
这个JS版本使用currying将其减少一个字节，这也适用于C＃：（a=>b=>a%b<1;注意：然后必须将其称为f(a)(b)而不是f(a,b)）
— David Conrad
1
@DavidConrad太好了，谢谢。
— JustinM-恢复莫妮卡
7

Brainfuck，53个字节

将输入作为字节，输出是0x00或的字节值0x01。这是DivMod算法，后跟布尔值求反。

,>,<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>,>[<+>,]+<[>-<-]>.

在线尝试 -+末尾有很多附加功能，因此您可以看到ASCII输出。

— mbomb007
source
您可以删除事物的“ div”部分以节省字节吗？
— Leaky Nun
1
@LeakyNun这是给出模数的最短已知算法。删除它的一部分实际上会使它更长，因为您需要更多的临时单元格。您无法找到模而不除。
— mbomb007 '16
我明白了，谢谢。
— Leaky Nun
@LeakyNun只看除法算法有多长时间。
— mbomb007 '16
可能短一些，但是如果是这样，则没有人找到或发布它们。
— mbomb007 '16
7

Brain-Flak，88 86字节

(<({}<>)>)<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}<>(({}<{}>)){{}{}(<(())>)}{}

这是Green Eggs和Iron Man DJMcMayhem 博士和我自己编写的原始Brain-Flak可除性测试算法的密集版本。

以下是其工作原理的简短说明：

  ({}<>)        #Move the top of the stack to the other stack #Start Mod
(<      >)      #Push zero
<>              #Switch stacks
{               #While the top of the stack is not zero
 ({}[()])       #Subtract one from the top of the stack
 <>             #Switch stacks
   {}()         #Pop the top, add one and ...
       [({})]   #Subtract the second element on the stack
 ((          )) #Push twice
 {              #If the top is not zero
  {}            #Pop the duplicate
    ({}({}))    #Add the second element to the first
  (<        >)  #Push zero
 }              #End if
 {}             #Pop the zero
 <>             #Switch back
}               #End While
<>              #Switch to the other stack
 ({}<{}>)       #Remove the second value on the stack         #End Mod
(        )      #Duplicate the result of modulation
{               #If the top is not zero
 {}{}           #Pop the top two elements
 (<(())>)       #Push a one and a zero
}               #End if
{}              #Pop the zero

在线尝试！

— 小麦巫师
source
链接到在线口译员吗？
— Leaky Nun
干得好！也欢迎光临本站！希望你在这里玩得开心。（我当然有）
— DJMcMayhem
好的第一答案，欢迎来到PPCG！
— Leaky Nun
6

C，60字节

#include <stdio.h>
main(){int a,b;scanf("%d %d",&a,&b);a%b==0;}
— 罗龙纳
source
1
为什么是-1？向我解释
— Ronronner '16
3
可能没有人投票赞成。这是一个简短的答案，因此它被自动标记为低质量，然后您对其进行了编辑。由于某种原因，这会产生自动降票。对于那个很抱歉。+1从我。另外，我们允许使用功能，因此您可以轻松地将其缩短到int f(a,b){return !(a%b);}甚至更短。
— DJMcMayhem
3
不，我的意思是，它不必是一个完整的程序。您可以只提交一个函数。int f(a,b){return!(a%b);}是25个字节，如果使用正确的编译器，您甚至可以做f(a,b){return!(a%b);}21个字节。
— DJMcMayhem
3
更短的功能提交：#define f(a,b)!(a%b)（ideone链接）
— 美高
2
您需要定义一个函数或一个程序，而不仅仅是一个片段。
— Leaky Nun
5

Java 8，11字节

a->b->a%b<1

哎呀，有JS和C＃版本，为什么还没有Java版本？

用法：

import java.util.function.Function;

public class Program {
    public static void main(String[] args) {
        System.out.printf("%d, %d %b%n", 9, 3, divides(9, 3, a->b->a%b<1));
        System.out.printf("%d, %d %b%n", 3, 9, divides(3, 9, a->b->a%b<1));
    }

    public static boolean divides(int a, int b,
            Function<Integer, Function<Integer, Boolean>> f) {
        return f.apply(a).apply(b);
    }
}
— 戴维·康拉德
source
a->b->a%b<1这会引发语法错误，不是吗？
— dorukayhan希望莫妮卡回到
2
不，这是有效的Java 8
— 大卫·康拉德
有时甚至Java都看起来像Perl ...
— Mega Man
是的，我要补充一点，这仅是Java 8;）。
— 魔术章鱼缸
因此，对于Java 8，我们只需要计算lambda表达式字节，而不需要计算整个类和函数的样板，很酷！
— 西科斯基
4

Python，16个字节

lambda D,d:D%d<1
— 丹尼斯
source
1
请注意，如果允许使用负整数，则此方法将无效。幸运的是，这些输入严格是积极的。
— TLW
我做到了lambda a,b:1.*a/b==a/b，但印象深刻。这是一段如此复杂的代码...
— Egg the Outgolfer '16
4

CJam，6个 4字节

由于丹尼斯节省了2个字节

q~%!

在线尝试

q    e# Take in the input
 ~   e# Dump the individual values to the stack
  %  e# Modulus
   ! e# Boolean NOT
— 商务猫
source
3

Fortran 95，78个字节

function f(i,j)result(k)
integer::i,j,k
k=merge(1,0,MOD(i,j)<1)
end function f
— 杰里米
source
3

MarioLANG，121个 109 107字节

感谢Martin Ender，节省了14个字节

;>(-)-)+(([!)
)"=========#[
; +(![-)< )<!+
  ==#==="  "#:
>!< >(+ !![(<
=#"="===##=:"
  !      <
  #======"

在线尝试！

说明

该算法只是简单地从中减去d，n以查看是否可以进行整数倍且没有余数。

;
)
;

>
=
 
 

首先，收集输入。n在第一个单元格中，d在第二个单元格中。

 >(-)-)+(([!
 "=========#
          )<
           "
 !
 #"="===##=
  
  

这本质上是主循环。它减少第一个和第二个单元格，并增加第三个。

           [!)
           =#[
             !+
             #:
            (<
            :"
 
 

这是最终的输出。如果在递增/递减之后，第一个单元格为0，那么我们已经消除了n。如果在此之后，第二个单元格（d）为0，则均匀d进入n。我们增加并打印（1）。否则，请移回第一个单元格（0）并进行打印。

 
 
  +(![-)<  
  ==#==="  
 !< >(+ !![
 #"="===##=
  !      <
  #======"

如果第二个单元格0在递增和递减之后发生此循环。它将第三个单元格复制到第二个单元格。如果单元格不是，底部的部分是绕过循环0。

— 商务猫
source
3

Tcl，34个字节

ge stdin a
ge stdin b
exp $a%$b<1

我第一次/ *成功* /在codegolf中尝试！该代码必须在Tcl shell中执行，否则将无法工作。

感谢@Lynn一个字节。

感谢@Lynn和@LeakyNun（现在我明白他的意思）了四个字节！

你可以省略?1:0吗？
— Leaky Nun
@LeakyNun这是三元运算。您的意思是只是在某物不可见时返回某物？
什么会$a%$b==0回来？
— Leaky Nun
1
我的意思是，您的第三行可以exp $a%$b==0吗？
— Leaky Nun
1
或者exp $a%$b<1，也许？
— 林恩
3

PHP，23 22字节

<?=$argv[1]%$argv[2]<1

打印1表示true，空字符串（= nothing）表示false

使用n和d作为参数从cli 调用

古代PHP的10个字节： <?=$n%$d<1

— 提图斯
source
如果您不介意使用PHP4.1 ：<?=!($A%$B)。该值可以作为你的一部分传递$_SESSION，$_COOKIE，$_POST，$_GET或者（如果我没有记错的话）了$_ENV。
— Ismael Miguel
@Ismael Miguel：实际上我不知道，但是我厌倦了发布旧PHP版本并添加for PHP<5.4 with register_globals=On。但我将其添加以供参考。
— 泰特斯
实际上，您不能说“ for PHP<5.4 with register_globals=On”，因为您必须计算php.ini包含的文件的字节数register_globals=On。但是，PHP4.1是特例。这是register_globals=On默认值的最新版本，大多数功能都可以从PHP4.1及更高版本获得。此版本还允许使用其他功能，例如ereg和split不使用警告。
— Ismael Miguel
3

J，3个字节

0=|

用法：

2 (0=|) 10

会回来的1。并且相当于伪代码10 MOD 2 EQ 0

请注意，这与APL答案非常相似，因为J受APL的启发

— Emiflake
source
好的第一答案，欢迎来到PPCG！
— Leaky Nun
@LeakyNun谢谢，我一直在浏览，很高兴最后回答。
— emiflake
3

PowerShell v2 +，20字节

!($args-join'%'|iex)

将输入作为两个命令行参数$args，-join使用%分隔符将它们一起组成一个字符串，以管道方式传递到iex（缩写Invoke-Expression和类似eval）。结果为0非零或非零，因此我们不!采用该结果的布尔值，即为$TRUE或$FALSE（PowerShell中的非零整数是真实的）。该布尔值保留在管道上，并且输出是隐式的。

备用版本，每个都有20字节

param($a,$b)!($a%$b)
!($args[0]%$args[1])

相同的概念，只是构成输入的方式略有不同。感谢@DarthTwon提供了这些。

例子

PS C:\Tools\Scripts\golfing> .\divisibility-test.ps1 24 12
True

PS C:\Tools\Scripts\golfing> .\divisibility-test.ps1 24 13
False

PS C:\Tools\Scripts\golfing> .\divisibility-test.ps1 12 24
False
— AdmBorkBork
source
：在这两个的我试过打高尔夫球这个问题的其他方法，我得到了他们20个字节也param($a,$b)!($a%$b)和!($args[0]%$args[1])
— ThePoShWolf
@DarthTwon确实。当处理少量操作时，采用输入参数的不同方式通常最多相差一两个字节。
— AdmBorkBork '16
我希望提出一些简短的：P，但是，是的，总有多种方法可以给猫蒙皮，尤其是在PS中。
— ThePoShWolf '16
3

哈斯克尔， 13 11字节

((1>).).mod

这定义了一个新功能(!) :: Integral n => n -> n -> Bool。由于mod n m如果n和m为正，则仅返回正数，因此我们可以使用1>代替来保存一个字节0==。

用法：

ghci> let n!d=1>mod n d
ghci> 100 ! 2
True
ghci> 100 ! 3
False
— 泽塔
source
您可以自由地保存2个字节：((1>).).mod。
— nimi
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.