如果数字的每半位数之和相等，则数字是平衡的，因此：1423是平衡的，因为1+4 = 2+3，所以是：42615因为4+2=1+5。请注意，如果数字的位数为奇数，则中间的数字不包含在任何一侧（或包含在两侧）。

挑战：

取一个正整数作为输入，如果它是平衡的，则输出一个真实值，如果不平衡，则输出一个虚假值。

测试案例（真实）

1
6
11
141
1221
23281453796004414
523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088

测试用例（假）

10
12
110
15421
5234095123508321
6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454

不会有从零开始的数字，例如00032代替32。您必须支持至少100个数字（大于2^64-1）的数字。与往常一样，是可选的输入格式，因此如果需要，您可以在数字前后加上撇号。

05AB1E，14 7字节

€D2äO`Q

说明

以141为例：

€D       # duplicate each (turns the number into a list of digits)
         # STACK: ['1','1','4','4','1','1']
  2ä     # split list in 2 (as we duplicated each element, 
         # the middle element will exist on both sides for an odd length input
         # STACK: [['1','1','4'],['4','1','1']]
    O    # sum each sublist
         # STACK: [6,6]
     `   # flatten
         # STACK: 6, 6
      Q  # compare for equality
         # STACK: 1 (true)

在线尝试！

> <>，31个 29字节

