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>

=={{header|Diego}}==

Diego has in-built <code>hash</code> and <code>dict</code> (short for 'dictionary') objects which function the same, except <code>hash</code> can only accept uuid datatypes for keys. Diego also has <code>hash_</code> verb and <code>_hash</code> posit, used to hash an object/command.

add_ary(keysDict)_values(a,b,c);

add_hash(aHash)_hash[valsDict]; // Keys will be new uuids

Arrays can manually be mapped from two arrays using a <code>_for</code> posit, for instance:

add_dict(bDict);

;

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

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.

f(.hash, .key, .value) more .hash, h{.key: .value},

h{}, w/a b c d/, [1, 2, 3, 4],

)

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

=={{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<_, _>>();