Loop over multiple arrays simultaneously: Difference between revisions

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

{{out}}

=={{header|360 Assembly}}==

LOOPSIM CSECT

USING LOOPSIM,R12 base register

PG DC CL80' ' buffer

YREGS

{{out}}

<pre>

and if they are not, it will simply read from the wrong addresses.

lxi b,0 ; Let (B)C be the array index

outer: lxi d,As ; Use DE to walk the array-of-arrays

Alen: equ $-A3

;;; Zero-terminated array-of-arrays

{{out}}

base addresses of the arrays into <code>bx</code> one by one.

bits 16

org 100h

;;; Array of arrays

As: dw A1,A2,A3

=={{header|ACL2}}==

(if (or (endp xs) (endp ys) (endp zs))

nil

(rest zs)))))

=={{header|Action!}}==

CHAR ARRAY a="abc",b="ABC"

BYTE ARRAY c=[1 2 3]

PrintF("%C%C%B%E",a(i+1),b(i+1),c(i))

OD

{{out}}

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

=={{header|Ada}}==

procedure Array_Loop_Test is

(Index))(2));

end loop;

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

1.8-8d] - due to extensive use of '''format'''[ted] ''transput''}}

z=(1,2,3);

FOR i TO UPB x DO

printf(($ggd$, x[i], y[i], z[i], $l$))

{{out}}

<pre>

=={{header|ALGOL W}}==

% declare the three arrays %

string(1) array a, b ( 1 :: 3 );

% loop over the arrays %

for i := 1 until 3 do write( i_w := 1, s_w := 0, a(i), b(i), c(i) );

If the arrays are not the same length, a subscript range error would occur when a non-existant element was accessed.

vectors, zeroes for numeric vectors) to match the longest vector.

{{out}}

If we have a generic Applescript '''map''' function, we can use it to write a generic '''zipListsWith''', which applies a given function over lists derived from the nth members of an arbitrary list of (equal-length) lists. (Where lists are of uneven length, items beyond the maximum shared length are ignored).

-- zipListsWith :: ([a] -> b) -> [[a]] -> [[b]]

end script

end if

{{Out}}

<pre>aA1

But a transpose function might be simpler:

on run

on unlines(xs)

intercalate(linefeed, xs)

{{Out}}

<pre>aA1

=={{header|Arturo}}==

loop 0..2 'x ->

{{out}}

