O índice de equilíbrio de uma sequência é um índice tal que a soma dos elementos nos índices mais baixos é igual à soma dos elementos nos índices mais altos. Por exemplo, em uma sequência A:

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

3 é um índice de equilíbrio, porque:

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

6 também é um índice de equilíbrio, porque:

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

(a soma de zero elementos é zero) 7 não é um índice de equilíbrio, porque não é um índice válido da sequência A.

A idéia é criar um programa que, dada uma sequência (matriz), retorne seu índice de equilíbrio (qualquer) ou -1 se não houver índices de equilíbrio.

Golfscript 17 16

Como a forma da entrada não é especificada, isso pega uma string no formato de matriz Golfscript de stdin.

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

Então corra como por exemplo

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

A idéia é muito simples: ele pega uma matriz de A_ie mapeia para uma matriz de A_i + 2 SUM_{j<i} A_je depois procura o primeiro índice que é igual à soma de toda a matriz.

Para o desafio de @ mellamokb, ofereço:

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

por 29 caracteres.

Python - 72 caracteres

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

Recebe entrada separada por vírgula

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

Lê uma lista no estilo Haskell de stdin, por exemplo.

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

e retorna uma lista de índices do estilo Haskell, por exemplo.

[3,6]

O resultado é [], se não houver índice.

Por favor, diga-me, se a sua especificação quiser um comportamento diferente.

Editar% s:

• (95 → 83): a compreensão da lista é mais 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);}

Observe que isso imprime os índices de equilíbrio na ordem inversa.

Uso da amostra:

$ ./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: Versão mais curta, conforme sugerido por Ventero:

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

A entrada é um número por linha, a saída é uma lista de índices separados por vírgula entre colchetes.

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

Um verbo monádico em notação tácita que retorna um vetor de índices de equilíbrio. Espaços inseridos apenas para legibilidade.

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

Para explicar isso, primeiro observe sua definição explícita; yé o parâmetro formal:

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

• +adiciona seus argumentos. /é um advérbio que insere o verbo deixado entre os membros de seu argumento correto, por exemplo, +/ 1 2 3 4é o mesmo que 1 + 2 + 3 + 4.

• \é um advérbio que aplica o verbo à sua esquerda em todos os prefixos do seu argumento à direita. Por exemplo, ao <desenhar uma caixa em torno de seu argumento, <\ 1 2 3 4produz

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

• Assim, +/\calcula para cada prefixo do argumento correto a soma.

• \.é como, \mas opera em sufixos em vez de prefixos. Assim, +/\.calcula um vetor de somas de sufixos.
• =realiza uma comparação item a item de seus argumentos. Por exemplo, 1 1 3 3 = 1 2 3 4produz 1 0 1 0.
• Assim, (+/\. y) = (+/\ y)gera um para todos os índices nos quais a soma do sufixo é igual à soma do prefixo ou um equilíbrio é criado.
• Para vetores de zeros e uns, I.retorna um vetor dos índices nos quais o vetor contém um.

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

A idéia é rastrear a soma em execução se verificar se é metade da soma da matriz sem o elemento atual e, portanto, igual à soma da matriz após o elemento atual. Nesse caso, atualizamos o índice de equilíbrio para o índice atual. O último índice de equilíbrio é impresso ou o valor inicial, -1se não houver nenhum.

Na verdade, armazenamos o complemento de bit do índice de equilíbrio para inicializá-lo como 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)))

Imprime se o índice fornecido é ou não um índice de equilíbrio, não imprime as indecisões inteiras nas quais a matriz está equilibrada.

PHP, 134 caracteres

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

Eu tenho uma coceira de que isso está longe de ser o golfe ideal para o PHP, mas acabou o vapor (cérebro). Pelo menos é mais curto do que com 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

Como nenhuma entrada foi especificada, ela precisa ser inicializada com a matriz como a variável $a.