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.

 

=={{header|APL}}==

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

short lists.

 

 

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

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

INCR i

WEND

 

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

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

 

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

next i

 

 

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

}

 

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

 

with_mat(myMatrix)_foreach()_bycol()_var(columnArray)

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

 

{{out}}

<pre>

cC1

dD2

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

import extensions;

 

var a3 := new int[]{1,2,3};

{

console.printLine(a1[i], a2[i], a3[i])

console.readChar()

 

Using zipBy extension:

import extensions.

 

.zipBy(a3, (first,second => first + second.toString() ));

{ console.writeLine:e };

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.

 

If instead of reading the action had been to store a value into the array, then in the absence of bound checking, arbitrary damage will be done (to code or data) that will possibly result in something going wrong. And if you're lucky, it will happen swiftly.

 

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

</pre>

 

 

 

<pre>

aA1

bB2

</pre>

 

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

 

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

[http://www.cs.arizona.edu/icon/library/procs/numbers.htm Uses max from

numbers]

 

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

(An "empty box" is what a programmer in another language might call

"a pointer to a zero length array".)

 

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

 

{a:,/'($:'x);+a[;!(&/#:'a)]}("abc";"ABC";1 2 3 4)

 

=={{header|Kotlin}}==

 

val a1 = charArrayOf('a', 'b', 'c')

val a2 = charArrayOf('A', 'B', 'C')

println()

val a4 = intArrayOf(4, 5, 6, 7)

val a5 = charArrayOf('d', 'e')

 

{{out}}

 

=={{header|Lambdatalk}}==

1) loop over 3 sentences of equal length and returning 3 sentences

 

e d

s

 

=={{header|LFE}}==

(lists:zipwith3

(lambda (i j k)

'(A B C)

'(1 2 3))

 

If any of the data lists differ in size from the other,

function with something like <code lisp>(: lists map

...)</code>.

 

=={{header|Lisaac}}==

 

+ name := ARRAY_LOOP_TEST;

'\n'.print;

};

 

=={{header|LiveCode}}==

Arrays

local lowA, uppA, nums, z

put "a,b,c" into lowA

put z

 

"list" processing

local lowA, uppA, nums, z

put "a,b,c" into lowA

put z

 

Output - both behave similarly for this exercise.

<pre>aA1

{{works with|UCB Logo}}

 

; [aA1 bB2 cC3]

 

(foreach [a b c] [A B C] [1 2 3] [print (word ?1 ?2 ?3)]) ; as above,

 

=={{header|Lua}}==

This can be done with a simple for loop:

a1, a2, a3 = {'a' , 'b' , 'c' } , { 'A' , 'B' , 'C' } , { 1 , 2 , 3 }

for i = 1, 3 do print(a1[i]..a2[i]..a3[i]) end

but it may be more enlightening

(and in line with the spirit of the challenge) to use the generic for:

function iter(a, b, c)

local i = 0

 

for u, v, w in iter(a1, a2, a3) do print(u..v..w) end

 

=={{header|Maple}}==

L := [["a", "b", "c"],["A", "B", "C"], ["1", "2", "3"]];

M := Array(1..3, 1..3, L);

end proc:

 

{{out}}

<pre>

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

This can be done with a built-in function:

All arguments must be lists of the same length.

 

=={{header|Mercury}}==

:- module multi_array_loop.

:- interface.

print_elems(A, B, C, !IO) :-

io.format("%c%c%i\n", [c(A), c(B), i(C)], !IO).

The foldl_corresponding family of procedures all throw a

software_error/1

 

=={{header|Modula-3}}==

 

IMPORT IO, Fmt;

Fmt.Int(arr3[i]) & "\n");

END;

 

=={{header|MUMPS}}==

Pieces of String version

LOOPMULT

N A,B,C,D,%

K A,B,C,D,%

Q

When there aren't enough elements,

a null string will be returned from the $Piece function.

 

Local arrays version

LOOPMULU

N A,B,C,D,%

S %=$O(A("")) F Q:%="" W !,$G(A(%)),$G(B(%)),$G(C(%)) S %=$O(A(%))

K A,B,C,D,%

 

The commented out line will throw an <UNDEFINED> error when trying

=={{header|Nanoquery}}==

{{trans|Java}}

for i in range(0, len(list1) - 1)

for lista in list1

end for

println

 

=={{header|Nemerle}}==

It "feels" better to use zip() for this,

unfortunately the built in zip() only takes two lists.

using System.Console;

 

WriteLine($"$x$y$z");

}

 

Alternately: {{trans|C#}}

 

module LoopMult

WriteLine("{0}{1}{2}", first[i], second[i], third[i]);

}

 

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols nobinary

 

return smp

{{out}}

<pre style="overflow:scroll">

 

=={{header|NewLISP}}==

 

=={{header|Nim}}==

a = @['a','b','c']

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

 

for i in 0..2:

 

=={{header|Oberon-2}}==

Works with oo2c version 2

MODULE LoopMArrays;

IMPORT

DoLoop

END LoopMArrays.

Output:<br/>

<pre>

 

=={{header|Objeck}}==

class MultipleArrayAccess {

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

}

}

 

If the arrays are different lengths,

=={{header|OCaml}}==

an immediate solution:

and a2 = [| 'A'; 'B'; 'C' |]

and a3 = [| '1'; '2'; '3' |] ;;

print_char a3.(i);

print_newline()

 

a more generic solution could be to use a function

which iterates over a list of arrays:

 

| [] -> ()

| x::xs as al ->

let ai = List.map (fun a -> a.(i)) al in

f ai

 

this function raises Invalid_argument exception if arrays have different

and has this signature:

 

 

how to use it with arrays a1, a2 and a3 defined before:

 

n_arrays_iter [a1; a2; a3] ~f:(fun l ->

List.iter print_char l;

print_newline());

 

=={{header|Oforth}}==

If arrays don't have the same size, zipAll reduces to the minimum size

 

 

{{out}}

 

=={{header|ooRexx}}==

x = .array~of("a", "b", "c")

y = .array~of("A", "B", "C")

say x[i]y[i]z[i]

end

 

=={{header|Oz}}==

I in [a b c]

J in ['A' 'B' 'C']

do

{System.showInfo I#J#K}

 

The loop will stop when the shortest list is exhausted.

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

This version stops when the shortest vector is exhausted.

my(l=#V[1]);

for(i=2,#V,l=min(l,#V[i]));

print()

)

 

This version prints blanks when a vector is exhausted.

my(l=0);

for(i=1,#V,l=max(l,#V[i]));

print()

)

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

{

my $code = shift;

my @a3 = qw( 1 2 3 );

 

 

This implementation will stop producing items when the shortest array

If the arguments were not all the same length, attempts to retrieve non-existent elements could trigger a fatal run-time error, were it not for the min(). In print3, fairly obviously, we only extract up to the shortest length. The builtin columnize() routine can perform a similar task: I have provided a space defval and replaced the 3rd array with a string to ensure we get strings back, and extended it to show how columnize uses that default value for missing entries off the end of the first two arrays.

 

<span style="color: #008080;">procedure</span> <span style="color: #000000;">print3</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">c</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">min</span><span style="color: #0000FF;">({</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">b</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">c</span><span style="color: #0000FF;">)})</span> <span style="color: #008080;">do</span>

<span style="color: #000000;">print3</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"abc"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"ABC"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">})</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">columnize</span><span style="color: #0000FF;">({</span><span style="color: #008000;">"abc"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"ABC"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"1234"</span><span style="color: #0000FF;">},{},</span><span style="color: #008000;">' '</span><span style="color: #0000FF;">)</span>

 

{{out}}

 

=={{header|Phixmonti}}==

 

( "abc" "ABC" "123" )

nl

endfor

 

=={{header|PHP}}==

$b = array('A', 'B', 'C');

$c = array('1', '2', '3'); //These don't *have* to be strings, but it

foreach ($a as $key => $value){

echo "{$a[$key]}{$b[$key]}{$c[$key]}\n";

 

This implementation throws an exception if the arrays are not all the

If the lists/arrays are of uneven lengths, then the elements in the longer arrays are skipped.

 

 

go =>

println([A,B,C,D].join(''))

end,

 

{{out}}

 

=={{header|PicoLisp}}==

'(a b c)

'(A B C)

The length of the first argument list controls the operation.

If subsequent lists are longer, their remaining values are ignored.

avoids the usual off-by-one errors

 

array a1 = ({ "a", "b", "c" });

array a2 = ({ "A", "B", "C" });

foreach(a1; int index; string char_dummy)

write("%s%s%s\n", a1[index], a2[index], a3[index]);

{{Out}}

<pre>

 

=={{header|PL/I}}==

declare P(3) character (1) initial ('a', 'b', 'c'),

Q(3) character (1) initial ('A', 'B', 'C'),

put skip edit (P(i), Q(i), R(i)) (2 A, F(1));

end;

 

=={{header|PostScript}}==

{{libheader|initlib}}

% transpose is defined in initlib like this.

/transpose {

% using it.

[[/a /b /c] [/A /B /C] [1 2 3]] transpose

 

=={{header|PowerShell}}==

A cheap and chEasy 'zip' function:

function zip3 ($a1, $a2, $a3)

{

}

}

zip3 @('a','b','c') @('A','B','C') @(1,2,3)

{{Out}}

<pre>

c C 3

</pre>

zip3 @('a','b','c') @('A','B','C') @(1,2,3) | ForEach-Object {$_.Item1 + $_.Item2 + $_.Item3}

{{Out}}

<pre>

=={{header|Prolog}}==

Works with SWI-Prolog

maplist(display, L1, L2, L3).

 

display(A,B,C) :-

writef('%s%s%s\n', [[A],[B],[C]]).

{{out}}

<pre> ?- multiple_arrays("abc", "ABC", "123").

false.

</pre>

 

=={{header|Python}}==

Using <tt>zip()</tt>:

zip('abc', 'ABC', '123')) )

aA1

bB2

cC3

If lists are different lengths, <tt>zip()</tt> stops after

the shortest one.

 

Using <tt>map()</tt>:

aA1

bB2

cC3

If lists are different lengths, <tt>map()</tt> in Python 2.x pretends that the shorter lists were extended with

<tt>None</tt> items; <tt>map()</tt> in Python 3.x stops after the shortest one.

 

Using <tt>itertools.imap()</tt> (Python 2.x):

 

def join3(a,b,c):

print a+b+c

 

If lists are differnt lengths, <tt>imap()</tt> stops after

the shortest is exhausted.

fillvalue argument which defaults to <tt>None</tt> (similar to the behavior of

''map()'' in Python 2.x):

>>> print ( '\n'.join(''.join(x) for x in zip_longest('abc',

'ABCD', '12345', fillvalue='#')) )

#D4

##5

(The Python 2.X equivalent is itertools.izip_longest)

 

The code presented here will loop as many times as the number of characters in the first nest (i.e. "abc" in the example). If either of the other two nests are shorter than the first then the program will report a problem.

 

[ emit

over i^ peek emit

2drop ] is task ( $ $ $ --> )

 

 

{{out}}

 

=={{header|R}}==

{

# Retrieve inputs and convert to a list of character strings

}

}

 

Same thing as a single function call.

But throws error if the arrays differ in length.

 

apply(data.frame(letters[1:3], LETTERS[1:3], 1:3), 1,

function(row) { cat(row, "\n", sep='') })

 

=={{header|Racket}}==

of sequences of any kind at once:

 

#lang racket

 

[i (in-naturals 1)]) ; 1, 2, ... infinitely

