# Find the missing number in unordered arithmetic progression

Here given code implementation process.

``````import java.util.Arrays;
/*
Java program
Find the missing number in unordered arithmetic progression
*/
public class ArithmeticProgression
{
public int missingNo(int[] series,
int low, int high, int interval)
{
if (low >= high)
{
// When no result
return -1;
}
// Find middle element
int mid = low + (high - low) / 2;
if (mid + 1 <= high && (series[mid + 1] - series[mid]) != interval)
{
return series[mid] + interval;
}
if (mid > 0 && (series[mid] - series[mid - 1]) != interval)
{
return series[mid - 1] + interval;
}
if ((mid * interval) + series[0] == series[mid])
{
// When the middle position element is a valid element
// of the given arithmetic progression.
// Check sequence of right-sided elements from middle.
return missingNo(series, mid + 1, high, interval);
}
// Check sequence of left-sided elements from middle.
return missingNo(series, low, mid - 1, interval);
}
public void missingArithmeticPro(int[] series, int n)
{
if (n > 1)
{
// Sort series
Arrays.sort(series);
// When n is more than 1
// Find interval between sequence
int interval = (series[n - 1] - series[0]) / n;
// Find missing element
int value = missingNo(series, 0, n - 1, interval);
// Display missing element
System.out.print("\n " + value);
}
}
public static void main(String[] args)
{
// Arithmetic progression series with one missing element
int[] a = {
1 , 4 , 7 , 13 , 16 , 19
};
int[] b = {
60 , 6 , 66 , 12 , 30 , 48 , 36 , 42 , 18 , 54
};
int[] c = {
14 , 2 , 11 , 5
};
// Note : Here first and last elements are not considered as missing
// Test A
int n = a.length;
// arr[]  = [1 , 4 , 7 , 13 , 16 , 19]
// sort[] = ]1 , 4 , 7 , 13 , 16 , 19]
//                     -
// -----------------------------------
// Result = 10
// Test B
n = b.length;
// arr[]  = [ 60 , 6 , 66 , 12 , 30 , 48 , 36 , 42 , 18 , 54 ]
// sort[] = ] 6 , 12 , 18 , 30 , 36 , 42 , 48 , 54 , 60 , 66 ]
//                        -
// ---------------------------------------------------------
// Result = 24
// Test C
n = c.length;
// arr[]  = [14, 2 , 11 , 5]
// sort[] = ]2 , 5 , 11 , 14]
// result = 8
}
}``````

#### Output

`````` 10
24
8``````
``````// Include header file
#include <iostream>
#include <algorithm>

using namespace std;
/*
C++ program
Find the missing number in unordered arithmetic progression
*/
class ArithmeticProgression
{
public: int missingNo(int series[], int low,
int high, int interval)
{
if (low >= high)
{
// When no result
return -1;
}
// Find middle element
int mid = low + (high - low) / 2;
if (mid + 1 <= high && (series[mid + 1] - series[mid]) != interval)
{
return series[mid] + interval;
}
if (mid > 0 && (series[mid] - series[mid - 1]) != interval)
{
return series[mid - 1] + interval;
}
if ((mid *interval) + series[0] == series[mid])
{
// When the middle position element is a valid element
// of the given arithmetic progression.
// Check sequence of right-sided elements from middle.
return this->missingNo(series, mid + 1, high, interval);
}
// Check sequence of left-sided elements from middle.
return this->missingNo(series, low, mid - 1, interval);
}
void missingArithmeticPro(int series[], int n)
{
if (n > 1)
{
// Sort series
sort(series, series + n);
// When n is more than 1
// Find interval between sequence
int interval = (series[n - 1] - series[0]) / n;
// Find missing element
int value = this->missingNo(series, 0, n - 1, interval);
// Display missing element
cout << "\n " << value;
}
}
};
int main()
{
// Arithmetic progression series with one missing element
int a[] = {
1 , 4 , 7 , 13 , 16 , 19
};
int b[] = {
60 , 6 , 66 , 12 , 30 , 48 , 36 , 42 , 18 , 54
};
int c[] = {
14 , 2 , 11 , 5
};
// Note : Here first and last elements are not considered as missing
// Test A
int n = sizeof(a) / sizeof(a[0]);
// arr[]  = [1 , 4 , 7 , 13 , 16 , 19]
// sort[] = ]1 , 4 , 7 , 13 , 16 , 19]
//                     -
// -----------------------------------
// Result = 10
// Test B
n = sizeof(b) / sizeof(b[0]);
// arr[]  = [ 60 , 6 , 66 , 12 , 30 , 48 , 36 , 42 , 18 , 54 ]
// sort[] = ] 6 , 12 , 18 , 30 , 36 , 42 , 48 , 54 , 60 , 66 ]
//                        -
// ---------------------------------------------------------
// Result = 24
// Test C
n = sizeof(c) / sizeof(c[0]);
// arr[]  = [14, 2 , 11 , 5]
// sort[] = ]2 , 5 , 11 , 14]
// result = 8
return 0;
}``````

