Assigning Values to an Array: Difference between revisions

From Rosetta Code
Content added Content deleted
(→‎[[C]]: Added syntax highlighting. Yaay!)
(Blank page since people can't / don't read)
 
(87 intermediate revisions by 41 users not shown)
Line 1: Line 1:
{{task}}
{{DeprecatedTask}}

{{Template:clarify task}}
'''Please do not add new code, and move existing code to the [[Arrays]] task.'''


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.
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]]==
[[Category:ActionScript]]
arr[0] = 1;
arr[1] = 'a';
arr[2] = 5.678;

==[[Ada]]==
[[Category: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]]==
[[Category: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]]==
[[Category:C]]
'''Compiler:''' [[GCC]] 4.1.1
<highlightSyntax language=C>
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;
}</highlightSyntax>

==[[C sharp | C#]]==
[[Category:C sharp]]
'''Platform:''' [[.NET]]
'''Language Version:''' 1.0+

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

==[[C plus plus|C++]]==
[[Category:C plus plus]]
'''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 plus plus|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]]==
[[Category: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]]==
[[Category:Common Lisp]]
(defun assign-to-array (array index value)
(setf (aref array index) value))

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

==[[Forth]]==
[[Category:Forth]]
'''Interpreter:''' ANS Forth
: ]! ( n addr ix -- ) cells + ! ; \ ex. 3 buffer[ 2 ]!

==[[Fortran]]==
[[Category:Fortran]]
'''Compiler:''' Any ANSI F77 (e.g. GNU g77)

a(55) = 12

==[[Haskell]]==
'''Compiler:''' GHC 6.6
===List===
Most Haskell programs use lists instead of arrays. This is suitable for the general case.

====Simple Version====
<pre>
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)
</pre>

====Efficient Version====
<pre>
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)
</pre>

===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.
<pre>
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]]
</pre>

==[[Java]]==
[[Category:Java]]
'''Platform:''' [[J2SE]] 1.2+
public void writeToIntArray(int[] array, int loc, int val){ array[loc]=val; }

==[[JavaScript]]==
[[Category:JavaScript]]
function setElem(array, loc, val) { //returns 0 if out of bounds
if(typeof array[loc] == typeof undefined) {
return 0; //element doesn't already exist -- out of bounds
} else {
array[loc] = val
return 1; //OK
}//if
}//setElem
//use:
var ary=[10,20,30] //0,1,2 defined
var ok = setElem(ary,3,'three')
if(!ok) alert('oops, error')

Simpler if you don't mind adding an element if it does not already exist:
function writeToArray(array, loc, val) { array[loc] = val; }

==[[mIRC Scripting Language]]==
[[Category:mIRC Scripting Language]]
'''Interpreter:''' [[mIRC]]
'''Library:''' [[mArray Snippet]]
[[Category:mArray Snippet]]
alias write2array { echo -a $array_write(MyArray, 2, 3, Rosetta) }

==[[Objective-C]]==
[[Category:Objective-C]]
'''Compiler:''' [[GCC]] 3.3+

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

==[[OCaml]]==
[[Category:OCaml]]
'''Interpreter:''' [[OCaml]]
let writeToArray arr loc val = arr.(loc) <- val;;

variant:<br/>
'''Interpreter:''' [[OCaml]]
let writeToArray = Array.set

==[[Perl]]==
[[Category: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]]==
[[Category:PHP]]

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

Note that this is a "function" based example, and the relevant acting code is the following

$array[$index] = $value;

This does not conform to the (somewhat arbitrary) specific requirements of the task, in that it does not return an error if the key index) does not exist. To satisfy the task requirements:

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

==[[PL/SQL]]==
[[Category: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]]==
[[Category:Python]]
'''Interpreter:''' [[Python]]
array[index] = value

If the index is bigger than the size of the array (eg if the array is empty), 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]]==
[[Category: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]]==
[[Category: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]]==
[[Category:Tcl]]
proc setIfExist {theVariable value} {
upvar 1 $theVariable variable
if {[info exists theVariable]} {
set theVariable $value
} else {
error "$theVariable doesn't exist"
}
}
Note that <tt>setIfExist</tt> 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]]==
[[Category: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]]==
[[Category: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

Latest revision as of 15:06, 29 November 2019

Assigning Values to an Array was a programming task. It has been deprecated for reasons that are discussed in its talk page.

Please do not add new code, and move existing code to the Arrays task.

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.

Retrieved from "https://rosettacode.org/wiki/Assigning_Values_to_an_Array?oldid=6356"