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.

Ada

Compiler: GNAT GPL 2007

with Ada.Containers.Ordered_Maps;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Ada.Text_IO;

procedure Associative_Array is
   
   -- Instantiate the generic package Ada.Containers.Ordered_Maps

   package Associative_Int is new Ada.Containers.Ordered_Maps(Unbounded_String, Integer);
   use Associative_Int;
  
   Color_Map : Map;
   Color_Cursor : Cursor;
   Success : Boolean;
   Value : Integer;
begin

   -- Add values to the ordered map

   Color_Map.Insert(To_Unbounded_String("Red"), 10, Color_Cursor, Success);
   Color_Map.Insert(To_Unbounded_String("Blue"), 20, Color_Cursor, Success);
   Color_Map.Insert(To_Unbounded_String("Yellow"), 5, Color_Cursor, Success);

   -- retrieve values from the ordered map and print the value and key
   -- to the screen

   Value := Color_Map.Element(To_Unbounded_String("Red"));
   Ada.Text_Io.Put_Line("Red:" & Integer'Image(Value));
   Value := Color_Map.Element(To_Unbounded_String("Blue"));
   Ada.Text_IO.Put_Line("Blue:" & Integer'Image(Value));
   Value := Color_Map.Element(To_Unbounded_String("Yellow"));
   Ada.Text_IO.Put_Line("Yellow:" & Integer'Image(Value));
end 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);

E

[].asMap()                             # immutable, empty
["one" => 1, "two" => 2]               # immutable, 2 mappings
[].asMap().diverge()                   # mutable, empty
["one" => 2].diverge(String, float64)  # mutable, initial contents, 
                                       #   typed (coerces to float)

Groovy

Create an empty map and add values

 map = [:]
 map[7] = 7
 map['foo'] = 'foovalue'
 map.put('bar', 'barvalue')
 map.moo = 'moovalue'

 assert 7 == map[7]
 assert 'foovalue' == map.foo
 assert 'barvalue' == map['bar']
 assert 'moovalue' == map.get('moo')

Create a pre-populated map and verify values

 map = [7:7, foo:'foovalue', bar:'barvalue', moo:'moovalue']

 assert 7 == map[7]
 assert 'foovalue' == map.foo
 assert 'barvalue' == map['bar']
 assert 'moovalue' == map.get('moo')

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

You can use a NSDictionary to create a immutable hash. A dictionary can contain only objects; if you want store non objects like integer, you have to box it in NSNumber.

NSDictionary *dict = [NSDictionary dictionaryWithObjectsAndKeys:
    @"Joe Doe", @"name",
    [NSNumber numberWithUnsignedInt:42], @"age",
    [NSNull null], @"extra",
    nil];

To create a mutable dictionary, use NSMutableDictionary:

NSMutableDictionary *dict = [NSMutableDictionary dictionary];
[dict setObject:@"Joe Doe" forKey:@"name"];
[dict setObject:[NSNumber numberWithInt:42] forKey:@"age"];

Accessing values:

NSString *name = [dict objectForKey:@"name"];
unsigned age = [[dict objectForKey:@"age"] unsignedIntValue];

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";
 }

Pop11

;;; Create expandable hash table of initial size 50 and with default
;;; value 0 (default value is returned when the item is absent).
vars ht = newmapping([], 50, 0, true);
;;; Set value corresponding to string 'foo'
12 -> ht('foo');
;;; print it
ht('foo') =>
;;; Set value corresponding to vector {1 2 3}
17 -> ht({1 2 3});
;;; print it
ht({1 2 3}) =>
;;; Set value corresponding to number 42 to vector {0 1}
{0 1} -> ht(42);
;;; print it
ht(42) =>

;;; Iterate over keys printing keys and values.  
 appproperty(ht,
    procedure (key, value);
      printf(value, '%p\t');
      printf(key, '%p\n');
    endprocedure);

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

Toka

Toka provides associative arrays via a library.

needs asarray

( create an associative array )
1024 cells is-asarray foo

( store 100 as the "first" element in the array )
100 " first" foo asarray.put

( store 200 as the "second" element in the array )
200 " second" foo asarray.put

( obtain and print the values )
" first" foo asarray.get .
" second" foo asarray.get .