#### Output

`````` 10
24
8``````
``````// Include namespace system
using System;
/*
Csharp program
Find the missing number in unordered arithmetic progression
*/
public class ArithmeticProgression
{
public int missingNo(int[] series, int low, int high, int interval)
{
if (low >= high)
{
// When no result
return -1;
}
// Find middle element
int mid = low + (high - low) / 2;
if (mid + 1 <= high && (series[mid + 1] - series[mid]) != interval)
{
return series[mid] + interval;
}
if (mid > 0 && (series[mid] - series[mid - 1]) != interval)
{
return series[mid - 1] + interval;
}
if ((mid * interval) + series[0] == series[mid])
{
// When the middle position element is a valid element
// of the given arithmetic progression.
// Check sequence of right-sided elements from middle.
return this.missingNo(series, mid + 1, high, interval);
}
// Check sequence of left-sided elements from middle.
return this.missingNo(series, low, mid - 1, interval);
}
public void missingArithmeticPro(int[] series, int n)
{
if (n > 1)
{
// Sort series
Array.Sort(series);
// When n is more than 1
// Find interval between sequence
int interval = (series[n - 1] - series[0]) / n;
// Find missing element
int value = this.missingNo(series, 0, n - 1, interval);
// Display missing element
Console.Write("\n " + value);
}
}
public static void Main(String[] args)
{
// Arithmetic progression series with one missing element
int[] a = {
1 , 4 , 7 , 13 , 16 , 19
};
int[] b = {
60 , 6 , 66 , 12 , 30 , 48 , 36 , 42 , 18 , 54
};
int[] c = {
14 , 2 , 11 , 5
};
// Note : Here first and last elements are not considered as missing
// Test A
int n = a.Length;
// arr[]  = [1 , 4 , 7 , 13 , 16 , 19]
// sort[] = ]1 , 4 , 7 , 13 , 16 , 19]
//                     -
// -----------------------------------
// Result = 10
// Test B
n = b.Length;
// arr[]  = [ 60 , 6 , 66 , 12 , 30 , 48 , 36 , 42 , 18 , 54 ]
// sort[] = ] 6 , 12 , 18 , 30 , 36 , 42 , 48 , 54 , 60 , 66 ]
//                        -
// ---------------------------------------------------------
// Result = 24
// Test C
n = c.Length;
// arr[]  = [14, 2 , 11 , 5]
// sort[] = ]2 , 5 , 11 , 14]
// result = 8
}
}``````

#### Output

