# Append numbers at same position in strings

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Append numbers at same position in strings is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

Let given three list:
list1 = [1,2,3,4,5,6,7,8,9]
list2 = [10,11,12,13,14,15,16,17,18]
list3 = [19,20,21,22,23,24,25,26,27]
Append numbers at same position in strings.
The result should be:
list = [11019,21120,31221,41322,51423,61524,71625,81726,91827]

## 11l

```V list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
V list2 = [10, 11, 12, 13, 14, 15, 16, 17, 18]
V list3 = [19, 20, 21, 22, 23, 24, 25, 26, 27]

print(zip(list1, list2, list3).map((n1, n2, n3) -> String(n1)‘’n2‘’n3))```
Output:
```[11019, 21120, 31221, 41322, 51423, 61524, 71625, 81726, 91827]
```

```with Ada.Text_Io;

procedure Append_Numbers is

type List_Type is array (Positive range <>) of Natural;

procedure Put (List : List_Type) is
begin
Put ("[");
for E of List loop
Put (Natural'Image (E));
end loop;
Put ("]");
end Put;

List_1 : constant List_Type := ( 1,  2,  3,  4,  5,  6,  7,  8,  9);
List_2 : constant List_Type := (10, 11, 12, 13, 14, 15, 16, 17, 18);
List_3 : constant List_Type := (19, 20, 21, 22, 23, 24, 25, 26, 27);
List   : List_Type (List_1'Range);
begin
for A in List'Range loop
List (A) := Natural'Value
(Fixed.Trim (Natural'Image (List_1 (A)), Left) &
Fixed.Trim (Natural'Image (List_2 (A)), Left) &
Fixed.Trim (Natural'Image (List_3 (A)), Left));
end loop;

Put (List);  New_Line;
end Append_Numbers;
```
Output:
```[ 11019 21120 31221 41322 51423 61524 71625 81726 91827]
```

## ALGOL 68

```BEGIN # form a list of strings by concatenating numbers from 3 lists #
[]INT list1 = (  1,  2,  3,  4,  5,  6,  7,  8,  9 )
, list2 = ( 10, 11, 12, 13, 14, 15, 16, 17, 18 )
, list3 = ( 19, 20, 21, 22, 23, 24, 25, 26, 27 )
;
[ LWB list1 : UPB list1 ]STRING result;
FOR i FROM LWB list1 TO UPB list1 DO
result[ i ] := whole( list1[ i ], 0 ) + whole( list2[ i ], 0 ) + whole( list3[ i ], 0 )
OD;
STRING prefix := "[ ";
FOR i FROM LWB result TO UPB result DO
print( ( prefix, result[ i ] ) );
prefix := ", "
OD;
print( ( " ]", newline ) )
END```
Output:
```[ 11019, 21120, 31221, 41322, 51423, 61524, 71625, 81726, 91827 ]
```

## APL

Works with: Dyalog APL
```list1←1 2 3 4 5 6 7 8 9
list2←10 11 12 13 14 15 16 17 18
list3←19 20 21 22 23 24 25 26 27
append←⍎¨∘(,/)∘(⍕¨)∘(⍉↑)
append list1 list2 list3
```
Output:
`11019 21120 31221 41322 51423 61524 71625 81726 91827`

## AutoHotkey

```list1 := [1,2,3,4,5,6,7,8,9]
list2 := [10,11,12,13,14,15,16,17,18]
list3 := [19,20,21,22,23,24,25,26,27]
list4 := []

for i, v in list1
list4.Push(v . list2[i] . list3[i])
for i, v in list4
result .= v ", "
MsgBox % "[" trim(result, ", ") "]"
```
Output:
`[11019, 21120, 31221, 41322, 51423, 61524, 71625, 81726, 91827]`

## AWK

```# syntax: GAWK -f APPEND_NUMBERS_AT_SAME_POSITION_IN_STRINGS.AWK
BEGIN {
n1 = split("1,2,3,4,5,6,7,8,9",list1,",")
n2 = split("10,11,12,13,14,15,16,17,18",list2,",")
n3 = split("19,20,21,22,23,24,25,26,27",list3,",")
if (n1 != n2 || n1 != n3) {
print("error: arrays must be same length")
exit(1)
}
for (i=1; i<=n1; i++) {
list[i] = list1[i] list2[i] list3[i]
printf("%s ",list[i])
}
printf("\n")
exit(0)
}
```
Output:
```11019 21120 31221 41322 51423 61524 71625 81726 91827
```

