I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# Hash from two arrays

Hash from two arrays
You are encouraged to solve this task according to the task description, using any language you may know.

Using two Arrays of equal length, create a Hash object where the elements from one array (the keys) are linked to the elements of the other (the values)

## 11l

Translation of: Python
`V keys = [‘a’, ‘b’, ‘c’]V values = [1, 2, 3]V hash_ = Dict(zip(keys, values))print(hash_)`

## ActionScript

`package{    public class MyClass    {        public static function main():Void        {            var hash:Object = new Object();            var keys:Array = new Array("a", "b", "c");            var values:Array = new Array(1, 2, 3);             for (var i:int = 0; i < keys.length(); i++)                hash[keys[i]] = values[i];         }    }}`

Works with: GNAT version GPL 2007
`with Ada.Strings.Hash;with Ada.Containers.Hashed_Maps;with Ada.Text_Io;with Ada.Strings.Unbounded; use Ada.Strings.Unbounded; procedure Hash_Map_Test is   function Equivalent_Key (Left, Right : Unbounded_String) return Boolean is   begin      return Left = Right;   end Equivalent_Key;    function Hash_Func(Key : Unbounded_String) return Ada.Containers.Hash_Type is   begin      return Ada.Strings.Hash(To_String(Key));   end Hash_Func;    package My_Hash is new Ada.Containers.Hashed_Maps(Key_Type => Unbounded_String,      Element_Type => Unbounded_String,      Hash => Hash_Func,      Equivalent_Keys => Equivalent_Key);    type String_Array is array(Positive range <>) of Unbounded_String;    Hash : My_Hash.Map;   Key_List : String_Array := (To_Unbounded_String("foo"),       To_Unbounded_String("bar"),      To_Unbounded_String("val"));    Element_List : String_Array := (To_Unbounded_String("little"),       To_Unbounded_String("miss"),       To_Unbounded_String("muffet")); begin   for I in Key_List'range loop      Hash.Insert(Key => (Key_List(I)),         New_Item => (Element_List(I)));   end loop;   for I in Key_List'range loop      Ada.Text_Io.Put_Line(To_String(Key_List(I)) & " => " &         To_String(Hash.Element(Key_List(I))));   end loop; end Hash_Map_Test;`

## Amazing Hopper

Example:

` #!/usr/bin/hopper#include <hopper.h> main:   new hash(h)   add hash(h,"chile" :: 100)   add hash(h,"argentina"::200)   add hash(h,"brasil"::300)   {"\nLongitud HASH: "},len hash(h),println   println(hash(h))    println( get value("argentina",h) )   println( get value("chile",h) )   try      println( get value("guyana",h) )   catch(e)      {"***[",e,"]: "}get str error,println   finish   println( get key(300,h) )   println( get key(100,h) )    mod value("chile",101,h)   mod key(200,"madagascar",h)   try      mod key(130,"londres",h)      println( get key(130,h) )   catch(e)      {"***[",e,"]: "}get str error,println   finish    println( get key(200,h) )   println( get value("chile",h) )    println("HASH actual: \n")   println(hash(h))   {"\nLongitud HASH: "},len hash(h),println    put after value (200,"colombia",400,h)   put value (200,"mexico",401,h)   println(hash(h))    put after key ("chile","antartida",110,h)   put key ("chile","peru",99,h)    println("HASH actual: \n")   println(hash(h))   {"\nLongitud HASH: "},len hash(h),println    del by key("brasil",h)   del by value(101,h)    {"\nLongitud HASH: "},len hash(h),println   println(hash(h))   sort hash(h)   {"\nORDENADO: \n"}println   println(hash(h))    y={}  // para un stack de arreglos.      x=0,{5,5}rand array(x)   {x}push(y)   add hash(h,"arreglo 1"::x)    {"Ojalá que llueva café en el campo"}strtoutf8,push(y)   clear(x),w=0,{6,2}rand array(w)   {w}push(y)   add hash(h,"arreglo 2"::w)   clear(w)   add hash(h,"objeto",y)    println(hash(h))   println("arreglo 2?\n")   get value("arreglo 2",h)   println   println("arreglo 1?\n")   get value("arreglo 1",h)   println   /*  NO PUEDES ORDENAR UN HASH QUE CONTENGA ARRAYS      PORQUE SE BLOQUEARA EL PROGRAMA:    sort hash(h)   {"\nORDENADO: \n"}println   println(hash(h)) */    println("Objeto?\n")   get value("objeto",h)   z=0,mov(z)   /* Esto fallará, porque no se puede hacer un      push de pushs*/   pop(z),println   pop(z),println   pop(z),println   {"Esto significa que no puedes meter un stack dentro de un hash\nsolo arrays de cualquier dimension"}println   /* esto está bien, porque es un stack simple      aunque contenga arreglos como elementos. */   pop(y),println   {"Dato en la última posición del stack:"}strtoutf8,{"\n"},[1:end,1:end]get(y),println   {"Esto significa que, si vas a meter arreglos dentro de un stack\nsácalos con POP antes de usarlo"}strtoutf8,println   pop(y),println   pop(y),println    pauseexit(0) `

Output:

```Longitud HASH: 3
chile 100
argentina 200
brasil 300

200
100
brasil
chile
101
HASH actual:

chile 101
brasil 300

Longitud HASH: 3
chile 101
mexico 401
colombia 400
brasil 300

HASH actual:

peru 99
chile 101
antartida 110
mexico 401
colombia 400
brasil 300

Longitud HASH: 7

Longitud HASH: 5
peru 99
antartida 110
mexico 401
colombia 400

antartida 110
colombia 400
mexico 401
peru 99

antartida 110
colombia 400
mexico 401
peru 99
arreglo 1
arreglo 2
objeto

arreglo 2?

0.333623 0.056282
0.043443 0.218781
0.535042 0.147832
0.0998848 0.852316
0.89247 0.806435
0.148637 0.215199

arreglo 1?

0.881104 0.317274 0.744638 0.70655 0.296321
0.322729 0.49368 0.00842611 0.302231 0.74979
0.541794 0.139073 0.503212 0.586376 0.81519
0.282293 0.47536 0.822661 0.861344 0.427054
0.671334 0.0660376 0.441688 0.742367 0.50555

Objeto?

0.744638 0.70655 0.296321
0.00842611 0.302231 0.74979
0.503212 0.586376 0.81519
0.822661 0.861344 0.427054
0.441688 0.742367 0.50555

Esto significa que no puedes meter un stack dentro de un hash
solo arrays de cualquier dimension
0.333623 0.056282
0.043443 0.218781
0.535042 0.147832
0.0998848 0.852316
0.89247 0.806435
0.148637 0.215199

Dato en la última posición del stack:
0.881104 0.322729 0.541794 0.282293 0.671334

0.317274 0.49368 0.139073 0.47536 0.0660376

0.744638 0.00842611 0.503212 0.822661 0.441688

0.70655 0.302231 0.586376 0.861344 0.742367

0.296321 0.74979 0.81519 0.427054 0.50555

Esto significa que, si vas a meter arreglos dentro de un stack
sácalos con POP antes de usarlo
Ojalá que llueva café en el campo
0.881104 0.317274 0.744638 0.70655 0.296321
0.322729 0.49368 0.00842611 0.302231 0.74979
0.541794 0.139073 0.503212 0.586376 0.81519
0.282293 0.47536 0.822661 0.861344 0.427054
0.671334 0.0660376 0.441688 0.742367 0.50555
```

Macros used in the example, located in "hopper.h". (Observation: some of these macros will be converted to libraries, due to their extension.)

