Brain-Flak , 72 70 64 62 58 46 바이트
{({}[()]{(<()>)}{}<({}[()]<({}())>)>)}{}{{}}{}
배당 및 제수를 (순서대로) 입력으로 취하여 제수 (트러스트)를 인쇄하거나 아무것도 인쇄하지 않습니다. 각 스택에는 암시적이고 무한한 양의 0이 있으므로 빈 출력은 거짓으로 간주해야합니다.
스택 정리는 아니지만이 솔루션은 단일 스택 만 사용합니다.
온라인으로 사용해보십시오!
2 바이트를 골라내는 @WheatWizard에게 감사합니다!
작동 원리
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 을 떠나는 것과 거의 같습니다 . 각 스택에는 무한한 0이 포함됩니다.
온라인으로 사용해보십시오!
작동 원리
나누기 테스터의 두 루프와 계수 계산기를 비교하십시오.
{({}[()]{(<()>)}{}<({}[()]<({}())>)>)}
{({}[()]<({}[()]<({}())>)>{(<()>)}{})}
유일한 차이의 위치 {(<()>)}{}교환이 거라고 및 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.