Assigning Values to an Array

Assigning Values to an Array
You are encouraged to solve this task according to the task description, using any language you may know.

This task has been flagged for clarification. Code on this page in its current state may be flagged incorrect once this task has been clarified. See this page's Talk page for discussion.

In this task, the goal is to assign a value to an element of an array. The value should only replace an existing value, and not insert a new key should the key not exist. If the key does not exist, an error should be returned.

ActionScript

arr[0] = 1;
arr[1] = 'a';
arr[2] = 5.678;

Ada

Compiler: GCC 4.1.2

  package Pkg is
     type Arr is array (Positive range <>) of Integer;
     procedure Assign (Value : Integer; To : in out Arr; Index : Positive);
     --  Raise exception Constraint_Error if Index > To'Last
  end Pkg;
  package body Pkg is
     procedure Assign (Value : Integer; To : in out Arr; Index : Positive) is
     begin
        To (Index) := Value;
     end Assign;
  end Pkg;

AppleScript

on writeToArray(array, location, value)
    -- very important -- list index starts at 1 not 0
    set item location of array to value
    return array
end writeToArray

C

Compiler: GCC 4.1.1

int writeToIntArray(int *array, size_t array_sz, int loc, int val)
{
  // Check bounds on array
  if (loc > array_sz || loc < 0)
    return -1;
  array[loc] = val;
  return 0;
}

C#

Platform: .NET Language Version: 1.0+

  public void WriteToIntArray(int[] array, int loc, int val){  array[loc]=val;  }

C++

Compiler: GCC 4.1.2

  template<class T>
  inline int writeToArray(T array[], size_t loc, const T& val)
  {
    if (loc > sizeof(array))
      return -1; // Could throw an execption if so desired
    array[loc] = val;
    return 0;
  }

Compiler: Visual C++ 2005

  template<class C>
  inline void writeToArray(C& container, typename C::size_type loc, const typename C::value_type& val)
  {
    std::fill_n(container.begin() + loc, 1, val);
  }

ColdFusion

 <cffunction name="writeToArray">
   <cfargument name="array">
   <cfargument name="location">
   <cfargument name="value">
   <cfif arrayLen(arguments.array) GTE arguments.location>
     <cfset arguments.array[arguments.location] = arguments.value>
   <cfelse>
     <cfthrow message="Location does not exist">
   </cfif>
   <cfreturn arguments.array>
 </cffunction>
 
 <cfset myArray = arrayNew(1)>
 <cfset myArray[1] = 1>
 <cfset myArray = writeToArray(myArray, 1, 123456)>

Note that throwing errors in ColdFusion doesn't give that "friendly" appearance. The standard way to change/add a value in an array would be simply:

 <cfset myArray[3] = 987654>

Common Lisp

  (defun assign-to-array (array index value)
    (setf (aref array index) value))

Delphi

  procedure WriteToIntArray(var Arr: array of Integer; Loc: Integer; Val: Integer);
  begin
    Arr[Loc] := Val;
  end;

Forth

Interpreter: ANS Forth

  : ]! ( n addr ix -- ) cells + ! ; \ ex. 3 buffer[ 2 ]!

Haskell

Compiler: GHC 6.6

List

Most Haskell programs use lists instead of arrays. This is suitable for the general case.

Simple Version

setIndex
    :: [a] -- Original list
    -> Int -- Index to insert at
    -> a -- Value to insert
    -> [a] -- Resulting list
setIndex xs ii v = 
    let
        (h, (_ : ts)) = splitAt ii xs
    in
        h ++ (v : ts)

Efficient Version

setIndex xs ii v
    | ii < 0 = error "Bad index"
    | otherwise = _setIndex xs ii v
    where
        _setIndex [] _ _ = error "Bad index"
        _setIndex (_ : xs) 0 v = v : xs
        _setIndex (x : xs) ii v = x : (setIndex xs (ii - 1) v)

Array

Technically, this creates clones the original array, then updates the new array; the original array still exists. This applies a list of changes to the array.

import Data.Array

-- Create the array of data
a1 = array (0, 4) [(ii, ii * 2) | ii <- [0 .. 4]]

-- Update 1 entry
a2 = a1 // [(2, 12)]
-- Update several entries
a3 = a1 // [(ii, ii + 10) | ii <- [1 .. 3]]

Java

Platform: J2SE 1.2+

  public void writeToIntArray(int[] array, int loc, int val){  array[loc]=val;  }

JavaScript

  function writeToArray(array, loc, val) { array[loc] = val; }

Unfortunately, this will add an element if it did not already exist.

mIRC Scripting Language

Interpreter: mIRC Library: mArray Snippet

 alias write2array { echo -a $array_write(MyArray, 2, 3, Rosetta) }