` /* macros HASH */#defn createhash(_X_)        _X__KEY={#VOID},_X__HASH={#VOID}#synon createhash            newhash#defn addhash(_X_,_K_,_H_)   {_H_}push(_X__HASH),{_K_}push(_X__KEY)#defn getvalue(_X_,_Y_)      _Y_03Rx0W91=0,{_X_,_Y__KEY},array(1),dup,zero?do{{"getvalue: key not found"}throw(2000)}\                             mov(_Y_03Rx0W91),[_Y_03Rx0W91]get(_Y__HASH),clearmark,#defn getkey(_X_,_Y_)        _Y_03Rx0W91=0,{_X_,_Y__HASH},array(1),dup,zero?do{{"getkey: value not found"}throw(2001)}\                             mov(_Y_03Rx0W91),[_Y_03Rx0W91]get(_Y__KEY),clearmark,#defn modvalue(_K_,_H_,_X_)  _Y_03Rx0W91=0,{_K_,_X__KEY},array(1),dup,zero?do{{"modvalue: key not found"}throw(2002)}\                             mov(_Y_03Rx0W91),[_Y_03Rx0W91]{_H_}put(_X__HASH),clearmark,#defn modkey(_H_,_K_,_X_)    _Y_03Rx0W91=0,{_H_,_X__HASH},array(1),dup,zero?do{{"modkey: value not found"}throw(2003)}\                             mov(_Y_03Rx0W91),[_Y_03Rx0W91]{_K_}put(_X__KEY),clearmark,#defn putaftervalue(_H_,_K_,_V_,_X_)   _X_03Rx0W91=0,{_H_,_X__HASH},array(1),dup,zero?do{{"putaftervalue: value not found"}throw(2006)}\                                       plus(1),mov(_X_03Rx0W91),{_K_}{_X_03Rx0W91,_X__KEY}array(3),\                                       {_V_}{_X_03Rx0W91,_X__HASH}array(3) #defn putvalue(_H_,_K_,_V_,_X_)   _X_03Rx0W91=0,{_H_,_X__HASH},array(1),dup,zero?do{{"putvalue: value not found"}throw(2006)}\                                  mov(_X_03Rx0W91),{_K_}{_X_03Rx0W91,_X__KEY}array(3),\                                   {_V_}{_X_03Rx0W91,_X__HASH}array(3),#defn putafterkey(_H_,_K_,_V_,_X_)   _X_03Rx0W91=0,{_H_,_X__KEY},array(1),dup,zero?do{{"putafterkey: key not found"}throw(2007)}\                                     plus(1),mov(_X_03Rx0W91),{_K_}{_X_03Rx0W91,_X__KEY}array(3),\                                     {_V_}{_X_03Rx0W91,_X__HASH}array(3), #defn putkey(_H_,_K_,_V_,_X_)  _X_03Rx0W91=0,{_H_,_X__KEY},array(1),dup,zero?do{{"putkey: value not found"}throw(2008)}\                               mov(_X_03Rx0W91),{_K_}{_X_03Rx0W91,_X__KEY}array(3),\                                {_V_}{_X_03Rx0W91,_X__HASH}array(3),  #defn delbyvalue(_H_,_X_)    {_H_,_X__HASH},array(1),dup,zero?do{{"delbyvalue: value not found"}throw(2004)},\                             {_X__KEY},keep,array(4),{_X__HASH},array(4),clearstack #defn delbykey(_K_,_X_)      {_K_,_X__KEY},array(1),dup,zero?do{{"delbykey: key not found"}throw(2005)},\                             {_X__KEY},keep,array(4),{_X__HASH},array(4),clearstack #defn sorthash(_X_)          #RAND,_LEN_#RNDV=0,_DUP_H#RNDV=_X__HASH,_DUP_K#RNDV=_X__KEY,\                             {_X__KEY}keep,length,mov(_LEN_#RNDV),array(0),\                              _POS_#RNDV=0,_HASH_LOOP_#RNDV:,[_LEN_#RNDV]get(_X__KEY),{_DUP_K#RNDV}array(1),\                             mov(_POS_#RNDV),[_POS_#RNDV]get(_DUP_H#RNDV),[_LEN_#RNDV]put(_X__HASH),\                             --_LEN_#RNDV,{_LEN_#RNDV},jnz(_HASH_LOOP_#RNDV),clear(_DUP_H#RNDV),clear(_DUP_K#RNDV) #defn lenhash(_X_)           {_X__HASH}length,#defn hash(_X_)              #RAND,_TMP_#RNDV=0,{_X__HASH,_X__KEY}catcol(_TMP_#RNDV),{_TMP_#RNDV},clear(_TMP_#RNDV), /* Other... *//* TRY/CATCH */#defn try                  swtrap( #CATCH ),#defn raise(_ERR_,_M_)     {_M_}, throw(_ERR_),#defn catch(_X_)           jmp(#ENDCATCH), %CATCH:, clearstack,_X_=0, gettry(_X_),  // gettry hace poptry internamente?#defn finish               %ENDCATCH:, popcatch /* print... */#defn println(_X_)        #ATOM #CMPLX,{"\n"} print#define println           {"\n"}print  `

## Argile

Works with: Argile version 1.1.0
`use std, array, hash let keys = @["hexadecimal" "decimal" "octal" "binary"]let values = @[0xa 11 014 0b1101] (: 10 11 12 13 :)let hash = new hash of intfor each val int i from 0 to 3  hash[keys[i]] = values[i]del hash hash`

## Arturo

`h: dictionary.raw flatten couple [a b c d] [1 2 3 4]print h`
Output:
`[a:1 b:2 c:3 d:4]`

## AutoHotkey

`array1 := ["two", "three", "apple"]array2 := [2, 3, "fruit"]hash := {}Loop % array1.maxIndex()   hash[array1[A_Index]] := array2[A_Index]MsgBox % hash["apple"] "`n" hash["two"]`

## AWK

Awk arrays are used for both lists and hash maps.

`# usage:  awk -v list1="i ii iii" -v list2="1 2 3"  -f hash2.awkBEGIN { 	if(!list1) list1="one two three" 	if(!list2) list2="1 2 3"         split(list1, a);        split(list2, b);        for(i=1;i in a;i++) { c[a[i]] = b[i] };         for(i in c) print i,c[i]}`
Output:
```three 3
two 2
one 1
```

## BASIC256

Solution is at Associative_array/Creation#BASIC256.

## BBC BASIC

`      DIM array1\$(4) : array1\$() = "0", "1", "2", "3", "4"      DIM array2\$(4) : array2\$() = "zero", "one", "two", "three", "four"       FOR index% = 0 TO DIM(array1\$(),1)        PROCputdict(mydict\$, array2\$(index%), array1\$(index%))      NEXT      PRINT FNgetdict(mydict\$, "3")      END       DEF PROCputdict(RETURN dict\$, value\$, key\$)      IF dict\$ = "" dict\$ = CHR\$(0)      dict\$ += key\$ + CHR\$(1) + value\$ + CHR\$(0)      ENDPROC       DEF FNgetdict(dict\$, key\$)      LOCAL I%, J%      I% = INSTR(dict\$, CHR\$(0) + key\$ + CHR\$(1))      IF I% = 0 THEN = "" ELSE I% += LEN(key\$) + 2      J% = INSTR(dict\$, CHR\$(0), I%)      = MID\$(dict\$, I%, J% - I%)`

## Bracmat

`  two three apple:?arr1& 2 3 fruit:?arr2& new\$hash:?H&   whl  ' ( !arr1:%?k ?arr1    & !arr2:%?v ?arr2    & (H..insert)\$(!k.!v)    )& (H..forall)\$out& ; `
Output:
```apple.fruit
three.3
two.2```

## Brat

`zip = { keys, values |	h = [:]	keys.each_with_index { key, index |		h[key] = values[index]	} 	h} p zip [1 2 3] [:a :b :c]  #Prints [1: a, 2: b, 3: c]`

## C

There likely exist libraries that can be used for creating hashes that are better than the following implementation. There are also better functions for obtaining hash values from strings. The following implementation tries to be somewhat generic to facilitate using alternative key and value types.

`#include <stdio.h>#include <stdlib.h>#include <string.h> #define KeyType const char *#define ValType int #define HASH_SIZE 4096 // hash function useful when KeyType is char * (string)unsigned strhashkey( const char * key, int max){    unsigned h=0;    unsigned hl, hr;     while(*key) {        h += *key;        hl= 0x5C5 ^ (h&0xfff00000 )>>18;        hr =(h&0x000fffff );        h = hl ^ hr ^ *key++;    }    return h % max;} typedef struct sHme {    KeyType    key;    ValType    value;    struct sHme  *link;} *MapEntry; typedef struct he {    MapEntry  first, last;} HashElement; HashElement hash[HASH_SIZE]; typedef void (*KeyCopyF)(KeyType *kdest, KeyType ksrc);typedef void (*ValCopyF)(ValType *vdest, ValType vsrc);typedef unsigned (*KeyHashF)( KeyType key, int upperBound );typedef int (*KeyCmprF)(KeyType key1, KeyType key2); void HashAddH( KeyType key, ValType value,        KeyCopyF copyKey, ValCopyF copyVal, KeyHashF hashKey, KeyCmprF keySame ){    unsigned hix = (*hashKey)(key, HASH_SIZE);    MapEntry m_ent;     for (m_ent= hash[hix].first;            m_ent && !(*keySame)(m_ent->key,key); m_ent=m_ent->link);    if (m_ent) {        (*copyVal)(&m_ent->value, value);    }    else {        MapEntry last;        MapEntry hme = malloc(sizeof(struct sHme));        (*copyKey)(&hme->key, key);        (*copyVal)(&hme->value, value);        hme->link = NULL;        last = hash[hix].last;        if (last) {//	    printf("Dup. hash key\n");            last->link = hme;        }        else            hash[hix].first = hme;        hash[hix].last = hme;    }} int HashGetH(ValType *val, KeyType key, KeyHashF hashKey, KeyCmprF keySame ){    unsigned hix = (*hashKey)(key, HASH_SIZE);    MapEntry m_ent;    for (m_ent= hash[hix].first;            m_ent && !(*keySame)(m_ent->key,key); m_ent=m_ent->link);    if (m_ent) {        *val = m_ent->value;    }    return (m_ent != NULL);} void copyStr(const char**dest, const char *src){    *dest = strdup(src);}void copyInt( int *dest, int src){    *dest = src;}int strCompare( const char *key1, const char *key2){    return strcmp(key1, key2) == 0;} void HashAdd( KeyType key, ValType value ){    HashAddH( key, value, &copyStr, &copyInt, &strhashkey, &strCompare);} int HashGet(ValType *val, KeyType key){    return HashGetH( val, key, &strhashkey, &strCompare);} int main() {    static const char * keyList[] = {"red","orange","yellow","green", "blue", "violet" };    static int valuList[] = {1,43,640, 747, 42, 42};    int ix;     for (ix=0; ix<6; ix++) {        HashAdd(keyList[ix], valuList[ix]);    }    return 0;}`

