Un numero è bilanciato se la somma delle cifre su ciascuna metà del numero è uguale, quindi: 1423è bilanciata perché 1+4 = 2+3, così è: 42615perché 4+2=1+5. Nota che la cifra centrale non è inclusa su entrambi i lati (o è inclusa su entrambi i lati) se c'è un numero dispari di cifre.

Sfida:

Prendi un intero positivo come input e genera un valore di verità se è bilanciato e un valore di falsa se è sbilanciato.

Casi di prova (vero)

1
6
11
141
1221
23281453796004414
523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088

Casi di prova (falso)

10
12
110
15421
5234095123508321
6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454

Non ci saranno numeri che iniziano con zero, ad esempio 00032invece di 32. Devi supportare numeri fino ad almeno 100 cifre (quindi più grandi di 2^64-1). Come sempre, formato di input opzionale, quindi puoi circondare il numero con apostrofi, se lo desideri.

05AB1E , 14 7 byte

€D2äO`Q

Spiegazione

Usando 141 come esempio:

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

Provalo online!

> <> , 31 29 byte

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

Provalo online!

Riga 1: loop di input standard

Riga 2: scarta il -1 in cima allo stack, spingi due 0 e ruota uno in fondo allo stack (questo assicura che gli input di lunghezza <3 non esauriscano lo stack più avanti nel programma)

Linea 3: se la lunghezza della pila è> 3, aggiungi insieme i due elementi in alto e in basso due della pila.

Riga 4: se la parte superiore e inferiore della pila sono uguali, produrre 1, 0 altrimenti.

Modifica: realizzato che non è necessario prendere i caratteri mod 12, 2 byte salvati

Haskell, 64 63 byte

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

Un byte salvato grazie a nimi

Brachylog , 20 byte

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

Provalo online!

Spiegazione

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

Nota: l'input è dato come StringJava non può gestire senza BigInteger(e BigIntegers sono costruiti usando un ... String)

Test e non golfato:

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

Spiegazione

Speravo davvero di poter usare questo approccio in qualche lingua, e sembra che stia andando abbastanza bene in Mathematica. L'idea è di evitare di dover ottenere sia la metà anteriore che posteriore combinando l'elenco con il suo rovescio e osservando solo la metà anteriore.

...&@*IntegerDigits

Innanzitutto, trasformiamo l'input in un elenco di cifre decimali e passiamo il risultato alla funzione senza nome a sinistra.

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

Ora sottraggiamo il retro dell'elenco dall'elenco stesso. Se le cifre sono allora il risultato sarà .{a1,a2,...,an}{a1-an,a2-an-1,...,an-a1}

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

Estraggiamo la prima metà di questo elenco (escludendo la cifra centrale sebbene ciò non contenga effettivamente, poiché la differenza corrispondente sarà 0comunque).

Tr@...

E quindi riassumiamo questo elenco. Così è:

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

Riorganizzare:

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

L'ingresso è bilanciato se le due metà hanno la stessa somma. Quindi, questa espressione è zero se l'ingresso è bilanciato. Quindi è quello che controlliamo:

...==0

JavaScript (ES6), 59 55 51 44 42 byte

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

Ho scoperto che stavo usando completamente la strategia sbagliata. Questa versione trova ricorsivamente la somma della prima metà meno la somma della seconda metà, quindi restituisce il NOT logico del risultato.

Se potessimo restituire la falsità al posto della verità e viceversa, questo sarebbe 35 byte:

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

Test snippet

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)

Prende l'input $acome stringa (necessario per supportare i numeri >2^64-1senza entrare in un [biginteger]casting estremamente goffo sulla riga di comando).

Per la spiegazione, supponiamo che input di '1423'. Stiamo quindi costruendo una nuova stringa. Le due fette di matrice sono evidenti ( $a[...]), e che è circondato da tre ulteriori stringhe (, 0)-(e 0)formulando una serie di chars e strings. Nota ,sul davanti per applicare la concatenazione dell'array, non la concatenazione di stringhe.

L'intero array viene -joineditato insieme +, risultando in una stringa simile (+1+4+0)-(+2+3+0)e puoi vedere che 0sono necessari per prevenire errori di sintassi. Viene inserito in |iex(abbreviato Invoke-Expressione simile a eval), che calcolerà il risultato matematico. Fintanto che la stringa è bilanciata, otterrai 0come output, che incapsuliamo in parentesi e prendiamo il booleano e non la stessa !(...), per l'output True. Se è un numero intero diverso da zero, verrà generato False.

Casi test

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

Include +5 per -lpF

Indicare il numero su 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;};

Provalo online!

Fonte completa, compreso il caso di test:

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

Il tipo di dati BigInteger consente qualsiasi lunghezza numerica. Se il numero è troppo grande, il compilatore si lamenta ( errore CS1021: costante integrale troppo grande ), al suo posto viene utilizzato il metodo BigInteger.Parse (String) .

La soluzione può effettivamente essere ridotta a 72 byte considerando che l'input è una stringa (e aggiorna il programma di conseguenza):

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 byte di @Rod !

Rubino, 63 byte

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

Nota: arg s deve essere una stringa.

Test (minimo 5+ richiesto):

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

La funzione ricorsiva gsrotola una stringa numerica da entrambe le estremità prendendo ripetutamente la testa, quindi invertendo. Sottrae il risultato ricorsivo dalla testa, che le fa alternare coefficienti di +1 e -1, con +1 applicato alla prima metà e -1 alla seconda metà.

   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

Quindi, prende la somma della prima metà meno la somma della seconda metà. Questo ha il problema che con un numero dispari di cifre, il pareggio centrale si sposta a sinistra, ma la funzione principale risolve questo problema (<*"xx"), che raddoppia ogni carattere, ovvero "12345" diventa "1122334455". In questo modo la cifra centrale si divide uniformemente su entrambi i lati e si annulla.

Retina, 64 44 byte

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

Provalo online

Il primo stadio divide la stringa nel mezzo, omettendo il carattere centrale se ce n'è uno ( preso e modificato da qui . Per gentile concessione di Martin.) Quindi, sostituisci le cifre con la loro rappresentazione unaria e abbina se le due metà sono della stessa lunghezza.

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

Somma ricorsivamente la differenza della prima e dell'ultima cifra fino a quando rimangono meno di due cifre:

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

Si scopre che R è molto prolisso. Accetta input come personaggio.

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

Formattato bene:

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

Spiegazione

• y<-as.numeric(unlist(strsplit(x,""))) Dividere l'input (una stringa_ e forzarlo in un vettore anziché in un elenco, quindi trasformarlo nuovamente in numeri interi.
• sum(tail(y,: tailprende gli ultimi n elementi, trovati da:
  • length(y)%/%2)), dove %/%è la divisione intera, per ottenere il massimale del quoziente, dove la lunghezza è dispari.
• sum(head(y,length(y)%/%2)): like tail, headaccetta i primi n elementi del vettore, trovati allo stesso modo.

Le modifiche

• Salvati sette byte grazie a Niam
• Passato a =invece di <-, salvato altri due byte.

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

Ecco una versione di 178 byte che utilizza il -aflag.

26 byte scartati da DJMcMayhem

Provalo online

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

Ecco una versione più lunga di 410 byte che non usa il -aflag.

Provalo online

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

Spiegazione

Ecco una spiegazione della soluzione più breve

Per iniziare il numero viene convertito in tutti i suoi valori ASCII dal -aflag.

Spingiamo l'altezza della pila (cioè il numero di cifre) e dividiamo per due.

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

Per ogni numero inferiore al numero che abbiamo appena premuto spostiamo una cifra sull'altro stack

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

Se le pile hanno altezze diverse, rimuoviamo l'oggetto in cima alla pila corrente

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

Vogliamo la differenza tra le somme di ogni pila. Quindi usiamo il seguente algoritmo per sommare ogni pila.

{{}}

Ciò presuppone che nessuna cifra abbia un valore ASCII pari a zero, il che è un presupposto valido.

Lo eseguiamo per entrambe le pile e prendiamo la differenza ( <(())>è necessario per la parte successiva.

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

Vogliamo ora annullare la somma. Se la somma è zero, aprirà la parte superiore rivelando quella che abbiamo spinto in precedenza, altrimenti rimuoverà sia il numero che quello e posizionerà uno zero in cima.

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

In realtà, 17 16 byte

Questa risposta si ispira alla risposta Python 2 di ElPedro e alla loro idea da utilizzare [-b:]. Suggerimenti di golf benvenuti. Provalo online!

$♂≈;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 byte

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

Provalo

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

Provalo

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

Provalo ^{_{(da Jo King )}}

Spiegazione:

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

Buoni vecchi loop ES5

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

Cosa sta succedendo qui?

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

I test sono su ideone

Dobbiamo usare str()piuttosto che `` poiché npotrebbe essere al di fuori dell'intervallo di int firmato.

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

MODIFICARE

ridotto a 77 con l'aiuto di @Rod

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

Esempi:

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

Richiede PHP 7.1 per gli offset di stringa negativi:

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

Correre:

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

Versione precedente

Nota: richiede PHP 7 per l'operatore dell'astronave.

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

Esegui in questo modo:

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

Spiegazione

Scorre le cifre nel numero. Verifica se la cifra appartiene alla prima metà o alla seconda metà (o è la cifra centrale) confrontando l'indice della cifra con la lunghezza dell'input con il confronto combinato (2 * $x <=> $l - 1 ). Quindi moltiplicalo per la cifra, prendi la somma di tutte le cifre. Se è un numero bilanciato, la somma sarà0 .

Esempio con 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

Ritocchi

• Non impostare la cifra su $d , solo iterare la lunghezza dell'input. 5 byte salvati.
• nullNon è necessario eseguire il cast dell'offset della stringaint affinché PHP lo interpreti come 0. 1 byte salvato.
• Utilizzo di offset stringa negativi per ottenere le cifre dalla seconda metà e iterazione a metà della stringa. Salvato 7 byte, ma richiede PHP 7.1
• Salvato 3 byte utilizzando $argn

Clojure, 66 64 byte

Aggiornamento: rimosso strdalla map intfunzione.

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

Questo sarebbe stato abbreviato se il formato di input fosse più flessibile, ora dovevo prima mappare l'intero in una sequenza di valori ASCII. L'interno mapcalcola le differenze di valori di coppia rispetto alle due metà e verifica se la somma dei delta è zero.

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

In realtà questo ha finito per avere la stessa lunghezza del solo fare il mapping all'interno di a lete definire una singola funzione.

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

Uscita:
1 per vero
0 per falso

Provalo online!

Python 2.7, 102 92 byte

For loop funziona meglio: /

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

Stessa idea, basta usare la lunghezza - i per ottenere l'altro lato. Non raggiungerà mai il centro di un numero dispari.

Vecchio codice

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

Ottiene l'input
Salva la lunghezza dell'input
Function ricorsiva per ottenere la somma della stringa
Confronta la somma della prima metà con la somma della seconda metà

Cercare di portarlo al di sotto di 100, ma è difficile: /

Funzione 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.

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

Versione dettagliata:

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

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

Produzione:

#t
#t
#f
#f

Pyke, 20 byte

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

Provalo qui!

Mathematica, 69

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