L'indice d'équilibre d'une séquence est un indice tel que la somme des éléments aux indices inférieurs est égale à la somme des éléments aux indices supérieurs. Par exemple, dans une séquence A:

A[0]=-7 A[1]=1 A[2]=5 A[3]=2 A[4]=-4 A[5]=3 A[6]=0

3 est un indice d'équilibre, car:

A[0]+A[1]+A[2]=A[4]+A[5]+A[6]

6 est également un indice d'équilibre, car:

A[0]+A[1]+A[2]+A[3]+A[4]+A[5]=0

(la somme de zéro éléments est nulle) 7 n'est pas un indice d'équilibre, car ce n'est pas un indice valide de la séquence A.

L'idée est de créer un programme qui, étant donné une séquence (tableau), renvoie son indice d'équilibre (n'importe lequel) ou -1 s'il n'existe aucun indice d'équilibre.

Golfscript 17 16

Étant donné que la forme de l'entrée n'est pas spécifiée, cela prend une chaîne au format de tableau Golfscript de stdin.

~0\{1$+.@+\}/])?

Alors courez comme par exemple

golfscript.ry eqindex.gs <<<"[-7 1 5 2 -4 3 0]"

L'idée est très simple: il prend un tableau de A_iet mappe sur un tableau de A_i + 2 SUM_{j<i} A_jpuis recherche le premier index qui est égal à la somme de l'ensemble du tableau.

Pour le défi de @ mellamokb, j'offre:

~0\{1$+.@+\}/:S;]:A,,{A=S=},`

pour 29 caractères.

Python - 72 caractères

A=input()
print[i for i in range(len(A))if sum(A[:i])==sum(A[i+1:])]or-1

Prend une entrée séparée par des virgules

Haskell ( 95 83)

e l=[n|n<-[0..length l-1],sum(take n l)==sum(drop(n+1)l)]
main=interact$show.e.read

Lit une liste dans le style Haskell de stdin, par exemple.

[-7,1,5,2,-4,3,0]

et renvoie une liste de style Haskell des indices, par exemple.

[3,6]

Le résultat est [], s'il n'y a pas d'index.

S'il vous plaît dites-moi, si votre spécification veut un comportement différent.

Modifications:

• (95 → 83): la compréhension des listes est plus brève

C - 96

a[99],*p=a,s;main(){for(;scanf("%d",p)>0;s+=*p++
);for(;p>a;s-=*p)(s-=*--p)||printf("%d\n",p-a);}

Notez que cela imprime les indices d'équilibre dans l'ordre inverse.

Exemple d'utilisation:

$ ./equilibrium <<< "-7 1 5 2 -4 3 0"
6
3

Ruby (83 77)

a=*$<.map(&:to_i)
p (0...a.size).select{|x|a[0..x].reduce(:+)==a[x..-1].reduce(:+)}

Edit: Version plus courte comme suggéré par Ventero:

a=$<.map &:to_i
p (0...a.size).select{|x|eval"#{a[0..x]*?+}==#{a[x..-1]*?+}"}

L'entrée est un nombre par ligne, la sortie est une liste d'index séparés par des virgules entre crochets.

JavaScript (161)

P=parseInt;L=prompt().split(',');S=function(A)A.reduce(function(a,b)P(a)+P(b),0);R=[i for(i in L)if(S(L.slice(0,i))==S(L.slice(P(i)+1)))];alert(R.length>0?R:-1);

http://jsfiddle.net/6qYQv/1/

scala, 108

val l=readline().split(" ").map(w=>w.toInt)
for(i<-0 to l.length-1
if l.take(i).sum==l.drop(i+1).sum)yield i

J (12 caractères)

Verbe monadique en notation tacite qui renvoie un vecteur d'indices d'équilibre. Espaces insérés pour la lisibilité uniquement.

[: I. +/\. = +/\

Pour expliquer cela, observez d'abord sa définition explicite; yest le paramètre formel:

3 : 'I. (+/\. y) = (+/\ y)'

• +ajoute ses arguments. /est un adverbe qui insère le verbe à gauche entre les membres de son argument de droite, par exemple +/ 1 2 3 4est le même que 1 + 2 + 3 + 4.

• \est un adverbe qui applique le verbe à sa gauche à tous les préfixes préfixes de son argument de droite. Par exemple, en <dessinant une boîte autour de son argument, <\ 1 2 3 4produit

  ┌─┬───┬─────┬───────┐
  │1│1 2│1 2 3│1 2 3 4│
  └─┴───┴─────┴───────┘
  

• Ainsi, +/\calcule pour chaque préfixe de son argument de droite la somme.

• \.est comme \mais opère sur des suffixes au lieu de préfixes. Ainsi, +/\.calcule un vecteur de sommes de suffixes.
• =effectue une comparaison point par point de ses arguments. Par exemple, les 1 1 3 3 = 1 2 3 4rendements 1 0 1 0.
• Ainsi, (+/\. y) = (+/\ y)donne un pour tous les indices pour lesquels la somme des suffixes est égale à la somme des préfixes, ou, un équilibre est créé.
• Pour les vecteurs de zéros et de uns, I.renvoie un vecteur des indices auxquels le vecteur contient un.

Python 2, 70

A=input()
e=i=s=0
for x in A:e=[e,~i][s*2==sum(A)-x];s+=x;i+=1
print~e

L'idée est de suivre la somme en cours set de vérifier si elle est la moitié de la somme du tableau sans l'élément courant, et donc égale à la somme du tableau après l'élément courant. Dans l'affirmative, nous mettons à jour l'indice d'équilibre à l'indice actuel. Le dernier indice d'équilibre est imprimé, ou la valeur initiale -1s'il n'y en a pas.

En fait, nous stockons le complément binaire de l'indice d'équilibre afin de pouvoir l'initialiser à la place.

Python - 114

i=map(lambda x:int(x),raw_input().split(" "));x=0
print map(lambda x:(sum(i[0:x])==sum(i[x+1::])),range(0,len(i)))

Python - 72

i=input()
print map(lambda x:sum(i[0:x])==sum(i[x+1::]),range(0,len(i)))

Imprime si l'indice donné est ou non un indice d'équilibre, n'imprime pas les indices entières auxquelles le tableau est équilibré.

PHP, 134 caractères

<?for($a=explode(",",fgets(STDIN));++$i<($c=count($a));$o.=$s==0?$i:"")for($n=$s=0;$n<$c;)$s+=$n<$i?$a[$n++]:-$a[++$n];echo$o?$o:"-1";

J'ai une démangeaison que ce soit loin d'être un golf PHP optimal, mais juste à bout de souffle (cerveaux). Au moins, c'est plus court qu'avec array_sum et array_splice :-)

PHP (81)

for($i=count($a)-1,$c=0;$i+1&&$c!=(array_sum($a)-$a[$i])/2;$c+=$a[$i--]);echo $i;

http://3v4l.org/qJvhO

Puisqu'aucune entrée n'a été spécifiée, cela doit être initialisé avec le tableau comme variable $a.