La description

Nous considérons un entier avec au moins 3 chiffres à triple équilibre si, lorsqu'il est divisé en trois parties, les chiffres de chaque partie se résument au même nombre. Nous avons divisé les nombres comme suit:

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)

Défi

Votre tâche consiste à écrire un programme qui, étant donné un nombre entier avec au moins 3 chiffres, détermine si le nombre donné est triple équilibré et génère une valeur vraie ou fausse en fonction de son résultat.

Cas de test

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

Il s'agit de code-golf , donc les failles standard s'appliquent et la réponse la plus courte en octets peut gagner!

Python 2 , 93 88 86 octets

-4 octets grâce à @LeakyNun
-2 octets grâce à @ 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))

Essayez-le en ligne!

Gelée , 23 octets

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

Essayez-le en ligne!

Il doit y avoir un moyen plus court qui a en quelque sorte survolé ma tête ...

Rétine , 89 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. Explication: La première étape ajoute des sauts de ligne au début et à la fin de l'entrée. La deuxième étape essaie ensuite de déplacer les chiffres à travers les nouvelles lignes par paires, mais s'il n'y a pas assez de chiffres au milieu, la troisième étape est capable de les reculer, provoquant l'arrêt de la boucle. La quatrième étape convertit ensuite chaque chiffre séparément en unaire, les additionnant ainsi, tandis que la dernière étape vérifie simplement que les sommes sont égales.

Mathematica, 142 octets

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

Gelée , 20 octets

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

Essayez-le en ligne!

Comment ça fonctionne

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 octets

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

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Javascript, 178 octets

(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 octets

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

Prend l'entrée comme un int[].

Explication:

Essayez-le ici.

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

Voici un aperçu des pièces indexées 0 (exclusives) pour chaque longueur:

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

• Car anous bouclons de 0à (length + 1) / 3)(cette valeur est maintenant stockée dans s);
• Car bnous bouclons de sà length / 3 * 2 +( 0si la longueur modulo-3 est 0;1 si la longueur modulo-3 est 1 ou 2) (cette valeur est maintenant stockée danss );
• Car cnous bouclons de sà length.

(les trois boucles sont exclusivement indexées 0)

Röda , 82 octets

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

Essayez-le en ligne!

Explication:

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 octets

([...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 fonction r tranche la chaîne en fonction des paramètres b et e, puis additionne les chiffres et renvoie la valeur.

Afin de couper dans les tailles correctes, nous divisons la longueur par 3 et arrondissons le résultat. L'appel de slice (0, result) nous donne le premier bloc, slice (result, -result) nous donne le second, et slice (result) nous donne le dernier. En raison de la façon dont j'appelle slice, j'ai utilisé slice (result, 4 * result) au lieu du dernier mais cela donne le même résultat.

Enfin, je compare les résultats montrent que les valeurs sont égales.

Edit: même principe, meilleur golf