i:0(?v
~00}v>
v+r+>l4(?
>{=n;

在线尝试！

第1行：标准输入回路

第2行：丢弃堆栈顶部的-1，推两个0，然后将其旋转一个到堆栈底部（这确保长度小于3的输入不会在以后的程序中耗尽堆栈）

第3行：如果堆栈的长度> 3，则将堆栈的顶部两个元素和底部两个元素相加。

第4行：如果堆栈的顶部和底部相等，则输出1，0，否则。

编辑：意识到不需要带字符mod 12，节省了2个字节

Haskell，64 63字节

b(a:t@(r:s))=a-last t+b(init t);b _=0
(==0).b.map fromEnum.show

感谢nimi，节省了一个字节

Brachylog，20个字节

@eL@2tM,Lr@2t:M:+a#=

在线尝试！

说明

@eL                    Get the list of digits L of the input
  L@2tM,               Get the second half M of L
        Lr@2t          Get the second half of the reverse of L
             :M        The list [L, M]
               :+a#=   The sum of elements of L and the sum of elements of M must be equal

Java，85个字节

n->{int s=0,i=0,l=n.length();for(;i<l/2;)s+=n.charAt(i)-n.charAt(l-++i);return s==0;}

注意：输入是String因为Java无法处理而给出的BigInteger（BigIntegers是使用...构造的String。）

测试和取消高尔夫：

import java.util.function.Predicate;

public class Main {

  public static void main(String[] args) {
    Predicate<String> f = n -> {
      int s = 0, i = 0, l = n.length();
      for (; i < l / 2;) {
        s += n.charAt(i) - n.charAt(l - ++i);
      }
      return s == 0;
    };

    String[] truthies = {"1",
      "6",
      "11",
      "141",
      "23281453796004414",
      "523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088"};
    for (String s : truthies) {
      boolean result = f.test(s);
      System.out.println(result);
    }
    String[] falsies = {"10",
      "12",
      "110",
      "15421",
      "5234095123508321",
      "6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454"};
    for (String s : falsies) {
      boolean result = f.test(s);
      System.out.println(result);
    }
  }
}

Mathematica，57个字节

Tr@(#-Reverse@#)[[;;⌊Length@#/2⌋]]==0&@*IntegerDigits

说明

我真的希望我可以在某种语言中使用这种方法，并且在Mathematica中似乎做得不错。这样做的目的是避免将列表及其后半部分组合在一起，而只看前半部分，从而不必同时获得前半部分和后半部分。

...&@*IntegerDigits

首先，我们将输入转换成十进制数字列表，并将结果传递到左侧的未命名函数。

...(#-Reverse@#)...

现在，我们从列表本身中减去列表的倒序。如果数字是0，则结果将为。{a1,a2,...,an}{a1-an,a2-an-1,...,an-a1}

...[[;;⌊Length@#/2⌋]]

我们提取该列表的前半部分（中间的数字除外，尽管这实际上并不重要，因为0无论如何都会有相应的差异）。

Tr@...

然后我们对这个列表求和。所以那是：

a1 - an + a2 - an-1 + ... + a⌊n/2⌋ - a⌈n/2⌉+1

重新排列：

a1 + a2 + ... + a⌊n/2⌋ - (a⌈n/2⌉+1 + ... + an-1 + an)

如果两个部分的总和相同，则输入是平衡的。因此，如果输入是平衡的，则该表达式为零。这就是我们检查的内容：

...==0

JavaScript（ES6），59 55 51 44 42字节

f=([x,...a],n=0)=>a[0]?f(a,x-a.pop()+n):!n

原来我完全是在使用错误的策略。此版本递归地找到前一半的总和减去后一半的总和，然后返回结果的逻辑非。

如果我们可以将falsy替换为true，反之亦然，则将为35个字节：

f=([x,...a])=>a[0]?x-a.pop()+f(a):0

测试片段

f=([x,...a],n=0)=>a[0]?f(a,x-a.pop()+n):!n

<input id=I value="23281453796004414"><br>
<button onclick="console.log(`Result of f(${I.value}): `+f(I.value))">Run</button>

PowerShell v2 +，85个字节

param($a)!((,'('+$a[0..(($b=$a.length)/2-1)]+'0)-('+$a[($b/2)..$b]+'0)')-join'+'|iex)

将输入$a作为字符串（必须支持数字，>2^64-1而不必[biginteger]在命令行中进行笨拙的转换）。

为了进行说明，我们假设输入'1423'。然后，我们正在构造一个新的字符串。两个阵列片是显而易见的（$a[...]），而这由三个附加字符串包围(，0)-(和0)，配制的阵列charS和string秒。请注意,前面的强制执行数组串联，而不是字符串串联。

整个数组-join与一起被ed +，得到一个类似的字符串(+1+4+0)-(+2+3+0)，您可以看到0需要使用来防止语法错误。这被馈入|iex（的缩写Invoke-Expression，类似于eval），它将计算数学结果。只要字符串是平衡的，您就可以得到0输出，我们将其封装在parens中，并采用Boolean-not !(...)来输出True。如果它是任何非零整数，则将输出False。

测试用例

PS C:\Tools\Scripts\golfing> '1','6','11','141','23281453796004414','523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088'|%{$_;.\is-it-a-balanced-number.ps1 $_;'---'}
1
True
---
6
True
---
11
True
---
141
True
---
23281453796004414
True
---
523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088
True
---

PS C:\Tools\Scripts\golfing> '10','110','15421','5234095123508321','6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454'|%{$_;.\is-it-a-balanced-number.ps1 $_;'---'}
10
False
---
110
False
---
15421
False
---
5234095123508321
False
---
6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454
False
---

Perl，29个字节

包括+5 -lpF

在STDIN上输入号码

balanced.pl <<< 1423

balanced.pl：

#!/usr/bin/perl -lpF
$;+=$_-pop@F for@F;$_=!$

C＃，83个字节

n=>{var t=n+"";int l=t.Length,i=0,r=0;for(;i<l/2;)r+=t[i]-t[l-1-i++];return r==0;};

在线尝试！

完整的源代码，包括测试用例：

using System;
using System.Numerics;

namespace BalancedNumber
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<BigInteger,bool>s= n=>{var t=n+"";int l=t.Length,i=0,r=0;for(;i<l/2;)r+=t[i]-t[l-1-i++];return r==0;};

            Console.WriteLine(s(1));    //true
            Console.WriteLine(s(6));    //true
            Console.WriteLine(s(11));   //true
            Console.WriteLine(s(141));  //true
            Console.WriteLine(s(23281453796004414));    //true
            BigInteger bi = BigInteger.Parse("523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088");
            Console.WriteLine(s(bi));   //true
            Console.WriteLine(s(10));   //false
            Console.WriteLine(s(12));   //false
            Console.WriteLine(s(110));  //false
            Console.WriteLine(s(15421));    //false
            Console.WriteLine(s(5234095123508321)); //false
            bi = BigInteger.Parse("6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454");
            Console.WriteLine(s(bi));   //false
        }
    }
}

BigInteger数据类型允许任何数字长度。如果数字太大，则编译器会抱怨（错误CS1021：积分常数太大），因此改用BigInteger.Parse（String）方法。

考虑到输入是一个字符串，该解决方案实际上可以减少到72个字节（并相应地更新程序）：

t=>{int l=t.Length,i=0,r=0;for(;i<l/2;)r+=t[i]-t[l-1-i++];return r==0;};

Python 3，107 102 76字节

n=input()
l=len(n)
print(sum(map(int,n[:l//2]))==sum(map(int,n[l//2+l%2:])))

@Rod -26字节！

Ruby，63个字节

->s{e=s.chars*?+
l=s.size
e[l-1-r=l%2,2*r+1]="=="
l<2||eval(e)}

注意：arg s必须是字符串。

测试（要求至少5+）：

require 'minitest/autorun'

class TestRunner < Minitest::Test
  def setup
    @truthy_nums = %w(1 6 11 141 23281453796004414 523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088)
    @falsy_nums = %w(10 110 15421 5234095123508321 6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454)

@f=->s{e=s.chars*?+
l=s.size
e[l-1-r=l%2,2*r+1]="=="
l<2||eval(e)}

  end
  def test_true
    @truthy_nums.each do |e|
      assert @f[e], e
    end
  end
  def test_false
    @falsy_nums.each do |e|
      assert !@f[e], e
    end
  end
end

Haskell，55个字节

g(h:t)=read[h]-g(reverse t)
g _=0
(==0).g.(<*"xx").show

递归函数g通过反复取回头部然后反转来从两端解开数字字符串。它从磁头减去递归结果，这导致它交替使用+1和-1的系数，其中+1应用于上半部，而-1应用于下半部。

   g "12345" 
== 1 - g "5432"
== 1 - (5 - g "432")
== 1 - (5 - (4 - g "32"))
== 1 - (5 - (4 - (3 - g "2"))
== 1 - (5 - (4 - (3 - 2))
== 1 + 2 + 3 - 4 - 5

因此，它需要上半部分的总和减去下半部分的总和。出现的问题是，位数奇数时，中心抢七向左打，但主要功能通过来解决(<*"xx")，将每个字符加倍，即“ 12345”变为“ 1122334455”。这样，中间数字在两侧均分并且抵消。

视网膜，64 44字节

^((.)*?).?(?=(?<-2>.)*$)
$1 
\d
$*
^(1+) \1$

在线尝试

第一个阶段在中间分割字符串，如果有中间字符则省略中间字符（从此处获取并修改。由Martin提供。）然后，用一元表示形式替换数字，并且如果两半长度相等，则进行匹配。

JavaScript（ES6），74 67 ... 59 50字节

递归求和第一位和最后一位的差，直到剩下的位数少于两位：

let f =

n=>!(F=n=>n[1]?(n.pop()-n.shift()+F(n)):0)([...n])

// some truthy examples
console.log(f("11"));
console.log(f("141"));
console.log(f("523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088"));

// some falsy examples
console.log(f("12"));
console.log(f("110"));
console.log(f("6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454"));

R，105 96字节

事实证明R非常冗长。将输入作为字符。

function(x){y<-as.numeric(unlist(strsplit(x,"")));l<-length(y)%/%2;sum(tail(y,l))==sum(head(y,l))}

格式很好：

function(x){
    y=as.numeric(unlist(strsplit(x,"")))
    l=length(y)%/%2
    sum(tail(y,l))==sum(head(y,l))
}

说明

• y<-as.numeric(unlist(strsplit(x,""))) 分割输入（一个string_，并将其强制转换为向量而不是列表，然后将其转换回整数。
• sum(tail(y,： tail采用最后n个元素，由以下元素找到：
  • length(y)%/%2))，其中%/%为整数除法，以得到长度为奇数的商的上限。
• sum(head(y,length(y)%/%2))：like tail，head采用以相同方式找到的向量的前n个元素。

编辑

• 感谢niam，节省了七个字节
• 切换至，=而不是<-，另存了两个字节。

脑高射炮，410 206 204 178 + 3 = 181个字节

这是使用该-a标志的178字节版本。

DJMcMayhem打了26个字节

在线尝试

([])(<(()()(<>))>)<>{({}[()])<>(({}()[({}<({}())>)])){{}(<({}({}<({}[()])>))>)}{}<>}{}<>{}{}({}<>){({}[()]<({}<>)<>>)}{}([]<>[[]]<>){(<{}{}>)}{}({{}<>[{}]<>}<(())>){{}{}((<>))}{}

这是一个较长的410字节版本，不使用该-a标志。

在线尝试

{(({}))(<((()()()()()){}<>)>)<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}{}<>({}<{}>)<>(<((()()()()()){}(<>))>)<>{({}[()])<>(({}()[({}<({}())>)])){{}(<({}({}<({}[()])>))>)}{}<>}{}<>{}{}({}<>)}{}<>([])(<(()()(<>))>)<>{({}[()])<>(({}()[({}<({}())>)])){{}(<({}({}<({}[()])>))>)}{}<>}{}<>{}{}({}<>){({}[()]<({}<>)<>>)}{}([]<>[[]]<>){{}{}(<>)}{}(([])<>)({<{}>{}<([])>}{}<>[{<{}>{}<([])>}{}]<(())>){{}{}((<>))}{}

说明

这是较短解决方案的说明

首先，该数字将通过-a标志转换为其所有ASCII值。

我们推堆栈高度（即位数）并除以2。

([])(<(()()(<>))>)<>{({}[()])<>(({}()[({}<({}())>)])){{}(<({}({}<({}[()])>))>)}{}<>}{}<>{}{}({}<>)

对于每个小于我们刚刚推入的数字的数字，我们将一个数字移至另一个堆栈

{({}[()]<({}<>)<>>)}{}

如果堆叠的高度不同，我们将从当前堆叠中移除顶部物品

([]<>[[]]<>){(<{}{}>)}{}

我们想要每个堆栈之和之间的差。因此，我们使用以下算法对每个堆栈求和。

{{}}

假定没有数字的ASCII值为零，这是一个有效的假设。

我们对两个堆栈都运行此命令，然后求差（<(())>下一部分是必需的。

({{}}<>[{{}}]<(())>)

现在，我们要求和。如果总和为零，它将弹出顶部，显示我们早先推送的数字，否则将删除数字和数字，然后在顶部放置零。

{{}{}((<>))}{}

其实17 16字节

该答案的灵感来自ElPedro的Python 2答案及其使用思路[-b:]。欢迎打高尔夫球。在线尝试！

$♂≈;l½L│±aHΣ)tΣ=

开球

      Implicit input n.
$♂≈   list(str(n)). This converts n to a list of n's digits.
;l    Duplicate the list of digits and get its length. Call it len.
½L    Push len//2.
│     This duplicates the stack.
        Stack: len//2, digit_list, len//2, digit_list
±     Negate the len//2 at TOS for later.
a     Invert the stack.
        Stack: digit_list, len//2, digit_list, -(len//2)
HΣ    Push digit_list[:len//2], then push its sum.
)     Rotate this first sum to BOS.
tΣ    Push digit_list[-(len//2):], then push its sum.
=     Check if those sums are equal.
      Implicit return.

Perl 6的， 42个39  33字节

{[==] .comb[{^($_/2),Int($_/2)..*}]>>.sum}

测试一下

{[==] .comb[^(*/2),(*/2).Int..*]>>.sum}

测试一下

{[==] .comb[^*/2,^*/2+*/2]>>.sum}

测试 ^{_{（来自Jo King）}}

说明：

{ # lambda with implicit parameter ｢$_｣

  [==]                   # reduce the following using &infix:«==»

    .comb\               # split input into individual characters
    [                    # index into that using:

      # first half of the values (includes middle value)
      # ｢(0/2) ..^ (*/2)｣
      ^ * / 2,     

      # last half of the values (includes middle value)
      ^ * / 2            # same number of values as first half
        + * / 2          # shifted up by half

    ]\
    >>.sum               # sum each of the two halves separately
}

Javascript，73个字节

好的ES5循环

for(a=c=0,b=(l=(s=prompt()).length)-1;a<~-l/2;c-=s[a++]-s[b--]);alert(!c)

这里发生了什么事？

for(
    a=c=0,               // a = left digits of the number
                         // c = the result
    b=                   // b = right digits of number
        (l=              // l = length of number - 1
            (s=prompt()) // s = the number as input from user
        .length)-1; 

    a<~-l/2;             // while a < length of number / 2, rounded down (~-)

    c-=
        s[a++]           // c -= left digit
        -
        s[b--]           // c += right digit (because - and - == +)
 );
                         // for balanced numbers c should be 0
 alert(!c)               // 0 equals false in javascript, so output the opposite of c

Python 2，73个字节

def f(n):x=map(int,str(n));d=len(x)/2;print sum(x[:d])==sum(x[-d:])or d<1

测试在ideone

我们必须使用str()而不是``，因为n可能不在signed int的范围内。

Python 2，83 77字节

g=[int(h)for h in raw_input()];b=int(len(g)/2);print sum(g[:b])==sum(g[-b:])or b==0

编辑

@Rod的帮助下减少到77

g=[int(h)for h in raw_input()];b=len(g)/2;print sum(g[:b])==sum(g[-b:])or b<1

例子：

D:\>bal.py
1
True

D:\>bal.py
6
True

D:\>bal.py
523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088
True

D:\>bal.py
10
False

D:\>bal.py
110
False

D:\>bal.py
 6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454
False

PHP，73 67 60 57字节

需要PHP 7.1的负字符串偏移量：

for(;2*$x<strlen($a=$argn);)$s+=$a[$x++]-$a[-$x];echo!$s;

跑：

echo 15324 | php -nR 'for(;2*$x<strlen($a=$argn);)$s+=$a[$x++]-$a[-$x];echo!$s;';echo

先前版本

注意：太空飞船操作员需要PHP 7。

for(;$x<$l=strlen($a=$argv[1]);)$s+=(2*$x<=>$l-1)*$a[$x++];echo!$s;

像这样运行：

php -d error_reporting=30709 -r 'for(;$x<$l=strlen($a=$argv[1]);)$s+=(2*$x<=>$l-1)*$a[$x++];echo!$s;' -- 15324;echo

说明

遍历数字中的数字。通过使用组合比较（2 * $x <=> $l - 1）将数字的索引与输入的长度进行比较，来检查数字是否属于前半部分或后半部分（或是中间数字）。然后将其与数字相乘，取所有数字的总和。如果是平衡数字，则总和为0。

输入示例15324：

  index     0  1  2  3  4 
  digit     1  5  3  2  4

  2*index   0  2  4  6  8
  length-1  4  4  4  4  4
  factor    1  1  0 -1 -1  # Result of the spaceship operator

  result    1  5  0 -2 -4
           --------------
  sum                   0

调整

• 不要将数字设置为$d，只需迭代输入的长度即可。保存了5个字节。
• null无需将字符串偏移量强制转换int为PHP即可将其解释为0。保存了1个字节。
• 使用负的字符串偏移量获取数字的后半部分，然后迭代到字符串的一半。保存了7个字节，但需要PHP 7.1
• 通过使用节省了3个字节 $argn

Clojure，66 64字节

更新：str退出该map int功能。

(comp #(=(apply +(map -(drop(/(count %)2)%)%))0)#(map int %)str)

如果输入格式更灵活，则可以将其简化，现在我必须首先将整数映射为ASCII值序列。内部map计算两个半部分的值的成对差异，这将检查增量之和是否为零。

((comp f g h) x y z)= (f (g (h x y z))。

实际上，最终的长度与在a内进行映射let并定义一个函数的长度相同。

sed（165 + 1对于-r）166

/^.$/c1
:l;s,^([^!])([^!]*)([^!])!?([^=]*)=?(.*),\2!\4\1=\5\3,;tl;:
s,.?!|0,,;s,2,11,;s,3,21,;s,4,31,;s,5,41,;s,6,51,;s,7,61,
s,8,71,;s,9,81,;t;s,1=1,=,;t;/^=$/c1
c0

输出：
1为真
0为假

在线尝试！

Python 2.7版，102个 92字节

For循环效果更好：/

s=`input()`
a,b,l=0,0,len(s)
for i in range(l/2):a=a+int(s[i]);b=b+int(s[l-i-1])
print a==b

同样的想法，只是用长度-我得到另一面。它永远不会到达奇数的中心。

旧代码

s=input()
l=len(s)
def n(i):return 0if not i else int(i[0])+n(i[1:])
print n(s[:l/2])==n(s[l/2+l%2:])

获取输入
保存输入长度
递归函数获取字符串
的总和将前一半和后一半进行比较

试图使其低于100，但是很难：/

C函数，74

l;i;t;f(char *n){l=strlen(n);for(t=i=0;i<l/2;)t+=n[i]-n[l-++i];return !t;}

伊迪恩

球拍204字节

(define(f n)(let*((s(number->string n))(g(λ(x y)(apply +(map(λ(x)(string->number(string x)))
(string->list(substring s x y))))))(l(string-length s))(h(/ l 2)))(if(=(g 0(floor h))(g(ceiling h)l))#t #f)))

详细版本：

(define (f1 n)
(let* (  (s (number->string n))
         (g(λ(x y)
              (apply + (map
                        (λ(x)
                          (string->number
                           (string x)))
                        (string->list
                         (substring s x y))))))
         (l (string-length s))
         (h (/ l 2)))
    (if(= (g 0 (floor h)) (g (ceiling h) l)) 
       #t #f  ) ) ) 

测试：

(f 23281453796004414)
(f 523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088)
(f 15421)
(f 5234095123508321)

输出：

#t
#t
#f
#f

Pyke，20个字节

[QleQ`)>[R<]mmbms$X!

在这里尝试！

Mathematica，69岁

Tr@#[[;;⌊l=Length@#/2⌋]]==Tr@#[[⌈l⌉+1;;]]&@*IntegerDigits