Beschreibung

Wir betrachten eine ganze Zahl mit mindestens drei Ziffern als dreifach ausgeglichen, wenn sich bei einer Aufteilung in drei Teile die Ziffern in jedem Teil zu derselben Zahl summieren. Wir teilen die Zahlen wie folgt auf:

abcdefghi - Standard case: the number of digits is divisable through 3:
abc def ghi

abcdefgh - Number % 3 == 2: The outer groups are both assigned another digit
abc de fgh (the inner group will have one digit less than both outer groups)

abcdefghij - Number % 3 == 1: The inner group is assigned the extra digit
abc defg hij (the inner group will have one digit more than the outer groups)

Herausforderung

Ihre Aufgabe ist es, ein Programm zu schreiben, das bei einer mindestens dreistelligen Ganzzahl feststellt, ob die angegebene Zahl dreifach ausgeglichen ist, und basierend auf dem Ergebnis einen wahrheitsgemäßen oder falschen Wert ausgibt.

Testfälle

333 -> True
343 -> False
3123 -> True
34725 -> True
456456 -> False
123222321 -> True

Dies ist Code-Golf , so dass Standard-Lücken gelten und die kürzeste Antwort in Bytes gewinnen kann!

Python 2 , 93 88 86 Bytes

-4 Bytes dank @LeakyNun
-2 Bytes dank @ Mr.Xcoder

def g(i):l=-~len(i)/3;print f(i[:l])==f(i[l:-l])==f(i[-l:])
f=lambda a:sum(map(int,a))

Probieren Sie es online!

Jelly , 23 Bytes

DµL‘:3‘Ṭ©œṗ⁸U®œṗЀS€€FE

Probieren Sie es online!

Es muss einen kürzeren Weg geben, der irgendwie über meinen Kopf flog ...

Netzhaut , 89 Bytes

