Hash from two arrays: Difference between revisions

{{trans|Python}}

 

V values = [1, 2, 3]

V hash_ = Dict(zip(keys, values))

 

=={{header|ActionScript}}==

{

public class MyClass

}

}

 

=={{header|Ada}}==

{{works with|GNAT|GPL 2007}}

with Ada.Containers.Hashed_Maps;

with Ada.Text_Io;

end loop;

 

=={{header|Amazing Hopper}}==

Example:

#!/usr/bin/hopper

#include <hopper.h>

pause

exit(0)

Output:

<pre>Longitud HASH: 3

(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}

#define println {"\n"}print

 

 

=={{header|Argile}}==

{{works with|Argile|1.1.0}}

 

let keys = @["hexadecimal" "decimal" "octal" "binary"]

for each val int i from 0 to 3

hash[keys[i]] = values[i]

 

=={{header|Arturo}}==

{{out}}

 

=={{header|AutoHotkey}}==

array2 := [2, 3, "fruit"]

hash := {}

Loop % array1.maxIndex()

hash[array1[A_Index]] := array2[A_Index]

 

=={{header|AWK}}==

Awk arrays are used for both lists and hash maps.

<!-- http://ideone.com/MsdNUc -->

BEGIN {

if(!list1) list1="one two three"

for(i in c) print i,c[i]

 

{{out}}

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

{{works with|BBC BASIC for Windows}}

DIM array2$(4) : array2$() = "zero", "one", "two", "three", "four"

IF I% = 0 THEN = "" ELSE I% += LEN(key$) + 2

J% = INSTR(dict$, CHR$(0), I%)

 

=={{header|Bracmat}}==

& 2 3 fruit:?arr2

& new$hash:?H

& (H..forall)$out

& ;

{{out}}

<pre>apple.fruit

 

=={{header|Brat}}==

h = [:]

keys.each_with_index { key, index |

}

 

 

=={{header|C}}==

following implementation tries to be somewhat generic to facilitate using alternative key and

value types.

#include <stdlib.h>

#include <string.h>

}

return 0;

 

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

===C# 1.0===

{

static void Main()

}

}

 

<code>Hashtable.Add</code> 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:

 

===Modern===

<code>Enumerable.Zip</code> truncates the longer of its arguments.

 

 

static class Program

.ToDictionary(keySelector: kv => kv.k, elementSelector: kv => kv.v);

}

 

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

#include <string>

 

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

hash[ keys[i] ] = vals[i] ;

 

{{libheader|range-v3}}

#include <unordered_map>

#include <string>

std::unordered_map<std::string, std::string> hash(ranges::view::zip(keys, vals));

}

 

=={{header|Ceylon}}==

value keys = [1, 2, 3];

value items = ['a', 'b', 'c'];

value hash = map(zipEntries(keys, items));

 

=={{header|Clojure}}==

 

=={{header|Coco}}==

values = <[red yellow orange purple]>

 

object = new

 

=={{header|CoffeeScript}}==

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

values = [1,2,3]

map = {}

map[key] = values[i] for key, i in keys

 

=={{header|ColdFusion}}==

