Un nombre est équilibré si la somme des chiffres de chaque moitié du nombre est égale. Ainsi: 1423est équilibré parce que 1+4 = 2+3, ainsi est: 42615parce que 4+2=1+5. Notez que le chiffre du milieu n'est inclus ni d'un côté ni de l'autre s'il existe un nombre impair de chiffres.

Défi:

Prenez un entier positif en entrée et indiquez une valeur de vérité si elle est équilibrée et une valeur de fausseté si elle est déséquilibrée.

Cas de test (true)

1
6
11
141
1221
23281453796004414
523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088

Cas de test (faux)

10
12
110
15421
5234095123508321
6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454

Il n'y aura pas de nombres commençant par zéro, par exemple 00032au lieu de 32. Vous devez prendre en charge des nombres d'au moins 100 chiffres (plus grands que 2^64-1). Comme toujours, le format d’entrée facultatif vous permet d’entourer le nombre d’apostrophes si vous le souhaitez.

05AB1E , 14 à 7 octets

€D2äO`Q

Explication

En utilisant 141 comme exemple:

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

Essayez-le en ligne!

> <> , 31 29 octets

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

Essayez-le en ligne!

Ligne 1: boucle d'entrée standard

Ligne 2: Jeter le -1 en haut de la pile, appuyer sur deux 0 et faire pivoter l’un vers le bas de la pile (ceci garantit que les entrées de longueur <3 n’épuisent pas la pile plus tard dans le programme)

Ligne 3: Si la longueur de la pile est> 3, additionnez les deux éléments du haut et du bas.

Ligne 4: Si le haut et le bas de la pile sont égaux, donnez 1, sinon 0.

Edit: réalisé qu'il n'y a pas besoin de prendre les caractères mod 12, 2 octets enregistrés

Haskell, 64 63 octets

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

Un octet enregistré grâce à nimi

Brachylog , 20 octets

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

Essayez-le en ligne!

Explication

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

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

Remarque: l'entrée est donnée sous la forme Stringque Java ne peut pas gérer sans BigInteger(et BigIntegers sont construits à l'aide de .... String)

Essais et non-golfés:

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 octets

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

Explication

J'espérais vraiment pouvoir utiliser cette approche dans certaines langues, et cela semble bien se passer dans Mathematica. L'idée est d'éviter d'avoir à obtenir à la fois la moitié avant et la moitié arrière en combinant la liste avec son envers et en ne regardant que la moitié avant.

...&@*IntegerDigits

Tout d'abord, nous transformons l'entrée en une liste de chiffres décimaux et passons le résultat à la fonction non nommée de gauche.

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

Maintenant, nous soustrayons l'inverse de la liste de la liste elle-même. Si les chiffres sont alors le résultat sera .{a1,a2,...,an}{a1-an,a2-an-1,...,an-a1}

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

Nous extrayons la première moitié de cette liste (en excluant le chiffre du milieu, bien que cela n’importe vraiment pas, car la différence correspondante sera de 0toute façon).

Tr@...

Et puis on résume cette liste. Donc, c'est:

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

Réarrangement:

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

L'entrée est équilibrée si les deux moitiés ont la même somme. Par conséquent, cette expression est égale à zéro si l'entrée est équilibrée. Donc c'est ce que nous vérifions:

...==0

JavaScript (ES6), 59 55 51 44 42 octets

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

Il s'avère que j'utilisais entièrement la mauvaise stratégie. Cette version trouve récursivement la somme de la première moitié moins la somme de la seconde moitié, puis renvoie le NON logique du résultat.

Si nous pouvions retourner la fausseté à la place de la vérité et vice-versa, ce serait 35 octets:

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

Extrait de test

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 octets

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

Prend les entrées $asous forme de chaîne (nécessaire pour prendre en charge les nombres >2^64-1sans entrer dans une [biginteger]distribution extrêmement maladroite sur la ligne de commande).

Pour l'explication, supposons l'entrée de '1423'. Nous construisons ensuite une nouvelle chaîne. Les deux tranches de tableau sont évidentes ( $a[...]), et qui est entouré de trois chaînes supplémentaires (, 0)-(et 0), la formulation d' un tableau de chars et strings. Notez le ,début pour appliquer la concaténation de tableau, pas la concaténation de chaîne.

Ce tableau entier est -joinédité avec +, ce qui donne une chaîne semblable à (+1+4+0)-(+2+3+0), et vous pouvez voir que les 0s sont nécessaires pour éviter les erreurs de syntaxe. C'est introduit dans |iex(court pour Invoke-Expressionet similaire à eval), qui calculera le résultat mathématique. Tant que la chaîne est équilibrée, vous obtenez 0une sortie, que nous encapsulons dans des entre parenthèses et prenons le booléen-not de celle-ci !(...), à la sortie True. S'il s'agit d'un entier non nul, il sera affiché False.

Cas de 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 octets

Comprend +5 pour -lpF

Donner un numéro sur STDIN

balanced.pl <<< 1423

balanced.pl:

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

C #, 83 octets

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

Essayez-le en ligne!

Source complète, incluant le cas de 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
        }
    }
}

Le type de données BigInteger autorise toute longueur de nombre. Si le nombre est trop grand, le compilateur se plaint ( erreur CS1021: la constante intégrale est trop grande ). La méthode BigInteger.Parse (String) est donc utilisée à la place.

La solution peut en réalité être réduite à 72 octets en considérant que l'entrée est une chaîne (et met à jour le programme en conséquence):

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 octets

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

-26 octets par @Rod !

Ruby, 63 octets

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

Remarque: arg sdoit être une chaîne.

Test (minimum 5+ requis):

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 octets

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

La fonction récursive gdéroule une chaîne numérique des deux côtés en prenant la tête à plusieurs reprises, puis en inversant. Il soustrait le résultat récursif de la tête, ce qui lui donne des coefficients alternés de +1 et -1, +1 étant appliqué à la première moitié et -1 à la seconde moitié.

   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

Donc, il prend la somme de la première moitié moins la somme de la seconde moitié. Cela pose le problème qu’avec un nombre impair de chiffres, le centre se sépare à gauche, mais la fonction principale corrige ce problème en (<*"xx")doublant chaque caractère, c’est-à-dire que "12345" devient "1122334455". De cette façon, le chiffre du milieu se divise de manière égale des deux côtés et s’annule.

Retina, 64 44 octets

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

Essayez-le en ligne

La première étape divise la chaîne au milieu, en omettant le caractère du milieu s'il en existe un ( pris et modifié à partir d' ici . Avec l'aimable autorisation de Martin.) Ensuite, remplacez les chiffres par leur représentation unaire et faites correspondre si les deux moitiés sont égales.

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

Additionne de manière récursive la différence entre les premier et dernier chiffres jusqu'à ce qu'il ne reste plus que deux chiffres:

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 octets

Il s'avère que R est très prolixe. Prend la saisie en tant que personnage.

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

Bien formaté:

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

Explication

• y<-as.numeric(unlist(strsplit(x,""))) Fractionner l'entrée (une chaîne de caractères) et la contraindre à un vecteur au lieu d'une liste, puis la reconvertir en nombres entiers.
• sum(tail(y,: tailprend les n derniers éléments, trouvés par:
  • length(y)%/%2)), où %/%est la division entière, pour obtenir le plafond du quotient, où la longueur est impair.
• sum(head(y,length(y)%/%2)): like tail, headprend les n premiers éléments du vecteur, trouvés de la même manière.

Édite

• Sept octets sauvés grâce à niam
• Commuté sur au =lieu de <-, enregistré deux autres octets.

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

Voici une version de 178 octets qui utilise le -adrapeau.

26 octets joués par DJMcMayhem

Essayez-le en ligne

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

Voici une version plus longue de 410 octets qui n'utilise pas l' -aindicateur.

Essayez-le en ligne

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

Explication

Voici une explication de la solution plus courte

Pour commencer, le nombre est converti en toutes ses valeurs ASCII par le -adrapeau.

Nous poussons la hauteur de la pile (c'est-à-dire le nombre de chiffres) et divisons par deux.

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

Pour chaque nombre inférieur au nombre que nous venons de pousser, nous passons un chiffre à l'autre pile

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

Si les piles ont des hauteurs différentes, nous retirons l’élément supérieur de la pile actuelle.

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

Nous voulons la différence entre les sommes de chaque pile. Nous utilisons donc l'algorithme suivant pour additionner chaque pile.

{{}}

Cela suppose qu'aucun chiffre ne possède une valeur ASCII égale à zéro, ce qui est une hypothèse valide.

Nous courons cela pour les deux piles et prenons la différence (Le <(())>est nécessaire pour la prochaine partie.

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

Nous voulons maintenant annuler la somme. Si la somme est égale à zéro, la partie supérieure apparaîtra, révélant celle que nous avons poussée précédemment, sinon le numéro et le numéro seront supprimés et un zéro s'affichera.

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

En fait, 17 16 octets

Cette réponse est inspirée de la réponse d' ElPedro à Python 2 et de leur idée d'utilisation [-b:]. Les suggestions de golf sont les bienvenues. Essayez-le en ligne!

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

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

Essaye-le

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

Essaye-le

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

Testez-le ^{_{(de Jo King )}}

Explication:

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

Bonnes boucles ES5

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

Qu'est-ce qu'il se passe ici?

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 octets

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

Les tests sont à l' idéone

Nous devons utiliser str()plutôt que «puisque npeut être en dehors de la plage de int signé.

Python 2, 83 77 octets

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

MODIFIER

réduit à 77 avec l'aide de @Rod

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

Exemples:

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 octets

Requiert PHP 7.1 pour les décalages de chaîne négatifs:

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

Courir:

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

La version précédente

Note: nécessite PHP 7 pour l'opérateur du vaisseau spatial.

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

Courez comme ça:

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

Explication

Itère sur les chiffres du numéro. Vérifie si le chiffre appartient à la première moitié ou à la seconde moitié (ou est le chiffre du milieu) en comparant l'index du chiffre à la longueur de l'entrée avec la comparaison combinée ( 2 * $x <=> $l - 1). Puis multipliez cela par le chiffre, prenez la somme de tous les chiffres. Si c'est un nombre équilibré, la somme sera0 .

Exemple avec entrée 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

• Ne définissez pas le chiffre sur $d, répétez simplement la longueur de l'entrée. Enregistré 5 octets.
• Le décalage de chaîne nulln'a pas besoin d'être converti pour intque PHP l'interprète comme 0. Enregistré 1 octet.
• Utilisation des décalages de chaîne négatifs pour obtenir les chiffres de la seconde moitié et itération jusqu'à la moitié de la chaîne. Enregistré 7 octets, mais nécessite PHP 7.1
• 3 octets enregistrés en utilisant $argn

Clojure, 66 64 octets

Mise à jour: strsortie de la map intfonction.

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

Cela aurait été raccourci si le format d'entrée était plus flexible, je devais maintenant d'abord mapper l'entier en une séquence de valeurs ASCII. Le mapcalcul interne calcule les différences de valeurs par paires des deux moitiés et vérifie si la somme des deltas est égale à zéro.

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

En fait, cela a fini par avoir la même longueur que de simplement faire le mappage dans un letet simplement définir une fonction.

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

Sortie:
1 pour vrai
0 pour faux

Essayez-le en ligne!

Python 2.7, 102 92 octets

Car la boucle fonctionne mieux: /

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

Même idée, utilisez simplement la longueur - je veux obtenir un autre côté. Il n'atteindra jamais le centre d'un nombre impair.

Ancien code

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

Gets input
Enregistre la longueur de l'entrée
Fonction récursive pour obtenir la somme de la chaîne
Comparer la première moitié de la somme à la seconde moitié de la somme

Essayer de l'obtenir en dessous de 100, mais c'est difficile: /

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

Idéone.

Raquette 204 octets

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

Version détaillée:

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

Essai:

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

Sortie:

#t
#t
#f
#f

Pyke, 20 octets

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

Essayez-le ici!

Mathematica, 69

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