^|$
¶
{`¶(.)(.*)(.)¶
$1¶$2¶$3
}`^((.)*.)(.)¶((?<-2>.)*)¶(.)
$1¶$3$4$5¶
\d
$*
^(1+)¶\1¶\1$

Probieren Sie es online! Link enthält Testfälle. Erläuterung: In der ersten Stufe werden am Anfang und am Ende der Eingabe Zeilenumbrüche eingefügt. Die zweite Stufe versucht dann, die Ziffern paarweise über die Zeilenumbrüche zu verschieben. Wenn jedoch nicht mehr genügend Ziffern in der Mitte vorhanden sind, kann die dritte Stufe sie zurückschieben, wodurch die Schleife angehalten wird. Die vierte Stufe wandelt dann jede Ziffer einzeln in eine unäre um und summiert sie, während die letzte Stufe einfach prüft, ob die Summen gleich sind.

Mathematica, 142 Bytes

(s=IntegerDigits@#;c=Floor;If[Mod[t=Length@s,3]==2,a=-1;c=Ceiling,a=Mod[t,3]];Length@Union[Tr/@FoldPairList[TakeDrop,s,{z=c[t/3],z+a,z}]]==1)&

Gelee , 20 Bytes

DµL‘:3x2jSạ¥¥LRṁ@ḅ1E

Probieren Sie es online!

Wie es funktioniert

DµL‘:3x2jSạ¥¥LRṁ@ḅ1E  Main link. Argument: n

D                     Decimal; convert n to base 10, yielding a digits array A.
 µ                    Begin a new chain with argument A.
  L                   Compute the length of A.
   ‘                  Increment; add 1 to the length.
    :3                Divide the result by 3.
                      This yields the lengths of the outer chunks.
      x2              Repeat the result twice, creating an array C.
             L        Compute l, the length of A.
            ¥         Combine the two links to the left into a dyadic chain.
                      This chain will be called with arguments C and l. 
           ¥              Combine the two links to the left into a dyadic chain.
         S                    Take the sum of C.
          ạ                   Compute the absolute difference of the sum and l.
        j                 Join C, using the result to the right as separator.
                      We now have an array of the lengths of all three chunks the
                      digits of n have to be split in.
              R       Range; map each chunk length k to [1, ..., k].
               ṁ@     Mold swapped; takes the elements of A and give them the shape
                      of the array to the right, splitting A into chunks of the
                      computed lengths.
                 ḅ1   Convert each chunk from unary to integer, computing the sum
                      of its elements.
                   E  Test if the resulting sums are all equal.

MATL , 26 Bytes

3:jnZ^!S!tgtYswG48-*Z?da~a

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Javascript, 178 Bytes

(a)=>{b=a.split(/(\d)/).filter((v)=>v);s=Math.round(b.length/3);f=(m,v)=>m+parseInt(v);y=b.slice(s,-s).reduce(f,0);return b.slice(0,s).reduce(f,0)==y&&y==b.slice(-s).reduce(f,0)}

Java 8, 149 Bytes

q->{int l=q.length,s=(l+1)/3,a=0,b=0,c=0,i=0;for(;i<s;a+=q[i++]);for(i=s,s=l/3*2+(l%3<1?0:1);i<s;b+=q[i++]);for(i=s;i<l;c+=q[i++]);return a==b&b==c;}

Nimmt die Eingabe als int[].

Erläuterung:

Probieren Sie es hier aus.

q->{                 // Method with int-array parameter and boolean return-type
  int l=q.length,    //  Length of the input-array
      s=(l+1)/3,     //  (Length + 1) divided by 3
      a=0,b=0,c=0,   //  Three sums starting at 0
      i=0;           //  Index-integer
  for(;i<s;          //  Loop (1) from 0 to `s1` (exclusive)
    a+=q[i++]        //   And increase `a` with the next digit
  );                 //  End of loop (1)
  for(i=s,s=l/3*2+(l%3<1?0:1);i<s;
                     //  Loop (2) from `s1` to `s2` (exclusive)
    b+=q[i++]        //   And increase `b` with the next digit
  );                 //  End of loop (2)
  for(i=s;i<l;       //  Loop (3) from `s2` to `l` (exclusive)
    c+=q[i++]        //   And increase `c` with the next digit
  );                 //  End of loop (3)
  return a==b&b==c;  //  Return if `a`, `b` and `c` are equal
}                    // End of method

Hier ist eine Übersicht der 0-indizierten (exklusiven) Teile für jede Länge:

Length:  Parts:    0-indexed (exclusive) parts:

 3       1,1,1     0,1 & 1,2 & 2,3
 4       1,2,1     0,1 & 1,3 & 3,4
 5       2,1,2     0,2 & 2,3 & 3,5
 6       2,2,2     0,2 & 2,4 & 4,6
 7       2,3,2     0,2 & 2,5 & 5,7
 8       3,2,3     0,3 & 3,5 & 5,8
 9       3,3,3     0,3 & 3,6 & 6,9
10       3,4,3     0,3 & 3,7 & 7,10
...

• Für die aSchleife von 0bis (length + 1) / 3)(dieser Wert wird jetzt in gespeichert s);
• Zum b Schleife von sbis length / 3 * 2 +( 0wenn Länge Modulo-3 0 ist; 1wenn Länge Modulo-3 1 oder 2 ist) (dieser Wert wird jetzt in gespeicherts );
• Zum c wir machen eine Schleife von sbis length.

(Alle drei Schleifen sind exklusiv mit 0 Indizes versehen.)

Röda , 82 Bytes

f s{n=((#s+1)//3)[s[:n],s[n:#s-n],s[#s-n:]]|[chars(_)|[ord(_)-48]|sum]|[_=_,_=_1]}

Probieren Sie es online!

Erläuterung:

f s{ /* function declaration */
    n=((#s+1)//3)
    [s[:n],s[n:#s-n],s[#s-n:]]| /* split the string */
    [ /* for each of the three strings: */
        chars(_)|    /* push characters to the stream */
        [ord(_)-48]| /* convert characters to integers */
        sum          /* sum the integers, push the result to the stream */
    ]|
    [_=_,_=_1] /* take three values from the stream and compare equality */
}

JavaScript, 129 , 104 Bytes

([...n],l=n.length/3+.5|0,r=(b,e=b*-4,z=0)=>n.slice(b,e).map(x=>z-=x)&&z)=>r(0,l)==r(-l)&&r(l,-l)==r(-l)

Die Funktion r schneidet die Zeichenfolge basierend auf den Parametern b und e, summiert dann die Ziffern und gibt den Wert zurück.

Um die richtigen Größen zu ermitteln, teilen wir die Länge durch 3 und runden das Ergebnis. Wenn Sie slice (0, result) aufrufen, erhalten Sie den ersten Block, slice (result, -result) den zweiten und slice (result) den letzten. Aufgrund der Art, wie ich slice aufrufe, habe ich slice (result, 4 * result) anstelle des letzten verwendet, aber es gibt das gleiche Ergebnis.

Zum Schluss vergleiche ich die Ergebnisse und stelle fest, dass die Werte gleich sind.

Edit: Gleiches Prinzip, besseres Golfen