function makeHash(keyArray, valueArray) {

var x = 1;

valueArray = [1, 2, 3];

map = makeHash(keyArray, valueArray);

 

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

 

(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)

 

Or, using cl:loop:

 

(loop initially (assert (= (length vector-1) (length vector-2)))

with table = (make-hash-table :test test :size (length vector-1))

for v across vector-2

do (setf (gethash k table) v)

 

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

=={{header|Crystal}}==

 

vals = (1..26).to_a # => 1, 2, 3 ... 26

 

hash = Hash.zip(keys, vals)

 

<pre>

 

=={{header|D}}==

import std.array, std.range;

 

immutable hash = ["a", "b", "c"].zip([1, 2, 3]).assocArray;

 

=={{header|Déjà Vu}}==

local :h_values [ 1 2 3 ]

local :h {}

for item in h_keys:

set-to h item pop-from h_values

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

{{libheader| System.Generics.Collections}}

program Hash_from_two_arrays;

 

end.

 

{{out}}

<pre>

c 3

</pre>

=={{header|E}}==

 

def values := [1, 2, 3]

 

=={{header|EchoLisp}}==

(lib 'hash)

 

(hash-ref H 'elvis)

→ "the king"

 

=={{header|Elixir}}==

[:one, :two, :three]

iex(2)> values = [1, 2, 3]

[1, 2, 3]

iex(3)> Enum.zip(keys, values) |> Enum.into(Map.new)

 

=={{header|Erlang}}==

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

 

=={{header|F Sharp|F#}}==

 

=={{header|Factor}}==

 

=={{header|Falcon}}==

keys = [ 'a', 'b', 'c', 'd' ]

values = [ 1, 2, 3, 4 ]

hash = [ => ]

for i in [ 0 : keys.len() ]: hash[ keys[ i ] ] = values[ i ]

 

=={{header|Fantom}}==

 

class Main

{

}

}

 

 

=={{header|FreeBASIC}}==

Dim As String values(1 To 5) = {"one", "two", "three", "four", "five"}

Dim As String hash(Lbound(keys) To Ubound(keys))

Print keys(i); " "; hash(i)'; " "; i

Next i

{{out}}

<pre> 1 one

=={{header|Frink}}==

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

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

 

=={{header|Gambas}}==

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

Dim sValue As String[] = ["Zero", "One", "Two", "Three", "Four", "Five"]

Dim sKey As String[] = [0, 1, 2, 3, 4, 5]

Next

 

Output:

<pre>

 

=={{header|Go}}==

 

import "fmt"

}

fmt.Println(hash)

{{out}}

<pre>

=={{header|Groovy}}==

 

def vals = ['aaa', 'bbb', 'ccc']

def hash = [:]

keys.eachWithIndex { key, i ->

hash[key] = vals[i]

 

Alternative Version:

 

Test:

 

=={{header|Harbour}}==

LOCAL hash := { => }

LOCAL i, j

FOR EACH i, j IN arr1, arr2

hash[ i ] := j

 

=={{header|Haskell}}==

{{works with|GHC|GHCi|6.6}}

 

 

makeMap ks vs = fromList $ zip ks vs

 

=={{header|Huginn}}==

 

main() {

values = ['a', 'b', 'c'];

hash = materialize( zip( key, values ), lookup );

 

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

 

procedure main(arglist) #: demonstrate hash from 2 lists

 

write(ximage(T)) # show result

 

=={{header|Ioke}}==

 

=={{header|J}}==

 

'''Solution:'''

'''For example:'''

 

vals=: > ;:'zero one two three four five six seven eight nine'

hash=: vals {~ keys&i.

six

seven

Here,<code> keys </code>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<code> vals </code>is a 10 by 5 character matrix.

 

=={{header|Java}}==

public static void main(String[] args){

String[] keys= {"a", "b", "c"};

hash.put(keys[i], vals[i]);

}

 

=={{header|JavaScript}}==

 

===Iterative===

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

var values = [1, 2, 3];

map[ keys[i] ] = values[i];

}

 

===Iterative Using Foreach===

function arrToObj(keys, vals) {

var map = {};

return map;

}

 

===Using Reduce===

function arrToObj(keys, vals) {

return keys.reduce(function(map, key, index) {

}, {});

}

 

=={{header|jq}}==

jq only supports hashing of strings. In the following, accordingly, we assume that

one array (keys) is an array of strings.

# and values taken from the input array in turn.

# "keys" must be an array of strings.

( {}; . + { (keys[$i]) : $values[$i] });

 

{{Out}}

{

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

"1": 10,

"2": 20,

"3": 30

 

=={{header|Jsish}}==

From Javascript.

function hashTwo(k:array, v:array):object {

var hash = {};

hashTwo([], []) ==> {}

=!EXPECTEND!=

{{out}}

<pre>prompt$ jsish -u hashTwo.jsi

 

'''Using comprehension''':

v = [1, 2, 3]

 

 

'''Using constructor''':

 

'''Specifying types''':

 

=={{header|K}}==

The keys in a dictionary must be a symbol.

b: 0 1 2

 

 

d[`one]

 

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

 

split:{1_'(&x=y)_ x:y,x}

vals:split["zero one two three four five six seven eight nine";" "]

 

$d[s 1] / leading "$" converts back to string

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

val hash = mapOf(*names.zip(ages).toTypedArray())

hash.forEach { println("${it.key.padEnd(6)} aged ${it.value}") }

 

{{out}}

 

=={{header|Lang5}}==

 

=={{header|langur}}==

=== the easy way ===

 

 

=== a longer way ===

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

)

 

 

{{out}}

 

=={{header|Lasso}}==

array1 = array('a', 'b', 'c'),

array2 = array(1, 2, 3),

}

 

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

 

=={{header|LFE}}==

(vals (list '"foo data" '"bar data" '"baz data"))

(tuples (: lists zipwith

(my-dict (: dict from_list tuples)))

(: io format '"fetched data: ~p~n" (list (: dict fetch 'baz my-dict))))

 

=={{header|Lingo}}==

values = [1,2,3]

 

 

put props

 

=={{header|LiveCode}}==

put 10,20,30 into list2

split list1 using comma

 

-- ouput

 

=={{header|Lua}}==

local t = {}

for i=1, #keys do

t[keys[i]] = values[i]

end

 

=={{header|M2000 Interpreter}}==

Module CheckAll {

Module CheckVectorType {

}

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$()) {

}

Checkit

 

=={{header|Maple}}==

B := ["one", "two", three"];

 

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

Transpose[{{1, 2, 3}, {"one", "two", "three"}}]]

 

->Hash[1]=one

->Hash[2]=two

 

=={{header|MATLAB}} / {{header|Octave}}==

See [[Associative arrays/Creation#MATLAB_.2F_Octave|Associative arrays/Creation]] for clarification of limitations and differences between the two methods.

===MATLAB/Octave: structs===

% allKeys must be cell array of strings of valid field-names

% allVals can be cell array or array of numbers

end

end

{{out}}

<pre>>> ages = StructFromArrays({'Joe' 'Bob' 'Sue'}, [21 35 27])

 

=={{header|MiniScript}}==

values = ["little", "miss", "muffet"]

 

end for

 

{{out}}

<pre>{"bar": "miss", "foo": "little", "val": "muffet"}</pre>

 

=={{header|Neko}}==

<doc><h2>Hash from two arrays, in Neko</h2></doc>

**/

*/

var show = function(k, v) $print("Hashed key: ", sprintf("%10d", k), " Value: ", v, "\n")

 

{{out}}

 

=={{header|Nemerle}}==

using System.Console;

using Nemerle.Collections;

WriteLine("{0}: {1}", item.Key, item.Value);

}

 

=={{header|NetRexx}}==

=== REXX Style ===

{{trans|REXX}}

* 04.11.2012 Walter Pachl derived from REXX

**********************************************************************/

Say ' 'keys

Parse Ask z

 

=== Java Collections ===

NetRexx has access to Java's Collection objects too.

options replace format comments java crossref symbols nobinary

 

 

return

 

=={{header|Nim}}==

 

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

let values = @[1, 2, 3]

 

 

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

Works with oo2c version 2

MODULE HashFromArrays;

IMPORT

Do;

END HashFromArrays.

 

=={{header|Objeck}}==

 

use Structure;

 

}

}

 

=={{header|Objective-C}}==

 

NSArray *values = @[@1, @2, @3];

 

=={{header|OCaml}}==

The idiomatic solution uses lists rather than arrays.

 

and vals = [ 16384; 32768; 65536 ]

and hash = Hashtbl.create 0;;

 

 

The solution is similar with arrays.

 

and vals = [| 16384; 32768; 65536 |]

and hash = Hashtbl.create 0;;

 

 

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:

 

 

let keys = [ "foo"; "bar"; "baz" ]

and map = StringMap.empty;;

 

 

=={{header|ooRexx}}==

array2 = .array~of("555-9862", "555-5309", "555-6666")

 

Say 'Enter a name'

Parse Pull name

{{out}}

<pre>Enter a name

 

=={{header|Oz}}==

fun {ZipRecord Keys Values}

{List.toRecord unit {List.zip Keys Values MakePair}}

end

in

 

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

 

 

=={{header|Pascal}}==

{{works with|Free_Pascal}}

{{libheader|contnrs}}

 

uses

writeln ('Length of hash table: ', hash.Count);

hash.Destroy;

{{out}}

<pre>% ./HashFromTwoArrays

 

=={{header|Perl}}==

my @vals = (1, 2, 3);

my %hash;

 

Alternatively, using {{libheader|List::MoreUtils}}:

 

 

=={{header|Phix}}==

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

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">make_hash</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">keyarray</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">sequence</span> <span style="color: #000000;">valuearray</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">getd</span><span style="color: #0000FF;">(</span><span style="color: #004600;">PI</span><span style="color: #0000FF;">,</span><span style="color: #000000;">dict</span><span style="color: #0000FF;">)</span>

<span style="color: #000080;font-style:italic;">--?valuearray[getd(1,dict)]</span>

{{out}}

<pre>

 

=={{header|Phixmonti}}==

 

def getd /# array key -- array data #/

"two" getd print nl

PI getd tostr print nl

{{out}}

<pre>

=={{header|PHP}}==

{{works with|PHP|5}}

$values = array(1, 2, 3);

 

{{works with|PHP|4}}

$values = array(1, 2, 3);

$hash = array();

for ($idx = 0; $idx < count($keys); $idx++) {

$hash[$keys[$idx]] = $values[$idx];

 

=={{header|Picat}}==

A = [a,b,c,d,e],

B = [1,2,3,4,5],

Map = new_map([K=V : {K,V} in zip(A,B)]),

 

{{out}}

 

=={{header|PicoLisp}}==

(mapc println

{{out}}

<pre>(one . 1)

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

{{Out}}

<pre>

=={{header|Pop11}}==

 

vars vals = { 2 3 valb valc};

vars i;

for i from 1 to length(keys) do

vals(i) -> ht(keys(i));

 

=={{header|PostScript}}==

{{libheader|initlib}}

% push our arrays

[/a /b /c /d /e] [1 2 3 4 5]

% show that we have created the hash

{= =} forall

 

=={{header|PowerShell}}==

$h = @{}

if ($keys.Length -ne $values.Length) {

}

return $h

 

=={{header|Prolog}}==

 

 

:-dynamic hash/2.

make_hash_pure(Q,Q1,R).

 

 

=={{header|PureBasic}}==

Dim vals.s(3)

NewMap Hash.s()

ForEach Hash()

Debug Hash()

 

=={{header|Python}}==

{{works with|Python|3.0+ and 2.7}}

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

values = [1, 2, 3]

 

{{works with|Python|2.2+}}

values = [1, 2, 3]

hash = dict(zip(keys, values))

# Lazily, Python 2.3+, not 3.x:

from itertools import izip

 

{{works with|Python|2.0+}}

values = [1, 2, 3]

hash = {}

for k,v in zip(keys, values):

 

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

def __hash__(self):

return id(self) ^ 0xBEEF

<__main__.Hashable object at 0x012AFC50> : 0

>>> # Notice that the key "True" disappeared, and its value got associated with the key "1"

 

=={{header|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 [[wp:Hash_table#Separate_chaining|Wikipedia page on hash tables]].

keys <- c("John Smith", "Lisa Smith", "Sam Doe", "Sandra Dee", "Ted Baker")

values <- c(152, 1, 254, 152, 153)

values["Sam Doe"] # vals["Sam Doe"]

# Get all keys corresponding to a value

 

=={{header|Racket}}==

 

Alternatively:

(define (connect keys vals) (for/hash ([k keys] [v vals]) (values k v)))

;; Example:

(connect #("a" "b" "c" "d") #(1 2 3 4))

 

=={{header|Raku}}==

 

{{works with|rakudo|2018.03}}

my @values = ^5;

 

 

quietly # suppress warnings about unused hash

 

=={{header|Raven}}==

 

 

=={{header|REXX}}==

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

key.= /*names of the nine regular polygons. */

vals= 'triangle quadrilateral pentagon hexagon heptagon octagon nonagon decagon dodecagon'

hash.map= word(@val, j)

end /*j*/

{{out|output|text=&nbsp; when using the input value of: &nbsp; &nbsp; <tt> phive </tt>}}

<pre>

 

=={{header|Ring}}==

# Project : Hash from two arrays

 

see c[i] + " " + i + nl

next

Output:

<pre>

two 2

three 3

</pre>

 

=={{header|Ruby}}==

keys = ['hal',666,[1,2,3]]

vals = ['ibm','devil',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:

vals = ['ibm', 'devil', 123]

 

 

=={{header|Rust}}==

 

fn main() {

let hash = keys.iter().zip(values.iter()).collect::<HashMap<_, _>>();

println!("{:?}", hash);

 

=={{header|Sather}}==

zip(k:ARRAY{K}, e:ARRAY{E}) :MAP{K, E}

pre k.size = e.size

end;

 

 

=={{header|Scala}}==

val values = Array("A", "B", "C") // Array mixed with List

val map = keys.zip(values).toMap // and other Seq are possible.

// Testing

assert(map == Map(1 ->"A", 2 -> "B", 3 -> "C"))

 

=={{header|Scheme}}==

=== Using [http://srfi.schemers.org/srfi-69/srfi-69.html SRFI 69] ===

 

=== Using association lists ===

 

;; Because the task calls for ‘arrays’, I start with actual arrays

;; ("b" . 2)

;; ("d" . 4)

 

=== Using [[Associative_array/Creation#A_persistent_associative_array_from_scratch|''persistent'' associative arrays]] ===

You need to compile this code along with the [[Associative_array/Creation#A_persistent_associative_array_from_scratch|persistent associative arrays]] code. And, yes, the hash function for that implementation ''can'' return floating point numbers, the way the one here does.

 

 

;; Because the task calls for ‘arrays’, I start with actual arrays

;;

;; Looking up "b" and "d": 2 4

 

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

=={{header|Seed7}}==

 

 

const type: numericHash is hash [string] integer;

myHash @:= [keyList[number]] valueList[number];

end for;

 

=={{header|SenseTalk}}==

set keyList to ["red", "green", "blue"]

set valueList to [150,0,128]

--> (blue:"128", green:"0", red:"150")

 

 

=={{header|Sidef}}==

var vals = [1, 2, 3]

 

var hash = Hash()

hash{keys...} = vals...

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

 

dictionaryWithValues: array [ |d|

d := Dictionary new.

 

({ 'red' . 'one' . 'two' }

 

{{works with|Smalltalk/X}}

{{works with|VisualWorks Smalltalk}}

withKeys:#('one' 'two' 'three')

 

{{works with|Smalltalk/X}}

 

=={{header|SNOBOL4}}==

{{works with|CSnobol}}

 

keys = array(5); vals = array(5)

ks = 'ABCDE'; vs = '12345'

str = str ch ':' hash<ch> ' ' :(tloop)

out output = str

 

{{out}}

 

=={{header|Sparkling}}==

let vals = { 13, 37, 42 };

var hash = {};

for var i = 0; i < sizeof keys; i++ {

hash[keys[i]] = vals[i];

 

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

Using functional binary search trees instead of hash tables:

 

type ord_key = string

val compare = String.compare

and myMap = StringMap.empty;

 

 

{{works with|SML/NJ}}

Using hash tables:

 

 

val keys = [ "foo", "bar", "baz" ]

and hash = HashTable.mkTable (HashString.hashString, op=) (42, NotFound);

 

 

=={{header|Swift}}==

{{works with|Swift|1.2+}}

let vals = [1,2,3]

var hash = [String: Int]()

for (key, val) in zip(keys, vals) {

hash[key] = val

 

=={{header|Tcl}}==

"<i>lists</i> of equal length",

then the task might look like this:

set values [list barber plumber tailor]

array set arr {}

foreach a $keys b $values { set arr($a) $b }

 

{{out}}

<pre>

 

Alternatively, a dictionary could be used: <!-- http://ideone.com/6lI4k5 -->

set keys [list fred bob joe]

}

{{out}}

<pre>

===One-liner, using quasiquoted hash syntax===

 

 

===One-liner, using <code>hash-construct</code> function===

 

 

===Explicit construction and stuffing===

 

(let ((table (hash . hash-args)))

(mapcar (do sethash table) vec1 vec2)

table))

 

 

<pre>$ ./txr hash-from-two.tl

=={{header|UNIX Shell}}==

{{works with|Bash|4}}

values=( 123 456 789 )

declare -A hash

for key in "${!hash[@]}"; do

printf "%s => %s\n" "$key" "${hash[$key]}"

 

{{out}}

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

 

apple

boy

KEYS

 

 

=={{header|Ursala}}==

There is a built-in operator for this.

values = <12354,145430,76748>

 

test program:

 

{{out}}

<pre><145430,76748,12354,145430></pre>

=={{header|Vala}}==

{{libheader|Gee}}

using Gee;

 

}

}

 

=={{header|VBScript}}==

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

 

os = Array("Windows", "Linux", "MacOS")

owner = Array("Microsoft", "Linus Torvalds", "Apple")

MsgBox dict.Item("Linux")

MsgBox dict.Item("MacOS")

 

{{out}} (in message boxes):

and the order that the arguments are passed to the <code>Add</code> method.

 

os = Array("Windows", "Linux", "MacOS")

owner = Array("Microsoft", "Linus Torvalds", "Apple")

Debug.Print dict.Item("Linux")

Debug.Print dict.Item("MacOS")

 

=={{header|WDTE}}==

let s => import 'stream';

 

set scope k v;

)

 

'''Example:'''

 

['a'; 'b'; 'c']

[1; 2; 3]

-> s.collect

-- io.writeln io.stdout

 

{{out}}

<pre>[[a; 1]; [b; 2]; [c; 3]]</pre>

 

keys := ["a", "b", "c"]

vals := [1, 2, 3]

}

println(hash)

{{out}}

<pre>

=={{header|Wortel}}==

Wortel has an inbuilt operator to do this: <code>@hash</code>.

This function can also be defined as:

Example:

hash ^(@obj @zip)

!!hash ["a" "b" "c"] [1 2 3]

{{out|Returns}}

<pre>{a 1 b 2 c 3}</pre>

=={{header|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 values = ["first", "second", "third", "fourth","fifth"]

var hash = {}

(0..4).each { |i| hash[keys[i]] = values[i] }

 

{{out}}

{2: second, 1: first, 3: third, 5: fifth, 4: fourth}

</pre>

 

=={{header|zkl}}==

d:=keys.zip(vals).toDictionary();

d.println();

{{out}}

<pre>D(a:1,b:2,c:3,d:4)