## C#

### C# 1.0

`static class Program{    static void Main()    {        System.Collections.Hashtable h = new System.Collections.Hashtable();         string[] keys = { "foo", "bar", "val" };        string[] values = { "little", "miss", "muffet" };         System.Diagnostics.Trace.Assert(keys.Length == values.Length, "Arrays are not same length.");         for (int i = 0; i < keys.Length; i++)        {            h.Add(keys[i], values[i]);        }    }}`

`Hashtable.Add` throws an exception when a key already exists.

An alternative method to add entries is to use the indexer setter, which replaces the old value associated with a key, if any:

`h[keys[i]] = values[i];`

### Modern

Uses `System.Collections.Generic.Dictionary<TKey, TValue>`, `Enumerable.ToDictionary` from LINQ, extension method syntax, and lambda expressions.

`Enumerable.Zip` truncates the longer of its arguments.

`using System.Linq; static class Program{    static void Main()    {        string[] keys = { "foo", "bar", "val" };        string[] values = { "little", "miss", "muffet" };         var h = keys            .Zip(values, (k, v) => (k, v))            .ToDictionary(keySelector: kv => kv.k, elementSelector: kv => kv.v);    }}`

## C++

`#include <unordered_map>#include <string> int main(){  std::string keys[] = { "1", "2", "3" };  std::string vals[] = { "a", "b", "c" };   std::unordered_map<std::string, std::string> hash;  for( int i = 0 ; i < 3 ; i++ )     hash[ keys[i] ] = vals[i] ;}`
Library: range-v3
`#include <range/v3/view/zip.hpp>#include <unordered_map>#include <string>  int main(){  std::string keys[] = { "1", "2", "3" };  std::string vals[] = { "foo", "bar", "baz" };   std::unordered_map<std::string, std::string> hash(ranges::view::zip(keys, vals));} `

## Ceylon

`shared void run() {	value keys = [1, 2, 3];	value items = ['a', 'b', 'c'];	value hash = map(zipEntries(keys, items));}`

## Clojure

`(zipmap [\a \b \c] [1 2 3])`

## Coco

`keys = <[apple banana orange grape]>values = <[red yellow orange purple]> object = new    @[keys[i]] = values[i] for i til keys.length`

## CoffeeScript

`   keys = ['a','b','c']  values = [1,2,3]  map = {}  map[key] = values[i] for key, i in keys `

## ColdFusion

`<cfscript>function makeHash(keyArray, valueArray) {  var x = 1;  var result = {};  for( ; x <= ArrayLen(keyArray); x ++ ) {    result[keyArray[x]] = valueArray[x];  }  return result;} keyArray = ['a', 'b', 'c'];valueArray = [1, 2, 3];map = makeHash(keyArray, valueArray);</cfscript>`

## Common Lisp

`(defun rosetta-code-hash-from-two-arrays (vector-1 vector-2 &key (test 'eql))  (assert (= (length vector-1) (length vector-2)))  (let ((table (make-hash-table :test test :size (length vector-1))))    (map nil (lambda (k v) (setf (gethash k table) v))             vector-1 vector-2)    table))`

Or, using cl:loop:

`(defun rosetta-code-hash-from-two-arrays (vector-1 vector-2 &key (test 'eql))  (loop initially (assert (= (length vector-1) (length vector-2)))        with table = (make-hash-table :test test :size (length vector-1))        for k across vector-1        for v across vector-2        do (setf (gethash k table) v)        finally (return table)))`

In Common Lisp terminology, a vector is a one-dimensional array.

## Crystal

`keys = ('a'..'z').to_a	# => a, b, c ... zvals = (1..26).to_a	# => 1, 2, 3 ... 26 hash = Hash.zip(keys, vals)p hash`
```{'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5, 'f' => 6, 'g' => 7, 'h' => 8, 'i' => 9, 'j' => 10, 'k' => 11, 'l' => 12, 'm' => 13, 'n' => 14, 'o' => 15, 'p' => 16, 'q' => 17, 'r' => 18, 's' => 19, 't' => 20, 'u' => 21, 'v' => 22, 'w' => 23, 'x' => 24, 'y' => 25, 'z' => 26}
```

## D

`void main() {    import std.array, std.range;     immutable hash = ["a", "b", "c"].zip([1, 2, 3]).assocArray;}`

## Déjà Vu

`local :h_keys [ :one :two :three ]local :h_values [ 1 2 3 ]local :h {}for item in h_keys:    set-to h item pop-from h_values `

## Delphi

` program Hash_from_two_arrays; {\$APPTYPE CONSOLE} uses  System.SysUtils,  System.Generics.Collections; type  THash = TDictionary<string, Integer>;   THashHelper = class helper for THash    procedure AddItems(keys: TArray<string>; values: TArray<Integer>);  end; { THashHelper } procedure THashHelper.AddItems(keys: TArray<string>; values: TArray<Integer>);var  i: Integer;begin  Assert(length(keys) = Length(values), 'Keys and values, must have the same size.');  for i := 0 to High(keys) do    AddOrSetValue(keys[i], values[i]);end; var  hash: TDictionary<string, Integer>;  i: integer;  key: string; begin  hash := TDictionary<string, Integer>.Create();  hash.AddItems(['a', 'b', 'c'], [1, 2, 3]);   for key in hash.Keys do    Writeln(key, '   ', hash[key]);   hash.Free;   readln;end.  `
Output:
```b   2
a   1
c   3
```

## E

`def keys := ["one", "two", "three"]def values := [1, 2, 3]__makeMap.fromColumns(keys, values)`

## EchoLisp

` (lib 'hash) (define H (make-hash))(define keys '(elvis simon antoinette))(define kvalues '("the king" "gallubert" "de gabolde d'Audan")) (list->hash (map cons keys kvalues) H)    → #hash:3(hash-ref H 'elvis)    → "the king" `

## Elixir

`iex(1)> keys = [:one, :two, :three][:one, :two, :three]iex(2)> values = [1, 2, 3][1, 2, 3]iex(3)> Enum.zip(keys, values) |> Enum.into(Map.new)%{one: 1, three: 3, two: 2}`

## Erlang

` Dictionary = dict:from_list( lists:zip([key1, key2, key3], [value1, 2, 3]) ). `

## F#

`HashMultiMap(Array.zip [|"foo"; "bar"; "baz"|] [|16384; 32768; 65536|], HashIdentity.Structural)`

## Factor

`USING: hashtables ;{ "one" "two" "three" } { 1 2 3 } zip >hashtable`

## Falcon

` keys = [ 'a', 'b', 'c', 'd' ]values = [ 1, 2, 3, 4 ]hash = [ => ]for i in [ 0 : keys.len() ]:  hash[ keys[ i ] ] = values[ i ] `

## Fantom

` class Main{  public static Void main ()  {    keys := [1,2,3,4,5]    values := ["one", "two", "three", "four", "five"]     // create an empty map    map := [:]      // add the key-value pairs to it    keys.size.times |Int index|    {      map.add(keys[index], values[index])    }  }} `

## FreeBASIC

`Dim As String keys(1 To 5) = {"1", "2", "3", "4", "5"}Dim As String values(1 To 5) = {"one", "two", "three", "four", "five"}Dim As String hash(Lbound(keys) To Ubound(keys))Dim As Integer i, temp For i = Lbound(values) To Ubound(values)    temp = Val(keys(i))    hash(temp) = values(i)Next i  For i = Lbound(hash) To Ubound(hash)    Print keys(i); " "; hash(i)'; " "; iNext iSleep`
Output:
``` 1 one
2 two
3 three
4 four
5 five```

## Frink

There is a built-in dictionary/hash constructor that takes two arrays as input.

` a = new dict[["a", "b", "c"], [1, 2, 3]] `

## Gambas

`Public Sub Main()Dim sValue As String[] = ["Zero", "One", "Two", "Three", "Four", "Five"]Dim sKey As String[] = [0, 1, 2, 3, 4, 5]Dim sCol As New CollectionDim siCount As Short For siCount = 0 To sKey.max  sCol.Add(sValue[siCount], sKey[siCount])Next For siCount = 0 To sKey.max  Print Str(sicount) & " = " & sCol[siCount]Next End`