`````` 10
24
8``````
``````package main
import "sort"
import "fmt"
/*
Go program
Find the missing number in unordered arithmetic progression
*/
type ArithmeticProgression struct {}
func getArithmeticProgression() * ArithmeticProgression {
var me *ArithmeticProgression = &ArithmeticProgression {}
return me
}
func(this ArithmeticProgression) missingNo(series[] int,
low int, high int, interval int) int {
if low >= high {
// When no result
return -1
}
// Find middle element
var mid int = low + (high - low) / 2
if mid + 1 <= high && (series[mid + 1] - series[mid]) != interval {
return series[mid] + interval
}
if mid > 0 && (series[mid] - series[mid - 1]) != interval {
return series[mid - 1] + interval
}
if (mid * interval) + series[0] == series[mid] {
// When the middle position element is a valid element
// of the given arithmetic progression.
// Check sequence of right-sided elements from middle.
return this.missingNo(series, mid + 1, high, interval)
}
// Check sequence of left-sided elements from middle.
return this.missingNo(series, low, mid - 1, interval)
}
func(this ArithmeticProgression) missingArithmeticPro(series[] int, n int) {
if n > 1 {
// Sort series
sort.Ints(series)
// When n is more than 1
// Find interval between sequence
var interval int = (series[n - 1] - series[0]) / n
// Find missing element
var value int = this.missingNo(series, 0, n - 1, interval)
// Display missing element
fmt.Print("\n ", value)
}
}
func main() {
var task * ArithmeticProgression = getArithmeticProgression()
// Arithmetic progression series with one missing element
var a = [] int {
1,
4,
7,
13,
16,
19,
}
var b = [] int {
60,
6,
66,
12,
30,
48,
36,
42,
18,
54,
}
var c = [] int {
14,
2,
11,
5,
}
// Note : Here first and last elements are not considered as missing
// Test A
var n int = len(a)
// arr[]  = [1 , 4 , 7 , 13 , 16 , 19]
// sort[] = ]1 , 4 , 7 , 13 , 16 , 19]
//                     -
// -----------------------------------
// Result = 10
// Test B
n = len(b)
// arr[]  = [ 60 , 6 , 66 , 12 , 30 , 48 , 36 , 42 , 18 , 54 ]
// sort[] = ] 6 , 12 , 18 , 30 , 36 , 42 , 48 , 54 , 60 , 66 ]
//                        -
// ---------------------------------------------------------
// Result = 24
// Test C
n = len(c)
// arr[]  = [14, 2 , 11 , 5]
// sort[] = ]2 , 5 , 11 , 14]
// result = 8
}``````

#### Output

`````` 10
24
8``````
``````<?php
/*
Php program
Find the missing number in unordered arithmetic progression
*/
class ArithmeticProgression
{
public	function missingNo(\$series, \$low, \$high, \$interval)
{
if (\$low >= \$high)
{
// When no result
return -1;
}
// Find middle element
\$mid = \$low + (int)((\$high - \$low) / 2);
if (\$mid + 1 <= \$high &&
(\$series[\$mid + 1] - \$series[\$mid]) != \$interval)
{
return \$series[\$mid] + \$interval;
}
if (\$mid > 0 && (\$series[\$mid] - \$series[\$mid - 1]) != \$interval)
{
return \$series[\$mid - 1] + \$interval;
}
if ((\$mid * \$interval) + \$series[0] == \$series[\$mid])
{
// When the middle position element is a valid element
// of the given arithmetic progression.
// Check sequence of right-sided elements from middle.
return \$this->missingNo(\$series, \$mid + 1, \$high, \$interval);
}
// Check sequence of left-sided elements from middle.
return \$this->missingNo(\$series, \$low, \$mid - 1, \$interval);
}
public	function missingArithmeticPro(\$series, \$n)
{
if (\$n > 1)
{
// Sort series
sort(\$series);
// When n is more than 1
// Find interval between sequence
\$interval = (int)((\$series[\$n - 1] - \$series[0]) / \$n);
// Find missing element
\$value = \$this->missingNo(\$series, 0, \$n - 1, \$interval);
// Display missing element
echo("\n ".\$value);
}
}
}

