Descripción

Consideramos un número entero con al menos 3 dígitos con triple equilibrio si, cuando se divide en tres partes, los dígitos en cada parte suman el mismo número. Dividimos los números de la siguiente manera:

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)

Desafío

Su tarea es escribir un programa que, dado un número entero con al menos 3 dígitos, determine si el número dado es triplemente balanceado y genera un valor verdadero o falso basado en su resultado.

Casos de prueba

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

Este es el código de golf , por lo que se aplican las lagunas estándar y ¡puede ganar la respuesta más corta en bytes!

Python 2 , 93 88 86 bytes

-4 bytes gracias a @LeakyNun
-2 bytes gracias a @ 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))

Pruébalo en línea!

Jalea , 23 bytes

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

Pruébalo en línea!

Debe haber un camino más corto que de alguna manera voló sobre mi cabeza ...

Retina , 89 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. Explicación: La primera etapa agrega nuevas líneas al comienzo y al final de la entrada. Luego, la segunda etapa intenta mover los dígitos a través de las nuevas líneas en pares, sin embargo, si no quedan suficientes dígitos en el medio, la tercera etapa puede moverlos hacia atrás, haciendo que el ciclo se detenga. Luego, la cuarta etapa convierte cada dígito por separado en unario, sumando así, mientras que la última etapa simplemente verifica que las sumas sean iguales.

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

Jalea , 20 bytes

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

Pruébalo en línea!

Cómo funciona

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

Pruébalo en línea! O verificar todos los casos de prueba .

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

Toma la entrada como un int[].

Explicación:

Pruébalo aquí.

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

Aquí hay una descripción general de las partes indexadas 0 (exclusivas) para cada longitud:

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

• Para abucle de 0a (length + 1) / 3)(este valor ahora se almacena en s);
• Para bbucle de sa length / 3 * 2 +( 0si la longitud del módulo-3 es 0; 1si la longitud del módulo-3 es 1 o 2) (este valor ahora se almacena ens );
• Para el cbucle de sa length.

(los tres bucles son exclusivos indexados a 0)

Röda , 82 bytes

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

Pruébalo en línea!

Explicación:

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)

La función r corta la cadena en función de los parámetros bye, y luego suma los dígitos y devuelve el valor.

Para cortar en los tamaños correctos, dividimos la longitud por 3 y redondeamos el resultado. Llamar a slice (0, resultado) nos da el primer bloque, slice (resultado, -resultado) nos da el segundo, y slice (resultado) nos da el último. Debido a la forma en que llamo rebanada, utilicé rebanada (resultado, resultado 4 *) en lugar de la última pero da el mismo resultado.

Finalmente, comparo los resultados muestran que los valores son iguales.

Editar: mismo principio, mejor golf