Un número está equilibrado si la suma de los dígitos en cada mitad del número es igual, entonces: 1423está equilibrado porque 1+4 = 2+3, así es: 42615porque 4+2=1+5. Tenga en cuenta que el dígito del medio no se incluye en ninguno de los lados (o se incluye en ambos lados) si hay un número impar de dígitos.

Reto:

Tome un entero positivo como entrada y genere un valor verdadero si está equilibrado y un valor falso si no está equilibrado.

Casos de prueba (verdadero)

1
6
11
141
1221
23281453796004414
523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088

Casos de prueba (falso)

10
12
110
15421
5234095123508321
6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454

No habrá números que comiencen con cero, por ejemplo, en 00032lugar de 32. Debe admitir números de hasta al menos 100 dígitos (tan grande como 2^64-1). Como siempre, formato de entrada opcional, por lo que puede rodear el número con apóstrofos si lo desea.

05AB1E , 14 7 bytes

€D2äO`Q

Explicación

Usando 141 como ejemplo:

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

Pruébalo en línea!

> <> , 31 29 bytes

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

Pruébalo en línea!

Línea 1: bucle de entrada estándar

Línea 2: deseche el -1 en la parte superior de la pila, presione dos ceros y gire uno hacia la parte inferior de la pila (esto asegura que las entradas de longitud <3 no agoten la pila más adelante en el programa)

Línea 3: si la longitud de la pila es> 3, agregue los dos elementos superiores e inferiores de la pila juntos.

Línea 4: Si la parte superior e inferior de la pila son iguales, salida 1, 0 de lo contrario.

Editar: me di cuenta de que no es necesario tomar los caracteres mod 12, 2 bytes guardados

Haskell, 64 63 bytes

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

Un byte guardado gracias a nimi

Brachylog , 20 bytes

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

Pruébalo en línea!

Explicación

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

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: la entrada se da como StringJava no puede manejar sin BigInteger(y BigIntegers se construyen usando un ... String)

Pruebas y sin golf:

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 bytes

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

Explicación

Realmente esperaba poder usar este enfoque en algún idioma, y ​​parece estar funcionando bastante bien en Mathematica. La idea es evitar tener que obtener tanto la mitad frontal como la posterior combinando la lista con su reverso y mirando solo la mitad frontal.

...&@*IntegerDigits

Primero, convertimos la entrada en una lista de dígitos decimales y pasamos el resultado a la función sin nombre a la izquierda.

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

Ahora restamos el reverso de la lista de la lista misma. Si los dígitos son entonces el resultado será .{a1,a2,...,an}{a1-an,a2-an-1,...,an-a1}

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

Extraemos la primera mitad de esta lista (excluyendo el dígito del medio, aunque eso en realidad no importa, porque la diferencia correspondiente será de 0todos modos).

Tr@...

Y luego sumamos esta lista. Así que eso es:

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

Reorganizando:

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

La entrada se equilibra si las dos mitades tienen la misma suma. Por lo tanto, esta expresión es cero si la entrada está equilibrada. Entonces eso es lo que verificamos:

...==0

JavaScript (ES6), 59 55 51 44 42 bytes

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

Resulta que estaba usando la estrategia equivocada por completo. Esta versión encuentra recursivamente la suma de la primera mitad menos la suma de la segunda mitad, luego devuelve el NOT lógico del resultado.

Si pudiéramos devolver falsedad en lugar de verdad y viceversa, esto sería 35 bytes:

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

Fragmento de prueba

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 bytes

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

Toma la entrada $acomo una cadena (necesaria para admitir números >2^64-1sin entrar extremadamente torpe[biginteger] conversión en la línea de comando).

Para la explicación, supongamos la entrada de '1423' . Entonces estamos construyendo una nueva cadena. Las dos rebanadas de matriz son obvias ( $a[...]), y que está rodeado por tres cadenas adicionales (, 0)-(y 0), la formulación de una matriz de chars y strings. Tenga ,en cuenta el frente para aplicar la concatenación de matriz, no la concatenación de cadenas.

Esa matriz completa se -joinedita junto con +, dando como resultado una cadena como (+1+4+0)-(+2+3+0), y puede ver que los 0s son necesarios para evitar errores de sintaxis. Eso se introduce en |iex(abreviatura Invoke-Expressiony similar a eval), que calculará el resultado matemático. Mientras la cadena esté equilibrada, obtendrá 0como salida, que encapsulamos en parens y tomamos el booleano, no del mismo !(...), para generarTrue . Si se trata de un número entero distinto de cero, se generará False.

Casos de prueba

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 bytes

Incluye +5 para -lpF

Dar número en STDIN

balanced.pl <<< 1423

balanced.pl:

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

C #, 83 bytes

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

Pruébalo en línea!

Fuente completa, incluido el caso de prueba:

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

El tipo de datos BigInteger permite cualquier longitud de número. Si el número es demasiado grande, el compilador se queja ( error CS1021: la constante integral es demasiado grande ), entonces BigInteger.Parse (String) se utiliza el método .

La solución en realidad se puede reducir a 72 bytes considerando que la entrada es una cadena (y actualizando el programa en consecuencia):

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 bytes

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

-26 bytes por @Rod !

Ruby, 63 bytes

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

Nota: arg s debe ser una cadena.

Prueba (se requiere minitest 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 bytes

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

La función recursiva gdesenvuelve una cadena de números de ambos extremos tomando repetidamente la cabeza y luego invirtiendo. Resta el resultado recursivo de la cabeza, lo que provoca coeficientes alternos de +1 y -1, con +1 aplicado a la primera mitad y -1 a la segunda mitad.

   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

Entonces, toma la suma de la primera mitad menos la suma de la segunda mitad. Esto tiene el problema de que con un número impar de dígitos, el centro se rompe a la izquierda, pero la función principal lo corrige (<*"xx"), lo que duplica cada carácter, es decir, "12345" se convierte en "1122334455". De esa manera, el dígito del medio se divide de manera uniforme en ambos lados y se cancela.

Retina, 64 44 bytes

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

Pruébalo en línea

La primera etapa divide la cadena en el medio, omitiendo el carácter del medio si hay uno ( tomado y modificado a partir de aquí . Cortesía de Martin). Luego, reemplace los dígitos con su representación unaria y haga coincidir si las dos mitades son de igual longitud.

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

Suma recursivamente la diferencia del primer y último dígito hasta que queden menos de dos dígitos:

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 bytes

Resulta que R es muy detallado. Toma la entrada como un personaje.

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

Formateado muy bien:

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

Explicación

• y<-as.numeric(unlist(strsplit(x,""))) Divida la entrada (una cadena_, y conviértala en un vector en lugar de una lista, y luego vuelva a convertirla en enteros.
• sum(tail(y,: tailtoma los últimos n elementos, encontrados por:
  • length(y)%/%2)), donde %/%está la división de enteros, para obtener el techo del cociente, donde la longitud es impar.
• sum(head(y,length(y)%/%2)): como tail, headtoma los primeros n elementos del vector, encontrados de la misma manera.

Ediciones

• Guardado siete bytes gracias a niam
• Cambiado a en =lugar de <-, guardado otros dos bytes.

Cerebro-Flak , 410 206 204 178 + 3 = 181 bytes

Aquí hay una versión de 178 bytes que usa la -abandera.

26 bytes de golf de DJMcMayhem

Pruébalo en línea

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

Aquí hay una versión más larga de 410 bytes que no usa la -abandera.

Pruébalo en línea

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

Explicación

Aquí hay una explicación de la solución más corta.

Para comenzar, el número se convierte a todos sus valores ASCII mediante la -abandera.

Empujamos la altura de la pila (es decir, el número de dígitos) y la dividimos por dos.

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

Por cada número menor que el número que acabamos de presionar, movemos un dígito a la otra pila

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

Si las pilas tienen diferentes alturas, eliminamos el elemento superior de la pila actual

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

Queremos la diferencia entre las sumas de cada pila. Entonces usamos el siguiente algoritmo para sumar cada pila.

{{}}

Esto supone que ningún dígito tiene un valor ASCII de cero, que es una suposición válida.

Ejecutamos esto para ambas pilas y tomamos la diferencia (El <(())> es necesario para la siguiente parte.

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

Ahora queremos negar la suma. Si la suma es cero, se abrirá la parte superior revelando la que presionamos anteriormente; de ​​lo contrario, eliminará tanto el número como el uno y colocará un cero en la parte superior.

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

En realidad, 17 16 bytes

Esta respuesta está inspirada en la respuesta de Python 2 de ElPedro y su idea de usar [-b:]. Sugerencias de golf bienvenidas. Pruébalo en línea!

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

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

Pruébalo

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

Pruébalo

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

Pruébalo ^{_{(de Jo King )}}

Explicación:

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

Buenos viejos bucles ES5

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

¿Que esta pasando aqui?

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 bytes

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

Las pruebas están en ideone

Tenemos que usar en str()lugar de `` ya que npuede estar fuera del rango de int firmado.

Python 2, 83 77 bytes

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

EDITAR

reducido a 77 con ayuda de @Rod

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

Ejemplos:

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 bytes

Requiere PHP 7.1 para compensaciones de cadena negativas:

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

Correr:

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

Versión previa

Nota: requiere PHP 7 para el operador de la nave espacial.

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

Corre así:

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

Explicación

Itera sobre los dígitos en el número. Comprueba si el dígito pertenece a la primera mitad o la segunda mitad (o es el dígito del medio) comparando el índice del dígito con la longitud de la entrada con la comparación combinada ( 2 * $x <=> $l - 1). Luego multiplique eso con el dígito, tome la suma de todos los dígitos. Si es un número equilibrado, la suma será0 .

Ejemplo con entrada 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

Ajustes

• No establezca el dígito en $d, solo itere la longitud de la entrada. Guardado 5 bytes.
• nullNo es necesario convertir el desplazamiento de cadena intpara que PHP lo interprete0 . Guardado 1 byte.
• Usando compensaciones de cadena negativas para obtener los dígitos de la segunda mitad e iterando a la mitad de la cadena. Guardado 7 bytes, pero requiere PHP 7.1
• Guardado 3 bytes usando $argn

Clojure, 66 64 bytes

Actualización: se eliminó strde la map intfunción.

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

Esto se habría acortado si el formato de entrada fuera más flexible, ahora tenía que asignar primero el entero en una secuencia de valores ASCII. El interiormap calcula las diferencias de valores por pares de las dos mitades, y esto verifica si la suma de deltas es cero.

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

En realidad, esto terminó teniendo la misma longitud que simplemente hacer el mapeo dentro de ay letsolo definir una sola función.

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

Salida:
1 para verdadero
0 para falso

Pruébalo en línea!

Python 2.7, 102 92 bytes

Para el bucle funciona mejor: /

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

La misma idea, solo usa la longitud - i para obtener el otro lado. Nunca llegará al centro de un número impar.

Código antiguo

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

Obtiene la entrada
Guarda la longitud de la entrada
Función recursiva para obtener la suma de la cadena
Compare la primera mitad de la suma con la segunda mitad de la suma

Tratando de llegar por debajo de 100, pero es difícil: /

Función 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;}

Ideona

Raqueta 204 bytes

(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ón detallada:

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

Pruebas:

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

Salida:

#t
#t
#f
#f

Pyke, 20 bytes

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

Pruébalo aquí!

Mathematica, 69

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