Hash from two arrays: Difference between revisions

{{omit from|BASIC}} <!-- Does not have hash tables or other map structures. -->

{{omit from|PowerBASIC}}

{{omit from|TI-89 BASIC}}

 

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)

 

 

=={{header|ActionScript}}==

{

public class MyClass

}

}

 

=={{header|Ada}}==

{{works with|GNAT|GPL 2007}}

with Ada.Containers.Hashed_Maps;

with Ada.Text_Io;

end loop;

 

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

 

def values := [1, 2, 3]

 

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

 

=={{header|Java}}==

public static void main(String[] args){

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

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

}

 

=={{header|JavaScript}}==

 

var values = [1, 2, 3];

var map = {};

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

 

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

 

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

local t = {}

for i=1, #keys do

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

end

 

=={{header|Maple}}==

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

 

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

 

[35] [21] [27]</pre>

 

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

 

 

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

let values = @[1, 2, 3]

 

 

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

 

 

 

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

 

hash[array1[i]] = array2[i]

end

=={{header|Oz}}==

fun {ZipRecord Keys Values}

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

end

in

 

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

(mapc println

{{out}}

<pre>(one . 1)

(two . 2)

(three . 3)</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|Raven}}==

 

 

=={{header|REXX}}==

 

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

 

 

 

 

 

 

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

 

=={{header|Seed7}}==

 

 

const type: numericHash is hash [string] integer;

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

end for;

 

=={{header|Sidef}}==

 

 

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

let vals = [1,2,3]

var hash = [String: Int]()

hash[key] = val

 

=={{header|Tcl}}==

 

set values [list barber plumber tailor]

array set arr {}

dict set jobs $a $b

 

=={{header|TXR}}==

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

 

 

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

 

 

===Explicit construction and stuffing===

 

 

 

#H(() (c 3) (b 2) (a 1))</pre>

 

=={{header|UnixPipes}}==

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

 

apple

boy

KEYS

 

 

=={{header|Ursala}}==

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

{{trans|VBScript}}

 

 

 

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

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

Debug.Print dict.Item("Linux")

Debug.Print dict.Item("MacOS")

 

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

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

 

=={{header|zkl}}==

d.println();

{{out}}

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