(printf "~s: ~s ~s ~s\n" i x y z))

 

The loop stops as soon as the first sequence terminates -- in the above

 

=== Basic functionality ===

say $x, $y, $z;

 

The <code>Z</code> operator stops emitting items as soon as the shortest input list is exhausted. However, short lists are easily extended by replicating all or part of the list, or by appending any kind of lazy list generator to supply default values as necessary.

Note that we can also factor out the concatenation by making the <tt>Z</tt> metaoperator apply the <tt>~</tt> concatenation operator across each triple:

 

 

We could also use the zip-to-string with the reduction metaoperator:

 

 

We could also write that out "long-hand":

 

 

returns the exact same result so if you aren't comfortable with the concise operators, you have a choice.

The common case of iterating over a list and a list of its indices can be done using the same method:

 

 

or by using the <code>.kv</code> (key and value) method on the list (and dropping the parentheses because the list returned by <code>.kv</code> is a flattened list):

 

 

=== Iterate until all exhausted ===

If you have different sized lists that you want to pull a value from each per iteration, but want to continue until '''all''' of the lists are exhausted, we have <code>roundrobin</code>.

 

{{out|yields}}

<pre>a A 0

When a variable is used in a path notation, we put a colon in front of it. :counter

 

== [["a" "b" "c"] ["A" "B" "C"] [1 2 3]]

 