function main()
{
// Arithmetic progression series with one missing element
\$a = array(1, 4, 7, 13, 16, 19);
\$b = array(60, 6, 66, 12, 30, 48, 36, 42, 18, 54);
\$c = array(14, 2, 11, 5);
// Note : Here first and last elements are not considered as missing
// Test A
\$n = count(\$a);
// arr[]  = [1 , 4 , 7 , 13 , 16 , 19]
// sort[] = ]1 , 4 , 7 , 13 , 16 , 19]
//                     -
// -----------------------------------
// Result = 10
// Test B
\$n = count(\$b);
// arr[]  = [ 60 , 6 , 66 , 12 , 30 , 48 , 36 , 42 , 18 , 54 ]
// sort[] = ] 6 , 12 , 18 , 30 , 36 , 42 , 48 , 54 , 60 , 66 ]
//                        -
// ---------------------------------------------------------
// Result = 24
// Test C
\$n = count(\$c);
// arr[]  = [14, 2 , 11 , 5]
// sort[] = ]2 , 5 , 11 , 14]
// result = 8
}
main();``````

#### Output

`````` 10
24
8``````
``````/*
Node JS program
Find the missing number in unordered arithmetic progression
*/
class ArithmeticProgression
{
missingNo(series, low, high, interval)
{
if (low >= high)
{
// When no result
return -1;
}
// Find middle element
var mid = low + parseInt((high - low) / 2);
if (mid + 1 <= high &&
(series[mid + 1] - series[mid]) != interval)
{
return series[mid] + interval;
}
if (mid > 0 && (series[mid] - series[mid - 1]) != interval)
{
return series[mid - 1] + interval;
}
if ((mid * interval) + series[0] == series[mid])
{
// When the middle position element is a valid element
// of the given arithmetic progression.
// Check sequence of right-sided elements from middle.
return this.missingNo(series, mid + 1, high, interval);
}
// Check sequence of left-sided elements from middle.
return this.missingNo(series, low, mid - 1, interval);
}
missingArithmeticPro(series, n)
{
if (n > 1)
{
// Sort series
series.sort(function(a, b)
{
return a - b;
});
// When n is more than 1
// Find interval between sequence
var interval = parseInt((series[n - 1] - series[0]) / n);
// Find missing element
var value = this.missingNo(series, 0, n - 1, interval);
// Display missing element
process.stdout.write("\n " + value);
}
}
}

function main()
{
// Arithmetic progression series with one missing element
var a = [1, 4, 7, 13, 16, 19];
var b = [60, 6, 66, 12, 30, 48, 36, 42, 18, 54];
var c = [14, 2, 11, 5];
// Note : Here first and last elements are not considered as missing
// Test A
var n = a.length;
// arr[]  = [1 , 4 , 7 , 13 , 16 , 19]
// sort[] = ]1 , 4 , 7 , 13 , 16 , 19]
//                     -
// -----------------------------------
// Result = 10
// Test B
n = b.length;
// arr[]  = [ 60 , 6 , 66 , 12 , 30 , 48 , 36 , 42 , 18 , 54 ]
// sort[] = ] 6 , 12 , 18 , 30 , 36 , 42 , 48 , 54 , 60 , 66 ]
//                        -
// ---------------------------------------------------------
// Result = 24
// Test C
n = c.length;
// arr[]  = [14, 2 , 11 , 5]
// sort[] = ]2 , 5 , 11 , 14]
// result = 8
}
main();``````

#### Output

`````` 10
24
8``````
``````#    Python 3 program
#    Find the missing number in unordered arithmetic progression
class ArithmeticProgression :
def missingNo(self, series, low, high, interval) :
if (low >= high) :
#  When no result
return -1

#  Find middle element
mid = low + int((high - low) / 2)
if (mid + 1 <= high and(series[mid + 1] - series[mid]) != interval) :
return series[mid] + interval

