Associative array/Creation

Associative array/Creation
You are encouraged to solve this task according to the task description, using any language you may know.

In this task, the goal is to create an associative array.

C++

Compiler: g++ 4.0.2

 #include <map>
 #include <string>
 #include <iostream>
 #include <ostream>
 
 int main()
 {
   // This is an associative array which maps strings to ints
   typedef std::map<std::string, int> colormap_t;
   colormap_t colormap;
   
   // First, populate it with some values
   colormap["red"] = 0xff0000;
   colormap["green"] = 0x00ff00;
   colormap["blue"] = 0x0000ff;
   colormap["my favourite color"] = 0x00ffff;
   
   // then, get some values out
   int color = colormap["green"]; // color gets 0x00ff00
   color = colormap["black"]; // accessing unassigned values assigns them to 0
   
   // get some value out without accidentally inserting new ones
   colormap_t::iterator i = colormap.find("green");
   if (i == colormap.end())
   {
     std::cerr << "color not found!\n";
   }
   else
   {
     color = i->second;
   }
   
   // Now I changed my mind about my favourite color, so change it
   colormap["my favourite color"] = 0x337733;
   
   // print out all defined colors
   for (colormap_t::iterator i = colormap.begin(); i != colormap.end(); ++i)
     std::cerr << "colormap[\"" << i->first << "\"] = 0x" << std::hex << i->second << "\n";
 }

A simpler example which only creates the array and assigns a value.

Compiler: g++ 4.0.2

#include <map>
#include <string>

int
main( int argc, char* argv[] )
{
 std::map< std::string, std::string > hash ;
 
 hash[ "key-1" ] = "val1" ;
}

C#

Platform: .NET 1.x

 System.Collections.HashTable map = new System.Collections.HashTable();
 map["key1"] = "foo";

Platform: .NET 2.0

 Dictionary<string, string> map = new Dictionary<string,string>();
 map[ "key1" ] = "foo";

ColdFusion

 <cfset myHash = structNew()>
 <cfset myHash.key1 = "foo">
 <cfset myHash["key2"] = "bar">
 <cfset myHash.put("key3","java-style")>

In ColdFusion, a map is literally a java.util.HashMap, thus the above 3rd method is possible.