Objective-C

Compiler: GCC 3.3+

 - (void)addValue:(id)value toArray:(NSMutableArray *)array position:(unsigned)pos
 {
   [array insertObject:value atIndex:pos];
 }

OCaml

Interpreter: OCaml

  let writeToArray arr loc val = arr.(loc) <- val;;

variant:
Interpreter: OCaml

  let writeToArray = Array.set

Perl

Interpreter: Perl 5.8.8 For a single index/value assignment:

 $array[$index] = $value;

To assign multiple values to multiple indexes:

 @array[@indexes] = @values;

To assign an array slice:

 @array[3..5] = @values;
 # will replace the 4th, 5th and 6th element with the first 3 values in @values

PHP

<?php
function writeToArray(&$array, $index, $value)
{
    $array[$index] = $value;
}
// Usage example
writeToArray($array, 1, 6 );
?>

PL/SQL

Interpreter: Oracle compiler

 set serveroutput on
 declare
 	type myarray is table of number index by binary_integer;
 	x myarray;
 	i pls_integer;
 begin
 	-- populate array
 	for i in 1..5 loop
 		x(i) := i;
 	end loop;
 	i :=0;
 
 	-- print array
 	loop
 		i := i + 1;
 		begin
 			dbms_output.put_line(x(i));
 		exception 
 			when no_data_found then exit;
 		end;
 	end loop;
 
 end;
 /

Python

Interpreter: Python

  array[index] = value

If the index is bigger than the size of the array, an IndexError is thrown. To have the function append a value at the end of the array if the array is not of the right size:

Interpreter: Python

  array.append(value)

Ruby

Interpreter: Ruby 1.8.5

  # To specify a value for a known index
  # Usage: arr[index] = value
  arr = 1,2,3,4,5
  arr[0] = 10

  # To push a value onto an array. This accepts single or multiple arguments:
  arr.push( 1 )
  arr.push( 1, 2, 3 )

  # To push a value onto an array. This accepts a single argument. This is
  # also consistent usage for concatenating strings which is an array of
  # bytes:
  arr << 1 
  "Hello " << "World!"  

Scala

 val array = new Array[int](10) // create a 10 element array of integers
 array(3) = 44
 array(22) = 11 // java.lang.ArrayIndexOutOfBoundsException: 22

 import scala.collection.mutable.ArrayBuffer
 val array2 = new ArrayBuffer[int]
 array2 += 1
 array2 += 2
 array2 += 3
 array2(1) // 2 (zero based indexing)
 array2(1) = 33
 array2.toString // ArrayBuffer(1,33,3)

 var l = List(1,2,3)
 l = 44 :: l //  List(44,1,2,3)
 l(2) // 2

Tcl

 proc setIfExist {theVariable value} {
     upvar 1 $theVariable variable
     if {[info exists variable]} {
         set variable $value
     } else {
         error "$theVariable doesn't exist"
     }
 }

Note that setIfExist is general purpose and works on regular variables as well as arrays:

 setIfExist foo(bar) 10 ;# error if foo(bar) doesn't exist
 setIfExist x 10        ;# error if x doesn't exist

Visual Basic

Language Version: 5.0+

Private Function writeToArray(intArray() As Integer, arraySize As Integer, loc As Integer, value As Integer) As Integer
   If loc > arraySize Then
     writeToArray = -1
   Else
     intArray(loc) = value
     writeToArray = 0
   End If
End Function

VBScript

Simple Example

Define our Array

 Dim myArray (5)

Use a For Next loop to set the array data.

 For i = 0 To 4
   myArray(i) = i
 Next

Use a For Next loop and MsgBox to display the array data.

 MsgBox("Print array values")
 For i = 0 To 4
   msgbox("myArray element " & i & " = " & myArray(i))
 Next

Variable Array Length

Example where we don't know the required array size at the start and where we need to increase the array size as we go

Define an array - but we don't know how big yet.

 Dim myArray2 ()

OK, now we know how big an array we need.

 ReDim myArray2(3)

Load the array

 For i = 0 To 2
   myArray2(i) = i
 Next

Print the array

 MsgBox("We've set the new array size and set the data")
 For i = 0 To 2
   MsgBox "myArray2 element " & i & " = " & myArray2(i)
 Next

Now we need to make the array bigger. Note the Preserve keyword so that the existing data in the array is not lost when we resize it.

 ReDim Preserve myArray2(5)

Load the array

 For i = 3 To 4
   myArray2(i) = i
 Next

Print the array

 MsgBox ("We've increased the array size and loaded more data")
 For i = 0 To 4
   MsgBox "myArray2 element " & i & " = " & myArray2(i)
 Next