if (mid > 0 and(series[mid] - series[mid - 1]) != interval) :
return series[mid - 1] + interval

if ((mid * interval) + series[0] == series[mid]) :
#  When the middle position element is a valid element
#  of the given arithmetic progression.
#  Check sequence of right-sided elements from middle.
return self.missingNo(series, mid + 1, high, interval)

#  Check sequence of left-sided elements from middle.
return self.missingNo(series, low, mid - 1, interval)

def missingArithmeticPro(self, series, n) :
if (n > 1) :
#  Sort series
series.sort()
#  When n is more than 1
#  Find interval between sequence
interval = int((series[n - 1] - series[0]) / n)
#  Find missing element
value = self.missingNo(series, 0, n - 1, interval)
#  Display missing element
print("\n ", value, end = "")

def main() :
#  Arithmetic progression series with one missing element
a = [1, 4, 7, 13, 16, 19]
b = [60, 6, 66, 12, 30, 48, 36, 42, 18, 54]
c = [14, 2, 11, 5]
#  Note : Here first and last elements are not considered as missing
#  Test A
n = len(a)
#  arr[]  = [1 , 4 , 7 , 13 , 16 , 19]
#  sort[] = ]1 , 4 , 7 , 13 , 16 , 19]
#                      -
#  -----------------------------------
#  Result = 10
#  Test B
n = len(b)
#  arr[]  = [ 60 , 6 , 66 , 12 , 30 , 48 , 36 , 42 , 18 , 54 ]
#  sort[] = ] 6 , 12 , 18 , 30 , 36 , 42 , 48 , 54 , 60 , 66 ]
#                         -
#  ---------------------------------------------------------
#  Result = 24
#  Test C
n = len(c)
#  arr[]  = [14, 2 , 11 , 5]
#  sort[] = ]2 , 5 , 11 , 14]
#  result = 8

if __name__ == "__main__": main()``````

#### Output

``````  10
24
8``````
``````#    Ruby program
#    Find the missing number in unordered arithmetic progression
class ArithmeticProgression
def missingNo(series, low, high, interval)
if (low >= high)
#  When no result
return -1
end

#  Find middle element
mid = low + (high - low) / 2
if (mid + 1 <= high && (series[mid + 1] - series[mid]) != interval)
return series[mid] + interval
end

if (mid > 0 && (series[mid] - series[mid - 1]) != interval)
return series[mid - 1] + interval
end

if ((mid * interval) + series[0] == series[mid])
#  When the middle position element is a valid element
#  of the given arithmetic progression.
#  Check sequence of right-sided elements from middle.
return self.missingNo(series, mid + 1, high, interval)
end

#  Check sequence of left-sided elements from middle.
return self.missingNo(series, low, mid - 1, interval)
end

def missingArithmeticPro(series, n)
if (n > 1)
#  Sort series
series = series.sort
#  When n is more than 1
#  Find interval between sequence
interval = (series[n - 1] - series[0]) / n
#  Find missing element
value = self.missingNo(series, 0, n - 1, interval)
#  Display missing element
print("\n ", value)
end

end

end

def main()
#  Arithmetic progression series with one missing element
a = [1, 4, 7, 13, 16, 19]
b = [60, 6, 66, 12, 30, 48, 36, 42, 18, 54]
c = [14, 2, 11, 5]
#  Note : Here first and last elements are not considered as missing
#  Test A
n = a.length
#  arr[]  = [1 , 4 , 7 , 13 , 16 , 19]
#  sort[] = ]1 , 4 , 7 , 13 , 16 , 19]
#                      -
#  -----------------------------------
#  Result = 10
#  Test B
n = b.length
#  arr[]  = [ 60 , 6 , 66 , 12 , 30 , 48 , 36 , 42 , 18 , 54 ]
#  sort[] = ] 6 , 12 , 18 , 30 , 36 , 42 , 48 , 54 , 60 , 66 ]
#                         -
#  ---------------------------------------------------------
#  Result = 24
#  Test C
n = c.length
#  arr[]  = [14, 2 , 11 , 5]
#  sort[] = ]2 , 5 , 11 , 14]
#  result = 8
end

