Eine Zahl ist ausgeglichen, wenn die Summe der Ziffern in jeder Hälfte der Zahl gleich ist, also: 1423ausgeglichen, weil 1+4 = 2+3, also: 42615weil 4+2=1+5. Beachten Sie, dass die mittlere Ziffer auf keiner Seite (oder auf beiden Seiten) enthalten ist, wenn die Anzahl der Ziffern ungerade ist.

Herausforderung:

Nehmen Sie eine positive ganze Zahl als Eingabe und geben Sie einen Wahrheitswert aus, wenn er ausgeglichen ist, und einen falschen Wert, wenn er nicht ausgeglichen ist.

Testfälle (wahr)

1
6
11
141
1221
23281453796004414
523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088

Testfälle (falsch)

10
12
110
15421
5234095123508321
6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454

Es wird zum Beispiel keine Zahlen geben, die mit Null beginnen, 00032anstatt 32. Sie müssen Zahlen mit bis zu mindestens 100 Stellen unterstützen (also größer als 2^64-1). Wie immer optionales Eingabeformat, sodass Sie die Zahl bei Bedarf mit Apostrophen umgeben können.

05AB1E , 14 7 Bytes

€D2äO`Q

Erläuterung

Verwenden Sie 141 als Beispiel:

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

Probieren Sie es online!

> <> , 31 29 Bytes

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

Probieren Sie es online!

Zeile 1: Standard-Eingangsschleife

Zeile 2: Verwerfen Sie das -1 oben auf dem Stapel, drücken Sie zwei Nullen und drehen Sie eine bis zum Ende des Stapels (dies stellt sicher, dass Eingaben mit einer Länge von <3 den Stapel später im Programm nicht erschöpfen).

Zeile 3: Wenn die Länge des Stapels> 3 ist, addieren Sie die beiden oberen und unteren Elemente des Stapels.

Zeile 4: Wenn Ober- und Unterseite des Stapels gleich sind, wird ansonsten 1, 0 ausgegeben.

Edit: erkannte, dass es nicht nötig ist, die Zeichen mod 12 zu nehmen, 2 Bytes gespeichert

Haskell, 64 63 Bytes

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

Ein Byte gespart dank nimi

Brachylog , 20 Bytes

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

Probieren Sie es online!

Erläuterung

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

Hinweis: Die Eingabe wird angegeben, Stringda Java ohne sie nicht umgehen kann BigInteger(und BigIntegers mit einem ... erstellt werden String).

Testen und 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 Bytes

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

Erläuterung

Ich hatte wirklich gehofft, dass ich diesen Ansatz in einer Sprache anwenden kann, und in Mathematica scheint er ziemlich gut zu funktionieren. Die Idee ist zu vermeiden, sowohl die vordere als auch die hintere Hälfte zu erhalten, indem die Liste mit ihrer Rückseite kombiniert wird und nur die vordere Hälfte betrachtet wird.

...&@*IntegerDigits

Zuerst wandeln wir die Eingabe in eine Liste von Dezimalstellen um und übergeben das Ergebnis an die unbenannte Funktion auf der linken Seite.

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

Nun subtrahieren wir die Umkehrung der Liste von der Liste selbst. Wenn die Ziffern sind, wird das Ergebnis sein .{a1,a2,...,an}{a1-an,a2-an-1,...,an-a1}

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

Wir extrahieren die erste Hälfte dieser Liste (ohne die mittlere Ziffer, obwohl das eigentlich keine Rolle spielt, da der entsprechende Unterschied 0sowieso sein wird).

Tr@...

Und dann fassen wir diese Liste zusammen. So das ist:

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

Neuordnung:

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

Der Eingang ist ausgeglichen, wenn die beiden Hälften dieselbe Summe haben. Daher ist dieser Ausdruck Null, wenn die Eingabe ausgeglichen ist. Das überprüfen wir also:

...==0

JavaScript (ES6), 59 55 51 44 42 Byte

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

Es stellte sich heraus, dass ich die falsche Strategie angewendet hatte. Diese Version findet rekursiv die Summe der ersten Hälfte minus der Summe der zweiten Hälfte und gibt dann das logische NICHT des Ergebnisses zurück.

Wenn wir anstelle von truthy und umgekehrt falsy zurückgeben könnten, wären dies 35 Bytes:

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

Testschnipsel

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)

Nimmt Eingaben $aals Zeichenfolge (erforderlich, um Zahlen zu unterstützen, >2^64-1ohne in [biginteger]der Befehlszeile extrem klobig zu werden).

Für die Erklärung nehmen wir die Eingabe von an '1423'. Wir konstruieren dann eine neue Zeichenfolge. Die beiden Scheiben sind offensichtlich Array ( $a[...]), und das um drei weitere Saiten umgeben ist (, 0)-(und 0), eine Reihe von Formulierungs chars und strings. Beachten Sie, dass ,an der Vorderseite die Array-Verkettung und nicht die String-Verkettung erzwungen werden soll.

Das gesamte Array wird mit -joined zusammengefügt +, was zu einer Zeichenfolge wie folgt führt (+1+4+0)-(+2+3+0), und Sie können sehen, dass die 0s erforderlich sind, um Syntaxfehler zu vermeiden. Das ist eingespeist in |iex(kurz für Invoke-Expressionund ähnlich zu eval), das das mathematische Ergebnis berechnen wird. Solange der String ausgeglichen ist, erhalten Sie 0eine Ausgabe, die wir in Parens einkapseln und für die !(...)Ausgabe das Boolesche-Nicht davon verwenden True. Wenn es sich um eine Ganzzahl ungleich Null handelt, wird sie ausgegeben False.

Testfälle

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

Beinhaltet +5 für -lpF

Gib die Nummer bei STDIN an

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

Probieren Sie es online!

Vollständige Quelle, einschließlich Testfall:

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

Der BigInteger-Datentyp erlaubt eine beliebige Länge. Wenn die Zahl zu groß ist, beschwert sich der Compiler ( Fehler CS1021: Integrale Konstante ist zu groß ), sodass stattdessen die Methode BigInteger.Parse (String) verwendet wird.

Die Lösung kann auf 72 Byte reduziert werden, wenn die Eingabe eine Zeichenfolge ist (und das Programm entsprechend aktualisiert wird):

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 von @Rod !

Ruby, 63 Bytes

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

Hinweis: arg smuss ein String sein.

Testen (mindestens 5+ erforderlich):

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

Bei der rekursiven Funktion gwird eine Zahlenfolge von beiden Enden abgewickelt, indem der Kopf wiederholt und dann umgekehrt wird. Es subtrahiert das rekursive Ergebnis vom Kopf, wodurch sich die Koeffizienten +1 und -1 abwechseln, wobei +1 auf die erste Hälfte und -1 auf die zweite Hälfte angewendet wird.

   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

Es wird also die Summe der ersten Hälfte minus der Summe der zweiten Hälfte berechnet. Dies hat das Problem, dass bei einer ungeraden Anzahl von Ziffern die Mitte nach links (<*"xx")abweicht , die Hauptfunktion jedoch das Problem behebt, durch das jedes Zeichen, dh "12345", zu "1122334455" verdoppelt wird. Auf diese Weise wird die mittlere Ziffer gleichmäßig auf beiden Seiten aufgeteilt und annulliert.

Retina, 64 44 Bytes

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

Probieren Sie es online aus

In der ersten Stufe wird die Zeichenfolge in der Mitte aufgeteilt, wobei das mittlere Zeichen weggelassen wird, sofern es eines gibt ( entnommen und geändert von hier . Mit freundlicher Genehmigung von Martin.). Ersetzen Sie dann die Ziffern durch ihre unäre Darstellung und passen Sie an, ob die beiden Hälften gleich lang sind.

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

Summiert rekursiv die Differenz zwischen der ersten und der letzten Ziffer, bis weniger als zwei Ziffern übrig sind:

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

Es stellt sich heraus, dass R sehr ausführlich ist. Nimmt die Eingabe als Zeichen.

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

Schön formatiert:

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

Erläuterung

• y<-as.numeric(unlist(strsplit(x,""))) Teilen Sie die Eingabe (eine Zeichenfolge_, und konvertieren Sie sie in einen Vektor anstelle einer Liste. Wandeln Sie sie dann wieder in Ganzzahlen um.
• sum(tail(y,: tailnimmt die letzten n Elemente, gefunden von:
  • length(y)%/%2)), wobei %/%Ganzzahldivision ist, um die Decke des Quotienten zu erhalten, wobei die Länge ungerade ist.
• sum(head(y,length(y)%/%2)): like tail, headnimmt die ersten n Elemente des Vektors, die auf die gleiche Weise gefunden wurden.

Bearbeitungen

• Dank niam sieben Bytes gespart
• Geschaltet =statt <-, gespeichert noch zwei Bytes.

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

Hier ist eine 178-Byte-Version, die das -aFlag verwendet.

26 Bytes von DJMcMayhem abgespielt

Probieren Sie es online

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

Hier ist eine längere 410-Byte-Version, die das -aFlag nicht verwendet .

Probieren Sie es online

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

Erläuterung

Hier ist eine Erklärung der kürzeren Lösung

Zu Beginn wird die Zahl durch das -aFlag in alle ihre ASCII-Werte konvertiert .

Wir schieben die Stapelhöhe (dh die Anzahl der Stellen) und teilen durch zwei.

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

Für jede Zahl, die kleiner als die Zahl ist, die wir gerade gedrückt haben, verschieben wir eine Ziffer auf den anderen Stapel

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

Wenn die Stapel unterschiedliche Höhen haben, entfernen wir den obersten Gegenstand vom aktuellen Stapel

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

Wir wollen die Differenz zwischen den Summen jedes Stapels. Daher verwenden wir den folgenden Algorithmus, um jeden Stapel zu summieren.

{{}}

Dies setzt voraus, dass keine Ziffer einen ASCII-Wert von Null hat, was eine gültige Annahme ist.

Wir führen dies für beide Stapel durch und nehmen den Unterschied (Der <(())>ist für den nächsten Teil notwendig.

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

Wir wollen jetzt die Summe negieren. Wenn die Summe Null ist, springt das Oberteil ab und zeigt das zuvor geschobene an. Andernfalls werden sowohl die Zahl als auch das Oberteil entfernt und eine Null darüber platziert.

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

Eigentlich 17 16 Bytes

Diese Antwort ist inspiriert von ElPedros Python 2-Antwort und ihrer zu verwendenden Idee [-b:]. Golfvorschläge sind willkommen. Probieren Sie es 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 Bytes

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

Probier es aus

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

Probier es aus

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

Teste es ^{_{(von Jo King )}}

Erläuterung:

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

Gute alte ES5-Loops

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

Was passiert hier?

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

Tests sind bei ideone

Wir müssen str()statt `` verwenden, da nes außerhalb des Bereichs von signed int liegen kann.

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

BEARBEITEN

Mit Hilfe von @Rod auf 77 reduziert

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

Beispiele:

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

Benötigt PHP 7.1 für negative String-Offsets:

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

Lauf:

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

Vorherige Version

Hinweis: Benötigt PHP 7 für den Raumschiff-Operator.

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

Laufen Sie wie folgt:

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

Erläuterung

Iteriert über die Ziffern in der Nummer. Überprüft, ob die Ziffer zur ersten oder zweiten Hälfte gehört (oder die mittlere Ziffer ist), indem der Index der Ziffer mit der Länge der Eingabe verglichen wird ( 2 * $x <=> $l - 1). Dann multiplizieren Sie das mit der Ziffer, nehmen Sie die Summe aller Ziffern. Wenn es eine ausgeglichene Zahl ist, wird die Summe sein 0.

Beispiel mit Eingabe 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

Optimierungen

• Setzen Sie die Ziffer nicht auf $d, sondern iterieren Sie die Länge der Eingabe. 5 Bytes gespeichert.
• Der String-Offset nullmuss nicht umgewandelt werden, damit intPHP ihn interpretiert 0. 1 Byte gespeichert.
• Verwenden negativer Zeichenfolgen-Offsets, um die Ziffern aus der zweiten Hälfte abzurufen und auf die Hälfte der Zeichenfolge zu iterieren. 7 Bytes gespeichert, erfordert aber PHP 7.1
• 3 Bytes mit gespeichert $argn

Clojure, 66 64 Bytes

Update: strAus der map intFunktion genommen.

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

Dies wäre gekürzt worden, wenn das Eingabeformat flexibler gewesen wäre. Jetzt musste ich die Ganzzahl zunächst einer Folge von ASCII-Werten zuordnen. Der innere mapberechnet paarweise Wertunterschiede zwischen den beiden Hälften und prüft, ob die Summe der Deltas Null ist.

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

Tatsächlich hat dies dieselbe Länge wie das Mapping innerhalb von a letund definiert nur eine einzige Funktion.

sed (165 + 1 für -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

Ausgabe:
1 für wahr
0 für falsch

Probieren Sie es online!

Python 2.7, 102 92 Bytes

For-Schleife funktioniert besser: /

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

Dieselbe Idee, benutze einfach die Länge - ich, um die andere Seite zu bekommen. Es wird niemals die Mitte einer ungeraden Zahl erreichen.

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

Ruft die Eingabe ab
Speichert die Länge der Eingabe.
Rekursive Funktion zum Abrufen der Stringsumme.
Vergleichen Sie die erste Halbsumme mit der zweiten Halbsumme

Der Versuch, es unter 100 zu bekommen, aber es ist schwer: /

C-Funktion, 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.

Schläger 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)))

Ausführliche Version:

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

Testen:

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

Ausgabe:

#t
#t
#f
#f

Pyke, 20 Bytes

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

Probieren Sie es hier aus!

Mathematica, 69

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