Opis

Rozważamy liczbę całkowitą z co najmniej 3 cyframi trzykrotnie zrównoważonymi, jeśli podzielone na trzy części, cyfry w każdej części sumują się do tej samej liczby. Dzielimy liczby w następujący sposób:

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)

Wyzwanie

Twoim zadaniem jest napisanie programu, który, biorąc pod uwagę liczbę całkowitą składającą się z co najmniej 3 cyfr, określa, czy podana liczba jest potrójnie zbalansowana i generuje wartość prawdy czy fałszu na podstawie jej wyniku.

Przypadki testowe

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

To jest golf golfowy , więc obowiązują standardowe luki i może wygrać najkrótsza odpowiedź w bajtach!

Python 2 , 93 88 86 bajtów

-4 bajty dzięki @LeakyNun
-2 bajty dzięki @ 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))

Wypróbuj online!

Galaretka , 23 bajty

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

Wypróbuj online!

Musi być krótsza droga, która jakoś przeleciała mi nad głową ...

Siatkówka , 89 bajtów

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

Wypróbuj online! Link zawiera przypadki testowe. Objaśnienie: Pierwszy etap dodaje nowe linie na początku i na końcu danych wejściowych. Drugi etap następnie próbuje przenosić cyfry wzdłuż nowych linii parami, jednak jeśli nie ma wystarczającej liczby cyfr na środku, trzeci etap jest w stanie przenieść je z powrotem, powodując zatrzymanie pętli. Czwarty etap przekształca następnie każdą cyfrę osobno w unarną, sumując je, a ostatni etap po prostu sprawdza, czy sumy są równe.

Mathematica, 142 bajty

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

Galaretka , 20 bajtów

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

Wypróbuj online!

Jak to działa

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 bajtów

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

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

JavaScript, 178 bajtów

(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 bajtów

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

Przyjmuje dane wejściowe jako int[].

Wyjaśnienie:

Wypróbuj tutaj.

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

Oto przegląd części z indeksowaniem 0 (wyłącznych) dla każdej długości:

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

• Ponieważ azapętlamy od 0do (length + 1) / 3)(ta wartość jest teraz przechowywana w s);
• Gdyż bpętlujemy od sdo length / 3 * 2 +( 0jeśli długość modulo-3 wynosi 0; 1jeśli długość modulo-3 wynosi 1 lub 2) (ta wartość jest teraz zapisywana w s);
• Ponieważ cpętlujemy od sdo length.

(wszystkie trzy pętle są wyłączne dla indeksowania 0)

Röda , 82 bajty

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

Wypróbuj online!

Wyjaśnienie:

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 bajtów

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

Funkcja r wycina ciąg w oparciu o parametry b i e, a następnie sumuje cyfry i zwraca wartość.

Aby pokroić na właściwe rozmiary, dzielimy długość przez 3 i zaokrąglamy wynik. Wywołanie wycinka (0, wynik) daje nam pierwszy blok, wycinek (wynik, -wynik) daje nam drugi, a wycinek (wynik) daje nam ostatni. Ze względu na sposób, w jaki nazywam wycinek, użyłem wycinka (wynik, wynik 4 *) zamiast ostatniego, ale daje ten sam wynik.

Na koniec porównuję wyniki, aby pokazać, że wartości są równe.

Edycja: ta sama zasada, lepsza gra w golfa