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>

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

 (setf my-hash (make-hash-table))
 (setf (gethash "H2O" my-hash) "Water")
 (setf (gethash "HCl" my-hash) "Hydrochloric Acid")
 (setf (gethash "CO" my-hash) "Carbon Monoxide")

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

Lua

Lua tables are Hashes

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

Returns nil on unknown key.

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');

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

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'

Iterate over key/value

 foreach($array as $key => $value)
 {
    echo('Key: '.$key.' Value: '.$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);

Python

In Python, hashes are called dictionaries.

 # 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'

SmallTalk

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