Output:

```0 = Zero
1 = One
2 = Two
3 = Three
4 = Four
5 = Five
```

## Go

`package main import "fmt" func main() {    keys := []string{"a", "b", "c"}    vals := []int{1, 2, 3}    hash := map[string]int{}    for i, key := range keys {        hash[key] = vals[i]    }    fmt.Println(hash)}`
Output:
```map[b:2 a:1 c:3]
```

## Groovy

`def keys = ['a','b','c']def vals = ['aaa', 'bbb', 'ccc']def hash = [:]keys.eachWithIndex { key, i -> hash[key] = vals[i] }`

Alternative Version:

`List.metaClass.hash = { list -> [delegate, list].transpose().collectEntries { [(it[0]): it[1]] } }`

Test:

`assert (['a', 'b', 'c'].hash(['aaa', 'bbb', 'ccc'])) == [a: 'aaa', b: 'bbb', c: 'ccc']`

## Harbour

`LOCAL arr1 := { 6, "eight" }, arr2 := { 16, 8 }LOCAL hash := { => }LOCAL i, j FOR EACH i, j IN arr1, arr2   hash[ i ] := j NEXT`

Works with: GHCi version 6.6
`import Data.Map makeMap ks vs = fromList \$ zip ks vsmymap = makeMap ['a','b','c'] [1,2,3]`

## Huginn

`from Algorithms import materialize, zip; main() {  keys = [1, 2, 3];  values = ['a', 'b', 'c'];  hash = materialize( zip( key, values ), lookup );}`

## Icon and Unicon

`link ximage    # to format the structure procedure main(arglist)                          #: demonstrate hash from 2 listslocal keylist  if *arglist = 0 then arglist := [1,2,3,4]        # ensure there's a listevery put(keylist := [], "key-" || !arglist)     # make keys for each entry every  (T := table())[keylist[ i := 1 to *keylist ]] := arglist[i]  # create the hash table write(ximage(T))                                 # show resultend`

## Ioke

`{} addKeysAndValues([:a, :b, :c], [1, 2, 3])`

## J

What exactly is a hash?