a A 1

b B 2

 

=={{header|REXX}}==

<br><br>

When &nbsp; ''all'' &nbsp; elements are blank, then it signifies the end of the arrays.

x. = ' '; x.1 = "a"; x.2 = 'b'; x.3 = "c"

y. = ' '; y.1 = "A"; y.2 = 'B'; y.3 = "C"

output = x.j || y.j || z.j

say output

'''output'''

<pre>

In this example, two of the arrays are extended (past the 1^st example).

<br>Also note that REXX doesn't require quotes around non-negative numbers (they're optional).

x.=' '; x.1="a"; x.2='b'; x.3="c"; x.4='d'

y.=' '; y.1="A"; y.2='B'; y.3="C";

output=x.j || y.j || z.j

say output

'''output'''

<pre>

 

===dissimilar sized lists===

x = 'a b c d'

y = 'A B C'

output = word(x,j) || word(y,j) || word(z,j)

say output

'''output'''

<pre>

 

===idiomatic method for lists===

x = 'a b c d'

y = 'A B C'

do j=1 for max(words(x), words(y), words(z))

say word(x,j) || word(y,j) || word(z,j)

'''output'''

<pre>

 

=={{header|Ring}}==

array1 = ["a", "b", "c"]

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

see array1[n] + array2[n] + array3[n] + nl

