Equilibrium index: Difference between revisions

=={{header|11l}}==

{{trans|Python}}

R (0 .< arr.len).filter(i -> sum(@arr[0.<i]) == sum(@arr[i+1..]))

 

 

{{out}}

 

=={{header|ABAP}}==

 

TYPES: y_i TYPE STANDARD TABLE OF i WITH EMPTY KEY.

LET z = sequences[ i ] IN

NEXT x = COND #( WHEN y = ( total_sum - y - z ) THEN VALUE y_i( BASE x ( i - 1 ) ) ELSE x )

 

=={{header|Ada}}==

 

equilibrium.ads:

 

generic

function Get_Indices (From : Array_Type) return Index_Vectors.Vector;

 

equilibrium.adb:

 

function Get_Indices (From : Array_Type) return Index_Vectors.Vector is

end Get_Indices;

 

Test program using two different versions, one with vectors and one with arrays:

with Equilibrium;

with Ada.Containers.Vectors;

end loop;

Ada.Text_IO.New_Line;

{{out}}

(Index_Type is based on 1):

{{works with|Ada 2005}}

equilibrium.adb:

 

procedure Equilibrium is

Ada.Text_IO.Put_Line ("X4:" & Seq_Img (X4));

Ada.Text_IO.Put_Line ("Eqs:" & Seq_Img (X4_Result));

{{out}}

<pre>Results:

 

=={{header|Aime}}==

eqindex(list l)

{

 

0;

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}

 

PROC gen equilibrium index = ([]INT arr, YIELDINT yield)VOID:

# OD # );

print(new line)

{{out}}

<pre>

 

=={{header|AppleScript}}==

{{Trans|JavaScript}}(ES6 version)

on equilibriumIndices(xs)

end repeat

return lst

{{Out}}

<pre>{{3, 6}, {}, {1}, {0, 1, 2, 3, 4, 5, 6}, {0}, {}}</pre>

 

=={{header|AutoHotkey}}==

