## Algorithm

Problem Name: Algorithms - Simple Array Sum

In this HackerRank Functions in Algorithms - Java programming problem solution,

Given an array of integers, find the sum of its elements.

For example, if the array ar = [1,2,3], 1 + 2 + 3 = 6 ,so return 6 .

Function Description

Complete the simpleArraySum function in the editor below. It must return the sum of the array elements as an integer.

simpleArraySum has the following parameter(s):

• ar: an array of integers

nput Format

The first line contains an integer, n , denoting the size of the array.
The second line contains n pace-separated integers representing the array's elements.

Constraints

0 <= ni ,ar [i] <= 1000

Output Format

Print the sum of the array's elements as a single integer.

Sample Input

``````6
1 2 3 4 10 11
``````

Sample Output

``````31
``````

Explanation

We print the sum of the array's elements:

1 + 2 + 3 + 4 + 10 + 11 = 31.

## Code Examples

### #1 Code Example with C Programming

```Code - C Programming```

``````
#include <assert.h>
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char** split_string(char*);

/*
* Complete the simpleArraySum function below.
*/
int simpleArraySum(int ar_count, int* ar) {
/*
* Write your code here.
*/
int sum = 0;
for(int i = 0; i  <  ar_count; i++){
sum += ar[i];
}
return sum;
}

int main()
{
FILE* fptr = fopen(getenv("OUTPUT_PATH"), "w");

char* ar_count_endptr;
char* ar_count_str = readline();
int ar_count = strtol(ar_count_str, &ar_count_endptr, 10);

if (ar_count_endptr == ar_count_str || *ar_count_endptr != '\0') { exit(EXIT_FAILURE); }

char** ar_temp = split_string(readline());

int ar[ar_count];

for (int ar_itr = 0; ar_itr  <  ar_count; ar_itr++) {
char* ar_item_endptr;
char* ar_item_str = ar_temp[ar_itr];
int ar_item = strtol(ar_item_str, &ar_item_endptr, 10);

if (ar_item_endptr == ar_item_str || *ar_item_endptr != '\0') { exit(EXIT_FAILURE); }

ar[ar_itr] = ar_item;
}

int result = simpleArraySum(ar_count, ar);

fprintf(fptr, "%d\n", result);

fclose(fptr);

return 0;
}

size_t alloc_length = 1024;
size_t data_length = 0;
char* data = malloc(alloc_length);

while (true) {
char* cursor = data + data_length;
char* line = fgets(cursor, alloc_length - data_length, stdin);

if (!line) { break; }

data_length += strlen(cursor);

if (data_length  <  alloc_length - 1 || data[data_length - 1] == '\n') { break; }

size_t new_length = alloc_length << 1;
data = realloc(data, new_length);

if (!data) { break; }

alloc_length = new_length;
}

if (data[data_length - 1] == '\n') {
data[data_length - 1] = '\0';
}

data = realloc(data, data_length);

return data;
}

char** split_string(char* str) {
char** splits = NULL;
char* token = strtok(str, " ");

int spaces = 0;

while (token) {
splits = realloc(splits, sizeof(char*) * ++spaces);
if (!splits) {
return splits;
}

splits[spaces - 1] = token;

token = strtok(NULL, " ");
}

return splits;
}
``````
Copy The Code &

### #2 Code Example with C++ Programming

```Code - C++ Programming```

``````
#include <bits/stdc++.h>
#include <numeric>

using namespace std;

vector < string> split_string(string);

/*
* Complete the simpleArraySum function below.
*/
int simpleArraySum(vector<int> ar) {
/*
* Write your code here.
*/
return accumulate(ar.begin(), ar.end(), 0);

}

int main()
{
ofstream fout(getenv("OUTPUT_PATH"));

int ar_count;
cin >> ar_count;
cin.ignore(numeric_limits < streamsize>::max(), '\n');

string ar_temp_temp;
getline(cin, ar_temp_temp);

vector < string> ar_temp = split_string(ar_temp_temp);

vector<int> ar(ar_count);

for (int ar_itr = 0; ar_itr  <  ar_count; ar_itr++) {
int ar_item = stoi(ar_temp[ar_itr]);

ar[ar_itr] = ar_item;
}

int result = simpleArraySum(ar);

fout << result << "\n";

fout.close();

return 0;
}

vector < string> split_string(string input_string) {
string::iterator new_end = unique(input_string.begin(), input_string.end(), [] (const char &x, const char &y) {
return x == y and x == ' ';
});

input_string.erase(new_end, input_string.end());

while (input_string[input_string.length() - 1] == ' ') {
input_string.pop_back();
}

vector < string> splits;
char delimiter = ' ';

size_t i = 0;
size_t pos = input_string.find(delimiter);

while (pos != string::npos) {
splits.push_back(input_string.substr(i, pos - i));

i = pos + 1;
pos = input_string.find(delimiter, i);
}

splits.push_back(input_string.substr(i, min(pos, input_string.length()) - i + 1));

return splits;
}
``````
Copy The Code &

### #3 Code Example with Java Programming

```Code - Java Programming```

``````
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

public static void main(String[] args) {
int sum = 0;
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int arr[] = new int[n];
for(int arr_i=0; arr_i  <  n; arr_i++){
arr[arr_i] = in.nextInt();
sum += arr[arr_i];
}
System.out.println(sum);
}
}
``````
Copy The Code &

### #4 Code Example with Javascript Programming

```Code - Javascript Programming```

``````
'use strict';

const fs = require('fs');

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
inputString += inputStdin;
});

process.stdin.on('end', _ => {
inputString = inputString.trim().split('\n').map(str => str.trim());

main();
});

return inputString[currentLine++];
}

/*
* Complete the simpleArraySum function below.
*/
function simpleArraySum(ar) {
let sum = 0;
for (let i = 0; i  <  ar.length; i++){
sum += ar[i]
}

return sum;

}

function main() {
const ws = fs.createWriteStream(process.env.OUTPUT_PATH);

const arCount = parseInt(readLine(), 10);

const ar = readLine().split(' ').map(arTemp => parseInt(arTemp, 10));

let result = simpleArraySum(ar);

ws.write(result + "\n");

ws.end();
}
``````
Copy The Code &

### #5 Code Example with C# Programming

```Code - C# Programming```

``````
using System;
using System.Linq;
class Solution
{
static void Main(String[] args)
{
//no need of the element count as I use LINQ to create the sum instead of iterating the array explicitly in my code.