We shall interpret 'hash' as "a function between some arbitrary values and some other arbitrary values". (Technically speaking a hash is more of a reference to a collection of techniques for achieving this, with something of an emphasis on an arbitrary and opaque intermediate result, than the actual end result. But people have spoken very glowingly of these techniques so let's pretend that the result actually matters.)

Solution:

`hash=: vals {~ keys&i.`

For example:

`   keys=: 10?.100    vals=: > ;:'zero one two three four five six seven eight nine'   hash=: vals {~ keys&i.    keys46 99 23 62 42 44 12 5 68 63   \$vals10 5    hash 46zero    hash 99one     hash 63 5 12 5 23nine sevensix  seventwo`

Here,` keys `is a list of 10 integers between 0 and 99 chosen arbitrarily (we like to call this "randomly" but there is some mathematical controversy about implementations of randomness) without repetition, and` vals `is a 10 by 5 character matrix.

## Java

`import java.util.HashMap;public static void main(String[] args){	String[] keys= {"a", "b", "c"};	int[] vals= {1, 2, 3};	HashMap<String, Integer> hash= new HashMap<String, Integer>(); 	for(int i= 0; i < keys.length; i++){	   hash.put(keys[i], vals[i]);	}}`

## JavaScript

### Iterative

` var keys = ['a', 'b', 'c'];var values = [1, 2, 3];var map = {};for(var i = 0; i < keys.length; i += 1) {  map[ keys[i] ] = values[i];} `

### Iterative Using Foreach

` function arrToObj(keys, vals) {  var map = {};  keys.forEach(function (key, index) {    map[key] = val[index];  });  return map;} `

### Using Reduce

` function arrToObj(keys, vals) {  return keys.reduce(function(map, key, index) {    map[key] = vals[index];    return map;  }, {});} `

## jq

jq only supports hashing of strings. In the following, accordingly, we assume that one array (keys) is an array of strings.

`# hash(keys) creates a JSON object with the given keys as keys# and values taken from the input array in turn.# "keys" must be an array of strings.# The input array may be of any length and have values of any type,# but only the first (keys|length) values will be used; # the input will in effect be padded with nulls if required.def hash(keys):  . as \$values  | reduce range(0; keys|length) as \$i      ( {}; . + { (keys[\$i]) : \$values[\$i] }); [1,2,3] | hash( ["a","b","c"] )`
Output:
`jq -n -f Hash_from_two_arrays.jq{  "a": 1,  "b": 2,  "c": 3}`

To hash an array of distinct integers, the tostring filter can be used, e.g.

```[10,20,30] | hash( [1,2,3] | map(tostring) )
```
yields:
`{  "1": 10,  "2": 20,  "3": 30}`

## Jsish

From Javascript.

`/* Hash from two arrays, in Jsish */function hashTwo(k:array, v:array):object {    var hash = {};    for (var i = 0; i < k.length; i++) hash[k[i]] = v[i];    return hash;} ;hashTwo(['a','b','c'], [1,2,3]);;hashTwo(['a','b'], [1,[2,4,8],3]);;hashTwo(['a','b','c'], [1,2]);;hashTwo([], []); /*=!EXPECTSTART!=hashTwo(['a','b','c'], [1,2,3]) ==> { a:1, b:2, c:3 }hashTwo(['a','b'], [1,[2,4,8],3]) ==> { a:1, b:[ 2, 4, 8 ] }hashTwo(['a','b','c'], [1,2]) ==> { a:1, b:2, c:undefined }hashTwo([], []) ==> {}=!EXPECTEND!=*/`
Output:
```prompt\$ jsish -u hashTwo.jsi
[PASS] hashTwo.jsi```

Use jsish --U hashTwo.jsi to see echo mode test lines.

## Julia

Works with: Julia version 0.6

Using comprehension:

`k = ["a", "b", "c"]v = [1, 2, 3] Dict(ki => vi for (ki, vi) in zip(k, v))`

Using constructor:

`Dict(zip(keys, values))`

Specifying types:

`Dict{String,Int32}(zip(keys, values))`

## K

The keys in a dictionary must be a symbol.

`   a: `zero `one `two  / symbols   b: 0 1 2    d:. a,'b  / create the dictionary.((`zero;0;)  (`one;1;)  (`two;2;))    d[`one]1`

Here we use integers as keys (which must be converted to symbols) and strings as values (here also converted to symbols).

`   keys: !10   / 0..9   split:{1_'(&x=y)_ x:y,x}   vals:split["zero one two three four five six seven eight nine";" "]    s:{`\$\$x}  / convert to symbol   d:. (s'keys),'s'vals.((`"0";`zero;)  (`"1";`one;)  (`"2";`two;)  (`"3";`three;)  (`"4";`four;)  (`"5";`five;)  (`"6";`six;)  (`"7";`seven;)  (`"8";`eight;)  (`"9";`nine;))    \$d[s 1] / leading "\$" converts back to string"one"`

## Kotlin

`// version 1.1.0 fun main(args: Array<String>) {    val names = arrayOf("Jimmy", "Bill", "Barack", "Donald")    val ages  = arrayOf(92, 70, 55, 70)    val hash  = mapOf(*names.zip(ages).toTypedArray())    hash.forEach { println("\${it.key.padEnd(6)} aged \${it.value}") }}`
Output:
```Jimmy  aged 92
Bill   aged 70
Barack aged 55
Donald aged 70
```

## Lang5

`: >table  2 compress -1 transpose ;['one 'two 'three 'four] [1 2 3 4] >table`

## langur

### the easy way

`writeln toHash w/a b c d/, [1, 2, 3, 4]`

Note that w/a b c d/ is a semantic convenience equivalent to ["a", "b", "c", "d"].

### a longer way

Using the append operator would silently overwrite hash values for matching keys, but the more() function will not.

`val .new = foldfrom(    f(.hash, .key, .value) more .hash, h{.key: .value},    h{}, w/a b c d/, [1, 2, 3, 4],) writeln .new`
Output:
`h{"d": 4, "a": 1, "b": 2, "c": 3}`

## Lasso

`local(	array1	= array('a', 'b', 'c'),	array2	= array(1, 2, 3),	hash	= map) loop(#array1 -> size) => {	#hash -> insert(#array1 -> get(loop_count) = #array2 -> get(loop_count))} #hash`

-> map(a = 1, b = 2, c = 3)

## LFE

`(let* ((keys (list 'foo 'bar 'baz))       (vals (list '"foo data" '"bar data" '"baz data"))       (tuples (: lists zipwith                 (lambda (a b) (tuple a b)) keys vals))       (my-dict (: dict from_list tuples)))  (: io format '"fetched data: ~p~n" (list (: dict fetch 'baz my-dict)))) `

## Lingo

`keys = ["a","b","c"]values = [1,2,3] props = [:]cnt = keys.countrepeat with i = 1 to cnt  props[keys[i]] = values[i]end repeat put props-- ["a": 1, "b": 2, "c": 3]`

## LiveCode

`put "a,b,c" into list1put 10,20,30 into list2split list1 using commasplit list2 using commarepeat with i=1 to the number of elements of list1    put list2[i] into list3[list1[i]]end repeatcombine list3 using comma and colonput list3 -- ouput-- a:10,b:20,c:30`

## Lua

`function(keys,values)  local t = {}  for i=1, #keys do    t[keys[i]] = values[i]  endend`

## M2000 Interpreter

` Module CheckAll {      Module CheckVectorType {            Dim Keys\$(4), Values(4)            Keys\$(0):= "one","two","three","four"            Values(0):=1,2,3,4            Inventory Dict            For i=0 to 3 {                  Append Dict, Keys\$(i):=Values(i)            }            Print Dict("one")+Dict("four")=Dict("two")+Dict("three")  ' true      }      Module CheckVectorType1 {            Dim Keys\$(4), Values\$(4)            Keys\$(0):= "one","two","three","four"            Values\$(0):="*","**","***","****"            Inventory Dict            For i=0 to 3 {                  Append Dict, Keys\$(i):=Values\$(i)            }            Print Dict\$("one")+Dict\$("four")=Dict\$("two")+Dict\$("three")  ' true      }      CheckVectorType      CheckVectorType1}CheckAll `

This is the real task, using two arrays as arguments in a function which return the hash table (an inventory object). Each pair has a key and a stack object. If a key found more than one we simply add to stack (at the bottom using Data - or at the top using Push). A module PrintKeyItems get the hash, the key to find, and the second array with values, and apply indexes from hash to array. The MakeHash add indexes using start value of array of values. So we can pass arrays with different start and end index, but they must be one dimension and have same number of items, else we get error

` Module Checkit {      Function MakeHash(&a\$(), &b\$()) {            if dimension(a\$())<>1 or  dimension(b\$())<>1 then Error "Only for one dimension arrays"            if len(a\$())<>len(b\$()) Then Error "Only for same size arrays"            start=dimension(a\$(),1, 0)            end=dimension(a\$(),1, 1)            start2=dimension(b\$(),1, 0)            Inventory Hash            For i=start to end {                   if Exist(hash, a\$(i)) Then {                         \\ s is a pointer to a stack object                        s=hash(a\$(i))                        Stack s {Data i-start+start2}                  } Else Append hash, a\$(i):=Stack:=i-start+start2            }            =Hash      }       Module PrintKeyItems (hash, akey\$, &b\$()) {            \\  n=hash(akey\$)  ' use this if akey\$ allways is a proper key            \\  and hide these two lines using \\            if not exist(hash, akey\$) then Error "Key not exist"            n=Eval(hash)            For i=1 to Len(n) {                  Print  b\$(stackitem(n,i)),            }            Print      }       Dim a\$(2 to 5)      Dim b\$(4 to 7)      a\$(2)="A", "B","A","C"      b\$(4)="A1","B1","A2", "C1"       MyHash=MakeHash(&a\$(), &b\$())       PrintkeyItems Myhash, "A", &b\$()    ' print A1 A2      PrintkeyItems Myhash, "B", &b\$()    ' print B1      PrintkeyItems Myhash, "C", &b\$()    ' print C1}Checkit `

## Maple

`A := [1, 2, 3];B := ["one", "two", three"];T := table( zip( `=`, A, B ) );`

## Mathematica/Wolfram Language

`Map[(Hash[Part[#, 1]] = Part[#, 2]) &, Transpose[{{1, 2, 3}, {"one", "two", "three"}}]] ?? Hash ->Hash[1]=one->Hash[2]=two->Hash[3]=three`

## MATLAB / Octave

See Associative arrays/Creation for clarification of limitations and differences between the two methods.

### MATLAB/Octave: structs

`function s = StructFromArrays(allKeys, allVals)% allKeys must be cell array of strings of valid field-names% allVals can be cell array or array of numbers% Assumes arrays are same size and valid types    s = struct;    if iscell(allVals)        for k = 1:length(allKeys)            s.(allKeys{k}) = allVals{k};        end    else        for k = 1:length(allKeys)            s.(allKeys{k}) = allVals(k);        end    endend`
Output:
```>> ages = StructFromArrays({'Joe' 'Bob' 'Sue'}, [21 35 27])

ages =

Joe: 21
Bob: 35
Sue: 27```

### MATLAB only: containers.Map

containers.Map constructor provides this functionality already.

```>> ages = containers.Map({'Joe' 'Bob' 'Sue'}, [21 35 27]);
>> keys(ages)

ans =

'Bob'    'Joe'    'Sue'

>> values(ages)

ans =

[35]    [21]    [27]```

## MiniScript

`keys = ["foo", "bar", "val"]values = ["little", "miss", "muffet"] d = {}for i in range(keys.len-1)    d[keys[i]] = values[i]end for print d`
Output:
`{"bar": "miss", "foo": "little", "val": "muffet"}`

## Neko

`/** <doc><h2>Hash from two arrays, in Neko</h2></doc>**/ var sprintf = \$loader.loadprim("[email protected]", 2) var array_keys = \$array("one",2,"three",4,"five")var array_vals = \$array("six",7,"eight",9,"zero")var elements = \$asize(array_keys) var table = \$hnew(elements) var step = elementswhile (step -= 1) >= 0 \$hadd(table, \$hkey(array_keys[step]), array_vals[step]) /* \$hiter accepts a hashtable and a function that accepts two args, key, val*/var show = function(k, v) \$print("Hashed key: ", sprintf("%10d", k), " Value: ", v, "\n")\$hiter(table, show)`
Output:
```prompt\$ nekoc hash-two-arrays.neko
prompt\$ neko hash-two-arrays.n
Hashed key:   13898426 Value: eight
Hashed key:      38662 Value: six
Hashed key:          2 Value: 7
Hashed key:          4 Value: 9
Hashed key:     737454 Value: zero```

## Nemerle

`using System;using System.Console;using Nemerle.Collections;using Nemerle.Collections.NCollectionsExtensions; module AssocArray{    Main() : void    {        def list1 = ["apples", "oranges", "bananas", "kumquats"];        def list2 = [13, 34, 12];        def inventory = Hashtable(ZipLazy(list1, list2));        foreach (item in inventory)            WriteLine("{0}:   {1}", item.Key, item.Value);    }}`

## NetRexx

### REXX Style

Translation of: REXX
`/* NetRexx program ***************************************************** 04.11.2012 Walter Pachl  derived from REXX**********************************************************************/options replace format comments java crossref savelog symbols nobinary  values='triangle quadrilateral pentagon hexagon heptagon octagon' -         'nonagon decagon dodecagon'  keys  ='three four five six seven eight nine ten twelve'  kcopy=keys  k=''                                 /* initialize the arrays      */  v=''  value='unknown'  Loop i=1 By 1 While kcopy>''         /* initialize the two arrays  */    Parse kcopy  ki kcopy;  k[i]=ki    Parse values vi values; v[i]=vi    End  Loop j=1 To i-1    value[k[j]]=v[j]    End  Say 'Enter one of these words:'  Say ' 'keys  Parse Ask z  Say z '->' value[z]`

### Java Collections

`/* NetRexx */options replace format comments java crossref symbols nobinary vals = [ 'zero', 'one', 'two', 'three', 'four', 'five' ]keys = [ 'k0', 'k1', 'k2', 'k3', 'k4', 'k5' ]hash1 = Rexxhash2 = Map hash1 = HashMap()hash2 = ''makeHash(hash1, keys, vals) -- using a Map object (overloaded method)makeHash(hash2, keys, vals) -- using a Rexx object (overloaded method) return -- Using a Java collection objectmethod makeHash(hash = Map, keys = Rexx[], vals = Rexx[]) static  loop k_ = 0 to keys.length - 1    hash.put(keys[k_], vals[k_])    end k_   key = Rexx  loop key over hash.keySet()    say key.right(8)':' hash.get(key)    end key  say   return -- For good measure a version using the default Rexx object as a hash (associative array)method makeHash(hash = Rexx, keys = Rexx[], vals = Rexx[]) static  loop k_ = 0 to keys.length - 1    hash[keys[k_]] = vals[k_]    end k_   loop key over hash    say key.right(8)':' hash[key]    end key  say   return `

## Nim

`import tables, sequtils let keys = @['a','b','c']let values = @[1, 2, 3] let table = toTable zip(keys, values)`

## Oberon-2

Works with oo2c version 2

` MODULE HashFromArrays;IMPORT   ADT:Dictionary,  Object:Boxed;TYPE  Key= STRING;  Value= Boxed.LongInt;   PROCEDURE Do;  VAR    a: ARRAY 128 OF Key;    b: ARRAY 128 OF Value;    hash: Dictionary.Dictionary(Key,Value);    i: INTEGER;   BEGIN    hash := NEW(Dictionary.Dictionary(Key,Value));    a[0] := "uno";    a[1] := "dos";    a[2] := "tres";    a[3] := "cuatro";    b[0] := Boxed.ParseLongInt("1");    b[1] := Boxed.ParseLongInt("2");    b[2] := Boxed.ParseLongInt("3");    b[3] := Boxed.ParseLongInt("4");    i := 0;    WHILE (i < LEN(a)) & (a[i] # NIL) DO      hash.Set(a[i],b[i]);      INC(i)    END;   END Do;BEGIN  Do;END HashFromArrays. `

## Objeck

` use Structure; bundle Default {  class HashOfTwo {    function : Main(args : System.String[]) ~ Nil {      keys := ["1", "2", "3"];      vals := ["a", "b", "c"];      hash := StringHash->New();      each(i : vals) {        hash->Insert(keys[i], vals[i]->As(Base));      };    }  }} `

## Objective-C

`NSArray *keys = @[@"a", @"b", @"c"];NSArray *values = @[@1, @2, @3];NSDictionary *dict = [NSDictionary dictionaryWithObjects:values forKeys:keys];`

## OCaml

The idiomatic solution uses lists rather than arrays.

`let keys = [ "foo"; "bar"; "baz" ]and vals = [ 16384; 32768; 65536 ]and hash = Hashtbl.create 0;; List.iter2 (Hashtbl.add hash) keys vals;;`

The solution is similar with arrays.

`let keys = [| "foo"; "bar"; "baz" |]and vals = [| 16384; 32768; 65536 |]and hash = Hashtbl.create 0;; Array.iter2 (Hashtbl.add hash) keys vals;;`

In either case, an exception is raised if the inputs are different lengths.

If you want to use functional binary search trees instead of hash tables:

`module StringMap = Map.Make (String);; let keys = [ "foo"; "bar"; "baz" ]and vals = [ 16384; 32768; 65536 ]and map = StringMap.empty;; let map = List.fold_right2 StringMap.add keys vals map;;`

## ooRexx

`array1 = .array~of("Rick", "Mike", "David")array2 = .array~of("555-9862", "555-5309", "555-6666") -- if the index items are constrained to string objects, this can-- be a directory too.hash = .table~new loop i = 1 to array1~size    hash[array1[i]] = array2[i]endSay 'Enter a name'Parse Pull nameSay name '->' hash[name]`
Output:
```Enter a name
Rick
Rick -> 555-9862```

## Oz

`declare  fun {ZipRecord Keys Values}     {List.toRecord unit {List.zip Keys Values MakePair}}  end   fun {MakePair A B}     A#B  endin  {Show {ZipRecord [a b c] [1 2 3]}}`

## PARI/GP

`hash(key, value)=Map(matrix(#key,2,x,y,if(y==1,key[x],value[x])));`

## Pascal

Works with: Free_Pascal
Library: contnrs
`program HashFromTwoArrays (Output); uses  contnrs; var  keys:   array[1..3] of string  = ('a', 'b', 'c');  values: array[1..3] of integer = ( 1,   2,   3 );  hash:   TFPDataHashTable;  i:      integer; begin  hash := TFPDataHashTable.Create;  for i := low(keys) to high(keys) do    hash.add(keys[i], @values[i]);  writeln ('Length of hash table: ', hash.Count);  hash.Destroy;end.`
Output:
```% ./HashFromTwoArrays
Length of hash table: 3
```

## Perl

`my @keys = qw(a b c);my @vals = (1, 2, 3);my %hash;@hash{@keys} = @vals;`
Alternatively, using :
`use List::MoreUtils qw(zip);my %hash = zip @keys, @vals;`

## Phix

You could of course make the values in the dictionary be indexes to valuearray instead, as shown commented out.

```with javascript_semantics
function make_hash(sequence keyarray, sequence valuearray)
integer dict = new_dict()
for i=1 to length(keyarray) do
setd(keyarray[i],valuearray[i],dict)
--      setd(keyarray[i],i,dict)
end for
return dict
end function

constant keyarray   = {1,"two",PI}
constant valuearray = {"one",2,PI}
integer dict = make_hash(keyarray,valuearray)
?getd(1,dict)
?getd("two",dict)
?getd(PI,dict)
--?valuearray[getd(1,dict)]
```
Output:
```"one"
2
3.141592654
```

## Phixmonti

`include ..\Utilitys.pmt def getd    /# array key -- array data #/    swap 1 get rot find nip    dup if        swap 2 get rot get nip    else        drop "Unfound"    endifenddef ( ( 1 "two" PI ) ( "one" 2 PI ) )   /# keys / data #/ 1 getd print nl"two" getd print nlPI getd tostr print nl3 getd print`
Output:
```one
2
3.141592653589793
Unfound
```

## PHP

Works with: PHP version 5
`\$keys = array('a', 'b', 'c');\$values = array(1, 2, 3);\$hash = array_combine(\$keys, \$values);`
Works with: PHP version 4
`\$keys = array('a', 'b', 'c');\$values = array(1, 2, 3);\$hash = array();for (\$idx = 0; \$idx < count(\$keys); \$idx++) {  \$hash[\$keys[\$idx]] = \$values[\$idx];}`

## Picat

`go =>  A = [a,b,c,d,e],  B = [1,2,3,4,5],  Map = new_map([K=V : {K,V} in zip(A,B)]),  println(Map).`
Output:
`(map)[d = 4,c = 3,b = 2,a = 1,e = 5]`

## PicoLisp

`(let (Keys '(one two three)  Values (1 2 3))   (mapc println      (mapcar cons Keys Values) ) )`
Output:
```(one . 1)
(two . 2)
(three . 3)```

## Pike

Any data type can be used as indices (keys) and values.

` array indices = ({ "a", "b", 42 });array values  = ({ Image.Color(0,0,0), "hello", "world" });mapping m = mkmapping( indices, values );write("%O\n", m); `
Output:
```([ /* 3 elements */
"a": Image.Color.black,
"b": "hello"
42: "world",
])
```

## Pop11

`vars keys = { 1 a b c};vars vals = { 2 3 valb valc};vars i;;;; Create hash tablevars ht = newmapping([], 500, 0, true);;;; Loop over input arrays (vectors)for i from 1 to length(keys) do  vals(i) -> ht(keys(i));endfor;`

## PostScript

Library: initlib
` % push our arrays [/a /b /c /d /e] [1 2 3 4 5] % create a dict with it{aload pop} dip let currentdict end% show that we have created the hash {= =} forall `

## PowerShell

`function create_hash ([array] \$keys, [array] \$values) {    \$h = @{}    if (\$keys.Length -ne \$values.Length) {        Write-Error -Message "Array lengths do not match" `                    -Category InvalidData `                    -TargetObject \$values    } else {        for (\$i = 0; \$i -lt \$keys.Length; \$i++) {            \$h[\$keys[\$i]] = \$values[\$i]        }    }    return \$h}`

## Prolog

`% this one with side effect hash table creation :-dynamic hash/2. make_hash([],[]).make_hash([H|Q],[H1|Q1]):-	assert(hash(H,H1)),	make_hash(Q,Q1). :-make_hash([un,deux,trois],[[a,b,c],[d,e,f],[g,h,i]])  % this one without side effects  make_hash_pure([],[],[]).make_hash_pure([H|Q],[H1|Q1],[hash(H,H1)|R]):-	make_hash_pure(Q,Q1,R). :-make_hash_pure([un,deux,trois],[[a,b,c],[d,e,f],[g,h,i]],L),findall(M,(member(M,L),assert(M)),L).`

## PureBasic

`Dim keys.s(3)Dim vals.s(3)NewMap Hash.s() keys(0)="a" : keys(1)="b" : keys(2)="c" : keys(3)="d" vals(0)="1" : vals(1)="2" : vals(2)="3" : vals(3)="4" For n = 0 To 3    Hash(keys(n))= vals(n)NextForEach Hash()   Debug Hash()Next`

## Python

Works with: Python version 3.0+ and 2.7

Shows off the dict comprehensions in Python 3 (that were back-ported to 2.7):

`keys = ['a', 'b', 'c']values = [1, 2, 3]hash = {key: value for key, value in zip(keys, values)}`
Works with: Python version 2.2+
`keys = ['a', 'b', 'c']values = [1, 2, 3]hash = dict(zip(keys, values)) # Lazily, Python 2.3+, not 3.x:from itertools import iziphash = dict(izip(keys, values))`
Works with: Python version 2.0+
`keys = ['a', 'b', 'c']values = [1, 2, 3]hash = {}for k,v in zip(keys, values):    hash[k] = v`

The original (Ruby) example uses a range of different types as keys. Here is similar in python (run at the shell):

`>>> class Hashable(object):	def __hash__(self):		return id(self) ^ 0xBEEF  >>> my_inst = Hashable()>>> my_int = 1>>> my_complex = 0 + 1j>>> my_float = 1.2>>> my_string = "Spam">>> my_bool = True>>> my_unicode = u'Ham'>>> my_list = ['a', 7]>>> my_tuple = ( 0.0, 1.4 )>>> my_set = set(my_list)>>> def my_func():	pass >>> class my_class(object):	pass >>> keys = [my_inst, my_tuple, my_int, my_complex, my_float, my_string,	my_bool, my_unicode, frozenset(my_set), tuple(my_list),	my_func, my_class]>>> values = range(12)>>> d = dict(zip(keys, values))>>> for key, value in d.items(): print key, ":", value 1 : 61j : 3Ham : 7Spam : 5(0.0, 1.3999999999999999) : 1frozenset(['a', 7]) : 81.2 : 4('a', 7) : 9<function my_func at 0x0128E7B0> : 10<class '__main__.my_class'> : 11<__main__.Hashable object at 0x012AFC50> : 0>>> # Notice that the key "True" disappeared, and its value got associated with the key "1">>> # This is because 1 == True in Python, and dictionaries cannot have two equal keys`

## R

Assuming that the keys are coercible to character form, we can simply use the names attribute to create a hash. This example is taken from the Wikipedia page on hash tables.

`# Set up hash tablekeys <- c("John Smith", "Lisa Smith", "Sam Doe", "Sandra Dee", "Ted Baker")values <- c(152, 1, 254, 152, 153)names(values) <- keys# Get value corresponding to a keyvalues["Sam Doe"]                          # vals["Sam Doe"]# Get all keys corresponding to a valuenames(values)[values==152]                 # "John Smith" "Sandra Dee"`

## Racket

` (make-hash (map cons '("a" "b" "c" "d") '(1 2 3 4)))`

Alternatively:

` (define (connect keys vals)  (for/hash ([k keys] [v vals]) (values k v)));; Example:(connect #("a" "b" "c" "d") #(1 2 3 4)) `

## Raku

(formerly Perl 6)

Using the "zipwith" meta-operator on the => pair composer:

Works with: rakudo version 2018.03
`my @keys = <a b c d e>;my @values = ^5; my %hash = @keys Z=> @values;  #Alternatively, by assigning to a hash slice:%hash{@keys} = @values;  # Or to create an anonymous hash:%( @keys Z=> @values );  # All of these zip forms trim the result to the length of the shorter of their two input lists.# If you wish to enforce equal lengths, you can use a strict hyperoperator instead: quietly # suppress warnings about unused hash{ @keys »=>« @values };  # Will fail if the lists differ in length`

## Raven

`[ 'a' 'b' 'c' ] as \$keys [ 1 2 3 ] as \$vals\$keys \$vals combine as \$hash`

## REXX

This REXX version allows multiple keys for a value,   the keys are case sensitive.

`/*REXX program demonstrates  hashing  of a  stemmed array  (from a key or multiple keys)*/key.=                                            /*names of the nine regular polygons.  */vals= 'triangle quadrilateral pentagon hexagon heptagon octagon nonagon decagon dodecagon'key.1='thuhree  vour          phive    sicks   zeaven   ate     nein    den     duzun'key.2='three    four          five     six     seven    eight   nine    ten     twelve'key.3='3        4             5        6       7        8       9       10      12'key.4='III      IV            V        VI      VII      VIII    IX      X       XII'key.5='iii      iv            v        vi      vii      viii    ix      x       xii'hash.='───(not defined)───'                      /* [↑]  blanks added to humorous keys  */                                                 /*      just because it looks prettier.*/      do k=1  while key.k\==''      call hash vals,key.k                       /*hash the   keys   to the   values.   */      end   /*k*/ parse arg query .                                /*obtain what was specified on the C.L.*/if query\==''  then say 'key:'   left(query,40)   "value:"   hash.queryexit                                             /*stick a fork in it,  we're all done. *//*──────────────────────────────────────────────────────────────────────────────────────*/hash: parse arg @val,@key                do j=1  for words(@key);          map= word(@key, j)                                             hash.map= word(@val, j)                end   /*j*/      return`
output   when using the input value of:     phive
```key: phive                                    value: pentagon
```
output   when using the input value of:     dingsta
```key: dingsta                                  value: ───(not defined)───
```

## Ring

` # Project : Hash from two arrays list1="one two three" list2="1 2 3"a = str2list(substr(list1," ",nl))b = str2list(substr(list2," ",nl))c = list(len(a))for i=1 to len(b)      temp = number(b[i])     c[temp] = a[i]next for i = 1 to len(c)     see c[i] + " " + i + nlnext `

Output:

```one 1
two 2
three 3
```

## Ruby

` keys = ['hal',666,[1,2,3]]vals = ['ibm','devil',123] hash = Hash[keys.zip(vals)] p hash  # => {"hal"=>"ibm", 666=>"devil", [1, 2, 3]=>123} #retrieve the value linked to the key [1,2,3]puts hash[ [1,2,3] ]  # => 123 `

In Ruby 2.1 the method "to_h" was introduced:

`keys = ['hal', 666, [1,2,3]]vals = ['ibm', 'devil', 123] keys.zip(vals).to_h`

## Rust

`use std::collections::HashMap; fn main() {    let keys = ["a", "b", "c"];    let values = [1, 2, 3];     let hash = keys.iter().zip(values.iter()).collect::<HashMap<_, _>>();    println!("{:?}", hash);}`

## Sather

`class ZIPPER{K,E} is  zip(k:ARRAY{K}, e:ARRAY{E}) :MAP{K, E}     pre k.size = e.size  is    m :MAP{K, E} := #;    loop m[k.elt!] := e.elt!; end;    return m;      end;end; class MAIN is   main is    keys:ARRAY{STR} := |"one", "three", "four"|;    values:ARRAY{INT} := |1, 3, 4|;    m ::= ZIPPER{STR,INT}::zip(keys, values);    loop       #OUT + m.pair! + " ";     end;    #OUT + "\n";  end; end;`

## Scala

`val keys = List(1, 2, 3)val values = Array("A", "B", "C") // Array mixed with Listval map = keys.zip(values).toMap  // and other Seq are possible. // Testingassert(map == Map(1 ->"A", 2 -> "B", 3 -> "C"))println("Successfully completed without errors.")`

## Scheme

### Using SRFI 69

`(define (lists->hash-table keys values . rest)  (apply alist->hash-table (map cons keys values) rest))`

### Using association lists

`;; Using SRFI-1, R6RS, or R7RS association lists. ;; Because the task calls for ‘arrays’, I start with actual arrays;; rather than lists.(define array1 (vector "a" "b" "c" "d"))(define array2 (vector 1 2 3 4)) ;; Making the hash is just a simple list operation.(define dictionary (map cons (vector->list array1)                        (vector->list array2))) ;; Now you can look up associations with assoc.(write (assoc "b" dictionary)) (newline)(write (assoc "d" dictionary)) (newline) ;; USING CHICKEN 5 SCHEME, OUTPUT FROM EITHER;; ‘csc -R srfi-1 thisprog.scm && ./thisprog’;; OR ‘csc -R r7rs thisprog.scm && ./thisprog’,;; AND ALSO TESTED IN CHEZ SCHEME (R6RS):;;;; ("b" . 2);; ("d" . 4);;`

### Using persistent associative arrays

You need to compile this code along with the persistent associative arrays code. And, yes, the hash function for that implementation can return floating point numbers, the way the one here does.

`(import (associative-arrays)) ;; Because the task calls for ‘arrays’, I start with actual arrays;; rather than lists.(define array1 (vector "a" "b" "c" "d"))(define array2 (vector 1 2 3 4)) (define (silly-hashfunc s)  (define h 1234)  (do ((i 0 (+ i 1)))      ((= i (string-length s)))    (set! h (+ h (char->integer (string-ref s i)))))  (sqrt (/ (* h 101) 9.80665))) ;; Here is the making of the associative array:(define dictionary (assoc-array silly-hashfunc))(vector-for-each (lambda (key data)                   (set! dictionary                     (assoc-array-set dictionary key data)))                 array1 array2) (display "Looking up \"b\" and \"d\": ")(write (assoc-array-ref dictionary "b"))(display " ")(write (assoc-array-ref dictionary "d"))(newline) ;; Output:;;;;   Looking up "b" and "d": 2 4;;`

Side note: association lists can be used in either a persistent or non-persistent manner.

## Seed7

`\$ include "seed7_05.s7i"; const type: numericHash is hash [string] integer;var numericHash: myHash is numericHash.value; const proc: main is func  local    var array string: keyList is [] ("one", "two", "three");    var array integer: valueList is [] (1, 2, 3);    var integer: number is 0;  begin    for number range 1 to length(keyList) do      myHash @:= [keyList[number]] valueList[number];    end for;  end func;`

## SenseTalk

` set keyList to ["red", "green", "blue"]set valueList to [150,0,128] repeat with n=1 to the number of items in keyList	set map.(item n of keyList) to item n of valueListend repeat put map--> (blue:"128", green:"0", red:"150")  `

## Sidef

`var keys = %w(a b c)var vals = [1, 2, 3] var hash = Hash()hash{keys...} = vals...say hash`

## Smalltalk

Works with: GNU Smalltalk
`Array extend [  dictionaryWithValues: array [ |d|    d := Dictionary new.    1 to: ((self size) min: (array size)) do: [:i|      d at: (self at: i) put: (array at: i).    ].    ^ d  ]].  ({ 'red' . 'one' . 'two' }  dictionaryWithValues: { '#ff0000'. 1. 2 }) displayNl.`
Works with: Smalltalk/X
`Dictionary     withKeys:#('one' 'two' 'three')    andValues:#('eins' 'zwei' 'drei')`
Works with: Smalltalk/X
`Dictionary withAssociations:{ 'one'->1 . 'two'->2 . 'three'->3 }`

## SNOBOL4

Works with: Macro Spitbol
Works with: Snobol4+
Works with: CSnobol
`*       # Fill arrays        keys = array(5); vals = array(5)        ks = 'ABCDE'; vs = '12345'kloop   i = i + 1; ks len(1) . keys<i> = :s(kloop)vloop   j = j + 1; vs len(1) . vals<j> = :s(vloop) *       # Create hash        hash = table(5)hloop   k = k + 1; hash<keys<k>> = vals<k> :s(hloop) *       # Test and display        ts = 'ABCDE'tloop   ts len(1) . ch = :f(out)        str = str ch ':' hash<ch> ' ' :(tloop)out     output = strend`
Output:
`A:1 B:2 C:3 D:4 E:5`

## Sparkling

`let keys = { "foo", "bar", "baz" };let vals = { 13, 37, 42 };var hash = {};for var i = 0; i < sizeof keys; i++ {    hash[keys[i]] = vals[i];}`

## Standard ML

Works with: SML/NJ

Using functional binary search trees instead of hash tables:

`structure StringMap = BinaryMapFn (struct                                     type ord_key = string                                     val compare = String.compare                                   end); val keys = [ "foo", "bar", "baz" ]and vals = [ 16384, 32768, 65536 ]and myMap = StringMap.empty; val myMap = foldl StringMap.insert' myMap (ListPair.zipEq (keys, vals));`
Works with: SML/NJ

Using hash tables:

`exception NotFound; val keys = [ "foo", "bar", "baz" ]and vals = [ 16384, 32768, 65536 ]and hash = HashTable.mkTable (HashString.hashString, op=) (42, NotFound); ListPair.appEq (HashTable.insert hash) (keys, vals);`

## Swift

Works with: Swift version 1.2+
`let keys = ["a","b","c"]let vals = [1,2,3]var hash = [String: Int]()for (key, val) in zip(keys, vals) {  hash[key] = val}`

## Tcl

Arrays in Tcl are automatically associative, i.e. there are no "not hashed arrays".
If we can take "arrays of equal length" to mean "lists of equal length", then the task might look like this:

`set keys   [list fred bob joe]set values [list barber plumber tailor]array set arr {}foreach a \$keys b \$values { set arr(\$a) \$b } parray arr`
Output:
```arr(bob)  = plumber
arr(fred) = barber
arr(joe)  = tailor
```

Alternatively, a dictionary could be used:

`package require Tcl 8.5 set keys   [list fred bob joe]set values [list barber plumber tailor] foreach a \$keys b \$values {    dict set jobs \$a \$b} puts "jobs: [dict get \$jobs]"`
Output:
```jobs: fred barber bob plumber joe tailor
```

## TXR

### One-liner, using quasiquoted hash syntax

`\$ txr -p  '^#H(() ,*[zip #(a b c) #(1 2 3)])))'#H(() (c 3) (b 2) (a 1))`

### One-liner, using `hash-construct` function

`\$ txr -p  '(hash-construct nil [zip #(a b c) #(1 2 3)])))'#H(() (c 3) (b 2) (a 1))`

### Explicit construction and stuffing

`(defun hash-from-two (vec1 vec2 . hash-args)  (let ((table (hash . hash-args)))    (mapcar (do sethash table) vec1 vec2)    table)) (prinl (hash-from-two #(a b c) #(1 2 3)))`
```\$ ./txr hash-from-two.tl
#H(() (c 3) (b 2) (a 1))```

## UNIX Shell

Works with: Bash version 4
`keys=( foo bar baz )values=( 123 456 789 )declare -A hash for (( i = 0; i < \${#keys[@]}; i++ )); do  hash["\${keys[i]}"]=\${values[i]}done for key in "\${!hash[@]}"; do  printf "%s => %s\n" "\$key" "\${hash[\$key]}"done`
Output:
```bar => 456
baz => 789
foo => 123```

## UnixPipes

Using a sorted file as an associative array (see Creating an associative array for usage.)

`cat <<VAL >p.valuesappleboycowdogelephantVAL cat <<KEYS >p.keysabcdeKEYS paste -d\   <(cat p.values | sort) <(cat p.keys | sort)`

## Ursala

There is a built-in operator for this.

`keys   = <'foo','bar','baz'>values = <12354,145430,76748> hash_function = keys-\$values`

test program:

`#cast %nL test = hash_function* <'bar','baz','foo','bar'>`
Output:
`<145430,76748,12354,145430>`

## Vala

Library: Gee
` using Gee; void main(){    // mostly copied from C# example                                                var hashmap = new HashMap<string, string>();     string[] arg_keys = {"foo", "bar", "val"};    string[] arg_values = {"little", "miss", "muffet"};     if (arg_keys.length	== arg_values.length ){	for (int i = 0;	i < arg_keys.length; i++){            hashmap[arg_keys[i]] = arg_values[i];	}    }} `

## VBScript

VBScript (and Visual Basic in general) calls hashes "dictionary objects".

`Set dict = CreateObject("Scripting.Dictionary")os = Array("Windows", "Linux", "MacOS")owner = Array("Microsoft", "Linus Torvalds", "Apple")For n = 0 To 2    dict.Add os(n), owner(n)NextMsgBox dict.Item("Linux")MsgBox dict.Item("MacOS")MsgBox dict.Item("Windows")`
Output:
(in message boxes):
```Linus Torvalds
Apple
Microsoft
```

## Visual Basic

Translation of: VBScript

The VBScript version can be used in Visual Basic unchanged, although it requires a reference to the Microsoft Scripting Runtime (scrrun.dll).

Alternately, instead of a `Dictionary` object, you can also use a `Collection` object, which serves a similar purpose, without the inclusion of an additional runtime library. In fact, the only immediately-obvious difference between this and the VBScript example is `dict`'s data type, and the order that the arguments are passed to the `Add` method.

`Dim dict As New Collectionos = Array("Windows", "Linux", "MacOS")owner = Array("Microsoft", "Linus Torvalds", "Apple")For n = 0 To 2    dict.Add owner(n), os(n)NextDebug.Print dict.Item("Linux")Debug.Print dict.Item("MacOS")Debug.Print dict.Item("Windows")`

## WDTE

`let a => import 'arrays';let s => import 'stream'; let toScope keys vals =>    s.zip (a.stream keys) (a.stream vals)    ->        s.reduce (collect (true)) (@ r scope kv =>            let [k v] => kv;            set scope k v;        )    ;`

Example:

`toScope    ['a'; 'b'; 'c']    [1; 2; 3]    : scope-> known-> a.stream-> s.map (@ m k => [k; at scope k])-> s.collect-- io.writeln io.stdout;`
Output:
`[[a; 1]; [b; 2]; [c; 3]]`

## Vlang

`fn main() {    keys := ["a", "b", "c"]    vals := [1, 2, 3]    mut hash := map[string]int{}    for i, key in keys {        hash[key] = vals[i]    }    println(hash)}`
Output:
```{'a': 1, 'b': 2, 'c': 3}
```

## Wortel

Wortel has an inbuilt operator to do this: `@hash`.

`@hash ["a" "b" "c"] [1 2 3] ; returns {a 1 b 2 c 3}`

This function can also be defined as:

`^(@obj @zip)`

Example:

`@let {  hash ^(@obj @zip)  !!hash ["a" "b" "c"] [1 2 3]}`
Returns:
`{a 1 b 2 c 3}`

## Wren

Wren's built-in Map class does not guarantee (as here) that iteration order will be the same as the order in which elements were added.

`var keys = [1, 2, 3, 4, 5]var values = ["first", "second", "third", "fourth","fifth"]var hash = {}(0..4).each { |i| hash[keys[i]] = values[i] }System.print(hash)`
Output:
```{2: second, 1: first, 3: third, 5: fifth, 4: fourth}
```

## zkl

`keys:=T("a","b","c","d"); vals:=T(1,2,3,4);d:=keys.zip(vals).toDictionary();d.println();d["b"].println();`
Output:
```D(a:1,b:2,c:3,d:4)
2
```