[http://www.autohotkey.com/docs/commands/StringSplit.htm StringSplit]

creates a pseudo-array

List2 = A,B,C

List3 = 1,2,3

Result .= List1_%A_Index% List2_%A_Index% List3_%A_Index% "`n"

Return, Result

An array that is too short on creation will return empty strings when

trying to retrieve further elements. The 2nd Message box shows:

([http://l.autohotkey.com/docs/Objects.htm Objects]) and the

[http://l.autohotkey.net/docs/commands/For.htm For loop].

List2 := ["A", "B", "C"]

List3 := [ 1 , 2 , 3 ]

Result .= value . List2[key] . List3[key] "`n"

Return, Result

The output from this script is identical to the first one.

=={{header|AWK}}==

split("a,b,c", a, ",");

split("A,B,C", b, ",");

print a[i] b[i] c[i];

}

=={{header|Axe}}==

L₃ for simplicity. In practice, one would want to arrange the arrays to

all fit within L₁ to avoid volatility issues with L₂ and L₃.

'b'→{L₁+1}

'c'→{L₁+2}

For(I,0,2)

Disp {L₁+I}►Char,{L₂+I}►Char,{L₃+I}►Dec,i

=={{header|Babel}}==

First, you could transpose the lists:

simul_array }

simul_array!:

{ trans

The 'trans' operator substitutes nil in the portions of each transposed

each list using a user-defined cdrall operator:

simul_array }

{ zap 0 last }

{ nil }

This solution is formally identical to the first and will handle lists

=={{header|BaCon}}==

DECLARE a1$[] = {"a", "b", "c"} TYPE STRING

DECLARE a2$[] = {"A", "B", "C"} TYPE STRING

INCR i

WEND

=={{header|BASIC256}}==

{{trans|FreeBASIC}}

dim arr2$(3) : arr2$ = {"A", "B", "C"}

dim arr3(3) : arr3 = {1, 2, 3}

print arr1$[i]; arr2$[i]; arr3[i]

next i

{{out}}

<pre>

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

array1$() = "a", "b", "c"

array2$() = "A", "B", "C"

FOR index% = 0 TO 2

PRINT array1$(index%) ; array2$(index%) ; array3%(index%)

=={{header|Beads}}==

This solution accounts for arrays of varying lengths, and if they are interspersed with undefined characters by replacing them with spaces.

calc main_init

const

const largest = max(tree_hi(x), tree_hi(y), tree_hi(z))

loop reps:largest count:i //where u_cc defines what to use for undefined characters

{{out}}

<pre>aA1

For arrays of differing lengths, you'd need to manually check for an out-of-range index and deal with it appropriately.

@_^#`2:+1,+55,<

abc

ABC

=={{header|C}}==

application-specific way.

char a1[] = {'a','b','c'};

printf("%c%c%i\n", a1[i], a2[i], a3[i]);

}

(Note: Some compilers may require a flag to accept this modern C code,

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

{

static void Main(string[] args)

Console.WriteLine("{0}{1}{2}", a[i], b[i], c[i]);

}

Using Enumerable.Zip (stops when either source runs out of elements):

int[] numbers = { 1, 2, 3, 4 };

string[] words = { "one", "two", "three" };

second));

Like how a perl programmer would write it (still using Zip):

Console.WriteLine((new[] { 1, 2, 3, 4 }).Zip(new[] { "a", "b", "c" },

(f, s) => f + " " + s));

Custom implementation for arrays of different lengths that pads with spaces after the end of the shorter arrays:

public static void Multiloop(char[] A, char[] B, int[] C)

{

Console.WriteLine($"{(i < A.Length ? A[i] : ' ')}, {(i < B.Length ? B[i] : ' ')}, {(i < C.Length ? C[i] : ' ')}");

}

usage:

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

With <code>std::vector</code>s:

#include <vector>

std::cout << *lIt << *uIt << *nIt << "\n";

}

Using static arrays:

int main(int argc, char* argv[])

"\n";

}

===C++11===

With <code>std::vector</code>s:

#include <vector>

std::cout << *ilow << *iup << *inum << "\n";

}

Using static arrays:

#include <iterator>

std::cout << *ilow << *iup << *inum << "\n";

}

With <code>std::array</code>s:

#include <array>

std::cout << *ilow << *iup << *inum << "\n";

}

With <code>std::array</code>s by indexes:

#include <array>

#include <algorithm>

std::cout << lowers[i] << uppers[i] << nums[i] << "\n";

}

===C++23===

#include <ranges>

#include <format>

std::cout << std::format("{}{}{}\n", x, y, z);

}

=={{header|Chapel}}==

var a2 = [ "A", "B", "C" ];

var a3 = [ 1, 2, 3 ];

for (x,y,z) in zip(a1, a2, a3) do

=={{header|Clojure}}==

The sequence stops when the shortest list is exhausted.

(apply map str ["abc" "ABC" "123"])

("aA1" "bB2" "cC3")

=={{header|COBOL}}==

PROGRAM-ID. Loop-Over-Multiple-Tables.

GOBACK

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

=== Using functional application ===

(format t "~{~A~}~%" args))

'(|a| |b| |c|)

'(a b c)

If lists are different lengths, it stops after the shortest one.

=== Using LOOP ===

(loop for x in '("a" "b" "c")

for y in '(a b c)

for z in '(1 2 3)

do (format t "~a~a~a~%" x y z))

=== Using DO ===