Common Lisp

 ;; default :test is #'eql, which is suitable for numbers only,
 ;; or for implementation identity for other types!
 ;; Use #'equalp if you want case-insensitive keying on strings.

 (setf my-hash (make-hash-table :test #'equal))
 (setf (gethash "H2O" my-hash) "Water")
 (setf (gethash "HCl" my-hash) "Hydrochloric Acid")
 (setf (gethash "CO" my-hash) "Carbon Monoxide")

D

int[char[]] hash;
hash["foo"] = 42;
hash["bar"] = 100;
assert("foo" in hash);

Haskell

Interpreter: GHCi

import Data.Map

dict = fromList [("key1","val1"), ("key2","val2")]

Java

Defining a Map

 Map<String, Integer> map = new HashMap<String, Integer>();
 map.put("foo", 5);
 map.put("bar", 10);
 map.put("baz", 15);

Retreiving a value

 map.get("foo") // => 5
 map.get("invalid") // => null

Iterate over keys

 for (String key: map.keySet()) 
    System.out.println(key);

Iterate over values

  for (int value: map.values())
     System.out.println(value);

Iterate over key,values

  for (Map.Entry<String, Integer> entry: map.entrySet())
     System.out.println(entry.getKey() + " => " + entry.getValue());

JavaScript

In Javascript we make an associative array from an empty object, otherwise if we make it from an array we'll get all the Array object's method and properties when we iterate over it

 var assoc = {};
 assoc['foo'] = 'bar';
 assoc['another-key'] = 3;
 assoc.thirdKey = 'we can also do this!';
 for(key in assoc)
 {
   alert('key:"'+key+'", value:"'+assoc[key]+'"');
 }

The above associative array can also be constructed using Javascript's object literal syntax

 var assoc = {
   foo:'bar',
   'another-key':3, //the key can either be enclosed by quotes or not
   thirdKey = 'we can also do this!'
 };

Lua

Lua tables are Hashes

 hash = {}
 hash[ "key-1" ] = "val1"
 hash[ "key-2" ] = 1
 hash[ "key-3" ] = {}

Returns nil on unknown key.

Objective-C

Compiler: gcc

In Objective C, you will use the NSMutableDictionary class to create a hash. To map to an integer, you will also need to make use of the NSNumber class.

 NSMutableDictionary *dict = [[NSMutableDictionary alloc] init];
 	
 [dict setObject:[NSNumber numberWithInt:2] forKey:@"Two"];
 [dict setObject:[NSNumber numberWithInt:7] forKey:@"Seven"];
 	
 int two = [[dict objectForKey:@"Two"] intValue];
 int seven = [[dict objectForKey:@"Seven"] intValue];
 	
 NSLog( @"%d, %d", two, seven );

OCaml

A simple idiom to create a hash table mapping strings to integers:

 let hash = Hashtbl.create 0;;
 List.iter (fun (key, value) -> Hashtbl.add hash key value)
   ["foo", 5; "bar", 10; "baz", 15];;

To retrieve a value:

 let bar = Hashtbl.find hash "bar";; (* bar = 5 *)

To retrieve a value, returning a default if the key is not found:

 let quux = try Hashtbl.find hash "quux" with Not_found -> some_value;;

Perl

Interpeter: Perl

Defining a Hash

# using => key does not need to be quoted unless it contains special chars
my %hash = (
  key1 => 'val1',
  'key-2' => 2,
  three => -238.83,
  4 => 'val3',
);

# using , both key and value need to be quoted if containing something non-numeric in nature
my %hash = (
  'key1', 'val1',
  'key-2', 2,
  'three', -238.83,
  4, 'val3',
);

Defining a HashRef

my $hashref = {
  key1 => 'val1',
  'key-2' => 2,
  three => -238.83,
  4 => 'val3',
}

Using a Hash

print $hash{'key1'};

$hash{'key1'} = 'val1';

@hash{'key1', 'three'} = ('val1', -238.83);

Using a HashRef

print $hash->{'key1'};

$hash->{'key1'} = 'val1';

@hash->{'key1', 'three'} = ('val1', -238.83);

PHP

 $array = array();
 $array['foo'] = 'bar';
 $array['bar'] = 'foo';
 
 echo($array['foo']); // bar
 echo($array['moo']); // Undefined index

 //alternative (inline) way
 $array2 = array('fruit'=>'apple, 'price'=>12.96, 'colour'=>'green');

Iterate over key/value

 foreach($array as $key => $value)
 {
    echo('Key: '.$key.' Value: '.$value);
 }

Python

Hashes are a built-in type called dictionaries (or mappings) in Python.

 hash = dict()  # 'dict' is the dictionary type.
 hash = dict(red="FF0000", green="00FF00", blue="0000FF")
 hash = { 'key1':1, 'key2':2, }
 value = hash[key]

Numerous methods exist for the mapping type http://docs.python.org/lib/typesmapping.html

 # empty dictionary
 d = {}
 d['spam'] = 1
 d['eggs'] = 2  

 # dictionaries with two keys
 d1 = {'spam': 1, 'eggs': 2}
 d2 = dict(spam=1, eggs=2)

 # dictionaries from tuple list
 d1 = dict([('spam', 1), ('eggs', 2)])
 d2 = dict(zip(['spam', 'eggs'], [1, 2]))

 # iterating over keys
 for key in d:
   print key, d[key]

 # iterating over (key, value) pairs
 for key, value in d.iteritems():
   print key, value

Create a generic mapping function that applys a callback to elements in a list:

Ruby

A hash object that returns nil for unknown keys

 hash={}
 hash[666]='devil'
 hash[777]  # => nil
 hash[666]  # => 'devil'

A hash object that returns 'unknown key' for unknown keys

 hash=Hash.new('unknown key')
 hash[666]='devil'
 hash[777]  # => 'unknown key'
 hash[666]  # => 'devil'

A hash object that returns "unknown key #{key}" for unknown keys

 hash=Hash.new{|h,k|h[k]="unknown key #{k}"}
 hash[666]='devil'
 hash[777]  # => 'unknown key 777'
 hash[666]  # => 'devil'

Scala

 // immutable maps
 var map = Map(1 -> 2, 3 -> 4, 5 -> 6)
 map(3) // 4
 map = map + (44 -> 99) // maps are immutable, so we have to assign the result of adding elements
 map.isDefinedAt(33) // false
 map.isDefinedAt(44) // true

 // mutable maps (HashSets)
 import scala.collection.mutable.HashMap
 val hash = new HashMap[int, int]
 hash + (1 -> 2)
 hash + (3 -> 4, 5 -> 6, 44 -> 99)
 hash(44) // 99
 hash.isDefinedAt(33) // false
 hash.isDefinedAt(44) // true

 // iterate over key/value
 hash.foreach {k => Console.println("key "+k._1+" value "+k._2)} // k is a 2 element Tuple

 // remove items where the key is <= 3
 map.filter {k => k._1 > 3} //  Map(5 -> 6, 44 -> 99)

Smalltalk

 "Tested with Dolphin Smalltalk"
 states := Dictionary new.
 states at: 'MI' put: 'Michigan'.
 states at: 'MN' put: 'Minnesota'.

Tcl

All arrays in Tcl are associative.

 # Create one element at a time:
 set hash(foo) 5

 # Create in bulk:
 array set hash {
   foo 5
   bar 10
   baz 15
 }

 # Access one element:
 set value $hash(foo)

 # Output all values:
 foreach key [array names hash] {
   puts $hash($key)
 }