Collections
You are encouraged to solve this task according to the task description, using any language you may know.
Collections are abstractions to represent sets of values. In strongly-typed languages, the values are typically of a common data type.
Create a collection, and add a few values to it.
C++
C++ has a range of different collections optimized for different use cases. Note that in C++, objects of user-defined types are mostly treated just like objects of built-in types; especially there's no different treatment for copllections. Thus all collections can simply be demonstrated with the built-in type int. For user-defined types, just replace int with the user-defined type. Any type which goes into a collection must be copyable and assignable (which in general is automatically the case unless you explicitly disallow it).
Note however that C++ collections store copies of the objects given to them, so you'll lose any polymorphic behaviour. If you need polymorphism, use a collection of pointers (or smart pointers like boost::shared_ptr).
vector
A vector is basically a resizeable array. It is optimized for adding/removing elements on the end, and fast access to elements anywhere. Inserting elements at the beginning or in the middle is possible, but in general inefficient.
#include <vector> std::vector<int> v; // empty vector v.push_back(5); // insert a 5 at the end v.insert(v.begin(), 7); // insert a 7 at the beginning
deque
A deque is optimized for appending and removing elements on both ends ofd the array. Accessing random elements is still efficient, but slightly less than with vector.
#include <deque> std::deque<int> d; // empty deque d.push_back(5); // insert a 5 at the end d.push_front(7); // insert a 7 at the beginning d.insert(v.begin()+1, 6); // insert a 6 in the middle
list
A list is optimized for insertion at an arbitrary place (provided you already have an iterator pointing to that place). Element access is efficient only in linear order.
#include <list> std::list<int> l; // empty list l.push_back(5); // insert a 5 at the end l.push_front(7); // insert a 7 at the beginning std::list::iterator i = l.begin(); ++l; l.insert(i, 6); // insert a 6 in the middle
set
A set keeps the inserted elements sorted, and also makes sure that each element occurs only once. Of course, if you want to put something into a set, it must be less-than-comparable, i.e. you must be able to compare which of two objects a and b is smaller using a<b (there's also a way to define sets with an user-defined order, in which case this restriction doesn't apply).
#include <set> std::set<int> s; // empty set s.insert(5); // insert a 5 s.insert(7); // insert a 7 (automatically placed after the 5) s.insert(5); // try to insert another 5 (will not change the set)
multiset
A multiset is like a set, except the same element may occur multiple times.
#include <multiset> std::multiset<int> m; // empty multiset m.insert(5); // insert a 5 m.insert(7); // insert a 7 (automatically placed after the 5) m.insert(5); // insert a second 5 (now m contains two 5s, followed by one 7)
E
E has both mutable and immutable builtin collections; the common types are list (array), map (hash table), and set (hash table). This interactive session shows mutable lists and immutable collections of all three types.
? def constList := [1,2,3,4,5] # value: [1, 2, 3, 4, 5] ? constList.with(6) # value: [1, 2, 3, 4, 5, 6] ? def flexList := constList.diverge() # value: [1, 2, 3, 4, 5].diverge() ? flexList.push(6) ? flexList # value: [1, 2, 3, 4, 5, 6].diverge() ? constList # value: [1, 2, 3, 4, 5]
? def constMap := [1 => 2, 3 => 4] # value: [1 => 2, 3 => 4] ? constMap[1] # value: 2
? def constSet := [1, 2, 3, 2].asSet() # value: [1, 2, 3].asSet() ? constSet.contains(3) # value: true
Java
ArrayList arrayList = new ArrayList(); arrayList.add(new Integer(0)); /*other features of ArrayList*/ //define the type in the arraylist, you can substitute a proprietary class in the "<>" private ArrayList<int> myarrlist; int i; int sum; myarrlist = new ArrayList<int>(); //add several values to the arraylist to be summed later for(i=0; i<10; i++) { myarrlist.add(i); }
//loop through myarrlist to sum each entry for(i=0; i<myarrlist.size(); i++) { sum+=myarrlist.get(i); } //or for(int i:myarrlist){ sum+= i; }
//remove the last entry in the ArrayList myarrlist.remove(myarrlist.size()-1)
//clear the ArrayList myarrlist.clear();
JavaScript
var array = []; array.push('abc'); array.push(123); array.push(new MyClass); alert( array[2] );
var map = {}; map['foo'] = 'xyz'; //equivalent to: map.foo = 'xyz'; map['bar'] = new MyClass; //equivalent to: map.bar = new MyClass; map['1x; ~~:-b'] = 'text'; //no equivalent alert( map['1x; ~~:-b'] );
Lua
Lua has only one type of collection, the table.
collection = {0, '1'}
collection = {["foo"] = 0, ["bar"] = '1'} -- a collection of key/value pairs
Objective-C
Compiler: gcc
The NSMutableArray class in Objective C provides a simple, editable array data structure.
NSMutableArray *array = [[NSMutableArray alloc] init]; [array addObject:@"String1"]; [array addObject:@"String2"]; [array insertObject:@"String3" atIndex:1]; NSLog( @"%@, %@, %@", [array lastObject], [array objectAtIndex:0], [array objectAtIndex:1] ); // prints: String2, String1, String3
Perl
Interpreter: Perl
Collections are just lists. Thus, you can use list functions to manipulate them and store them in arrays.
my @c = (IO::File->new, IO::File->new); # start collection with two objects push @c, IO::File->new; # add another object to the collection
PHP
$students = array(); array_push($students, array('name' => 'Joe Smith', 'age' => 21, height=> '72.5', gpa => 3.42 ));
Python
Interpreter: Python 2.5
Python supports lists, tuples, and dictionaries as built-in collection types. See http://docs.python.org/tut/node7.html for further details.
collection = [0, '1'] # Lists are mutable (editable) and can be sorted in place x = collection[0] # accessing an item (which happens to be a numeric 0 (zero) collection.append(2) # adding something to the end of the list collection.insert(0, '-1') # inserting a value into the beginning y = collection[0] # now returns a string of "-1" collection.extend([2,'3']) # same as [collection.append(i) for i in [2,'3']] ... but faster collection[2:6] # a "slice" (collection of the list elements from the third up to but not including the sixth) len(collection) # get the length of (number of elements in) the collection collection = (0, 1) # Tuples are immutable (not editable) collection[:] # ... slices work on these too; and this is equivalent to collection[0:len(collection)] collection[-4:-1] # negative slices count from the end of the string collection[::2] # slices can also specify a stride --- this returns all even elements of the collection collection="some string" # strings are treated as sequences of characters x = collection[::-1] # slice with negative step returns reversed sequence (string in this case). collection[::2] == "some string"[::2] # True, literal objects don't need to be bound to name/variable to access slices or object methods collection.__getitem__(slice(0,len(collection),2)) # same as previous expressions. collection = {0: "zero", 1: "one"} # Dictionaries (Hash) collection['zero'] = 2 # Dictionary members accessed using same syntax as list/array indexes. collection = set([0, '1']) # sets (Hash)
In addition Python classes support a number of methods allowing them to implement indexing, slicing, and attribute management features as collections. Thus many modules in the Python standard libraries allow one to treat files contents, databases, and other data using the same syntax as the native collection types. Some Python modules (such as Numeric and NumPy) provide low-level implementations of additional collections (such as efficient n-dimensional arrays).
Raven
Numerically indexed List:
[ 1 2 3 'abc' ] as a_list a_list print
list (4 items) 0 => 1 1 => 2 2 => 3 3 => "abc"
String key indexed Hash:
{ 'a' 1 'b' 2 } as a_hash a_hash print
hash (2 items) a => 1 b => 2
Set items:
17 a_list 1 set # set second item 42 a_hash 'b' set # set item with key 'b' 42 a_hash:b # shorthand
Get items:
a_list 1 get # get second item a_hash 'b' get # get item with key 'b' a_hash.b # shorthand
Other stuff:
42 a_list push # append an item a_list pop # remove last item 42 a_list shove # prepend an item a_list shift # remove first item 42 a_list 1 insert # insert item second, shuffling others down a_list 1 remove # retrieve second item, shuffling others up
Ruby
Ruby is a 100% object oriented language, so you can use the default Array or Hash structures as collection objects.
Scala
val l = List(1,2,3,4,-1,-2,-4) l.filter{0<} // get the positive values List(1,2,3,4) l.head // 1 -- first element l.tail // List(2,3,4,-1,-2,-4) -- the rest of the list l.take(3) // List(1,2,3) -- the first 3 elements in the list l.drop(4) // List(-1,-2,-4) -- get rid of the first 4 element in the list 88 :: l.tail // List(88,2,3,4,-1,-2,-4) l.take(2) ::: 18 :: l.takeRight(2) // List(1,2,18,-2,-4)
Smalltalk
| collection | collection := #(1 2 3 4 5) asOrderedCollection. collection add: $a; add: $b. collection remove: $a. collection removeIndex: 2.