您的任务是编写一个程序或函数，以确定一个数字是否可以被另一个数整除。要注意的是，即使没有给出数字的全部数字，也应尽快给出答案。

你的程序应该采取的整数d ≥2，然后是一连串的数字作为输入。这些代表的另一数字整数Ñ ≥1，开始于至少显著数字。在第一点ñ要么必须或不能被divisble d，你的程序应该输出适当的答案并退出。如果到达输入的末尾，则应输出完整的N是否可被D整除。

这是N可接受的输入格式的列表 （如果您认为应该允许不包含的内容，请留下评论）：

• 标准输入：数字在单独的行上给出； 输入的结尾为EOF或特殊值； exit表示函数返回或程序退出。

• 模拟输入：例如通过击键或代表每个数字的十个按钮； 输入的结尾是一个特殊值； exit表示函数返回或程序退出。

• 具有全局状态的功能：用连续的数字重复调用； 输入的结尾是一个特殊值； exit表示该函数返回一个非null值。请注意，如果您使用全局状态，则必须在返回值或以其他方式重置后清除它，以使该函数可以多次运行。

• Curried函数：返回另一个要用下一位数字或值调用的函数； 输入的结尾是一个特殊值或不带参数的函数； exit表示该函数返回答案，而不是另一个函数。

• GUI提示或类似内容：重复显示； 输入的结尾是“取消”或等效值，或特殊值； 退出意味着提示停止出现。

• 迭代器函数：输入是有状态对象或函数，在调用时返回下一个数字 ，输入结尾是异常或特殊值； 退出意味着迭代器停止被调用。

D的输入和输出可以通过任何可接受的标准方法进行。

测试用例：

2;   6               => true
5;   6               => false
20;  0 3             => false
20;  0 4             => true
100; 1               => false
100; 0 0             => true
100; 0 2             => false
4;   2 4             => false
4;   2 5             => true
4;   2 [eof]         => false
4;   4 [eof]         => true
625; 5 5             => false
625; 5 7 2           => false
625; 5 7 3 6         => false
625; 5 7 3 4         => true
7;   9 3 4 [eof]     => false
7;   9 3 4 5 [eof]   => true
140; 0 3             => false
140; 0 4 5 [eof]     => false
140; 0 4 5 1 [eof]   => true
14;  4 5 1 4 [eof]   => false
14;  4 5 1 4 1 [eof] => true

JavaScript（ES6），70个字节

输入格式：咖喱函数

$-1$$0$$1$

p=>(q='',g=(d,t=k=z=!~d||(q=d+q,p))=>k--?g(d,t-=(k+q)%p<1):t?t-z&&g:1)

在线尝试！

怎么样？

$p$$q$$n$$0 \le k < p$

$$k\times 10^n+q \pmod p\tag{1}$$

$x\ge p$$m\ge 1$$0 \le k < p$$x=mp+k$

$$x\times 10^n+q \pmod p=\\ (mp+k)\times 10^n+q \pmod p=\\ (mp\times 10^n \pmod p)+ (k\times 10^n+q \pmod p)\pmod p=\\ 0+(k\times 10^n+q \pmod p)\pmod p=\\ k\times 10^n+q \pmod p$$

$(1)$$0$$0 \le k < p$$0$$k \ge p$真。

$(1)$$0$$0 \le k < p$假。

$(1)$混合，我们尚无法确定，需要q的更多数字$q$ 或EOF通知。

已评论

p => (                       // p = divisor
  q = '',                    // q = dividend stored as a string, initially empty
  g = (                      // g() = curried function taking:
    d,                       //   d = next digit
    t =                      //   t = number of iterations yielding a non-zero value
    k =                      //   k = total number of iterations to process
    z =                      //   z = copy of k
      !~d ||                 //   if d == -1 (meaning EOF), use only 1 iteration
                             //   so that we simply test the current value of q
      (q = d + q, p)         //   otherwise, prepend d to q and use p iterations
  ) =>                       //
    k-- ?                    //   decrement k; if it was not equal to zero:
      g(                     //     do a recursive call to g():
        d,                   //       pass the current value of d (will be ignored anyway)
        t -= (k + q) % p < 1 //       test (k + q) % p and update t accordingly
      )                      //     end of recursive call
    :                        //   else:
      t ?                    //     if t is greater than 0:
        t - z && g           //       return 0 if t == z, or g otherwise
      :                      //     else:
        1                    //       return 1
)                            //

批，177个 169字节

@set n=
@set g=1
:l
@set/ps=
@if %s%==- goto g
@set n=%s%%n%
@set/ae=%1/g,g*=2-e%%2,g*=1+4*!(e%%5),r=n%%g
@if %g% neq %1 if %r%==0 goto l
:g
@cmd/cset/a!(n%%%1)

注意到d作为一个命令行参数并读出数字n在不同的行与-作为EOF标记。输出1可整除（0如果不是）。说明：

@set n=

初始化n为空字符串。

@set g=1

g 是 gcd(d, 10**len(n))

:l

开始循环读取数字。

@set/ps=

读取下一位。

@if %s%==- goto g

在EOF停止处理。

@set n=%s%%n%

在下一个数字前加上n。

@set/ae=%1/g,g*=2-e%%2,g*=1+4*!(e%%5),r=n%%g

g现在进行更新，len(n)并进行计算n%g。

@if %g% neq %1 if %r%==0 goto l

如果r为非零，则d绝对不会除n，因为g的因数d不会。如果r是零，那么我们只知道是否d分裂n，如果g平等的d，所以如果不是，继续循环。

:g

在EOF上突破数字阅读循环。

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

计算并隐式输出结果。