Números triplemente balanceados

13

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 , por lo que se aplican las lagunas estándar y ¡puede ganar la respuesta más corta en bytes!

racer290
fuente
1
Según tengo entendido, si puedes dividirlo equitativamente, deberías.
totalmente humano
@ Mr.Xcoder lo divide en tres partes (todavía no funciona según el comentario de @ MagicOctopusUnr:when split in three parts,
Stephen
44
Considere usar el Sandbox , para evitar tal situación en el futuro.
Sr. Xcoder
2
Whoops! Lamento la confusión sobre los casos de prueba, aparentemente tuve algún tipo de giro en mi cabeza. Ahora que están corregidos, espero que vote para reabrir mi desafío.
racer290
55
Por defecto, se permite que la entrada se tome como una cadena. ¿Se puede tomar como una matriz de dígitos?
Luis Mendo

Respuestas:

7

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!

ovs
fuente
3

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

Monja permeable
fuente
Parece sencillo pero realmente no es tbh ... Incluso difícil en 05AB1E debido a la división no predeterminada.
Magic Octopus Urn
3

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.

Neil
fuente
2

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)&
J42161217
fuente
2

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.
Dennis
fuente
1
Me encantaría leer una explicación
Felix Dombek
@FelixDombek He agregado una explicación.
Dennis
0

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)}
cdm
fuente
Bienvenido a PPCG! ¿Has leído las páginas de consejos ? Hay muchas posibilidades para jugar golf con tu respuesta.
Neil
En caso de que todavía esté interesado, pude reducir su respuesta a 106 bytes: ([...b],s=~b.length/3|0,f=(m,v)=>+m+ +v,y=b.splice(s).reduce(f))=>b.splice(-s).reduce(f)==y&y==b.reduce(f)(tenga cuidado al copiar de los comentarios ya que Stack Exchange inserta caracteres invisibles).
Neil
Beautyful! Muchas cosas que debo aprender allí.
cdm
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)

Kevin Cruijssen
fuente
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 */
}
fergusq
fuente
0

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

Grax32
fuente
¿Es posible cambiar &&a &JavaScript? Las comprobaciones de segunda mano ( &&zy &&y[1]==y[2]) no parecen modificar los valores, por lo que si es posible, no debería afectar el resultado de lo que puedo ver.
Kevin Cruijssen
Le echaré un vistazo. & es una operación de bit vs && es lógico, por lo que cambiará la salida a 1 o 0 en lugar de verdadero o falso, pero eso funciona muy bien en este caso.
Grax32