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|Action!}}==

INT i

Test(c,9)

Test(d,1)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Equilibrium_index.png Screenshot from Atari 8-bit computer]

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|Arturo}}==

suml: 0

delayed: 0

loop data 'd ->

{{out}}

=={{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>

=={{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|Delphi}}==

See [https://rosettacode.org/wiki/Equilibrium_index#Pascal Pascal].

=={{header|Elena}}==

ELENA 5.0 :

import system'routines;

import system'collections;

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

.forEach:printingLn

<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|Go}}==

import (

}

return

{{out}}

<pre>

=={{header|Haskell}}==

import Data.List (findIndices, takeWhile)

import Control.Monad (replicateM)

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 =

zip3

[1],

[]

{{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===

A composition of pure generic functions, returning '''all''' equilibrium indices.

"use strict";

// MAIN ---

return main();

{{Out}}

<pre>[3,6]

The top-level function is defined as a 0-arity filter that emits answers as a stream, as is idiomatic in jq.

def equilibrium_indices:

def indices(a; mx):

end;

[0, 0, (a|add)] | report;

'''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|Lua}}==

function array_sum(t)

assert(type(t) == "table", "t must be a table!")

print(equilibrium_index({-7, 1, 5, 2, -4, 3, 0}))

=={{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}}

iterator eqindex(data: openArray[int]): int =

for data in d:

echo "d = [", data.join(", "), ']'

{{out}}

=={{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}}==

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

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

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">equilibrium</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">equilibrium</span><span style="color: #0000FF;">({-</span><span style="color: #000000;">7</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">})</span>

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

===Prolog-style===

{{trans|Prolog}}

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

sum(Front) = sum(Back),

===Loop approach===

{{trans|Java}}

Len = A.length,

Ix1 = [],

RunningSum := RunningSum + AI

end,

Test the approaches.

As = [

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

println(r2=R2),

{{out}}

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

if __name__ == '__main__':

{{Out}}

<pre>Equilibrium indices:

=={{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|ReScript}}==

let sum = Js.Array2.reduce(arr, \"+", 0)

let len = Js.Array.length(arr)

let res = aux([], 0, 0, sum)

Js.log("Results:")

=={{header|REXX}}==

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*/

if x='' then x= copies(" 7 -7", 50) 7 /*Not specified? Then use the default.*/

if sum==0 then $= $ i

end /*i*/ /* [↑] Zero? Found an equilibrium index*/

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> -7 &nbsp; 1 &nbsp; 5 &nbsp; 2 &nbsp; -4 &nbsp; 3 &nbsp; 0 </tt>}}

<pre>

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

;Functional Style

list.each_index.select do |i|

list[0...i].sum == list[i+1..-1].sum

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 0, list.first, list.drop(1).sum, 0

result

;Imperative Style (faster)

left, right = 0, list.sum

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>

=={{header|Rust}}==

extern crate num;

println!("Equilibrium indices for {:?} are: {:?}", v, indices);

}

{{out}}

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

=={{header|Wren}}==

{{libheader|Wren-fmt}}

var equilibrium = Fn.new { |a|

for (test in tests) {

System.print("%(Fmt.s(24, test)) -> %(equilibrium.call(test))")

{{out}}

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