L'indice di equilibrio di una sequenza è un indice tale che la somma degli elementi agli indici inferiori è uguale alla somma degli elementi agli indici più alti. Ad esempio, in una sequenza A:

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

3 è un indice di equilibrio, perché:

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

6 è anche un indice di equilibrio, perché:

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

(la somma di zero elementi è zero) 7 non è un indice di equilibrio, perché non è un indice valido della sequenza A.

L'idea è di creare un programma che abbia una sequenza (array), restituisca il suo indice di equilibrio (qualsiasi) o -1 se non esistono indici di equilibrio.

Golfscript 17 16

Poiché la forma dell'input non è specificata, questa prende una stringa in formato array Golfscript da stdin.

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

Quindi corri come ad es

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

L'idea è molto semplice: prende un array di A_ie si mappa su un array di A_i + 2 SUM_{j<i} A_je quindi cerca il primo indice che è uguale alla somma dell'intero array.

Per la sfida di @ mellamokb offro:

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

per 29 caratteri.

Python - 72 caratteri

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

Accetta input separato da virgole

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

Legge un elenco in stile Haskell da stdin, ad es.

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

e restituisce un elenco di indici in stile Haskell, ad es.

[3,6]

Il risultato è che []se non c'è indice.

Per favore dimmi, se le tue specifiche vogliono un comportamento diverso.

modifiche:

• (95 → 83): la comprensione dell'elenco è più breve

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

Si noti che ciò stampa gli indici di equilibrio in ordine inverso.

Esempio di utilizzo:

$ ./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(:+)}

Modifica: versione più breve come suggerito da Ventero:

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

L'input è un numero per riga, l'output è un elenco separato da virgole di indici tra parentesi quadre.

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

Un verbo monadico in notazione tacita che restituisce un vettore di indici di equilibrio. Spazi inseriti solo per leggibilità.

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

Per spiegare ciò, osservare innanzitutto la sua definizione esplicita; yè il parametro formale:

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

• +aggiunge i suoi argomenti. /è un avverbio che inserisce il verbo rimasto di esso tra i membri del suo argomento destro, ad esempio +/ 1 2 3 4è lo stesso di 1 + 2 + 3 + 4.

• \è un avverbio che applica il verbo alla sua sinistra a tutti i prefissi prefissi del suo argomento destro. Ad esempio, <disegnando una casella attorno al suo argomento, <\ 1 2 3 4produce

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

• Quindi, +/\calcola la somma per ogni prefisso del suo argomento giusto.

• \.è come \ma opera sui suffissi anziché sui prefissi. Pertanto, +/\.calcola un vettore di somme di suffissi.
• =esegue un confronto a livello di elemento dei suoi argomenti. Ad esempio, i 1 1 3 3 = 1 2 3 4rendimenti 1 0 1 0.
• Pertanto, (+/\. y) = (+/\ y)produce uno per tutti gli indici in cui la somma del suffisso è uguale alla somma del prefisso, oppure viene creato un equilibrio.
• Per i vettori di zero e uno, I.restituisce un vettore degli indici in cui il vettore contiene uno.

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'idea è quella di tenere traccia della somma corrente se verificare se è la metà della somma della matrice senza l'elemento corrente, e quindi uguale alla somma della matrice dopo l'elemento corrente. In tal caso, aggiorniamo l'indice di equilibrio sull'indice corrente. Viene stampato l'ultimo indice di equilibrio o il valore iniziale -1se non ce n'è.

In realtà, memorizziamo il complemento di bit dell'indice di equilibrio in modo da poterlo inizializzare su 0.

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

Stampa se l'indice dato è o meno un indice di equilibrio, non stampa gli indici interi in cui l'array è bilanciato.

PHP, 134 caratteri

<?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";

Ho il prurito che questo è ben lungi dall'essere un golf PHP ottimale, ma è rimasto senza vapore (cervelli). Almeno è più breve rispetto a array_sum e 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

Poiché non è stato specificato alcun input, questo deve essere inizializzato con l'array come variabile $a.