next

 

=={{header|Ruby}}==

or

 

Both of these loops print <code>aA1</code>, <code>bB2</code>, <code>cC3</code>.

If an argument array is longer, the excess elements are ignored.

If an argument array is shorter, the value <code>nil</code> is supplied.

aA1

bB2

=> nil

irb(main):002:0> ['a','b','c'].zip(['A','B'], [1,2,3,4])

 

=={{header|Rust}}==

 

let a1 = ["a", "b", "c"];

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

println!("{}{}{}", x, y, z);

}

{{out}}

<pre>aA1

 

=={{header|Salmon}}==

any

// number of lists together.

c := [1, 2, 3];

iterate (x; zip(a, b, c))

 

The preceding code will throw an exception if the lists aren't the same

some lists are shorter than the longest:

 

any

// number of lists together.

c := [1, 2, 3];

iterate (x; zip(a, b, c))

 

=={{header|Sather}}==

main is

a :ARRAY{STR} := |"a", "b", "c"|;

end;

end;

 

=={{header|Scala}}==

("abc", "ABC", "123").zipped foreach { (x, y, z) =>

println(x.toString + y + z)

}

 

=={{header|Scheme}}==

into a new list.

 

(let ((a '("a" "b" "c"))

(b '("A" "B" "C"))

(newline))

a b c))

 

Scheme has a <code>vector</code> datatype with constant-time

and <code>vector-map</code>:

 

(let ((a (vector "a" "b" "c"))

(b (vector "A" "B" "C"))

(newline))

a b c))

 

Note, the lists or vectors must all be of the same length.

=={{header|Sidef}}==

The simplest way is by using the Array.zip{} method:

say (i, j, k)

{{out}}

<pre>

{{works with|GNU Smalltalk}}

 

a := OrderedCollection new addAll: #('a' 'b' 'c').

b := OrderedCollection new addAll: #('A' 'B' 'C').

(b at: i) display.

(c at: i) displayNl.

 

If index ''i'' is out of bound, a runtime error is raised.

