Hash from two arrays: Difference between revisions

 

 

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

three 3

two 2

 

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

& ;

<pre>apple.fruit

three.3

 

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

 

 

 

 

 

=={{header|E}}==

 

def values := [1, 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|Go}}==

 

import "fmt"

}

fmt.Println(hash)

{{out}}

<pre>

=={{header|Groovy}}==

 

keys.eachWithIndex { key, i ->

hash[key] = vals[i]

 

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

local t = {}

for i=1, #keys do

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

end

 

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

 

->Hash[1]=one

->Hash[2]=two

 

=={{header|NetRexx}}==

* 04.11.2012 Walter Pachl derived from REXX

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

Say ' 'keys

Parse Ask z

 

 

 

=={{header|Objeck}}==

 

use Structure;

 

}

}

 

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

 

 

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

<pre>% ./HashFromTwoArrays

Length of hash table: 3

 

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

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

 

=={{header|Raven}}==

 

 

=={{header|REXX}}==

 

</pre>

 

=={{header|Ruby}}==

 

 

p hash # => {"hal"=>"ibm", 666=>"devil", [1, 2, 3]=>123}

 

#retrieve the value linked to the key [1,2,3]

 

 

 

 

 

=={{header|Sather}}==

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

pre k.size = e.size

end;

 

 

=={{header|Scala}}==

 

=={{header|Scheme}}==

 

=={{header|Seed7}}==

 

 

const type: numericHash is hash [string] integer;

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

end for;

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

 

dictionaryWithValues: array [ |d|

d := Dictionary new.

 

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

 

=={{header|SNOBOL4}}==

{{works with|CSnobol}}

 

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

ks = 'ABCDE'; vs = '12345'

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

out output = str

 

<pre>A:1 B:2 C:3 D:4 E:5</pre>

 

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

 

set values [list barber plumber tailor]

array set arr {}

dict set jobs $a $b

 

=={{header|TXR}}==

 

 

 

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

 

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

 

Linus Torvalds

Apple

{{trans|VBScript}}

 

 

 

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

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

Debug.Print dict.Item("Linux")

Debug.Print dict.Item("MacOS")