## C

```#include<stdio.h>
#include<stdlib.h>

int main(void) {
int list[3][9], i;
for(i=0;i<27;i++) list[i/9][i%9]=1+i;
for(i=0;i<9;i++) printf( "%d%d%d  ", list[0][i], list[1][i], list[2][i] );
return 0;
}
```
Output:
`11019  21120  31221  41322  51423  61524  71625  81726  91827`

## BASIC

### BASIC256

Translation of: FreeBASIC
```arraybase 1
dim list1 = {1,2,3,4,5,6,7,8,9}
dim list2 = {10,11,12,13,14,15,16,17,18}
dim list3 = {19,20,21,22,23,24,25,26,27}
dim catlist(9)

for i = 1 to 9
temp\$ = string(list1[i]) + string(list2[i]) + string(list3[i])
print catlist[i]; "  ";
next i```
Output:
`Same as FreeBASIC entry.`

### Run BASIC

Translation of: FreeBASIC
```dim list1(9)
data 1,2,3,4,5,6,7,8,9
for i = 1 to 9
next i
dim list2(9)
data 10,11,12,13,14,15,16,17,18
for i = 1 to 9
next i
dim list3(9)
data 19,20,21,22,23,24,25,26,27
for i = 1 to 9
next i

dim catlist(9)
for i = 1 to 9
temp\$ = str\$(list1(i)) + str\$(list2(i)) + str\$(list3(i))
catlist(i) = val(temp\$)
print catlist(i); "  ";
next i```
Output:
`Same as FreeBASIC entry.`

### Yabasic

Translation of: FreeBASIC
```// Rosetta Code problem: http://rosettacode.org/wiki/Append_numbers_at_same_position_in_strings
// by Jjuanhdez, 09/2022

dim list1(9)
data 1,2,3,4,5,6,7,8,9
for i = 1 to 9
next i
dim list2(9)
data 10,11,12,13,14,15,16,17,18
for i = 1 to 9
next i
dim list3(9)
data 19,20,21,22,23,24,25,26,27
for i = 1 to 9
next i

dim catlist(9)
for i = 1 to 9
temp\$ = str\$(list1(i)) + str\$(list2(i)) + str\$(list3(i))
catlist(i) = val(temp\$)
print catlist(i), "  ";
next i```
Output:
`Same as FreeBASIC entry.`

## CLU

```append = proc (lists: sequence[sequence[int]]) returns (sequence[int])
n_lists: int := sequence[sequence[int]]\$size(lists)
n_items: int := sequence[int]\$size(lists[1])
out_list: array[int] := array[int]\$predict(1,n_items)
for i: int in int\$from_to(1, n_items) do
item: string := ""
for j: int in int\$from_to(1, n_lists) do
item := item || int\$unparse(lists[j][i])
end
end
return(sequence[int]\$a2s(out_list))
end append

start_up = proc ()
list1 = sequence[int]\$[1,2,3,4,5,6,7,8,9]
list2 = sequence[int]\$[10,11,12,13,14,15,16,17,18]
list3 = sequence[int]\$[19,20,21,22,23,24,25,26,27]
lists = sequence[sequence[int]]\$[list1,list2,list3]
po: stream := stream\$primary_output()
for n: int in sequence[int]\$elements(append(lists)) do
stream\$puts(po, int\$unparse(n) || " ")
end
end start_up```
Output:
`11019 21120 31221 41322 51423 61524 71625 81726 91827`

## F#

```// Append numbers at same position in strings. Nigel Galloway: December 29th., 2021
let rec fG n g l=seq{match n,g,l with (n::x,g::y,l::z)->yield int((string n)+(string g)+(string l)); yield! fG x y z |_->()}
fG [1;2;3;4;5;6;7;8;9] [10;11;12;13;14;15;16;17;18] [19;20;21;22;23;24;25;26;27] |> Seq.iter(printf "%d "); printfn ""
```
Output:
```11019 21120 31221 41322 51423 61524 71625 81726 91827
```

## Factor

Works with: Factor version 0.99 2021-06-02
```USING: kernel math.parser math.ranges present prettyprint
sequences ;

27 [1,b] 9 cut 9 cut [ [ present ] tri@ 3append dec> ] 3map .
```
Output:
```{ 11019 21120 31221 41322 51423 61524 71625 81726 91827 }
```

