staging.inyokaproject.org

#!/bin/bash
array_1=(foo bar baz)
array_2=(1 2 3)

if [ ${#array_1[@]} -eq ${#array_2[@]} ]; then
    array_3=()
    for i in ${!array_1[@]}; do
        array_3[$i]="${array_1[$i]} ${array_2[$i]}"
    done
else
    echo "arrays have different numbers of elements!"
fi
printf "%s\n" "${array_3[@]}"

#!/usr/bin/env io

main := method(
    list_a := List with("foo", "bar", "baz")
    list_b := List with(1, 2, 3)
    
    (list_a size != list_b size) ifTrue(
        Exception raise("lists have different lengths")
    )
    list_c := list_a map(index, value, value .. " " .. list_b at (index))
    
    list_c println
)

isLaunchScript ifTrue(main)

combined_list = [f"{a} {b}" for a, b in zip(["foo", "bar", "baz"], [1,2,3])]

#!/usr/bin/env coffee
'use strict'
_ = require 'lodash'

main = ->
  as = ['foo', 'bar', 'baz']
  bs = [1, 2, 3]
  throw new Error 'arrays have different lengths' if as.length != bs.length
  cs = _.zipWith as, bs, (a, b) -> "#{a} #{b}"
  console.log cs

main() if require.main == module

for i in {1..17}; do
    echo "${array1[i]} ${array2[i]}"
done

#include <algorithm>
#include <array>
#include <iostream>
#include <string>
using namespace std;

string f(string &s, int i) {
   return s + " " + to_string(i);
}

int main() {
   array<string, 3> as {{"foo", "bar", "baz"}};
   array<int, 3> bs {{1, 2, 3}};
   array<string, as.size()> cs;
   transform(as.begin(), as.end(), bs.begin(), cs.begin(), f);
   for (const auto& x: cs) {
      cout << x << endl;
   }
   return 0;
}

$ a=(foo bar)
$ echo "${a[1]}"
bar

GLOBALS
DEFINE  as ARRAY[3] OF CHAR(5),
        bs ARRAY[3] OF INTEGER,
        cs ARRAY[3] OF CHAR(10),
        i INTEGER
END GLOBALS

MAIN
  LET as[1] = "foo"
  LET as[2] = "bar"
  LET as[3] = "baz"
  LET bs[1] = 1
  LET bs[2] = 2
  LET bs[3] = 3

  FOR i = 1 TO 3
    LET cs[i] = as[i] CLIPPED, " ", bs[i]
  END FOR

  FOR i = 1 TO 3
    DISPLAY cs[i]
  END FOR
END MAIN

# Beispieldaten
a1 = 10.times.to_a
a2 = (11..20).to_a

# Merge 1
a3 = a1.zip(a2).each_with_object([]) {|(x,y),z| z << "#{x}-#{y}"}

# Merge 2
a3 = a1.zip(a2).inject([]) {|z, (x,y)| z << "#{x}-#{y}"}

# Merge 3
a3 = [].tap {|z| a1.zip(a2) {|x,y| z << "#{x}-#{y}"}}

# Ausgabe
p a3

main :: IO ()
main =
  let xs = ["foo", "bar", "baz"]
      ys = [1..3]
      zs = [x ++ " " ++ show y | (x, y) <- zip xs ys]
  in putStr $ unlines zs

#!/usr/bin/perl -w
# mergeArray.pl --- 

use warnings;
use strict;

my @array1 = qw! Aussentemperatur Innentemperatur Aussentemperatur !;
my @array2 = qw! 15 18 17 !;

foreach (0..$#array1) {
    print "$array1[$_] $array2[$_]\n";
}