：数がそう、番号の各半分の数字の合計が等しい場合にバランスされている1423ので、バランスされ1+4 = 2+3そうである。42615ため4+2=1+5。奇数の桁がある場合、中央の数字はどちらの側にも含まれません（または両側に含まれます）。

チャレンジ：

入力として正の整数を取り、バランスが取れている場合は真実の値を、バランスが取れていない場合は偽の値を出力します。

テストケース（true）

1
6
11
141
1221
23281453796004414
523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088

テストケース（false）

10
12
110
15421
5234095123508321
6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454

たとえば、の00032代わりにゼロで始まる数字はありません32。少なくとも100桁までの数字をサポートする必要があります（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を破棄し、2つの0を押して1つをスタックの一番下まで回転させます（これにより、長さが<3の入力がプログラムの後半でスタックを使い果たすことがなくなります）

3行目：スタックの長さが> 3の場合、スタックの上部2要素と下部2要素を一緒に追加します。

行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のおかげで1バイト節約

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;}

注：入力はStringJavaなしでは処理できないためBigInteger（およびBigIntegersはa ...を使用して構築されるため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

まず、入力を10進数のリストに変換し、結果を左側の名前のない関数に渡します。

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

次に、リスト自体からリストの逆を減算します。数字がある場合、結果はになります。{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)

2つの半分の合計が同じ場合、入力はバランスされます。したがって、入力のバランスが取れている場合、この式はゼロになります。それが私たちがチェックすることです：

...==0

JavaScript（ES6）、59 55 51 44 42バイト

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

間違った戦略を完全に使用していたことがわかりました。このバージョンは、前半の合計から後半の合計を引いたものを再帰的に検索し、結果の論理否定を返します。

真実の代わりに偽物を返すことができ、その逆の場合、これは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'。次に、新しい文字列を作成しています。2つの配列のスライスは、（明白である$a[...]）、およびそのは三つの追加の文字列に囲まれています(、0)-(と0)の配列策定、charsおよびstring秒。,文字列の連結ではなく配列の連結を強制するために、先頭に注意してください。

その配列全体がと-join一緒にedされ+、その結果、などの文字列が生成されます。構文エラーを防ぐためにsが必要で(+1+4+0)-(+2+3+0)あることがわかり0ます。それはに供給されます|iex（ショートInvoke-Expressionおよび類似のeval数学的な結果を計算します）。文字列のバランスが取れている限り0、出力として取得します。これを括弧でカプセル化し、そのブール値ではなくブール値!(...)をoutputに取り込みます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バイト！

ルビー、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")、すべての文字を2倍にします。つまり、「12345」は「1122334455」になります。これにより、中央の数字が両側で均等に分割され、キャンセルされます。

網膜、64 44バイト

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

オンラインで試す

存在する場合第一段階は、中間文字を省略し、途中で文字列を分割し（から採取し、変性ここ。マーティンの礼儀である。）そして、それらの単項表現との数字を交換し、2人の半分は同じ長さである場合に一致します。

JavaScript（ES6）、74 67 ... 59 50バイト

残りの2桁未満になるまで、最初と最後の桁の差を再帰的に合計します。

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))：のようにtail、head第一とるn個の同じ方法で見つかった、ベクトルの要素。

編集

• niamのおかげで7バイト節約
• の=代わりに切り替えて<-、さらに2バイト節約しました。

脳フラック、410 206 204 178 + 3 = 181のバイト

これは、-aフラグを使用する178バイトバージョンです。

DJMcMayhemによってゴルフオフされた26バイト

オンラインで試す

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

-aフラグを使用しない、より長い410バイトバージョンを次に示します。

オンラインで試す

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

説明

ここに短い解決策の説明があります

番号を開始するには、-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

テストは理想的です

signed intの範囲外になる可能性があるstr()ため、「」ではなく「」を使用する必要がありますn。

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バイトを保存しました。
• PHPで文字列オフセットを解釈nullするintためにキャストする必要はありません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は2つの半分の値のペアごとの差を計算し、これによりデルタの合計がゼロかどうかをチェックします。

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

実際、これは、a内でマッピングを行い、let単一の関数を定義するだけの長さと同じになりました。

sed（-rの場合は165 + 1）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

オンラインでお試しください！

パイソン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:])

取得した入力は、
入力の長さが保存し
た文字列の合計が取得する再帰funcを
後半和に前半の合計を比較します

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

パイク、20バイト

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

ここで試してみてください！

Mathematica、69

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