## FreeBASIC

```dim as integer list1(1 to 9) = {1,2,3,4,5,6,7,8,9}
dim as integer list2(1 to 9) = {10,11,12,13,14,15,16,17,18}
dim as integer list3(1 to 9) = {19,20,21,22,23,24,25,26,27}
dim as integer catlist(1 to 9)
dim as string temp

for i as uinteger = 1 to 9
temp = str(list1(i)) + str(list2(i)) + str(list3(i))
catlist(i) = val(temp)
print catlist(i);" ";
next i
```
Output:
`11019  21120  31221  41322  51423  61524  71625  81726  91827`

## Go

```package main

import "fmt"

func main() {
list1 := [9]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
list2 := [9]int{10, 11, 12, 13, 14, 15, 16, 17, 18}
list3 := [9]int{19, 20, 21, 22, 23, 24, 25, 26, 27}
var list [9]int
for i := 0; i < 9; i++ {
list[i] = list1[i]*1e4 + list2[i]*1e2 + list3[i]
}
fmt.Println(list)
}
```
Output:
```[11019 21120 31221 41322 51423 61524 71625 81726 91827]
```

```main :: IO ()
main =
mapM_ putStrLn \$
zipWith3
(\ x y z -> [x, y, z] >>= show)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[10, 11, 12, 13, 14, 15, 16, 17, 18]
[19, 20, 21, 22, 23, 24, 25, 26, 27]
```

or more flexibly (allowing for an arbitrary number of zipped lists) in terms of ZipList:

```import Control.Applicative

main :: IO ()
main =
mapM_ putStrLn \$
getZipList \$
(\x y z -> [x, y, z] >>= show) <\$>
ZipList [1, 2, 3, 4, 5, 6, 7, 8, 9] <*>
ZipList [10, 11, 12, 13, 14, 15, 16, 17, 18] <*>
ZipList [19, 20, 21, 22, 23, 24, 25, 26, 27]
```
Output:
```11019
21120
31221
41322
51423
61524
71625
81726
91827```

## jq

Works with: jq

Works with gojq, the Go implementation of jq

```def list1 : [ range(1;10) ];
def list2 : [ range(10; 19)];
def list3 : [ range(19; 28) ];

[list1, list2, list3]
| transpose
| map( map(tostring) | add | tonumber)```
Output:
```[11019,21120,31221,41322,51423,61524,71625,81726,91827]
```

## Julia

```list1 = [1,2,3,4,5,6,7,8,9]
list2 = [10,11,12,13,14,15,16,17,18]
list3 = [19,20,21,22,23,24,25,26,27]

println([prod(string(n) for n in z) for z in zip(list1, list2, list3)]) # ["11019", "21120", "31221", "41322", "51423", "61524", "71625", "81726", "91827"]
```

## Lambdatalk

```Using a function returning an array

{def append_numbers
{def append_numbers.rec
{lambda {:a :b :c :d}
{if {A.empty? :a}
then :d
else {append_numbers.rec {A.rest :a} {A.rest :b} {A.rest :c}
{A.addlast! {A.first :a}{A.first :b}{A.first :c} :d}}
}}}
{lambda {:a :b :c}
{append_numbers.rec :a :b :c {A.new}}}}
-> append_numbers

{append_numbers
{A.new {S.serie 1 9}}
{A.new {S.serie 10 18}}
{A.new {S.serie 19 27}}}
-> [11019,21120,31221,41322,51423,61524,71625,81726,91827]

or a map returning a sequence

{S.map {{lambda {:a :b :c :i}
{A.get :i :a}{A.get :i :b}{A.get :i :c}}
{A.new {S.serie 1 9}}
{A.new {S.serie 10 18}}
{A.new {S.serie 19 27}}
} {S.serie 0 8}}
-> 11019 21120 31221 41322 51423 61524 71625 81726 91827
```

## Mathematica / Wolfram Language

```list1 = {1, 2, 3, 4, 5, 6, 7, 8, 9};
list2 = {10, 11, 12, 13, 14, 15, 16, 17, 18};
list3 = {19, 20, 21, 22, 23, 24, 25, 26, 27};
FromDigits@Flatten[IntegerDigits /@ {##}] &, {list1, list2, list3}]
```
Output:
```
{11019,21120,31221,41322,51423,61524,71625,81726,91827}

```

## OCaml

