Ist es eine ausgeglichene Zahl?

38

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.

Stewie Griffin
quelle

Antworten:

12

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!

Emigna
quelle
Kannst du nicht Ëstatt verwenden `Q?
Erik der Outgolfer
@EriktheOutgolfer: Ëwar ein anderer Befehl als diese Herausforderung gemacht wurde, also leider nicht.
Emigna
10

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

Sok
quelle
7

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

Damien
quelle
Benötigen Snippets keine Klammern?
Michael Klein
@ michael-klein Nein, unbenannte Funktionen sind erlaubt. meta.codegolf.stackexchange.com/a/7615/20260
Damien
1
Ein Byte zum Speichern:b(a:t@(r:s))=a-last t+b(init t);b _=0
nimi
@ Nimi Danke ...
Damien
5

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
Tödlich
quelle
5

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);
    }
  }
}
Olivier Grégoire
quelle
Gute Antwort. Sie könnten 2 Bytes speichern , indem Sie die for-Schleife leer zu machen: for (; i < l / 2;s += n.charAt(i) - n.charAt(l - ++i));.
Todeale
@todeale Schau dir den Golf-Code an, nicht den nicht-Golf-Code. Ich denke, Ihr Vorschlag und meine Antwort auf das Golfen verwenden die gleiche Menge an Bytes
Olivier Grégoire
Hoppla! Jetzt sehe ich.
Todeale
5

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
Martin Ender
quelle
5

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

ETHproductions
quelle
Ich mag das wirklich n[i*2]! Schön.
Arnauld
@ Arnauld Danke :-) Ich habe jetzt einen völlig anderen Ansatz gefunden, der das überhaupt nicht benötigt ...
ETHproductions
Das ist großartig!
Arnauld
Kannst du nicht benutzen f=([x,...a])=>!(a[0]?x-a.pop()+f(a):0)?
mbomb007
@ mbomb007 Nein; Das würde nach jeder Rekursion einen Booleschen Wert (erzwungen auf 0 oder 1) zurückgeben, anstatt eine Summe.
ETHproductions
4

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
---
AdmBorkBork
quelle
4

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;$_=!$
Tonne Hospel
quelle
4

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;};
adrianmp
quelle
1
Es überrascht nicht, dass meine c-Antwort dieser ziemlich ähnlich sah. Können Sie t[l-++i]anstelle von t[l-1-i++]und return !ranstelle von tun return r==0?
Digital Trauma
Das Präfix des Inkrementoperators sollte den Trick ausführen und 2 Bytes speichern, aber in C # muss der Rückgabewert ein Boolescher Wert sein, damit! R ihn nicht schneidet. Danke, ich werde meine Antwort so schnell wie möglich aktualisieren.
adrianmp
4

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 !

Yytsi
quelle
2
Sie können floor(l/2)mit l//2und ceil(l/2)mit ersetzen l//2+l%2, um 7 Bytes zu sparen, und dann den Mathe-Import entfernen, um weitere 18
Rod
1
auch du brauchst das nicht 0an n[0:l//2]und könntest es n[l//2+l%2:]einfach sein n[-(l//2):]. Oder Sie könnten die //2zu bewegen l=len(n)//2und verwenden n[:l]undn[-l:]
Rod
5
Es sieht auch sehr seltsam aus, wenn Ihr Import nicht oben ist.
mbomb007
@ Rod Ich bin hergekommen, um all die Dinge zu ändern, die du im ersten Kommentar erwähnt hast, aber ich war erstaunt über den zweiten, vielen Dank! :)
Yytsi
@ Rod Indem Sie Ihren letzten Tipp in Ihrem zweiten Kommentar verwenden, geben die einstelligen Testfälle falsche Werte zurück :(
Yytsi
4

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
cia_rana
quelle
4

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.

xnor
quelle
3

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.

mbomb007
quelle
Warum würden Sie eine Gruppe ohne Capturing in einem Code-Golf verwenden? ;) Unabhängig davon ist es in .NET viel kürzer, die Zeichenfolge mit Bilanzgruppen zu teilen : retina.tryitonline.net/… (Ich habe auch mehrere Stufen ausprobiert, aber das führt zu einer etwas längeren retina.tryitonline.net/… ).
Martin Ender
@MartinEnder Ja, ich wusste, dass es so sein würde, aber ich habe das Konzept nie wirklich verstanden. Und ich nehme an, ich habe die Gruppe übersehen, die nicht gefangen genommen hat.
mbomb007
1
In diesem Fall ist es ganz einfach: Wir zählen die Zeichen mit (.)*?(jede Iteration schiebt ein Capture auf Stapel 2). Dann versuchen wir das Ende zu erreichen, indem wir erneut mit (?<-2>.)*$(nach einer optionalen mittleren Ziffer) vom Stapel springen. Das erste Mal ist dies möglich, wenn wir genau die Hälfte der Ziffern (abgerundet) in Gruppe 2 erfasst haben.
Martin Ender
3

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"));

Arnauld
quelle
1
Schöne Technik. Ich denke, du kannst es tun (s-=i<0?v:-v).
ETHproductions
@ETHproductions - Interessant zu sehen, wie nah die Methoden mit und ohne ausfallen Math.sign().
Arnauld
Verdammt, du hast mich vielleicht für immer geschlagen ... nette :)
ETHproductions
Ich habe mich geirrt ;-)
ETHproductions
3

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.
Azor Ahai
quelle
Kann man sich length(y)%/%2irgendwie an eine Variable binden und diese in den Aufrufen von tailund verwenden head?
nimi
@ nimi Oh ja, guter Punkt.
Azor Ahai
85 Bytes tio.run/…
Sumner18
durch Konsolidieren von y und l in der ersten Summe, Ändern von as.numeric in as.double (), Unlist () in el (). Dies erlaubte mir, alles in einer Zeile zu tun, Klammern zu entfernen und pryr :: f die Formale / Variablen aus dem Code zu
erraten
3

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.

{{}{}((<>))}{}
Weizen-Assistent
quelle
Warum verwenden, ([]){[{}]{}([])}{}um jeden Stapel zu summieren? ({{}})sollte einwandfrei funktionieren, und da Sie ASCII-Eingaben vornehmen, müssen Sie sich keine Sorgen machen, dass 0 die Schleife ruiniert.
DJMcMayhem
@ DJMcMayhem Guter Punkt. Ich habe vergessen, dass es keine Null auf dem Stapel geben kann
Wheat Wizard
3

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.
Sherlock9
quelle
3

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
}
Brad Gilbert b2gills
quelle
Dies scheint nicht mehr zu funktionieren (ich vermute eine Änderung im Umgang ..mit Nicht-Ganzzahlen). Wie wäre es stattdessen mit 33 Bytes
Jo King
2

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
Bassdrop Cumberwubwubwub
quelle
2

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.

Jonathan Allan
quelle
Ah, deshalb habe ich das L am Ende bekommen. +1
ElPedro
2

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
ElPedro
quelle
Sie können map(int,input())stattdessen verwenden [int(h)for h in raw_input()], len(g)/2wird immer int sein, keine Notwendigkeit zu konvertieren, und ist or b==0nicht wirklich notwendig
Rod
in der Tat b==0ist das für erforderlich len=1, aber Sie können es zu verkürzenb<1
Rod
2

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
aross
quelle
2

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.

NikoNyrh
quelle
1

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!

Riley
quelle
1

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

greyShift
quelle
1

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.

Digitales Trauma
quelle
Sie können strlen nicht ohne include verwenden #include"string.h"\n, wodurch Ihre Punktzahl um 19 erhöht wird .
NoSeatbelts
1
@NoSeatbelts Ja, Sie können den Ideone-Link ausprobieren. Der Compiler gibt Ihnen höchstwahrscheinlich eine Reihe von Warnungen, kompiliert aber trotzdem eine funktionierende ausführbare Datei (zumindest GCC und Clang). Welchen Compiler verwenden Sie? Es gibt sogar einen Code-Golf-Tipp dazu .
Digital Trauma
1
Keine Notwendigkeit für den Raum inchar *n
Cyoce
entferne Leerzeichen l;i;t;f(char*n){..return!t;}-2 Bytes
Khaled.K
1

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
rnso
quelle
1

Mathematica, 69

Tr@#[[;;⌊l=Length@#/2⌋]]==Tr@#[[⌈l⌉+1;;]]&@*IntegerDigits
shrx
quelle
2
Sie können ein paar Bytes sparen, indem Sie das Ende auf...;;]]&@*IntegerDigits
Martin Ender
@MartinEnder danke, aber wie funktioniert das?
Shrx
@*ist eine Abkürzung für Composition. f@*gist f[g[##]]&.
Martin Ender