目的：给定一个整数N > 0，从最小的整数A，B以及C使：
A，B以及C严格大于N;2分歧A;3分歧B;4划分C。这是一个代码高尔夫球，因此最短的答案以字节为单位。您可以使用在挑战后制作/更新的语言，但严格来说这是非竞争性的。
N => A, B, C
1 => 2, 3, 4
4 => 6, 6, 8
43 => 44, 45, 44
123 => 124, 126, 124
420 => 422, 423, 424
31415 => 31416, 31416, 31416
1081177 => 1081178, 1081179, 1081180
Answers:
~%2r4¤+‘
~%2r4¤+‘ Main link. Argument: n (integer)
~ Bitwise NOT; yield ~n = -(n + 1).
¤ Combine the three links to the left into a niladic chain:
2 Yield 2.
r4 Yield the range from 2 to 4, i.e., [2, 3, 4].
% Yield the remainder of the division of ~n by 2, 3 and 4.
In Python/Jelly, -(n + 1) % k = k - (n + 1) % k if n, k > 0.
‘ Yield n + 1.
+ Add each modulus to n + 1.
lambda n:[n+2&-2,n/3*3+3,n+4&-4]2和4的位算术，3的模块化算术。
我为k上面的下一个倍数找到了四个7字节表达式，n但没有一个短：
n-n%k+k
~n%k-~n
n/k*k+k
~n/k*-k当复制时k=2,3,4，Any会提供34字节，如果组合则为33字节：
[n/2*2+2,n/3*3+3,n/4*4+4]
[n/k*k+k for k in 2,3,4]但是，2和4是2的幂，它允许位技巧将最后1个或2个字节清零。
n+2&-2
n+4&-4这样就得到了6个字节（而不是7个字节）来获取下一个倍数，总共32个字节，超过了for k in 2,3,4。
不幸的是，看起来很有希望n|1+1并且n|3+1先完成了加法运算，所以增加输出要加上括号。
n+k-n%k。
n&3+1做加法第一吗？
2:4+t5M\-
说明：
2:4 #The array [2, 3, 4]
+ #Add the input to each element, giving us [12, 13, 14]
t #Duplicate this array
5M #[2, 3, 4] again
\ #Modulus on each element, giving us [0, 1, 2]
- #Subtract each element, giving us [12, 12, 12]
5M（功能输入的自动剪贴板）代替第二个来保存一个字节2:4。
Qt_2:4\+
使用Denis的Jelly算法，我很惊讶它的长度是一样的！
Q % takes implicit input and increments by one
t_ % duplicate, and negate top of stack (so it's -(n+1))
2:4 % push vector [2 3 4]
\ % mod(-(n+1),[2 3 4])
+ % add result to input+1
% implicit display
@(n)n-mod(n,d=2:4)+d
例子：
octave:60> f(123)
ans =
124 126 124
octave:61> f(1081177)
ans =
1081178 1081179 1081180
octave:62> f(420)
ans =
422 423 424
值得注意的是，我们最多可以执行9次而无需添加任何额外的字节：
@(n)n-mod(n,d=2:9)+d
输出（2520是可被所有一位数字均分的最小正整数）：
octave:83> f(2520)
ans =
2522 2523 2524 2525 2526 2527 2528 2529
:?
:
#/)
\ #
!"*@
"
这将以C, B, A换行符分隔的顺序输出结果。
与往常一样，简短的迷宫底漆：
尽管有两次无操作（"）使得布局看起来有些浪费，但是我对这种解决方案感到非常满意，因为它的控制流程实际上非常微妙。
IP从右上角的左上角:开始。它将立即碰到死胡同?并转身，因此程序实际上从以下线性代码开始：
: Duplicate top of main stack. This will duplicate one of the implicit zeros
at the bottom. While this may seem like a no-op it actually increases
the stack depth to 1, because the duplicated zero is *explicit*.
? Read n and push it onto main.
: Duplicate.
: Duplicate.
这意味着我们现在n在主堆栈上有3个副本，但其深度为4。这很方便，因为这意味着我们可以在处理输入的副本时，通过堆栈深度来检索当前的乘数。
IP现在进入（顺时针）3x3循环。请注意#，它推动堆栈深度，它将始终推动一个正值，这样我们就知道IP在这一点上将永远向东。
循环体是这样的：
# Push the stack depth, i.e. the current multiplier k.
/ Compute n / k (rounding down).
) Increment.
# Push the stack depth again (this is still k).
* Multiply. So we've now computed (n/k+1)*k, which is the number
we're looking for. Note that this number is always positive so
we're guaranteed that the IP turns west to continue the loop.
" No-op.
! Print result. If we've still got copies of n left, the top of the
stack is positive, so the IP turns north and does another round.
Otherwise, see below...
\ Print a linefeed.
Then we enter the next loop iteration.
遍历循环（最多!）3次后，的所有副本n都用完，并显示下面的零。因为"位于底部（否则看起来似乎毫无用处），因此该位置是一个交界处。这意味着在栈顶为零时，IP会尝试一直向前（向西），但是由于有一堵墙，它实际上会旋转180度并向东移动，就像碰到了死胡同。
结果，现在执行以下位：
" No-op.
* Multiply two zeros on top of the stack, i.e. also a no-op.
The top of the stack is now still zero, so the IP keeps moving east.
@ Terminate the program.
i;f(int*a,int n){for(i=1;++i<5;*a++=n+i-n%i);}
感谢Neil和nwellnhof节省了4个字节！
令人失望的长。我感觉这里有些不知所措的骇客，但我还找不到。返回指向包含三个元素的数组的指针。完整程序：
i;f(int*a,int n){for(i=1;++i<5;*a++=n+i-n%i);}
int main()
{
int array[3];
int n=10;
f(array, n);
printf("A:%d\tB:%d\tC:%d\n",array[0],array[1],array[2]);
return 0;
}
n + i - n % i++导致不确定的行为吗？
s/a[i-2]/*a++/节省两个字节。
f(a,n,i)int*a;{for(i=1;++i<5;)*a++=n+i-n%i;}
i1+#i2341ø>(1+)31j
i(2[¤, q!^$]æl0eq!~
i1+#i2341ø
i1+#i将输入设置为1 + input; 这是因为我们要处理严格大于输入的数字。234用我们的迭代值初始化磁带，然后1ø跳到下一行的开头。
i(2[¤, q!^$]æl0eq!~
i(将输入放入STOS，并2[使用前2个元素构成一个新堆栈。¤复制堆栈，并进行,模量计算。如果有剩余，则q!^跳出循环转到（b）。否则，我们可以打印。$删除多余的东西，]关闭堆栈，并æ很好地打印。l0wq!~如果堆栈包含零个成员，则终止。
>(1+)31j
q!^
(1+)将1加到STOS，然后31j跳转到循环中不会从堆栈中取出内容的部分。和利润。
多余的空格真的让我感到困扰。拿一个GIF。
感谢@MartinBüttner提供了 17个字节。
^ 1111： M！＆`（11 +）：（\ 1 *） ：
（请注意尾随换行符。）
一元输入，一元1输出，1以换行符分隔。
.+
11:$&;111:$&;1111:$&
\b(1+):(\1*)1*
$1$2
一元输入，一元输出，以分号（;）分隔。
.+
$&11;$&111;$&1111
((11)+)1*;((111)+)1*;((1111)+)1*
$1;$3;$5
一元输入，一元输出，以分号（;）分隔。
MATLAB和Octave：
f=2:4;@(x)f.*ceil((x+1)./f)
MATLAB和Octave更好（解决方案是等效的，但是当进一步打高尔夫球时，可能会优于其他解决方案）：
@(x)x-rem(x,2:4)+(2:4)
f=2:4;@(x)x+f-rem(x,f)
仅在八度音阶中：
@(x)x-rem(x,h=2:4)+h
试试这里。
n$z3[zi2+$d%-+N].
n$z Take number from input and store in register
3[ Open for loop that repeats 3 times
z Push value in register on stack
i2+ Loop counter plus 2
$d Duplicate stack
%-+ Mod, subtract, add
N Output as number
]. Close for loop and stop.
（由于@Neil减少了4个字节）
N=scan();cat(N+2:4-N%%2:4)
这（类似于我猜的其余答案）将2：4添加到输入中，并在对相同数字进行模运算后减少了余数。
N+2:4-N%%2:4吗？
╗52x"╝1`;╛@%Y@╜<*`╓"£M
有趣的事实：在编写此程序时，发现并修复了Actually解释器中的3个错误。
事实并非如此有趣：这3个错误使此解决方案变得更短。
说明：
╗52x"╝1`;╛@%Y@╜<*`╓"£M
╗ push input to reg0
52x push range(2,5) ([2,3,4])
"╝1`;╛@%Y@╜<*`╓"£M map (for n in [2,3,4]):
╝ push n to reg1
1`;╛@%Y@╜<*`╓ find the smallest integer k where:
;╛@%Y k is divisible by n and...
@╜<* is greater than the input
C B A如果答案中明确指定了结果，我们可以（一致地）以不同的顺序（例如）输出结果吗？