Angka seimbang jika jumlah angka pada setiap setengah angka sama, jadi: 1423seimbang karena 1+4 = 2+3, begitu juga: 42615karena 4+2=1+5. Perhatikan bahwa digit tengah tidak termasuk di kedua sisi (atau itu termasuk di kedua sisi) jika ada jumlah digit ganjil.

Tantangan:

Ambil bilangan bulat positif sebagai input, dan hasilkan nilai yang benar jika itu seimbang dan nilai yang salah jika tidak seimbang.

Uji kasus (benar)

1
6
11
141
1221
23281453796004414
523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088

Uji kasus (salah)

10
12
110
15421
5234095123508321
6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454

Tidak akan ada angka yang dimulai dengan nol, misalnya 00032bukan 32. Anda harus mendukung angka hingga setidaknya 100 digit (lebih besar dari 2^64-1). Seperti biasa, format input opsional, sehingga Anda dapat mengelilingi angka dengan apostrof jika diinginkan.

05AB1E , 14 7 byte

€D2äO`Q

Penjelasan

Menggunakan 141 sebagai contoh:

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

Cobalah online!

> <> , 31 29 byte

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

Cobalah online!

Baris 1: Loop input standar

Baris 2: Buang -1 di atas tumpukan, tekan dua 0 dan putar satu ke bawah tumpukan (ini memastikan bahwa input dengan panjang <3 jangan buang tumpukan nanti dalam program)

Baris 3: Jika panjang tumpukan adalah> 3, tambahkan dua elemen teratas dan paling bawah tumpukan.

Baris 4: Jika bagian atas dan bawah tumpukan sama, output 1, 0 sebaliknya.

Sunting: menyadari bahwa tidak perlu membawa karakter mod 12, 2 byte disimpan

Haskell, 64 63 byte

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

Satu Byte Disimpan berkat nimi

Brachylog , 20 byte

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

Cobalah online!

Penjelasan

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

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

Catatan: input diberikan karena StringJava tidak dapat menangani tanpa BigInteger(dan BigIntegers dibangun menggunakan .... String)

Pengujian dan ungolfed:

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 byte

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

Penjelasan

Saya benar-benar berharap saya bisa menggunakan pendekatan ini dalam beberapa bahasa, dan tampaknya cukup baik di Mathematica. Idenya adalah untuk menghindari mendapatkan bagian depan dan belakang dengan menggabungkan daftar dengan terbalik dan hanya melihat bagian depan.

...&@*IntegerDigits

Pertama, kami mengubah input menjadi daftar angka desimal dan meneruskan hasilnya ke fungsi yang tidak disebutkan namanya di sebelah kiri.

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

Sekarang kita kurangi kebalikan dari daftar dari daftar itu sendiri. Jika digitnya maka hasilnya akan menjadi .{a1,a2,...,an}{a1-an,a2-an-1,...,an-a1}

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

Kami mengekstrak paruh pertama daftar ini (tidak termasuk digit tengah meskipun itu sebenarnya tidak masalah, karena perbedaannya 0tetap saja).

Tr@...

Dan kemudian kita menjumlahkan daftar ini. Jadi itu:

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

Mengatur ulang:

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

Input seimbang jika kedua bagian memiliki jumlah yang sama. Oleh karena itu, ungkapan ini nol jika inputnya seimbang. Jadi itulah yang kami periksa:

...==0

JavaScript (ES6), 59 55 51 44 42 byte

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

Ternyata saya menggunakan strategi yang salah sepenuhnya. Versi ini secara rekursif menemukan jumlah babak pertama dikurangi jumlah babak kedua, lalu mengembalikan BUKAN logis dari hasilnya.

Jika kita dapat mengembalikan falsy sebagai pengganti truey dan sebaliknya, ini akan menjadi 35 byte:

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

Cuplikan tes

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 byte

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

Mengambil input $asebagai string (diperlukan untuk mendukung angka >2^64-1tanpa masuk ke [biginteger]casting yang sangat kikuk di baris perintah).

Untuk penjelasannya, mari kita asumsikan masukan dari '1423'. Kami kemudian membangun string baru. Dua potong array adalah jelas ( $a[...]), dan itu dikelilingi oleh tiga senar tambahan (, 0)-(dan 0), merumuskan berbagai chars dan strings. Catat ,di bagian depan untuk menerapkan rangkaian array, bukan rangkaian string.

Seluruh array itu -joindiedit bersama +, menghasilkan string seperti (+1+4+0)-(+2+3+0), dan Anda dapat melihat bahwa 0s diperlukan untuk mencegah kesalahan sintaks. Itu dimasukkan ke dalam |iex(kependekan Invoke-Expressiondan mirip dengan eval), yang akan menghitung hasil matematika. Selama string seimbang, Anda akan mendapatkan 0sebagai output, yang kami enkapsulasi dalam parens dan mengambil Boolean-bukan daripadanya !(...), ke output True. Jika bilangan bulat bukan nol, itu akan keluar False.

Uji Kasus

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 byte

Termasuk +5 untuk -lpF

Berikan nomor pada STDIN

balanced.pl <<< 1423

balanced.pl:

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

C #, 83 byte

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

Cobalah online!

Sumber lengkap, termasuk test case:

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

Tipe data BigInteger memungkinkan panjang angka apa pun. Jika angkanya terlalu besar, kompiler mengeluh ( kesalahan CS1021: Konstanta integral terlalu besar ), jadi metode BigInteger.Parse (String) digunakan sebagai gantinya.

Solusinya sebenarnya dapat dikurangi menjadi 72 byte mengingat inputnya adalah string (dan memperbarui program yang sesuai):

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 byte

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

-26 bytes oleh @Rod !

Ruby, 63 byte

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

Catatan: arg sharus berupa string.

Pengujian (minimal diperlukan 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 byte

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

Fungsi rekursif gmembuka bungkus string nomor dari kedua ujung dengan berulang-ulang mengambil kepala, lalu membalikkan. Ini mengurangi hasil rekursif dari kepala, yang menyebabkannya koefisien alternatif +1 dan -1, dengan +1 diterapkan pada paruh pertama dan -1 ke babak kedua.

   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

Jadi, dibutuhkan jumlah babak pertama dikurangi jumlah babak kedua. Ini memiliki masalah yang dengan angka ganjil digit, pusat tiebreak ke kiri, tetapi fungsi utama memperbaikinya dengan (<*"xx"), yang menggandakan setiap karakter, yaitu "12345" menjadi "1122334455". Dengan cara itu digit tengah terbagi rata di kedua sisi dan dibatalkan.

Retina, 64 44 byte

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

Cobalah online

Tahap pertama membagi string di tengah, menghilangkan karakter tengah jika ada satu ( diambil dan dimodifikasi dari sini . Courtesy of Martin.) Kemudian, ganti digit dengan representasi unary mereka, dan cocokkan jika kedua bagian memiliki panjang yang sama.

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

Secara rekursif merangkum perbedaan digit pertama dan terakhir hingga tersisa kurang dari dua digit:

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 byte

Ternyata R sangat bertele-tele. Mengambil input sebagai karakter.

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

Diformat dengan baik:

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

Penjelasan

• y<-as.numeric(unlist(strsplit(x,""))) Pisahkan input (string_, dan paksakan ke vektor alih-alih daftar, lalu ubah kembali menjadi bilangan bulat.
• sum(tail(y,: tailmengambil n elemen terakhir , ditemukan oleh:
  • length(y)%/%2)), Di mana %/%adalah pembagian bilangan bulat, untuk mendapatkan langit-langit hasil bagi, di mana panjangnya aneh.
• sum(head(y,length(y)%/%2)): seperti tail, headmengambil elemen n pertama dari vektor, ditemukan dengan cara yang sama.

Suntingan

• Disimpan tujuh byte berkat niam
• Beralih ke =alih-alih <-, menyimpan dua byte lagi.

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

Ini adalah versi 178 byte yang menggunakan -aflag.

26 byte golf dari DJMcMayhem

Cobalah secara Online

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

Ini adalah versi yang lebih panjang 410 byte yang tidak menggunakan -aflag.

Cobalah secara Online

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

Penjelasan

Berikut ini penjelasan tentang solusi yang lebih pendek

Untuk memulai, angka dikonversikan ke semua nilai ASCII oleh -abendera.

Kami mendorong ketinggian tumpukan (yaitu jumlah digit) dan membaginya dengan dua.

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

Untuk setiap nomor kurang dari jumlah yang baru saja kami dorong, kami memindahkan satu digit ke tumpukan lainnya

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

Jika ketinggian tumpukan berbeda, kami menghapus item teratas dari tumpukan saat ini

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

Kami ingin perbedaan antara jumlah setiap tumpukan. Jadi kami menggunakan algoritma berikut untuk menjumlahkan setiap tumpukan.

{{}}

Ini mengasumsikan tidak ada digit yang memiliki nilai ASCII nol, yang merupakan asumsi yang valid.

Kami menjalankan ini untuk kedua tumpukan dan mengambil perbedaan (Hal <(())>ini diperlukan untuk bagian selanjutnya.

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

Kami sekarang ingin meniadakan jumlahnya. Jika jumlahnya nol, maka akan muncul bagian atas yang memperlihatkan yang kita dorong sebelumnya, jika tidak maka akan menghapus nomor dan yang satu dan menempatkan nol di atas.

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

Sebenarnya, 17 16 byte

Jawaban ini terinspirasi oleh jawaban Python 2 ElPedro dan ide mereka untuk menggunakan [-b:]. Saran golf diterima. Cobalah online!

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

Tidak melakukanolf

      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 byte

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

Menguji

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

Menguji

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

Uji itu ^{_{(dari Jo King )}}

Penjelasan:

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

Loop ES5 yang bagus

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

Apa yang sedang terjadi disini?

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 byte

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

Tes ada di ideone

Kita harus menggunakan str()daripada `` karena nmungkin di luar kisaran int yang ditandatangani.

Python 2, 83 77 byte

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

EDIT

dikurangi menjadi 77 dengan bantuan dari @Rod

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

Contoh:

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 byte

Membutuhkan PHP 7.1 untuk offset string negatif:

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

Menjalankan:

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

Versi sebelumnya

Catatan: membutuhkan PHP 7 untuk operator pesawat ruang angkasa.

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

Jalankan seperti ini:

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

Penjelasan

Iterate di atas angka dalam angka. Memeriksa apakah digit milik bagian pertama atau babak kedua (atau digit tengah) dengan membandingkan indeks digit dengan panjang input dengan perbandingan gabungan ( 2 * $x <=> $l - 1). Kemudian gandakan dengan digit, ambil jumlah semua digit. Jika itu angka seimbang, jumlahnya akan menjadi 0.

Contoh dengan input 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

Tweaks

• Jangan mengatur digit ke $d, cukup iterate panjang input. Disimpan 5 byte.
• String offset nulltidak harus dilemparkan ke intPHP untuk menafsirkannya sebagai 0. Disimpan 1 byte.
• Menggunakan offset string negatif untuk mendapatkan digit dari babak kedua dan beralih ke setengah dari string. Disimpan 7 byte, tetapi membutuhkan PHP 7.1
• Disimpan 3 byte dengan menggunakan $argn

Clojure, 66 64 byte

Pembaruan: Mengambil strdari map intfungsi.

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

Ini akan disingkat jika format input lebih fleksibel, sekarang saya harus memetakan integer menjadi urutan nilai ASCII. Bagian dalam mapmenghitung perbedaan nilai pasangan dari dua bagian, dan ini memeriksa apakah jumlah delta adalah nol.

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

Sebenarnya ini berakhir dengan panjang yang sama dengan hanya melakukan pemetaan di dalam letdan hanya mendefinisikan satu fungsi.

sed (165 +1 untuk -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

Output:
1 untuk
0 benar untuk salah

Cobalah online!

Python 2.7, 102 92 byte

Agar loop bekerja lebih baik: /

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

Gagasan yang sama, cukup gunakan panjang - saya untuk mendapatkan sisi lain. Itu tidak akan pernah mencapai pusat nomor ganjil.

Kode lama

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

Mendapat input
Menghemat lama input
Fungsi rekursif untuk mendapatkan jumlah string
Bandingkan jumlah babak pertama dengan jumlah babak kedua

Mencoba mendapatkannya di bawah 100, tetapi sulit: /

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

Ideone.

Racket 204 byte

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

Versi detail:

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

Pengujian:

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

Keluaran:

#t
#t
#f
#f

Pyke, 20 byte

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

Coba di sini!

Mathematica, 69

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