main()``````

#### Output

`````` 10
24
8``````
``````import scala.collection.mutable._;
/*
Scala program
Find the missing number in unordered arithmetic progression
*/
class ArithmeticProgression()
{
def missingNo(series: Array[Int], low: Int,
high: Int, interval: Int): Int = {
if (low >= high)
{
// When no result
return -1;
}
// Find middle element
var mid: Int = low + (high - low) / 2;
if (mid + 1 <= high && (series(mid + 1) - series(mid)) != interval)
{
return series(mid) + interval;
}
if (mid > 0 && (series(mid) - series(mid - 1)) != interval)
{
return series(mid - 1) + interval;
}
if ((mid * interval) + series(0) == series(mid))
{
// When the middle position element is a valid element
// of the given arithmetic progression.
// Check sequence of right-sided elements from middle.
return missingNo(series, mid + 1, high, interval);
}
// Check sequence of left-sided elements from middle.
return missingNo(series, low, mid - 1, interval);
}
def missingArithmeticPro(series: Array[Int], n: Int): Unit = {
if (n > 1)
{
// Sort series
var v = series.sorted;
// When n is more than 1
// Find interval between sequence
var interval: Int = (v(n - 1) - v(0)) / n;
// Find missing element
var value: Int = missingNo(v, 0, n - 1, interval);
// Display missing element
print("\n " + value);
}
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: ArithmeticProgression = new ArithmeticProgression();
// Arithmetic progression series with one missing element
var a: Array[Int] = Array(1, 4, 7, 13, 16, 19);
var b: Array[Int] = Array(60, 6, 66, 12, 30, 48, 36, 42, 18, 54);
var c: Array[Int] = Array(14, 2, 11, 5);
// Note : Here first and last elements are not considered as missing
// Test A
var n: Int = a.length;
// arr[]  = [1 , 4 , 7 , 13 , 16 , 19]
// sort[] = ]1 , 4 , 7 , 13 , 16 , 19]
//                     -
// -----------------------------------
// Result = 10
// Test B
n = b.length;
// arr[]  = [ 60 , 6 , 66 , 12 , 30 , 48 , 36 , 42 , 18 , 54 ]
// sort[] = ] 6 , 12 , 18 , 30 , 36 , 42 , 48 , 54 , 60 , 66 ]
//                        -
// ---------------------------------------------------------
// Result = 24
// Test C
n = c.length;
// arr[]  = [14, 2 , 11 , 5]
// sort[] = ]2 , 5 , 11 , 14]
// result = 8
}
}``````

#### Output