<br>Also, most Smalltalks (all?) can concatenate non-string args&sup1;.

<br>At least in ST/X, the following works &sup1;:

 

a := #('a' 'b' 'c').

1 to: (a size) do: [ :i |

((a at: i),(b at: i),(c at: i)) displayNl.

 

Another alternative is to use a multi-collection enumerator,

which hides the element access (transparent to how elements are stored inside the collection):

 

a := #('a' 'b' 'c').

a with:b with:c do:[:ai :bi :ci |

(ai,bi,ci) displayNl.

 

1) concatenation of integer objects as shown above may require a change in the <tt>,</tt> (comma) implementation, to send "asString" to the argument.

 

=={{header|Standard ML}}==

The below code will combine arbitrarily many lists of strings

into a single list with length equal to that of the shortest list.

(*

* val combine_lists : string list list -> string list

(* ["a1Ax","b2By","c3Cz"] *)

combine_lists[["a","b","c"],["1","2","3"],["A","B","C"],["x","y","z"]];

 

=={{header|Stata}}==

Use an index variable.

 

local v A B C

matrix w=1,2,3

forv i=1/3 {

di "`: word `i' of `u''`: word `i' of `v''`=el("w",1,`i')'"

 

=== Mata ===

 

u="a","b","c"

v="A","B","C"

printf("%s%s%f\n",u[i],v[i],w[i])

}

 

=={{header|SuperCollider}}==

 

Using three variables and indexing (SuperCollider posts the last statement in the REPL)

#x, y, z = [["a", "b", "c"], ["A", "B", "C"], ["1", "2", "3"]];

3.collect { |i| x[i] ++ y[i] ++ z[i] }

 

A more idiomatic way of writing it, independent of the number of dimensions:

[["a", "b", "c"], ["A", "B", "C"], ["1", "2", "3"]].flop.collect { |x| x.join }

 

Or simpler:

[["a", "b", "c"], ["A", "B", "C"], ["1", "2", "3"]].flop.collect(_.join)

 

 

Same with lamination (a concept from APL/[http://rosettacode.org/wiki/Category:J#The_J_language J]):

["a", "b", "c"] +++ ["A", "B", "C"] +++ ["1", "2", "3"]

 

Independent of dimensions:

[["a", "b", "c"], ["A", "B", "C"], ["1", "2", "3"]].reduce('+++')

 

=={{header|Swift}}==

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

let a3 = [1, 2, 3]

for i in 0 ..< a1.count {

println("\(a1[i])\(a2[i])\(a3[i])")

{{out}}

<pre>aA1

=={{header|Tailspin}}==

Simplest iteration with an ordinary "loop" that will error on uneven sizes

def x: ['a', 'b', 'c'];

def y: ['A', 'B', 'C'];

1..$x::length -> '$x($);$y($);$z($);

' -> !OUT::write

{{out}}

<pre>

</pre>

A simple transpose method that gives the same output and also errors on uneven sizes

templates transpose

def a: $;

[$x, $y, $z] -> transpose... -> '$...;

' -> !OUT::write

A more complex transpose that uses "foreach" more in line with the task proposal and handles uneven arrays

def u: ['a', 'b'];

def v: ['A', 'B', 'C'];

[$u,$v,$w] -> transpose2... -> '$...;

' -> !OUT::write

{{out}}

<pre>

 

=={{header|Tcl}}==

set list2 {A B C}

set list3 {1 2 3}

foreach i $list1 j $list2 k $list3 {

puts "$i$j$k"

If lists are different lengths, the manual

[http://www.tcl.tk/man/tcl8.5/TclCmd/foreach.htm] says:

=={{header|TorqueScript}}==

 

$var[0] = "a b c"

$var[1] = "A B C";

for(%i=0;%i<3;%i++)

echo(getWord($var[0],%i) @ getWord($var[1],%i) @ getWord($var[2],%i));

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

arr1="a'b'c"

PRINT a,b,c

ENDLOOP

{{out}}

<pre>

===Pattern language===

 

@(bind b ("A" "B" "C"))

@(bind c ("1" "2" "3"))

aA1

bB2

 

===TXR Lisp, using <code>mapcar</code>===

finally printed in one go.

 

(repeat "\n")))'

aA1

bB2

 

===TXR Lisp, using <code>each</code>===

 

(put-line `@x@y@z`))'

aA1

bB2

 

===Translation of Scheme===

{{trans|Scheme}}

 

;; that happily works over strings and lists.

;; We don't need "srfi-43".

(display i3)

(newline))

 

===Translation of Logo===

{{trans|Logo}}

 

(defun question-var-to-meta-num (var)

^(sys:var ,(int-str (cdr (symbol-name var))))))

(defun show (x) (pprinl x))

 

 

{{out}}

 

== {{header|TypeScript}} ==

var arr1: string[] = ['a', 'b', 'c'];

var arr2: string[] = ['A', 'B', 'C'];

for (var i = 0; i <= 2; i++)

console.log(`${arr1[i]}${arr2[i]}${arr3[i]}`);

{{out}}

<pre>

{{works with|Bourne Shell}}

 

b=A:B:C

c=1:2:3

i=`expr $i + 1`

done

 

{{out}}

{{works with|Bourne Shell}}

 

B='b1 b2 b3'

 

printf "$a $1\n"

shift

 

{{out}}

{{works with|ksh93}}

 

b=(A B C)

c=(1 2 3)

for ((i = 0; i < ${#a[@]}; i++)); do

echo "${a[$i]}${b[$i]}${c[$i]}"

 

{{out}}

{{works with|pdksh}}

 

set -A b A B C

set -A c 1 2 3

echo "${a[$i]}${b[$i]}${c[$i]}"

((i++))

 

{{works with|zsh}}

 

b=(A B C)

c=(1 2 3)

for ((i = 1; i <= $#a; i++)); do

echo "$a[$i]$b[$i]$c[$i]"

 

==={{header|C Shell}}===

shell to exit with an error like ''b: Subscript out of range.''

 

set b=(A B C)

set c=(1 2 3)

echo "$a[$i]$b[$i]$c[$i]"

@ i += 1

 

=={{header|Ursa}}==

Looping over multiple arrays in an interactive session:

> append (split "abc" "") a

> append (split "ABC" "") b

bB2

cC3

If either of the arrays are smaller than (size a), then an indexerror is thrown. This could be caught with a <code>try...catch</code> block.

 

Compute the transpose of the list formed of the three lists.

If they're of unequal lengths, an exception occurs.

 

{{out}}

<pre>

 

=={{header|Vala}}==

const char a2[] = {'A','B','C'};

const int a3[] = {1, 2, 3};

for (int i = 0; i < 3; i++)

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

 

=={{header|VBScript}}==

 

a = Array("a","b","c")

buf = buf & vbCrLf & a(i) & b(i) & c(i)

Next

{{out}}

<pre>

</pre>

 

 

{{out}}

bB2

cC3

 

=={{header|Visual FoxPro}}==

LOCAL i As Integer, n As Integer, c As String

LOCAL ARRAY a1[3], a2[3], a3[4], a[3]

? "Solution using a cursor"

LIST OFF FIELDS c4

{{out}}

<pre>

</pre>

 

arrays := [['a','b','c'],['A','B','C'],['1','2','3']]

for i in 0..arrays[0].len {

println('${arrays[0][i]}${arrays[1][i]}${arrays[2][i]}')

}

 

=={{header|Wart}}==

 

=={{header|Wren}}==

The following script will work as expected provided the lengths of a1 and a2 are at least equal to the length of a3. Otherwise it will produce a 'Subscript out of bounds' error.

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

var a3 = [1, 2, 3]

 

{{out}}

{{works with|nasm}}

{{works with|windows}}

extern _printf

 

xor eax, eax

ret

 

=={{header|XPL0}}==

include c:\cxpl\codes; \intrinsic 'code' declarations

char A1, A2;

CrLf(0);

];

 

{{out}}

 

=={{header|Z80 Assembly}}==

 

 

db "ABC"

array3:

 

{{out}}

 

=={{header|zkl}}==

or

{{out}}

<pre>

 

=={{header|Zig}}==