给定一个整数n > 9，对于该整数中数字之间的每个可能插入，插入一个加法+并求值。然后，取那些结果取模的原始数。输出这些操作的总和。
的示例n = 47852：
47852 % (4785+2) = 4769
47852 % (478+52) = 152
47852 % (47+852) = 205
47852 % (4+7852) = 716
-----
5842
任何方便格式的一个正整数，n > 9。
遵循上述构造技术的单个整数输出。
47852 -> 5842
13 -> 1
111 -> 6
12345 -> 2097
54321 -> 8331
3729105472 -> 505598476
Answers:
f=
n=>eval(n.replace(/./g,'+'+n+"%($`+ +'$&$'')"))
I.oninput=_=>O.value=f(I.value)<input id=I>
<input id=O disabled>将输入作为字符串。
编辑：
+4个字节：JavaScript中的前导零将数字转换为八进制）：
(+'$&$''+$`)吗？
$`为空，并且尝试评估时将抛出错误(13+)（例如）。
:{$@~c#C:@$a+:?r%}f+
这实现了给定的公式。我们唯一需要注意的是，当a 0位于输入中间时：在这种情况下，Brachylog变得非常古怪，例如，它不接受以a开头的整数列表0可以连接成一个整数（这将需要忽略前导0-主要是通过这种方式进行编程以避免无限循环）。因此，为了避免该问题，我们将输入转换为字符串，然后将所有拆分的输入转换回整数。
Example Input: 47852
:{ }f Find all outputs of that predicate: [716,205,152,4769]
$@ Integer to String: "47852"
~c#C #C is a list of two strings which when concatenated yield the Input
e.g. ["47","852"]. Leave choice points for all possibilities.
:@$a Apply String to integer: [47,852]
+ Sum: 899
:?r% Input modulo that result: 205
+ Sum all elements of that list
ŒṖṖLÐṂḌS€⁸%S
ŒṖṖLÐṂḌS€⁸%S - Main link: n
ŒṖ - partitions (implicitly treats the integer n as a list of digits)
Ṗ - pop - remove the last partition (the one with length one)
ÐṂ - keep those with minimal...
L - length (now we have all partitions of length 2)
Ḍ - undecimal (convert each entry back to an integer)
S€ - sum each (add the pairs up)
⁸ - left argument, n
% - mod (vectorises)
S - sum
i,N,t,r,m;f(n){for(r=0,m=n;n;t=n%10,n/=10,N+=t*pow(10,i++),r+=m%(n+N));return r;}
#include<stdio.h>
#include<math.h>
i,N,t,r,m;
f(n)
{
m=n;
r=0;
while(n)
{
t=n%10;
n/=10;
N+=t*pow(10,i++);
r+=m%(n+N);
}
return r;
}
main()
{
printf("%d",f(47852));
}
r=0，以便再次调用该函数时结果正确。它在Meta中的某个地方，如果您使用全局变量，则必须处理多次调用函数的副作用。
r全局但可以在函数内部声明为语句r=0;，例如，请参见我的答案。
-4个字节感谢地图学家
lambda x:sum(int(x)%(int(x[:i])+int(x[i:]))for i in range(1,len(x)))
*输入为字符串
lambda n:sum(int(n)%eval(n[:i]+'+'+n[i:])for i in range(len(n)))
t,s;f(n){s=0;t=10;while(t<n)s+=n%(n/t+n%t),t*=10;return s;}t是10,100,1000,...并代表大量裁员。n/t是右侧和n%t左侧。如果t大于数字，则完成。
脱胶和用法：
t,s;
f(n){
s=0;
t=10;
while(t<n)
s += n % (n/t + n%t),
t *= 10;
return s;
}
main(){
printf("%d\n",f(47852));
}字节数假定为ISO 8859-1编码。
\B
,$';$_¶$`
G-2`
\d+|,
$*
(1+);\1*
1
效率不高...
在线尝试！（第一行启用换行分隔的测试套件。）
\B
,$';$_¶$`
在每对字符之间，我们插入一个逗号，比赛前的所有内容，分号，整个输入，换行符以及比赛后的所有内容。对于输入，12345这给我们：
1,2345;12345
12,345;12345
123,45;12345
1234,5;12345
12345
即，输入的所有可能拆分以及一对输入。但是我们不需要最后一行：
G-2`
我们丢弃它。
\d+|,
$*
这将用其一元表示形式替换每个数字以及逗号。由于逗号不是数字，因此将其视为零，然后将其删除。这将在每个拆分中添加两个部分。
(1+);\1*
这通过从第二个数字中删除第一个数字的所有副本来计算模数。
1
就是这样，我们只计算有多少 1字符串中还剩下 s并将其打印出来即可。
s.e%QssMc`Q]k`
接受整数输入并打印结果的程序。
怎么运行的
s.e%QssMc`Q]k` Program. Input: Q
s.e%QssMc`Q]k`Q Implicit input fill
.e `Q Map over str(Q) with k as 0-indexed index:
c`Q]k Split str(Q) into two parts at index k
sM Convert both elements to integers
s Sum
%Q Q % that
s Sum
Implicitly print
{sum $_ X%m:ex/^(.+)(.+)$/».sum}{ # bare block lambda with implicit parameter ｢$_｣
sum
$_ # the input
X% # cross modulus
m :exhaustive / # all possible ways to segment the input
^
(.+)
(.+)
$
/».sum # sum the pairs
}Tr@ReplaceList[IntegerDigits@#,{a__,b__}:>Mod[#,FromDigits/@({a}+{b}+{})]]&
这在数字列表上使用模式匹配将它们的所有分区提取为两部分。每个这样的分区a，b然后替换为
Mod[#,FromDigits/@({a}+{b}+{})]
这里值得注意的是，不等长列表的总和保持不变，因此，例如，如果ais 1,2和bis，3,4,5那么我们首先将其替换为{1,2} + {3,4,5} + {}。最后一项是确保当我们平均分配偶数个数字时，它仍然保持未被评估的状态。现在Map，Mathematica中的运算已被广泛推广，可以用于任何类型的表达式，而不仅限于列表。因此，如果我们映射FromDigits此总和，它将把这些列表中的每一个变回一个数字。此时，该表达式是整数的总和，现在可以对其求值。与传统的解决方案相比Tr[FromDigits/@{{a},{b}}]，该方法节省了一个字节，该解决方案首先转换两个列表，然后对结果求和。
欢迎打高尔夫球！在线尝试！
编辑： -1字节感谢蓝绿色鹈鹕。
;╗$lr`╤╜d+╜%`MΣ
开球
Implicit input n.
;╗ Save a copy of n to register 0.
$l Yield the number of digits the number has, len_digits.
r Yield the range from 0 to len_digits - 1, inclusive.
`...`M Map the following function over that range, with variable x.
╤ Yield 10**x.
╜ Push a copy of n from register 0.
d Push divmod(n, 10**x).
+ Add the div to the mod.
╜ Push a copy of n from register 0.
% Vectorized modulo n % x, where x is a member of parition_sums.
This function will yield a list of modulos.
Σ Sum the results together.
Implicit return.
╤╜d+╜%lrMΣ）
&10v
`#v_00p:::v>+%\00g1+:9
*v$v+55g00</|_\55+
\<$>>\1-:v ^<^!:-1
+^+^*+55\_$%\00g55
.@>+++++++
说明
& Read n from stdin.
100p Initialise the current digit number to 1.
-- The main loop starts here --
::: Make several duplicates of n for later manipulation.
v+55g00< Starting top right, and ending bottom right, this
>>\1-:v routine calculates 10 to the power of the
^*+55\_$ current digit number.
% The modulo of this number gives us the initial digits.
\ Swap another copy of n to the top of the stack.
_\55+*v Starting bottom left and ending top left, this
^!:-1\< is another calculation of 10 to the power of
00g55+^ the current digit number.
/ Dividing by this number gives us the remaining digits.
+ Add the two sets of digits together.
% Calculate n modulo this sum.
\ Swap the result down the stack bringing n back to the top.
00g1+ Add 1 to the current digit number.
:9`#v_ Test if that is greater than 9.
00p If not, save it and repeat the main loop.
-- The main loop ends here --
$$ Clear the digit number and N from the stack.
++++++++ Sum all the values that were calculated.
.@ Output the result and exit.
{+/⍵|⍨{(⍎⍵↑R)+⍎⍵↓R}¨⍳⍴1↓R←⍕⍵}
⎕IO必须是1。说明（我不擅长说明，对此的任何改进都非常受欢迎）：
{+/⍵|⍨{(⍎⍵↑R)+⍎⍵↓R}¨⍳⍴1↓R←⍕⍵}
{ } - Function (Monadic - 1 argument)
⍵ - The argument to the function
⍕ - As a string
R← - Stored in R
1↓ - All except the first element
⍳⍴ - 1 to the length
{ } - Another function
⍵↓R - R without ⍵ (argument of inner function) leading digits
⍎ - As a number
+ - Plus
( ) - Grouping
⍵↑R - The first ⍵ digits of R
⍎ - As a number
¨ - Applied to each argument
⍵|⍨ - That modulo ⍵ (outer function argument)
+/ - Sum
n=>{long d=n,s=0,p=1;while(d>9)s+=n%((d/=10)+n%(p*=10));return s;};
完整的程序，包含未解释的方法和测试用例：
using System;
public class Program
{
public static void Main()
{
Func<long,long> f=
n=>
{
long d = n, // stores the initial number
r, // remainder, stores the last digits
s = 0, // the sum which will be returned
p = 1; // used to extract the last digit(s) of the number through a modulo operation
while ( d > 9 ) // while the number has more than 1 digit
{
d /= 10; // divides the current number by 10 to remove its last digit
p *= 10; // multiplies this value by 10
r = n % p; // calculates the remainder, thus including the just removed digit
s += n % (d + r); // adds the curent modulo to the sum
}
return s; // we return the sum
};
// test cases:
Console.WriteLine(f(47852)); //5842
Console.WriteLine(f(13)); // 1
Console.WriteLine(f(111)); // 6
Console.WriteLine(f(12345)); // 2097
Console.WriteLine(f(54321)); // 8331
Console.WriteLine(f(3729105472)); // 505598476
}
}
Sum@{N[_]%Sum@Map[N]=>SplitAt[_,1..#_-1]}@Digits
Sum@{N[_]%Sum@Map[N]=>SplitAt[_,1..#_-1]}@Digits
Digits convert input to digits
{ }@ call lambda with digits as argument
SplitAt[_,1..#_-1] split digits at each partition
Map[N]=> Map N to two-deep elements
Sum@ Takes the sum of each sub array
N[_]% convert digits to int and vector mod
Sum@ sum the resultant array
Clojure，91 81字节
编辑：这更短，因为它声明了一个匿名函数(fn[v](->> ...))并且不使用->>宏，尽管这样更易于阅读和调用。
(fn[v](apply +(map #(mod v(+(quot v %)(mod v %)))(take 10(iterate #(* 10 %)1)))))
原版的：
(defn s[v](->> 1(iterate #(* 10 %))(take 10)(map #(mod v(+(quot v %)(mod v %))))(apply +)))
生成1、10、100，...的序列，并获取前10个项目（假设输入值小于10 ^ 11），映射为规范中指定的模并计算总和。较长的函数名称使此解决方案相当长，但至少应该是高尔夫球版也很容易遵循。
首先，我尝试在周围打杂字符串，但这需要大量的样板。
(let((s(number->string n))(h string->number)(g substring))(for/sum((i(range 1(string-length s))))(modulo n(+(h(g s 0 i))(h(g s i))))))
取消高尔夫：
(define (f n)
(let ((s (number->string n))
(h string->number)
(g substring))
(for/sum ((i (range 1 (string-length s))))
(modulo n (+ (h (g s 0 i)) (h (g s i)))))))
测试：
(f 47852)
(f 13)
(f 111)
(f 12345)
(f 54321)
(f 3729105472)
输出：
5842
1
6
2097
8331
505598476
N =INPUT
S N LEN(X) . L REM . R :F(O)
S =S + REMDR(N,L + R)
X =X + 1 :(S)
O OUTPUT =S
END
->q{t=0;q.times{|x|p=10**x;t+=q%(q/p+q%p)};t}
这是一个非常整洁的解决方案。从技术上讲这是正确的，但是效率极低。编写q.to_s.size.times {...}会更有效率。我们使用q.times是因为它保存字符，并且通过proc处理表达式的额外次数只是计算为零。
->q{(0..q).reduce{|s,x|p=10**x;s+q%(q/p+q%p)}}
n->{long m=n,r=0,p=1;for(;m>9;r+=n%((m/=10)+n%(p*=10)));return r;}
通过创建@adrianmp的C＃答案端口来生成-61字节。
¬x@%OvUi+Y
:Implicit input of string U
¬ :Split to an array of characters
@ :Pass each character at index Y through a function
Ui+Y : Insert a + in U at index Y
Ov : Evaluate as Japt
% : Modulo U by the above
x :Reduce by addition
D.s¨s.p¨R+¹s%O未看到此内容的情况下发布； P