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。各スタックには無限のゼロが含まれます。
オンラインでお試しください！
使い方
可分性テスターとモジュラス計算機の2つのループを比較します。
{({}[()]{(<()>)}{}<({}[()]<({}())>)>)}
{({}[()]<({}[()]<({}())>)>{(<()>)}{})}
唯一の違いは、の位置で{(<()>)}{}入れ替え、D及びRの場合、D = 0。モジュラスを計算するには、dをデクリメントし、rをインクリメントした後にこのスワップを実行します。
この変更は、結果に影響を与えない場合％のB> 0、しかし、もし％B = 0、それ葉（N、D、R）=（0、B、0） -なく、（N、D、R）= （0、0、b） –スタック上。
このように、弾性を得るために、我々は唯一のポップする必要がNと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.