---
# System prepended metadata

title: 'Refresher : 1D Arrays'

---

# Refresher : 1D Arrays
# Introduction To Arrays

---
## Definition

Array is the sequential collection of same types of data. The datatype can be of any type i.e, int, float, char, etc. Below is the declaration of the array:
```java
int arr[] = new int[5];
```
It can also be declared as:
```java
int[] arr = new int[5]
```
Here, ‘int’ is the datatype, ‘arr’ is the name of the array and ‘n’ is the size of an array. 
We can access all the elements of the array as arr[0], arr[1] ….. arr[n-1]. 

**Note:** Array indexing starts with 0.


---
### Question
Maximum index of array of size N is ?

Choose the correct answer

**Choices**

- [ ] 1
- [ ] 0
- [x] N-1
- [ ] N


---
### Question
Given an array as arr = {3,4,1,5,1}. What is ths sum of all elements in the array?

Choose the correct answer

**Choices**

- [ ] 12
- [ ] 13
- [x] 14
- [ ] 15


---
## Question 1

Take an integer array **arr** of size **N** as input and print its sum.

#### TestCase
##### Input
```java
N = 5
arr = {1,2,3,4,5}
```
##### Output
```plaintext
15
```

#### Explanation
To calculate the sum of all the elements in the array, we need a variable say **sum** which is initially zero. Then iterate all the elements and adding them to **sum**.

#### PseudoCode
```java
int sum = 0;
for (int i = 0; i < n; i++) {
    sum = sum + arr[i];
}
System.out.println("Sum is " + sum);
```
\
---
### Question
Given an array as arr = {3,4,1,5,1}. Find the maximum element.

Choose the correct answer

**Choices**

- [ ] 3
- [ ] 4
- [x] 5
- [ ] 1


---
## Question 2

Take an integer array **arr** of size **N** as input and print its maximum element.

#### TestCase
##### Input
```plaintext
N = 5
arr = {1,2,3,4,5}
```
##### Output
```plaintext
5
```

#### PseudoCode
```java
int maximum_element = 0;
for (int i = 0; i < n; i++) {
    if (maximum_element < arr[i]) maximum_element = arr[i];
}
system.out.println("Sum is " + maximum_element);
```

---
### Question

What will be the output of the above code with
N = 5
arr = {-3, -7, -2, -10, -1}
array as input ?

Choose the correct answer

**Choices**

- [ ] -7
- [ ] -1
- [x] 0
- [ ] 2

**Explanation**

Initially we have assumed 0 as the max element in the array and in the given case, all the element is smaller than 0. So, the max element is 0.

---
### Question 2 PseudoCode 

**Note:** We can fix it by initially assigning arr[0] to the maximum_element.
So the updated pseudocode is:

```java
int maximum_element = arr[0];
for (int i = 0; i < n; i++) {
    if (maximum_element < arr[i]) maximum_element = arr[i];
}
system.out.println("Sum is " + maximum_element);
```

---
## Question 3

Take an integer array **arr** of size **N** as input and return its minimum element.

#### TestCase
##### Input
```java
N = 5
arr = {1,2,3,4,5}
```
##### Output
```plaintext
1
```

#### PseudoCode
```java
public static int findMin(int arr[], int n) {
    int minimum_element = arr[0];
    for (int i = 0; i < n; i++) {
        if (minimum_element > arr[i]) minimum_element = arr[i];
    }
    return minimum_element;
}
```

---
## Question 4
Take an integer array **arr** of size **N** as input and check whether an integer **k** is present in that or not.

#### TestCase
##### Input
```java
N = 5
arr = {1,2,3,4,5}
k = 4
```
##### Output
```plaintext
true
```

#### Explanation
To check whether an integer **k** is present in the array or not, we need to check each element and compare it with **k**. If none of the element is equal to **k**,then return false.

#### PseudoCode
```java
public static boolean findK(int arr[], int n, int k) {
    for (int i = 0; i < n; i++) {
        if (arr[i] == k) return true;
    }
    return false;
}
```

---
### Question
Given an array as arr = {3,4,1,5,1}. What is the frequency of 1?

Frequency of any element is defined as the number of occurences of that element in the array.

Choose the correct answer

**Choices**

- [ ] 0
- [ ] 1
- [x] 2
- [ ] 3

---
## Question 5

Take an integer array **arr** of size **N** as input. Return the frequency of **K** in the array.

#### TestCase

##### Input
```java
N = 6
arr = {1,2,3,4,5,1}
k = 1
```
##### Output
```plaintext
2
```


**Note:** Here frequency is the number of times the element **k** occurs in the array.

#### PseudoCode
```java
public static int frequencyK(int arr[], int n, int k) {
    int frequency = 0;
    for (int i = 0; i < n; i++) {
        if (arr[i] == k) frequency++;
    }
    return frequency;
}
```


---
## Question 6

Given an integer array as an input, return the frequency count of the array.

#### TestCase
##### Input
```java
arr = {1,1,2,1,3,1,3}
```
##### Output
```plaintext
{4,4,1,4,2,4,2}
```

#### PseudoCode
```java
int[] frecount(int arr[]) {
    int n = arr.length;
    int[] ans = new int[n];
    for (int i = 0; i < n; i++) {
        ans[i] = frequencyK(arr, n, arr[i]);
    }
    return ans;
}
```


---
## Question 7

Given an integer array as an input, check whether it is strictly increasing.


#### TestCase
##### Input
```plaintext
N = 5
arr = {1,2,3,4,5}
```
##### Output
```plaintext
true
```
##### Explanation
All the element in the array is in sorted order. So, we can say that it is in strictly increasing order.
As
```plaintext
1 < 2 < 3 < 4 < 5
```

#### PseudoCode
```java
public static boolean strictlyincreasing(int arr[]) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        if (arr[i] >= arr[i + 1]) return false;
    }
    return true;
}
```