`````` 10
24
8``````
``````import Foundation;
/*
Swift 4 program
Find the missing number in unordered arithmetic progression
*/
class ArithmeticProgression
{
func missingNo(_ series: [Int], _ low: Int,
_ high: Int, _ interval: Int) -> Int
{
if (low >= high)
{
// When no result
return -1;
}
// Find middle element
let mid: Int = low + (high - low) / 2;
if (mid + 1 <= high &&
(series[mid + 1] - series[mid])  != interval)
{
return series[mid] + interval;
}
if (mid > 0 && (series[mid] - series[mid - 1])  != interval)
{
return series[mid - 1] + interval;
}
if ((mid * interval) + series[0] == series[mid])
{
// When the middle position element is a valid element
// of the given arithmetic progression.
// Check sequence of right-sided elements from middle.
return self.missingNo(series, mid + 1, high, interval);
}
// Check sequence of left-sided elements from middle.
return self.missingNo(series, low, mid - 1, interval);
}
func missingArithmeticPro(_ v: [Int], _ n: Int)
{
if (n > 1)
{
// Sort series
let series = v.sorted();
// When n is more than 1
// Find interval between sequence
let interval: Int = (series[n - 1] - series[0]) / n;
// Find missing element
let value: Int = self.missingNo(series, 0, n - 1, interval);
// Display missing element
print("\n ", value, terminator: "");
}
}
}
func main()
{
// Arithmetic progression series with one missing element
let a: [Int] = [1, 4, 7, 13, 16, 19];
let b: [Int] = [60, 6, 66, 12, 30, 48, 36, 42, 18, 54];
let c: [Int] = [14, 2, 11, 5];
// Note : Here first and last elements are not considered as missing
// Test A
var n: Int = a.count;
// arr[]  = [1 , 4 , 7 , 13 , 16 , 19]
// sort[] = ]1 , 4 , 7 , 13 , 16 , 19]
//                     -
// -----------------------------------
// Result = 10
// Test B
n = b.count;
// arr[]  = [ 60 , 6 , 66 , 12 , 30 , 48 , 36 , 42 , 18 , 54 ]
// sort[] = ] 6 , 12 , 18 , 30 , 36 , 42 , 48 , 54 , 60 , 66 ]
//                        -
// ---------------------------------------------------------
// Result = 24
// Test C
n = c.count;
// arr[]  = [14, 2 , 11 , 5]
// sort[] = ]2 , 5 , 11 , 14]
// result = 8
}
main();``````

#### Output

``````  10
24
8``````
``````/*
Kotlin program
Find the missing number in unordered arithmetic progression
*/
class ArithmeticProgression
{
fun missingNo(series: Array < Int > ,
low: Int, high: Int, interval: Int): Int
{
if (low >= high)
{
// When no result
return -1;
}
// Find middle element
val mid: Int = low + (high - low) / 2;
if (mid + 1 <= high && (series[mid + 1] - series[mid]) != interval)
{
return series[mid] + interval;
}
if (mid > 0 && (series[mid] - series[mid - 1]) != interval)
{
return series[mid - 1] + interval;
}
if ((mid * interval) + series[0] == series[mid])
{
// When the middle position element is a valid element
// of the given arithmetic progression.
// Check sequence of right-sided elements from middle.
return this.missingNo(series, mid + 1, high, interval);
}
// Check sequence of left-sided elements from middle.
return this.missingNo(series, low, mid - 1, interval);
}
fun missingArithmeticPro(series: Array < Int > , n: Int): Unit
{
if (n > 1)
{
// Sort series
series.sort();
// When n is more than 1
// Find interval between sequence
val interval: Int = (series[n - 1] - series[0]) / n;
// Find missing element
val value: Int = this.missingNo(series, 0, n - 1, interval);
// Display missing element
print("\n " + value);
}
}
}
fun main(args: Array < String > ): Unit
{
// Arithmetic progression series with one missing element
val a: Array < Int > = arrayOf(1, 4, 7, 13, 16, 19);
val b: Array < Int > = arrayOf(60, 6, 66, 12, 30, 48, 36, 42, 18, 54);
val c: Array < Int > = arrayOf(14, 2, 11, 5);
// Note : Here first and last elements are not considered as missing
// Test A
var n: Int = a.count();
// arr[]  = [1 , 4 , 7 , 13 , 16 , 19]
// sort[] = ]1 , 4 , 7 , 13 , 16 , 19]
//                     -
// -----------------------------------
// Result = 10
// Test B
n = b.count();
// arr[]  = [ 60 , 6 , 66 , 12 , 30 , 48 , 36 , 42 , 18 , 54 ]
// sort[] = ] 6 , 12 , 18 , 30 , 36 , 42 , 48 , 54 , 60 , 66 ]
//                        -
// ---------------------------------------------------------
// Result = 24
// Test C
n = c.count();
// arr[]  = [14, 2 , 11 , 5]
// sort[] = ]2 , 5 , 11 , 14]
// result = 8
}``````

#### Output

`````` 10
24
8``````

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.