StringSplit, A, list, `,

Loop % A0 {

}

return Res

{{out}}

<pre>3, 6</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f EQUILIBRIUM_INDEX.AWK

BEGIN {

return(str)

}

<p>Output:</p>

<pre>

indices: 1 2 3 4 5 6 7

</pre>

 

=={{header|Batch File}}==

setlocal enabledelayedexpansion

 

echo [!equilms!]

goto :EOF

{{Out}}

<pre>[3 6]

=={{header|BBC BASIC}}==

BBC BASIC's '''SUM''' function is useful for this task.

list() = -7, 1, 5, 2, -4, 3, 0

PRINT "Equilibrium indices are " FNequilibrium(list())

r += l(i%)

NEXT

'''Output:'''

<pre>

 

=={{header|C}}==

#include <stdlib.h>

 

 

return 0;

 

=={{header|C sharp|C#}}==

using System.Collections.Generic;

using System.Linq;

}

}

{{out}}

 

=={{header|C++}}==

#include <iostream>

#include <numeric>

 

std::for_each(indices.begin(), indices.end(), print<size_t>);

{{out}}

<pre>

=={{header|Clojure}}==

{{trans|Ocaml}}

(loop [acc '(), i 0, left 0, right (apply + lst), lst lst]

(if (empty? lst)

right (- right x)

acc (if (= left right) (cons i acc) acc)]

{{out}}

<pre>

 

=={{header|Common Lisp}}==

(if v v dflt))

 

(if (eql lsum rsum) (push i stack))

(setf lsum (+ lsum (car rest)))

{{out}}

 

=={{header|D}}==

===More Functional Style===

 

auto equilibrium(Range)(Range r) pure nothrow @safe /*@nogc*/ {

void main() {

[-7, 1, 5, 2, -4, 3, 0].equilibrium.writeln;

{{out}}

<pre>[3, 6]</pre>

{{trans|PHP}}

Same output.

 

size_t[] equilibrium(T)(in T[] items) @safe pure nothrow {

void main() {

[-7, 1, 5, 2, -4, 3, 0].equilibrium.writeln;

 

=={{header|Elena}}==

import system'routines;

import system'collections;

while(en.next())

{

right -= element;

bool found := (left == right);

}

enumerable() => en;

{

EquilibriumEnumerator.new(new int[]{ -7, 1, 5, 2, -4, 3, 0 })

<pre>

3

{{trans|Ruby}}

computes either side each time.

def index(list) do

last = length(list)

end)

end

 

faster version:

def index(list), do: index(list,0,0,Enum.sum(list),[])

defp index([h|t],i,left,right,acc) when left==right-h, do: index(t,i+1,left+h,right-h,[i|acc])

defp index([h|t],i,left,right,acc) , do: index(t,i+1,left+h,right-h,acc)

 

'''Test:'''

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

[2, 4, 6],

Enum.each(indices, fn list ->

IO.puts "#{inspect list} => #{inspect Equilibrium.index(list)}"

 

{{out}}

 

=={{header|ERRE}}==

PROGRAM EQUILIBRIUM

 

PRINT("Equilibrium indices are";RES$)

END PROGRAM

'''Output:'''

<pre>

 

=={{header|Euphoria}}==

integer lower_sum, higher_sum

sequence indices

end function

 

{{out}}

''(Remember that indices are 1-based in Euphoria)''

=={{header|Factor}}==

Executed in the listener. Note that <code>accum-left</code> and <code>accum-right</code> have different outputs than <code>accumulate</code> as they drop the final result.

: accum-left ( seq id quot -- seq ) accumulate nip ; inline

: accum-right ( seq id quot -- seq ) [ <reversed> ] 2dip accum-left <reversed> ; inline

: equilibrium-indices ( seq -- inds )

0 [ + ] [ accum-left ] [ accum-right ] 3bi [ = ] 2map

{{out}}

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

Array indices are 1-based.

implicit none

 

end subroutine

 

=={{header|FreeBASIC}}==

 

Sub equilibriumIndices (a() As Integer, b() As Integer)

Print

Print "Press any key to quit"

 

{{out}}

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Go}}==

 

import (

}

return

{{out}}

<pre>

 

=={{header|Haskell}}==

import Control.Monad (replicateM)

import Control.Arrow ((&&&))

 

equilibr xs =

flip ((&&&) <$> take <*> (drop . pred)) xs <$> [1 ..]

 

Small example

Long random list in langeSliert (several tries for this one)

 

 

Or, using default Prelude functions:

 

equilibriumIndices xs =

 

main :: IO ()

main =

mapM_

print

{{Out}}

<pre>[3,6]

 

=={{header|Icon}} and {{header|Unicon}}==

L := if *arglist > 0 then arglist else [-7, 1, 5, 2, -4, 3, 0] # command line args or default

every writes( "equilibrium indicies of [ " | (!L ||" ") | "] = " | (eqindex(L)||" ") | "\n" )

l +:= L[i] # sum of left side

}

{{out}}

<pre>equilibrium indicies of [ -7 1 5 2 -4 3 0 ] = 4 7</pre>

 

=={{header|J}}==

{{out|Example use}}

 

=={{header|Java}}==

{{works with|Java|1.5+}}

public class Equlibrium {

public static void main(String[] args) {

}

}

{{out}}

<pre>

 

===ES5===

var N = a.length, i, l = [], r = [], e = []

for (l[0] = a[0], r[N - 1] = a[N - 1], i = 1; i<N; i++)

].forEach(function(x) {

console.log(equilibrium(x))

{{Out}}

 

===ES6 Procedural===

Two pass O(n), returning only the first equilibrium index.

let sum = arr.reduce((a, b) => a + b);

let leftSum = 0;

return -1;

}

{{Out}}

 

===ES6 Functional===

 

 

 

// equilibriumIndices :: [Int] -> [Int]

const equilibriumIndices = xs =>

scanr1(add)(xs)

[i, ...a]

 

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

[2, 4, 6],

[1],

[]

 

 

 

// add (+) :: Num a => a -> a -> a

// Curried addition.

b => a + b;

 

// scanl :: (b -> a -> b) -> b -> [a] -> [b]

const v = f(a[0])(x);

 

 

// scanl1 :: (a -> a -> a) -> [a] -> [a]

const scanl1 = f =>

// scanl1 is a variant of scanl that has no

xs => xs.length > 0 ? (

scanl(f)(

)(xs.slice(1))

) : [];

 

// scanr1 :: (a -> a -> a) -> [a] -> [a]

)(xs.slice(0, -1))

) : [];

 

// zip :: [a] -> [b] -> [(a, b)]

const zip = xs =>

ys => Array.from({

length: Math.min(xs.length, ys.length)

 

// MAIN ---

return main();

{{Out}}

 

=={{header|jq}}==

 

 

def equilibrium_indices:

'''Example 1:'''

{{out}}

$ jq -M -n -f equilibrium_indices.jq

6

'''Example 2:'''

 

# Create an array of length n with "init" elements:

def array(n;init): reduce range(0;n) as $i ([]; . + [0]);

 

{{out}}

$ jq -M -n -f equilibrium_indices.jq

{{works with|Julia|0.6}}

 

rst = Vector{Int}(0)

suml, sumr, ddelayed = 0, sum(data), 0

@show equindex2pass([1, -1, 1, -1, 1, -1, 1])

@show equindex2pass([1, 2, 2, 1])

 

{{out}}

 

=={{header|K}}==

f -7 1 5 2 -4 3 0

f 1 -1 1 -1 1 -1 1

 

=={{header|Kotlin}}==

 

fun equilibriumIndices(a: IntArray): MutableList<Int> {

else -> println("The equilibrium indices are : ${ei.joinToString(", ")}")

}

 

{{out}}

 

=={{header|Liberty BASIC}}==

a(0)=-7

a(1)=1

if len(EQindex$)>0 then EQindex$=mid$(EQindex$, 1, len(EQindex$)-2) 'remove last ", "

end function

{{out}}

<pre>EQ Indices are 3, 6 </pre>

 

=={{header|Logo}}==

if equal? :before :after [make "ret lput :i :ret]

if empty? butfirst :tail [output :ret]

end

 

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Mathematica indexes are 1-based so the output of this program will be shifted up by one compared to solutions in languages with 0-based arrays.

Do[If[Total[data[[;; n - 1]]] == Total[data[[n + 1 ;;]]],Sow[n]],

{{out|Usage}}

<pre>equilibriumIndex[{-7 , 1, 5 , 2, -4 , 3, 0}]

=={{header|MATLAB}}==

MATLAB arrays are 1-based so the output of this program will be shifted up by one compared to solutions in languages with 0-based arrays.

 

indicies = [];

end

 

{{out}}

 

ans =

 

 

=={{header|NetRexx}}==

{{trans|Java}}

options replace format comments java crossref symbols nobinary

 

return

 

{{out}}

<pre>

=={{header|Nim}}==

{{trans|Python}}

var suml, ddelayed = 0

var sumr = sum(data)

if suml == sumr:

yield i

const d = @[@[-7, 1, 5, 2, -4, 3, 0],

@[2, 4, 6],

@[2, 9, 2],

@[1, -1, 1, -1, 1, -1, 1]]

for data in d:

 

=={{header|Objeck}}==

{{Trans|Java}}

function : Main(args : String[]) ~ Nil {

sequence := [-7, 1, 5, 2, -4, 3, 0];

};

}

 

Output:

 

=={{header|OCaml}}==

let sum = List.fold_left ( + ) 0 lst

 

print_string "Results:";

List.iter (Printf.printf " %d") res;

 

=={{header|Oforth}}==

Oforth collections are 1-based

 

| ls rs i e |

0 ->ls

rs e - dup ->rs ls == ifTrue: [ i over add ]

ls e + ->ls

 

{{out}}

=={{header|PARI/GP}}==

This uses 1-based vectors instead of 0-based arrays; subtract 1 from each index if you prefer the other style.

my(a=sum(i=2,#v,v[i]),b=0,u=[]);

for(i=1,#v-1,

);

if(b,u,concat(u,#v))

 

=={{header|Pascal}}==

 

function ArraySum(list: array of integer; first, last: integer): integer;

i: integer;

begin

for i := first to last do // not taken if first > last

end;

 

EquilibriumIndex(numbers, low(numbers));

writeln;

{{out}}

<pre>:> ./EquilibriumIndex

slightly modified.Calculating the sum only once.Using a zero-based array type.Data type could be any type of signed integer or float.

But beware, that during building the sum, the limits of the data type mustn't be violated.

{$IFDEF FPC}{$Mode delphi}{$ENDIF}

type

numbers[i]:= 0;

TestRun(numbers);

Equilibirum indices: 3 6

 

=={{header|Perl}}==

{{trans|Raku}}

my ( $i, $sum, %sums ) = ( 0, 0 );

 

print eq_index qw( 2 4 6 ); # (no eq point)

print eq_index qw( 2 9 2 ); # 1

 

=={{header|Phix}}==

{{out}}

(Remember that indices are 1-based in Phix)

 

=={{header|PHP}}==

$arr = array(-7, 1, 5, 2, -4, 3, 0);

 

echo "# results:\n";

foreach (getEquilibriums($arr) as $r) echo "$r, ";

{{out}}

<pre>

3, 6,

</pre>

 

=={{header|PicoLisp}}==

(make

(let Sum 0

(for ((I . L) Lst L (cdr L))

(and (= Sum (sum prog (cdr L))) (link I))

{{out}}

<pre>: (equilibria (-7 1 5 2 -4 3 0))

{{works with|PowerShell|2}}

In real life in PowerShell, one would likely leverage pipelines, ForEach-Object, Where-Object, and Measure-Object for tasks such as this. Normally in PowerShell, speed is an important, but not primary consideration, and the advantages of pipelines tend to outweigh the overhead incurred. However, for this particular task, keeping in mind that “the sequence may be very long,” this code was optimized primarly for speed.

function Get-EquilibriumIndex ( $Sequence )

{

return $EqulibriumIndex

}

Get-EquilibriumIndex -7, 1, 5, 2, -4, 3, 0

{{out}}

<pre>

=={{header|Prolog}}==

 

append(Front, [_|Back], List),

sumlist(Front, Sum),

sumlist(Back, Sum),

length(Front, Len),

 

Example:

 

Index = 3 ;

Index = 6 ;

 

=={{header|PureBasic}}==

{{trans|Java}}

Define i, c=CountProgramParameters()-1

For i=0 To c

If LSum=RSum: PrintN(Str(i)): EndIf

Next i

{{out}}

<pre>> Equilibrium.exe -7 1 5 2 -4 3 0

===Two Pass===

Uses an initial summation of the whole list then visits each item of the list adding it to the left-hand sum (after a delay); and subtracting the item from the right-hand sum. I think it should be quicker than algorithms that scan the list creating left and right sums for each index as it does ~2N add/subtractions rather than n*n.

"Two pass"

suml, sumr, ddelayed = 0, sum(data), 0

ddelayed = d

if suml == sumr:

===Multi Pass===

This is the version that does more summations, but may be faster for some sizes of input as the sum function is implemented in C internally:

"Multi pass"

for i in range(len(data)):

suml, sumr = sum(data[:i]), sum(data[i+1:])

if suml == sumr:

Shorter alternative:

return [i for i in xrange(len(s)) if sum(s[:i]) == sum(s[i+1:])]

 

===One Pass===

This routine would need careful evaluation against the two-pass solution above as, although it only runs through the data once, it may create a dict that is as long as the input data in its worst case of an input of say a simple 1, 2, 3, ... counting sequence.

 

def eqindex1Pass(data):

l += c

h[l * 2 - c].append(i)

===Tests===

d = ([-7, 1, 5, 2, -4, 3, 0],

[2, 4, 6],

print("d = %r" % data)

for func in f:

{{out|Sample output}}

<pre>d = [-7, 1, 5, 2, -4, 3, 0]

 

The ''right'' scan can be derived from the left as a map or equivalent list comprehension:

 

from itertools import (accumulate)

def equilibriumIndices(xs):

'''List indices at which the sum of values to the left

def go(xs):

ls = list(accumulate(xs))

n = ls[-1]

return go(xs) if xs else []

 

 

# main :: IO ()

def main():

 

 

 

# tabulated :: String -> (a -> b) -> [a] -> String

def tabulated(s):

def width(x):

return len(str(x))

 

 

if __name__ == '__main__':

{{Out}}

<pre>Equilibrium indices:

[1] -> [0]

[] -> []</pre>

 

=={{header|Racket}}==

#lang racket

(define (subsums xs)

 

(equivilibrium '(-7 1 5 2 -4 3 0))

{{out}}

'(3 6)

 

=={{header|Raku}}==

(formerly Perl 6)

my ($left,$right) = 0, [+] @list;

 

 

my @list = -7, 1, 5, 2, -4, 3, 0;

And here's an FP solution that manages to remain O(n):

my @a = [\+] @list;

my @b = reverse [\+] reverse @list;

^@list Zxx (@a »==« @b);

The <tt>[\+]</tt> is a reduction that returns a list of partial results. The <tt>»==«</tt> is a vectorized equality comparison; it returns a vector of true and false. The <tt>Zxx</tt> is a zip with the list replication operator, so we return only the elements of the left list where the right list is true (which is taken to mean 1 here). And the <tt>^@list</tt> is just shorthand for <tt>0 ..^ @list</tt>. We could just as easily have used <tt>@list.keys</tt> there.

=== Single-pass solution ===

Therefore (by substituting L for R), L + C + L == S at all equilibrium points.<br>

Restated, 2L + C == S.

0 1 2 3 4 5 6 # Index

-7 1 5 2 -4 3 0 # C (Value at index)

0 -7 -6 -1 1 -3 0 # L (Sum of left)

If we build a hash as we walk the list, with 2L+C as hash keys, and arrays of C-indexes as hash values, we get:

-7 => [ 0, 2 ],

-13 => [ 1 ],

-2 => [ 4 ],

-3 => [ 5 ],

After we have finished walking the list, we will have the sum (S), which we look up in the hash. Here S=0, so the equilibrium points are 3 and 6.

 

Note: In the code below, it is more convenient to calculate 2L+C *after* L has already been incremented by C; the calculation is simply 2L-C, because each L has an extra C in it. 2(L-C)+C == 2L-C.

my $sum = 0;

 

say eq_index < 2 4 6 >; # (no eq point)

say eq_index < 2 9 2 >; # 1

The <tt>.classify</tt> method creates a hash, with its code block's return value as key. Each hash value is an Array of all the inputs that returned that key.

 

We could have used <tt>.pairs</tt> instead of <tt>.keys</tt> to save the cost of <tt>@list</tt> lookups, but that would change each <tt>%h</tt> value to an Array of Pairs, which would complicate the return line.

=={{header|Red}}==

eqindex: func [a [block!]] [

collect [

prin "(1 based) equ indices are: "

probe eqindex [-7 1 5 2 -4 3 0]

{{out}}

<pre>(1 based) equ indices are: [4 7]</pre>

=={{header|REXX}}==

===version 1===

This REXX version utilizes a &nbsp; ''zero-based'' &nbsp; stemmed array to mimic the illustrative example in this Rosetta Code task's

<br>prologue, &nbsp; which uses a &nbsp; ''zero-based'' &nbsp; index.

parse arg x /*obtain the optional arguments from CL*/

say ' array list: ' space(x) /*echo the array list to the terminal. */

end /*j*/ /* [↑] assign @.0 @.1 @.3 ··· */

say /* ··· and also display a blank line. */

say 'equilibrium' word("(none) index: indices:", 1 + (w>0) + (w>1)) answer

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

<pre>

array list: -7 1 5 2 -4 3 0

equilibrium indices: 3 6

</pre>

<pre>

array list: 2 9 2

equilibrium index: 1

</pre>

<pre>

array list: 5 4 4 5

equilibrium (none)

</pre>

<pre>

array list: 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7 -7 7

 

===version 2===

* 30.06.2014 Walter Pachl

*--------------------------------------------------------------------*/

eil=eil im1

End

'''output'''

<pre> array list: -7 1 5 2 -4 3 0

 

=={{header|Ring}}==

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

see "equilibrium indices are : " + equilibrium(list) + nl

e = left(e,len(e)-1)

return e

Output:

<pre>

equilibrium indices are : 3,6

</pre>

 

=={{header|Ruby}}==

;Functional Style

list.each_index.select do |i|

end

;Tail Recursion

* This one would be good if Ruby did tail-call optimization (TCO).

* [[MRI]] does not do TCO; so this function fails with a long list (by overflowing the call stack).

result = []

list.empty? and return result

helper.call(left + current, new, right - new, index + 1)

end

result

;Imperative Style (faster)

equilibrium_indices = []

equilibrium_indices

 

;Test

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

[2, 4, 6],

indices.each do |x|

puts "%p => %p" % [x, eq_indices(x)]

{{out}}

<pre>

[2, 9, 2] => [1]

[1, -1, 1, -1, 1, -1, 1] => [0, 1, 2, 3, 4, 5, 6]

</pre>

 

=={{header|Scala}}==

 

val bigA: Array[BigInt] = A.map(BigInt(_))

val partialSums: Array[BigInt] = bigA.scanLeft(BigInt(0))(_+_).tail

def isRandLSumEqual(i: Int): Boolean = lSum(i) == rSum(i)

(0 until partialSums.length).find(isRandLSumEqual).getOrElse(-1)

 

=={{header|Seed7}}==

 

const array integer: numList is [] (-7, 1, 5, 2, -4, 3, 0);

end for;

writeln;

{{out}}

<pre>

 

=={{header|Sidef}}==

var (i, sum, sums) = (0, 0, Hash.new);

nums.each { |n|

}

sums{sum} \\ [];

 

Test:

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

[2, 4, 6],

for x in indices {

say ("%s => %s" % @|[x, eq_index(x)].map{.dump});

{{out}}

<pre>

=={{header|Swift}}==

 

func equilibriumIndexes() -> [Index] {

guard !isEmpty else {

let arr = [-7, 1, 5, 2, -4, 3, 0]

 

 

{{out}}

 

=={{header|Tcl}}==

set after 0

foreach item $list {incr after $item}

}

return $result

;Example of use

{{out}}

<pre>Equilibria=3, 6</pre>

 

=={{header|Ursala}}==

#import int

 

#cast %nL

 

{{out}}

<pre>

=={{header|VBScript}}==

Solution adopted from http://www.geeksforgeeks.org/equilibrium-index-of-an-array/ .

WScript.StdOut.Write equilibrium(arr,UBound(arr))

WScript.StdOut.WriteLine

leftsum = leftsum + arr(i)

Next

 

{{out}}

<pre>Indices: 3, 6,</pre>

 

=={{header|XPL0}}==

def Size = 1_000_000;

int I, S, A(Size), Hi(Size), Lo(Size);

for I:= 0 to Size-1 do

if Lo(I) = Hi(I) then [IntOut(0, I); ChOut(0, ^ )];

 

{{out}}

=={{header|Yorick}}==

Yorick arrays are 1-based so the output of this program will be shifted up by one compared to solutions in languages with 0-based arrays.

return where(A(psum) == A(::-1)(psum)(::-1));

{{out|Example interactive usage}}

<pre>> equilibrium_indices([-7, 1, 5, 2, -4, 3, 0])

=={{header|zkl}}==

{{trans|Clojure}}

reg acc=List(), left=0,right=lst.sum(0),i=0;

foreach x in (lst){

}

acc

{{trans|D}}

(0).filter(lst.len(),'wrap(n){ lst[0,n].sum(0) == lst[n+1,*].sum(0) })

If the input list is immutable, no new lists are generated (other than accumulating the result).

{{out}}

<pre>L(3,6)</pre>

=={{header|ZX Spectrum Basic}}==

{{trans|AWK}}

20 READ n

30 DIM a(n): LET sum=0: LET leftsum=0: LET s$=""

100 PRINT "Numbers: ";

110 FOR i=1 TO n: PRINT a(i);" ";: NEXT i