Sayının her bir yarısındaki rakamların toplamı eşit olduğunda bir sayı dengelenir, yani: 1423dengelidir çünkü 1+4 = 2+3şöyledir: 42615çünkü 4+2=1+5. Tek bir rakam varsa, orta hanenin her iki tarafa da dahil edilmediğine (veya her iki tarafa da dahil edildiğine) dikkat edin.

Meydan okuma:

Girdi olarak pozitif bir tamsayı alın ve dengeliyse dengesiz bir değer ve dengesizse sahte bir değer verin.

Test durumları (doğru)

1
6
11
141
1221
23281453796004414
523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088

Test durumları (yanlış)

10
12
110
15421
5234095123508321
6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454

Örneğin sıfır ile başlayan numaralar, olmayacak 00032yerine 32. En az 100 basamaklı rakamları desteklemelisiniz (çok daha büyük 2^64-1). Her zaman olduğu gibi, isteğe bağlı giriş formatı, bu sayede istenirse sayıları kesme işareti ile çevreleyebilirsiniz.

05AB1E , 14 7 bayt

€D2äO`Q

açıklama

Kullanılması 141 örnek olarak:

€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)

Çevrimiçi deneyin!

> <> , 31 29 bayt

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

Çevrimiçi deneyin!

Satır 1: Standart giriş döngüsü

Satır 2: Yığının üstündeki -1 değerini atın, iki 0'ı itin ve birini yığının altına doğru döndürün (bu, <3 uzunluğundaki girişlerin programı daha sonra yığında tüketmemesini sağlar)

Satır 3: Yığın uzunluğu> 3 ise, yığının en üst iki ve en alt iki öğesini birlikte ekleyin.

Satır 4: Yığının üstü ve altı eşitse, aksi halde 1, 0 çıkışı verir.

Düzenleme: mod 12, 2 byte kaydedilen karakterleri almaya gerek olmadığını fark etti

Haskell, 64 63 bayt

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

Bir Bayt nimi sayesinde kaydedildi

Brachylog , 20 bayt

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

Çevrimiçi deneyin!

açıklama

@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 bayt

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

Not: Giriş, StringJava'nın kullanamadığı şekilde verilir BigInteger(ve BigIntegers ... kullanılarak yapılır String.)

Test ve asılsız:

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 bayt

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

açıklama

Gerçekten bu yaklaşımı bir dilde kullanabileceğimi umuyordum ve Mathematica'da gayet iyi çalışıyor gibi görünüyor. Buradaki fikir, listeyi tersiyle birleştirerek ve sadece ön yarıya bakarak hem ön hem de arka yarıyı elde etmekten kaçınmaktır .

...&@*IntegerDigits

Öncelikle, girişi ondalık basamakların listesine dönüştürüyoruz ve sonucu soldaki isimsiz fonksiyona aktarıyoruz.

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

Şimdi listenin tersini listenin kendisinden çıkardık. Rakamlar o zaman sonuç olacaktır .{a1,a2,...,an}{a1-an,a2-an-1,...,an-a1}

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

Bu listenin ilk yarısını çıkardık (ortadaki rakam hariç, aslında farketmese de, buna karşılık gelen fark 0yine de olacak ).

Tr@...

Ve sonra bu listeyi toplarız. Yani bu:

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

yeniden düzenleme:

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

İki yarım aynı toplamı içeriyorsa giriş dengelidir. Dolayısıyla, giriş dengeli ise bu ifade sıfırdır. Demek kontrol ettiklerimiz:

...==0

JavaScript (ES6), 59 55 51 44 42 bayt

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

Tamamen yanlış stratejiyi kullandığım ortaya çıktı. Bu sürüm tekrar tekrar ilk yarıya eksi ikinci yarıya toplamı bulur, ardından sonucun mantıksal NOT'unu döndürür.

Eğer sahtekarlık yerine ve yerine tam tersini döndürürsek, bu 35 bayt olacaktır:

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

Test pasajı

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 bayt

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

$aBir dize olarak girdi alır ( komut satırında >2^64-1aşırı dağınıklık yapmadan numaraları desteklemek için gereklidir [biginteger]).

Açıklama için, girişini varsayalım '1423'. Daha sonra yeni bir dize inşa ediyoruz. İki dizi dilimleri (ortada $a[...]) ve bu üç ek dizeleri çevrilidir (, 0)-(ve 0)bir dizi formüle, chars ve strings. Not ,dizi birleştirme, dize birleştirme zorlamak için ön.

İşte tüm dizi olduğu -joinile birlikte ed +gibi bir dize sonuçlanan (+1+4+0)-(+2+3+0)ve bunu göremiyorsun 0ler sözdizimi hatalarını önlemek için gereklidir. Bu matematiksel sonucu hesaplayacak şekilde |iex(kısa Invoke-Expressionve buna benzer eval) beslenir . Çok uzun dize dengeli olduğunda, elde edersiniz 0biz Pars yerleştirdiğimiz ve bunların Boole-olmayan verdiğimiz bir çıkış olarak !(...)çıkışına, True. Sıfır olmayan bir tamsayıysa, çıktısı alınacaktır False.

Test Kılıfları

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 bayt

İçin +5 içerir -lpF

STDIN’e numara verin

balanced.pl <<< 1423

balanced.pl:

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

C #, 83 bayt

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

Çevrimiçi deneyin!

Test durumu da dahil olmak üzere tam kaynak:

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 veri türü, herhangi bir sayı uzunluğuna izin verir. Sayı çok büyükse, derleyici şikayet eder ( hata CS1021: Integral sabiti çok büyük ), bu nedenle bunun yerine BigInteger.Parse (String) yöntemi kullanılır.

Çözüm , girdi bir dize olduğu için (ve programı buna göre güncelleyerek) aslında 72 byte'a düşürülebilir :

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 bayt

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

-26 bytes @Rod !

Ruby, 63 bayt

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

Not: arg sdizgisi olmalıdır.

Test (en az 5+ gerekli):

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 bayt

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

Özyinelemeli işlev g, kafayı art arda alıp ardından tersine çevirerek her iki uçtan bir sayı dizesini açar. Özyinelemeli sonucu kafadan çıkarır, bu da +1 ve -1 alternatif katsayılarına neden olur; +1, ilk yarıya + 1 ve -1 ila ikinci yarıya uygulanır.

   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

Bu nedenle, ilk yarı eksi, ikinci yarı toplamı alır. Bu, tek sayıdaki rakamlarla, merkezin sola (<*"xx")döndüğünü , ancak ana fonksiyonun her karakteri ikiye bölen, yani "12345" "1122334455" haline geldiğini düzeltir. Bu şekilde orta hane her iki tarafa da eşit şekilde dağılır ve iptal eder.

Retina, 64 44 bayt

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

Çevrimiçi deneyin

İlk aşamada dizeyi ortada bölerek bir tane varsa orta karakteri atlar ( buradan alınmış ve buradan değiştirilmiş . Martin Nezaketinde.) Ardından, rakamları tek biçimli gösterimleriyle değiştirin ve iki yarıya eşit uzunlukta ise eşleştirin.

JavaScript (ES6), 74 67 ... 59 50 bayt

İki haneden az kalana kadar ilk ve son hanelerin farkını tekrar tekrar toplar:

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 bayt

R'nin çok ayrıntılı olduğu ortaya çıktı. Girdiyi karakter olarak alır.

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

Güzel biçimlendirilmiş:

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

açıklama

• y<-as.numeric(unlist(strsplit(x,""))) Girişi bölün (bir string_ ve liste yerine bir vektöre zorlayın ve tamsayılara geri çevirin.
• sum(tail(y,: tailbulunan son n elemanı alır :
  • length(y)%/%2))Burada, %/%tam sayı bölümü, uzunluğu tek bir bölüm, tavan alır.
• sum(head(y,length(y)%/%2)): gibi tail, aynı şekilde bulunan vektörün headilk n elemanlarını alır .

Düzenlemeler

• Niam sayesinde yedi bayt kurtarıldı
• Hesabına geçildi =yerine <-, başka bir iki bayt kaydedildi.

Brain-Flak , 410 206 204 178 + 3 = 181 bayt

-aBayrağı kullanan 178 baytlık bir sürüm .

DJMcMayhem tarafından oynanan 26 bayt

Çevrimiçi Deneyin

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

-aBayrağı kullanmayan daha uzun 410 baytlık bir sürüm .

Çevrimiçi Deneyin

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

açıklama

İşte kısa çözümün açıklaması

Sayı başlamak için -abayrak tarafından ASCII değerlerine dönüştürülür .

Yığın yüksekliğini (rakam sayısı) iter ve ikiye böleriz.

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

Az önce bastığımız sayıdan daha küçük olan her sayı için bir basamağı diğer yığına hareket ettiririz.

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

Yığınların farklı yükseklikleri varsa, üst öğeyi geçerli yığından kaldırırız

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

Her yığının toplamı arasındaki farkı istiyoruz. Bu yüzden her yığını toplamak için aşağıdaki algoritmayı kullanıyoruz.

{{}}

Bu, hiçbir basamağın, ASCII değerine sıfır olmadığını ve geçerli bir varsayım olduğunu varsayar.

Bunu her iki yığın için de çalıştırıyoruz ve farkı alıyoruz (Bir <(())>sonraki bölüm için gerekli).

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

Şimdi toplamı olumsuzlamak istiyoruz. Eğer toplam sıfırsa, daha önce bastığımızın göründüğü en üste çıkar. Aksi takdirde hem sayı hem de sayı kaldırılır ve üstüne sıfır yapılır.

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

Aslında, 17 16 bayt

Bu cevap, ElPedro'nun Python 2 cevabı ve kullanma fikirlerinden ilham almıştır[-b:] . Golf önerileri kabul edilir. Çevrimiçi deneyin!

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

Ungolfing

      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 bayt

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

Dene

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

Dene

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

Test et ^{_{( Jo King'den )}}

Açıklama:

{ # 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 bayt

İyi ES5 döngüler

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

Burada neler oluyor?

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 bayt

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

Testler ideone altında

İmzalanan int aralığının dışında olabileceğinden str(), `` yerine kullanmak zorundayız n.

Python 2, 83 77 bayt

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

DÜZENLE

@Rod'un yardımıyla 77'ye düşürüldü

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

Örnekler:

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 bayt

Negatif dize ofsetleri için PHP 7.1 gerektirir:

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

Çalıştırmak:

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

Önceki versiyon

Not: uzay gemisi operatörü için PHP 7 gerektirir.

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

Bu şekilde koş:

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

açıklama

Rakamdaki rakamları tekrar eder. Rakamın indeksini kombine karşılaştırma ( 2 * $x <=> $l - 1) ile girişin uzunluğu ile karşılaştırarak rakamın ilk yarısına mı, yoksa ikinci yarısına mı (veya orta rakam) ait olup olmadığını kontrol eder . Ardından rakamla çarparak tüm rakamların toplamını alın. Dengeli bir sayı ise, toplam olacaktır 0.

Girdili örnek 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üzenlemeler

• Rakamı ayarlamayın $d, sadece girişin uzunluğunu yineleyin. 5 bayt kaydedildi.
• Ofset dize nulliçin döküm zorunda değildir intPHP olarak yorumlamak için 0. 1 bayt kaydedildi.
• İkinci yarıdan haneleri almak için negatif dize ofsetlerini kullanma ve dizenin yarısına yineleme. 7 bayt kaydedildi, ancak PHP 7.1 gerekiyor
• Kullanarak 3 bayt kaydedildi $argn

Clojure, 66 64 bayt

Güncelleme: Fonksiyondan strçıkarıldı map int.

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

Girdi formatı daha esnek olsaydı, bu kısalabilirdi, şimdi önce tamsayıyı ASCII değerleri dizisine eşlemeliydim. İç kısım map, iki yarıdaki değerlerin çiftler arası farklarını hesaplar ve bu, deltaların toplamının sıfır olup olmadığını kontrol eder.

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

Aslında bu, sadece a içinde eşleştirmeyi yapmakla aynı uzunlukta olmak letve sadece tek bir işlevi tanımlamakla sonuçlandı .

sed (-r için 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

Çıktı:
1
için yanlış 0 için 0

Çevrimiçi deneyin!

Python 2.7, 102 92 bayt

Döngü için daha iyi çalışır:

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

Aynı fikir, sadece uzunluk kullanın - diğer tarafa geçmek için. Asla tek bir sayının merkezine ulaşmayacak.

Eski kod

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:])

Alır girdi
girişi uzunluğunu kaydeder
dize toplamı almak için Recursive fonksiyon
ikinci yarı toplamına ilk yarı toplamı karşılaştırın

100'ün altında almaya çalışırken, ancak zor: /

C işlevi, 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;}

Ideone.

Raket 204 bayt

(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)))

Detaylı versiyon:

(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  ) ) ) 

Test yapmak:

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

Çıktı:

#t
#t
#f
#f

Pyke, 20 bayt

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

Burada dene!

Mathematica, 69

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