(do ((x '("a" "b" "c") (rest x)) ;

(y '("A" "B" "C" "D") (rest y)) ;

((or (null x) (null y) (null z))) ; Break condition

(format t "~a~a~a~%" (first x) (first y) (first z))) ; On every loop print first elements

{{out}}

=={{header|D}}==

void main () {

foreach (a, b, c; zip("abc", "ABC", [1, 2, 3]))

writeln(a, b, c);

{{out}}

<pre>aA1

On default it stops when the shortest range is exhausted

(same as StoppingPolicy.shortest):

void main () {

foreach (p; zip(sp.requireSameLength, a1, a2))

writeln(p.tupleof);

{{out}}

<pre>11

There is also std.range.lockstep:

void main() {

foreach (index, a, b; lockstep(arr1, arr2))

writefln("Index %s: a = %s, b = %s", index, a, b);

Lower level code that stops at the shortest length:

void main () {

foreach (i; 0 .. min(s1.length, s2.length, a1.length))

writeln(s1[i], s2[i], a1[i]);

{{out}}

<pre>aA1

=={{header|Delphi}}==

{$APPTYPE CONSOLE}

Readln;

=={{header|Diego}}==

add_mat(myMatrix)_row(a,b,c)_row(A,B,C)_row(1,2,3);

me_msg([output]);

Diego has no issue when arrays are of a different length, the "missing" array entries will be handled as empty. Note, the <code>matrix</code> will become a <code>clump</code>, but can still be treated as a <code>matrix</code>.

add_clump(myClump)_row(a,b,c,d)_row(A,B,C,D,E,F)_row(-1,0,1,2,3); // The default spread is presumed to be 'origin'

me_msg([output]);

{{out}}

<pre>

element.

const a2 = ['A', 'B', 'C'];

const a3 = [1, 2, 3];

var i : Integer;

for i := 0 to 2 do

=={{header|E}}==

indexes as keys, so a not entirely awful idiom exists:

def a2 := ["A","B","C"]

def a3 := ["1","2","3"]

for i => v1 in a1 {

println(v1, a2[i], a3[i])

This will obviously fail if a2 or a3 are shorter than a1, and omit items

Given a parallel iteration utility, we might write this:

println(v1, v2, v3)

<code>zip</code> cannot yet be defined for all collections

collections.

to run(l1, l2) {

def zipped {

zipped

}

(This will stop when the end of the shortest collection is reached.)

=={{header|EchoLisp}}==

;; looping over different sequences : infinite stream, string, list and vector

;; loop stops as soon a one sequence ends.

1004 "E" 4 s

1005 "F" 5 t

=={{header|Efene}}==

run = fn () {

lists.foreach(fn ((A, B, C)) { io.format("~s~n", [[A, B, C]]) },

lists.zip3("abc", "ABC", "123"))

}

If the lists are not all the same length, an error is thrown.

=={{header|Eiffel}}==

example (a_array: READABLE_INDEXABLE [BOUNDED [ANY]]): STRING

-- Assemble output for a 2-dim array in `a_array'

>>

end

{{out}}

aA1

=={{header|Ela}}==

xs = zipWith3 (\x y z -> show x ++ show y ++ show z) ['a','b','c']

return $ each print xss

The code above can be written shorter. First there is no need in lists

composition operator:

=={{header|Elena}}==

ELENA 5.0 :

import extensions;

console.readChar()

Using zipBy extension:

import extensions.

console.readChar();

{{out}}

<pre>

=={{header|Elixir}}==

'''string list:'''

l2 = ["A", "B", "C"]

l3 = ["1", "2", "3"]

IO.inspect List.zip([l1,l2,l3]) |> Enum.map(fn x-> Tuple.to_list(x) |> Enum.join end)

'''char_list:'''

l2 = 'ABC'

l3 = '123'

IO.inspect List.zip([l1,l2,l3]) |> Enum.map(fn x-> Tuple.to_list(x) end)

When the length of the list is different:

['aA1', 'bB2', 'cC3']

iex(2)> List.zip(['abcde','ABC','12']) |> Enum.map(&Tuple.to_list(&1))

The zipping finishes as soon as any enumerable completes.

=={{header|Erlang}}==

Shortest option:

However, as every expression in Erlang has to return something, printing text returns 'ok'. A list with as many 'ok's as there are lines printed will thus be created. The technically cleanest way to do things would be with

<tt>lists:foreach/2</tt>, which also guarantees evaluation

order:

io:format("~s~n",[[A,B,C]]) end,

If the lists are not all the same length, an error is thrown.

are.

If they are all "strings", it's quite easy:

sequence a, b, c

puts(1, a[i] & b[i] & c[i] & "\n")

end for

If not, and the other sequence is known to contain only integers:

sequence a, b, c

printf(1, "%s%s%g\n", {a[i], b[i], c[i]})

end for

A general solution for any arbitrary strings of characters or numbers

printed out. One possible answer is as follows, if you know that only

alphanumeric characters are used:

for i = 1 to length(a) do

if (a[i] >= '0' and a[i] <= '9') then

printf(1, "%s%s%s\n", {a[i], b[i], c[i]})

end for

Just as in Java, using single quotes around a character gives you its

"char value". In Euphoria, though, it is simply that character's code

=={{header|F_Sharp|F#}}==

[1;2;3] do

When one sequence is exhausted, any remaining elements in the other

=={{header|Factor}}==

=={{header|Fantom}}==

This will stop when it reaches the end of the shortest list.

class LoopMultiple

{

}

}

=={{header|Fermat}}==

[b] := [('A','B','C')];

[c] := [(1,2,3)];

;{instead of a numerical ASCII code, and the}

;{:1 causes the integer to take up exactly one}

{{out}}</pre>aA1

bB2

=={{header|Forth}}==

create b char A , char B , char C ,

create c char 1 , char 2 , char 3 ,

loop

drop drop drop

=={{header|Fortran}}==

implicit none

end program main

If the arrays are of different length (say, array ns has no third element), then when its turn comes the next unit of storage along from the second element will be accessed, its content interpreted as an integer, and its decimal value printed... If however, array bound checking is activated (or there is a memory access protection scheme that would detect this), a feature unavailable via many compilers and not the default on the rest, then an error will be detected and the run will be terminated, possibly with a somewhat helpful message.

=={{header|FreeBASIC}}==

Function min(x As Integer, y As Integer) As Integer

Print

{{out}}

=={{header|Frink}}==

a2 = ["A", "B", "C"]

a3 = ["1", "2", "3"]

m = [a1, a2, a3]

for row = m.transpose[]

=={{header|FunL}}==

for x <- zip3( ['a', 'b', 'c'], ['A', 'B', 'C'], [1, 2, 3] )

{{out}}

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=3a69e733694aeab3b72c6a5c0316535b Click this link to run this code]'''

Dim a1 As String[] = ["a", "b", "c"]

Dim a2 As String[] = ["A", "B", "C"]

Next

Output:

=={{header|GAP}}==

# The Loop function will apply some function to every tuple built by

taking

aC3

bD1

=={{header|Go}}==

conditions are meaningful in your application and explicitly handle

whatever errors are plausible.

import "fmt"

fmt.Printf("%v%c%v\n", a1[i], a2[i], a3[i])

}

=={{header|Golfscript}}==

["A" "B" "C"]:b;

["1" "2" "3"]:c;

If there are arrays of different size, the shorter are treated as

=={{header|Groovy}}==

Solution:

assert a1 && a2 && a3

assert a1.size() == a2.size()

assert a2.size() == a3.size()

[a1, a2, a3].transpose().collect { "${it[0]}${it[1]}${it[2]}" }

Test:

def y = ['A', 'B', 'C']

def z = [1, 2, 3]

{{out}}

=={{header|Harbour}}==

'''Using FOR EACH ... NEXT statement'''

PROCEDURE Main()

LOCAL a1 := { "a", "b", "c" }, ;

NEXT

RETURN

Output:

aA1

'''Using list comprehension'''

'''Using Transpose'''

In this special case of transposing strings.

'''Using ZipWith*'''

'''Using applicative ZipLists'''

ZipLists generalize zipWith to any number of parameters

main :: IO [()]

<$> ZipList "abd"

<*> ZipList "ABC"

=={{header|Haxe}}==

using Std;

Sys.println(a[i] + b[i] + c[i].string());

}

=={{header|HicEst}}==

REAL :: C(3)

DO i = 1, 3

WRITE() A(i), "ABC"(i), C(i)

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

The first solution uses co-expressions to produce parallel evaluation.

a := create !["a","b","c"]

b := create !["A","B","C"]

c := create !["1","2","3"]

while write(@a,@b,@c)

The second solution is more like other procedural languages

and also handles unequal list lengths.

procedure main()

every i := 1 to max(*a,*b,*c) do

write(a[i]|"","\t",b[i]|"","\t",c[i]|"")

{{libheader|Icon Programming Library}}

=={{header|J}}==

For arrays of different types:

aA1

bB2

This approach works by representing the digits as characters.

Where arrays are all the same type (all numeric or all string):

aA1

bB2

Both of these implementations reject arrays with conflicting lengths.

Other options include:

aA1

bB2

aA1

bB2

These implementations pad short arrays with spaces.

Or:

┌─┬─┬─┐

│a│A│1│

├─┼─┼─┤

│c│C│3│

This implementation puts each item from each of the original lists

=={{header|Java}}==

for (int i = 0; i < list1.length; i++) {

for (String[] lista : list1) {

}

System.out.println();

=={{header|JavaScript}}==

This loops over the indices of the first array,

and uses that to index into the others.

b = ["A","B","C"],

c = [1,2,3],

for (i = 0; i < a.length; i += 1) {

output += a[i] + b[i] + c[i] + "\n";

If the b or c arrays are too "short",

you will see the string "undefined" appear in the output.

Alternatively, we can nest a couple of calls to '''.forEach()''': one for the array of three arrays, and one for each of the three index positions:

[["a", "b", "c"], ["A", "B", "C"], ["1", "2", "3"]].forEach(

);

===Functional composition===

Reduce / fold:

return lstArrays.reduce(

["A", "B", "C"],

["1", "2", "3"]

A fixed arity ZipWith:

// function of arity 3 mapped over nth items of each of 3 lists

return zipWith3(concat, x, y, z).join('\n')

Or we could write a generic '''zipListsWith''' applying some supplied function overs lists derived from the nth members of an arbitrary list of (equal-length) lists.

'use strict';

)

.join('\n');

{{Out}}

bB2

====ES6====

By transposition:

'use strict';

map(concat, transpose(xs))

);

{{Out}}

<pre>aA1

The first array determines the number of items in the output;

nulls are used for padding.

def zip:

. as $in

Example 1:

that pads all arrays shorter than the longest with nulls.

Here is such a variant:

# transpose a possibly jagged matrix

def transpose:

([]; . + [ [ $row[$i] ] + $t[$i] ])

end;

=={{header|Jsish}}==

var a1 = ['a', 'b', 'c'];

var a2 = ['A', 'B', 'C'];

undefinedundefinedundefinedundefined7

=!EXPECTEND!=

{{out}}

=={{header|Julia}}==

'''With a higher order function''':

'''With a loop''':

println(i, j, k)

{{out}}

=={{header|K}}==

{{out}}

The following is a more general approach where

&/#:'x

calculates the minimum length of the arrays

and is used to index the first elements in each array.

{+x[;!(&/#:'x)]}("abc";"ABC";"1234")

{{out}}

then the arrays must be converted to strings.