```let lists = [
["1"; "2"; "3"; "4"; "5"; "6"; "7"; "8"; "9"];
["10"; "11"; "12"; "13"; "14"; "15"; "16"; "17"; "18"];
["19"; "20"; "21"; "22"; "23"; "24"; "25"; "26"; "27"]]

let reduce f = function
| h :: t -> List.fold_left f h t
| _ -> invalid_arg "reduce"

let () =
reduce (List.map2 (^)) lists |> String.concat ", " |> print_endline
```
Output:
`11019, 21120, 31221, 41322, 51423, 61524, 71625, 81726, 91827`

## Pascal

The following program requires (at least) an ISO 7185-compliant processor supporting features at level 1 (specifically “conformant array parameters” are being used).

```program appendNumbersAtSamePositionInStrings(output);

type
wholeNumber = 0..maxInt;

var
i: integer;
{ Indices were chosen to ease up initialization in main block. }
list0: array[1..9] of wholeNumber;
list1: array[10..18] of wholeNumber;
list2: array[19..27] of wholeNumber;

{ Returns the number of digits necessary to express as decimal. }
function digitCount(i: wholeNumber): wholeNumber;
begin
{ Instead of an `if` branch you can simply write: }
i := i + ord(i = 0);
{ Remember: Argument to `ln` must be positive. }
digitCount := succ(trunc(ln(i) / ln(10)))
end;

{ Appends two list members in place. }
procedure append(
{ DI: Destination Index; SI: Source Index. }
var destination: array[diMin..diMax: integer] of wholeNumber;
source: array[siMin..siMax: integer] of wholeNumber
);
var
i, n: integer;
begin
{ Determine maximum index range. }
i := diMax - diMin;
if (siMax - siMin) < i then
begin
i := siMax - siMin
end;

{ NB: In Pascal `for`-loop-limits are evaluation exactly once only. }
for i := 0 to i do
begin
{ In Extended Pascal (ISO 10206) you could actually simply write: }
{ … := destination[diMin + i] * 10 pow digitCount(source[siMin + i]) }
for n := 1 to digitCount(source[siMin + i]) do
begin
destination[diMin + i] := destination[diMin + i] * 10
end;
destination[diMin + i] := destination[diMin + i] + source[siMin + i]
end
end;

{ Calls `append` twice. }
procedure appendTwo(
var destination: array[diMin..diMax: integer] of wholeNumber;
source0: array[si0Min..si0Max: integer] of wholeNumber;
source1: array[si1Min..si1Max: integer] of wholeNumber
);
begin
append(destination, source0);
append(destination, source1)
end;

{ === MAIN ============================================================= }
begin
for i := 1 to 9 do
begin
list0[i] := i
end;
for i := 10 to 18 do
begin
list1[i] := i
end;
for i := 19 to 27 do
begin
list2[i] := i
end;

appendTwo(list0, list1, list2);

for i := 1 to 9 do
begin
writeLn(list0[i])
end
end.
```
Output:
```      11019
21120
31221
41322
51423
61524
71625
81726
91827
```

## Perl

```use strict;
use warnings;

my @a = < 1  2  3  4  5  6  7  8  9>;
my @b = <10 11 12 13 14 15 16 17 18>;
my @c = <19 20 21 22 23 24 25 26 27>;
my @d = <1  2  2  2  2  2  2  2  2 >;
my @e = < 9  0  1  2  3  4  5  6  7>;
my @f = (\@a, \@b, \@d, \@e);

# for just the three given lists
print \$a[\$_] . \$b[\$_] . \$c[\$_] . ' ' for 0..\$#a; print "\n";

# for arbitrary number of lists
for my \$i (0 .. \$#{\$f[0]}) {
map {print \$f[\$_][\$i] } 0 .. \$#f and print ' '
}
print "\n";
```
Output:
```11019 21120 31221 41322 51423 61524 71625 81726 91827
11019 21120 31221 41322 51423 61524 71625 81726 91827```

## Phix

```printf(1,"%V%V\n",repeat(apply(apply(true,vslice,{{sq_mul({tagset(9),tagset(18,10),tagset(27,19)},{1e4,1e2,1})},tagset(9)}),sum),2))
```
Output:
```{11019,21120,31221,41322,51423,61524,71625,81726,91827}{11019,21120,31221,41322,51423,61524,71625,81726,91827}
```

## Python

```list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
list2 = [10, 11, 12, 13, 14, 15, 16, 17, 18]
list3 = [19, 20, 21, 22, 23, 24, 25, 26, 27]

print([
''.join(str(n) for n in z) for z
in zip(list1, list2, list3)
])
```

which is also expressible as a map:

```print(list(map(
lambda x, y, z: f'{x}{y}{z}',
[1, 2, 3, 4, 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14, 15, 16, 17, 18],
[19, 20, 21, 22, 23, 24, 25, 26, 27]
)))
```
Output:
`['11019', '21120', '31221', '41322', '51423', '61524', '71625', '81726', '91827']`

## Quackery

```  [ [] swap witheach
[ number\$ nested join ] ] is [number\$] (   [ --> [ )

[ swap witheach
[ over i^ peek
join swap
i^ poke ] ]             is zip       ( [ [ --> [ )

' [ 1 2 3 4 5 6 7 8 9 ]
' [ 10 11 12 13 14 15 16 17 18 ]
' [ 19 20 21 22 23 24 25 26 27 ]
3 times [ rot [number\$] ]
zip zip
witheach [ echo\$ sp ]```
Output:
`11019 21120 31221 41322 51423 61524 71625 81726 91827`

## Raku

Various manipulations.

```my @lists = 1..9, 10..18, 19..27;
put [Z~] @lists;         # the task
put [Z~] @lists».flip;   # each component reversed
put [RZ~] @lists;        # in reversed order
put ([Z~] @lists)».flip; # reversed components in reverse order
```
Output:
```11019 21120 31221 41322 51423 61524 71625 81726 91827
10191 21102 32112 43122 54132 65142 76152 87162 98172
19101 20112 21123 22134 23145 24156 25167 26178 27189
91011 02112 12213 22314 32415 42516 52617 62718 72819```

## Ring

```load "stdlib.ring"
list1 = [1,2,3,4,5,6,7,8,9]
list2 = [10,11,12,13,14,15,16,17,18]
list3 = [19,20,21,22,23,24,25,26,27]
list = []

for n = 1 to len(list1)
str1 = string(list1[n])
str2 = string(list2[n])
str3 = string(list3[n])
str = str1 + str2 + str3
next

showArray(list)

func showArray(array)
txt = ""
see "["
for n = 1 to len(array)
txt = txt + array[n] + ","
next
txt = left(txt,len(txt)-1)
txt = txt + "]"
see txt```
Output:
```list = [11019,21120,31221,41322,51423,61524,71625,81726,91827][11019,21120,31221,41322,51423,61524,71625,81726,91827]
```

## Ruby

```list1 = (1..9)  .to_a
list2 = (10..18).to_a
list3 = (19..27).to_a

p list = [list1, list2, list3].transpose.map{|trio| trio.join.to_i }
```
Output:
```[11019, 21120, 31221, 41322, 51423, 61524, 71625, 81726, 91827]
```

## Sidef

```var lists = [
[1,2,3,4,5,6,7,8,9],
[10,11,12,13,14,15,16,17,18],
[19,20,21,22,23,24,25,26,27],
]

say lists.zip.map_2d {|*a| a.join.to_i }
```
Output:
```[11019, 21120, 31221, 41322, 51423, 61524, 71625, 81726, 91827]
```

## V (Vlang)

Translation of: go
```fn main() {
list1 := [1, 2, 3, 4, 5, 6, 7, 8, 9]!
list2 := [10, 11, 12, 13, 14, 15, 16, 17, 18]!
list3 := [19, 20, 21, 22, 23, 24, 25, 26, 27]!
mut list := [9]int{}
for i in 0..9 {
list[i] = list1[i]*int(1e4) + list2[i]*int(1e2) + list3[i]
}
println(list)
}```
Output:
`[11019, 21120, 31221, 41322, 51423, 61524, 71625, 81726, 91827]`

## Wren

```var list1 = (1..9).toList
var list2 = (10..18).toList
var list3 = (19..27).toList
var list  = (0..8).map { |i| 1e4*list1[i] + 100*list2[i] + list3[i] }.toList
System.print(list)
```
Output:
```[11019, 21120, 31221, 41322, 51423, 61524, 71625, 81726, 91827]
```

## XPL0

`intI;forI:=1to9do[IntOut(0,I*10000+(I+9)*100+I+18);ChOut(0,^ )]`
Output:
```11019 21120 31221 41322 51423 61524 71625 81726 91827
```