programming

Tìm số lớn thứ hai trong mảng mà không cần sắp xếp

Vì vậy, trong bài đăng này, chúng ta sẽ tìm hiểu logic đằng sau việc tìm phần tử lớn thứ hai trong một mảng

#include 
using namespace std;

int secondLargest[int arr[], int n] {
  int i;
  sort[arr, arr + n];

  for [i = n - 2; i >= 0; i--] {
    if [arr[i] != arr[n - 1]] {
      return arr[i];
    }
  }

}

int main[] {
  int n = 5;
  int arr[] = {4, 2, 1, 3, 5};

  cout  maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}


Đầu ra của chương trìnhEnter number of elements in array: 6
Enter 6 numbers
5 -2 8 1 0 3
Second Maximum element: 5
_______5Để tìm phần tử lớn thứ hai trong mảng, chúng ta có thể sắp xếp mảng đầu vào rồi chọn phần tử cuối cùng thứ hai của mảng đã sắp xếp. Chúng ta có thể sử dụng bất kỳ thuật toán sắp xếp tiêu chuẩn nào để sắp xếp một mảng số nguyên như sắp xếp nhanh, sắp xếp hợp nhất, v.v.
 Chúng ta có thể tìm số lớn thứ hai trong một mảng trong java bằng cách sắp xếp mảng và trả về số lớn thứ 2. Cùng xem ví dụ đầy đủ để tìm số lớn thứ hai trong mảng java
Kiểm tra nó ngay bây giờđầu ra
Second Largest: 5
Second Largest: 77
Tìm số lớn thứ 2 trong mảng bằng Arrays
Hãy xem một ví dụ khác để lấy phần tử hoặc số lớn thứ hai trong mảng java bằng cách sử dụng các bộ sưu tập
Kiểm tra nó ngay bây giờđầu ra
Second Largest: 5
Second Largest: 77
Tìm số lớn thứ 2 trong mảng bằng Bộ sưu tập
Hãy xem một ví dụ khác để lấy số lớn thứ hai trong mảng java bằng cách sử dụng các bộ sưu tập
Kiểm tra nó ngay bây giờđầu ra
Second Largest: 5
Second Largest: 77
 3Cho một mảng các số nguyên, nhiệm vụ của chúng ta là viết chương trình tìm phần tử lớn thứ hai có trong mảng một cách hiệu quả.  
Ví dụ
Input: arr[] = {12, 35, 1, 10, 34, 1}
Output: The second largest element is 34.
Explanation: The largest element of the 
array is 35 and the second 
largest element is 34

Input: arr[] = {10, 5, 10}
Output: The second largest element is 5.
Explanation: The largest element of 
the array is 10 and the second 
largest element is 5

Input: arr[] = {10, 10, 10}
Output: The second largest does not exist.
Explanation: Largest element of the array 
is 10 there is no second largest element
Đề nghị thực hành
Lớn thứ hai
Thử nó
Cách tiếp cận ngây thơ
Ý tưởng là sắp xếp mảng theo thứ tự giảm dần và sau đó trả về phần tử thứ hai không bằng phần tử lớn nhất từ mảng đã sắp xếp
Dưới đây là triển khai ý tưởng trên
C++



def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
935
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
936
________ 1937 ________ 1938 ________ 100
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
01
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
02 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
03def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
05def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
07
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
________ 109 ________ 104 ________ 211
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
13
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
16
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
18function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
00/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
03/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
04
________ 109 ________ 306
________ 109 ________ 308
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
00
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
02
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04
________ 109 ________ 106 ________ 107
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
22
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
18____219Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
26Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
27
_______523____303____304
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
________ 109 ________ 306
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
18function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9358/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9361
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9363
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
________ 109 ________ 104 ________ 19367
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9370______19371def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9372def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9371def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9374
________ 109 ________ 19376
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
03 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9379
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9381
C



def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9382
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9383
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9384
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9385
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9387def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9388 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
02def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
000def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9388 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
02def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
003
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
03 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
007def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
009def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
011
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
01
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
02 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
03def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
05def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
07
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
________ 109 ________ 104 ________ 211
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
13
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
16
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
18function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
00/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
03/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
04
________ 109 ________ 306
________ 109 ________ 308
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
042def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
043def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9371function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
047
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
02
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04
________ 109 ________ 106 ________ 107
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
056
________ 217 ________ 1058
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
22
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
18____219Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
26Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
27
_______523____303____304
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
________ 109 ________ 306
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
18function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9358/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9361
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9363
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
________ 109 ________ 104 ________ 19367
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9370______19371def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9372def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9371def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9374
________ 109 ________ 19376
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
03 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9379
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9381
Java



function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
101
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
102
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
103 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
104
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
105 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
106
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
107
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
108
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
109 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
02 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
03______104 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
05
________ 2114 ________ 104 ________ 107
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
11
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
122
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
124
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
127____2128function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
129
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
133____300/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
03____304
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
142
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
144
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
146
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
148
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
06 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
151____2128function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
153function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
154function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
155
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
159
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
058
________ 109
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 ________ 2164function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
165 _______ 2166
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
169function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
133____2171 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
172
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
173function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
174function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
175
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
169/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
03/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
04
________ 109 ________ 306
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
133____2185 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
172
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
187function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
188/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
191
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
192 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
109 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
02 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
195
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
199_______3000/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
002/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
165/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
006/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
008/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
165/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
011
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 /*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
014
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9376
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
019
Python3



/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
020
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
021
 
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
022
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
023
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
024 /*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
025
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
026/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
027
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
028
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
030
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
032
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
127____2128/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
037
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
039____219/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
00function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
129
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
03
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
028
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
047
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
049
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
028
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
052
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
054
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
056
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
06 /*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
059/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
060 /*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
061/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
062/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
063function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
128/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
066/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
063function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
165____3001/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
063function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
165/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
072
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
028
________ 109 ________ 3075
________ 109 ________ 3077
________ 109
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 ________ 3080/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 _______ 3082/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
063 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
165 /*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
085
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
169/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
039function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
090/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001
_______523____3093
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
169/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
03
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
028
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
039function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
000function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
129
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
002
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
003/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
005/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
000/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
002/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
165/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
006/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
008/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
165def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
017
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
018/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
020def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
021
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
022
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
023
C#



def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
024
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
102
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
937 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
027
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
105 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
106
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
107
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
108
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
109 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
02 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
03______104 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
036
________ 2114 ________ 104 ________ 107
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
043
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
122
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
124
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
050
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
054/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
00/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
03____304
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
142
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
065
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
146
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
148
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
06____1072
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
169
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
159
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
058
________ 109 ________ 215 ________ 1082
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
169def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
054function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
171 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
172
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
187def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
090____2175
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
169/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
03/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
04
________ 109 ________ 306
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
________ 2118 ________ 1054 ________ 2185 ________ 2172
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
203function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
188/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
191
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
192 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
109 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
02 Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
211
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
215
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
218
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9376
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06

  
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
224
Javascript



Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
225
 
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
226
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
102
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
028
_______109____5230
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
232 Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
233
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____5235
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
028
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____5238
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
16
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
243/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
00/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
_______523____303____304
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
028
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
08
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____5255
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
028
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____5258
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
148
________ 217 ________ 106 ________ 107
_______523____1056
_______523____1058
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
22
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
203Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
243____5273 Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
274
_______5203____303____304
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
028
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
243____5285/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
________ 109 ________ 306
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
028
________ 109 ________ 5291
 
________ 109 ________ 5293
________ 109 ________ 5295
________ 109 ________ 19376
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
299
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93500
Đầu ra
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0
Phân tích độ phức tạp
Độ phức tạp về thời gian. O[n log n]. 
Thời gian cần thiết để sắp xếp mảng là O[n log n]. 
Không gian phụ trợ. Ô[1]. 
Vì không cần thêm dung lượng. 
Phương pháp tiếp cận hiệu quả.  
Cách tiếp cận là duyệt qua mảng hai lần. Trong lần duyệt đầu tiên, hãy tìm phần tử tối đa. Trong lần duyệt thứ hai, hãy tìm phần tử lớn nhất trong phần còn lại không bao gồm phần tử lớn nhất trước đó
Dưới đây là triển khai ý tưởng trên
C++14



def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93501
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93502
________ 1937 ________ 1938 ________ 100
 
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93507def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
05def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93511
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93514
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93516
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
06 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93521
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93524
_______523____193526
________ 109 ________ 306
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93530
________ 109 ________ 193532
_______ 109 ________ 106 ________ 219
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 ________ 193537
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93540
_______523____193542
_______523____193544
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93547
_______5203____193549
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93551 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93553
_______5203____193549
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
________ 109 ________ 306
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
03 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93562
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93565
________ 109 ________ 104 ________ 19367
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9370____19371def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93573____19371def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9374
________ 109 ________ 104 ________ 193578
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93581
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93583def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93584/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
04
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93551
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93583def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93590 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93591
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
Java



function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
101
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
102
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
103 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93596
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
105 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
106
 
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
230
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
109 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
02 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
03______104 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
05def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
07
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
________ 109 ________ 104 ________ 211
 
_______109____5238
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
127____2128function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
129
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
133/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
00/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
03/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
04
________ 109 ________ 306
 
________ 109 ________ 104 ________ 193631
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93633
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
06____193636function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
154def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93638
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____193642
________ 109 ________ 306
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93646
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
06____193636function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
154def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93638
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93656
_______523____193658
________ 109 ________ 306
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93663
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
133______2185 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
172
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
114function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
188/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93551
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
133______2171 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
172
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
114function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
174def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93679
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
191
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
192 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
109 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
02 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
195
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
199_______3000/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
002/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
165/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
006/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
008/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
165 /*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
011
________ 109 ________ 104 ________ 3014
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09
________ 109 ________ 19376
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
224
Python3



def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93711
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93712
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93713
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93714
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
023
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
024 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93717
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93719
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93721
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
127____2128/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
072
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
039function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
00/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
03/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
04
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93736 /*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 ________ 193738/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 ________ 3063def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93741/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
04
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93744
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
06 /*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
059/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
060 /*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
061function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
154def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93752
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93736/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93756def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93757
 
________ 109 ________ 193759
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
06 /*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
059/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
060 /*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
061function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
154def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93752
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 /*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
080/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93772
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93738/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93756def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93777
 
________ 109
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 ________ 193780/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 ________ 3063def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93741/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
072
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
039function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
185 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
172
________ 193791 ________ 193792 ________ 301
________ 109 ________ 193551 _______ 193796
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
039function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
171 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
172
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93791____193803def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93679
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
002
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93807/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081______3081 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93810def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93796
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
003/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
005/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
000/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001______3002/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
165/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93823/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
006____3001/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
008/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001____2165def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93829
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
018/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
020def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93834
________ 109 ________ 19376
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93837
C#



def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
024
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
102
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
937 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
027
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
105 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
106
 
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
230
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
109 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
02 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
03_______104 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
036def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
07
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
________ 109 ________ 193854
________ 109 ________ 104 ________ 193857
 
_______109____5238
________ 109 ________ 215 ________ 1050
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
054/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
00/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
03/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
04
________ 109 ________ 306
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93876def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93878
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93633
________ 109 ________ 106 _____ 193883
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____193887
________ 109 ________ 306
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93646
________ 109 ________ 106 _____ 193883
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93656
_______523____10001
________ 109 ________ 306
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0007____104def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0009
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
054function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
185 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
172
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0014function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
188/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93551
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
054function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
171 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
172
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0014def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
090def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93679
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
191
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
192 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
109 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
02 Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
211
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
________ 109 ________ 104 ________ 5215
________ 109 ________ 104 ________ 5218
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09
________ 109 ________ 19376
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
224
Javascript



Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
225
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
028
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
226
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
102
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118
_______109____5230
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
232 Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
233
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____10056
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____10058
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____5238
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
16
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
243/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
00/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
_______523____303____304
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0076
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
06 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0079
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0082
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
203def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0084
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0091
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
06 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0094
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0097
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
203def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0099
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
028
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0107
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
243____5285/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93551def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
243____5273 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0121
_______5203____303____304
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118
________ 109 ________ 5291
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
028
________ 109 ________ 5293
________ 109 ________ 5295
________ 109 ________ 19376
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93500
Đầu ra
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1
Phân tích độ phức tạp
Độ phức tạp về thời gian. Trên]. 
Cần có hai lần duyệt mảng. 
Không gian phụ trợ. Ô[1]. 
Vì không cần thêm dung lượng. 
Phương pháp tiếp cận hiệu quả.  
Tìm phần tử lớn thứ hai trong một lần truyền tải.  
Dưới đây là thuật toán hoàn chỉnh để làm điều này.   
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
0Dưới đây là việc thực hiện các phương pháp trên
C



def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0142
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
102
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0144
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9383
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
01
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
02 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
03def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
05def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
07
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
________ 109 ________ 104 ________ 211
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
13
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
16
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
18function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
00/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
03/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
04
________ 109 ________ 306
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0173
________ 109 ________ 106 ________ 10176
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0178
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93823____10180
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0183
_______523____10185
_______523____10187
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0191
________ 193823 ________ 10193
________ 217 ________ 193551 ________ 215 ________ 10197
_______523____10099
________ 109 ________ 306
________ 109 ________ 215 ________ 10204
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
18function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9358/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93551
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
18function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0215def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93679
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9361
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9363
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
________ 109 ________ 104 ________ 19367
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9370______19371def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9372def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9371def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9374
________ 109 ________ 19376
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
03 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9379
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
C++



def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0238
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93502
________ 1937 ________ 1938 ________ 100
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0243
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0244
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93507def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
05def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93511
________ 109 ________ 104 ________ 10253
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
06 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93521
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0261
_______523____10185
_______523____10265
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
________ 217 ________ 193551 ________ 215 ________ 10271
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0274
_______5203____10276
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
________ 109 ________ 306
________ 109 ________ 303 ________ 10283
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93565
________ 109 ________ 104 ________ 19367
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0292____19371def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93573def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9371def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0296
________ 109 ________ 215 ________ 10299
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93583def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0302/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
04
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93551
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93583def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93590 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0309
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
Java



def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0311
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
102
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
103 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93596
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
105 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0316
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0318
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0320
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
192 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
109 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
02 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
03def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
05
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0328def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
07
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
11
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
13
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
127function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
128def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0342
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0344/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
00/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
_______523____303____304
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0353
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
06 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93636function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
154def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0358
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23____10360
_______523____10362
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0183
_______5203____10185
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
203def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0187
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
_______523____10191
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0374def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0193
________ 523
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93551 ________ 215 ________ 10197
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
203def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0099
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93663
_______523____10344____10389
________ 10390 ________ 2172 ________ 10392 ________ 301
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____193551
_______523____10344____10398
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0390function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
172____10401 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0121
________ 109 ________ 306
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09____19361
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
192 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
109 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
02 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
195
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
199_______3000/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
002/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
165/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
006/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
008/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
165 /*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
011
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 /*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
014
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____19376
________ 109 ________ 306
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0437
Python3



def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0438
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0439
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0440
 
 
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
022
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
023
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
024 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93717
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93719
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____193721
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
127____2128/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
072
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
039function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
00function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
129
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
03
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09
 
________ 109
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0464/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 ________ 193738/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 ________ 3063def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0469
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
06 /*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
059____3060 /*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
061def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0475
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0478
_______5203____10480
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____10482
_______5203____10484
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0487
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93738/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0464
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0464____3081 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0496
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0499
_______5203____10501
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0503
________ 217
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0505 ________ 10506def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0507 ________ 10508/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 _______ 10510
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93738/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0496
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09
________ 109
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 ________ 193780/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 ________ 3063def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0469/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
072
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
039function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
000function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
129
________ 109 ________ 193551 _______ 193796
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
039function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
090def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0536
 
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0537
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0538
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
003/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
005/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
000/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
002/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
165/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
006/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
008/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
165def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
017
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
018/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
020def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
021
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
022
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0559
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0560
C#


  


def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0561
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
102
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
937 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
027
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
105 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0316
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
107
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
108
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
192 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
109 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
02 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
03def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0577
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0328def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
07
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
11
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____5238
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
16
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0592/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
00/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
_______523____303____304
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0601def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93878
________ 217 ________ 106 ________ 10176
_______523____10608
_______523____10610
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0183
_______5203____10185
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
203def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0187
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
_______523____10621
_______523____10623
________ 523
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93551 ________ 215 ________ 10197
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
203def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0099
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0007def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0009
_______523____1054____10389
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
114function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
172def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0392/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____193551
_______523____1054____10398
________ 2114 ________ 2172 ________ 10401 ________ 10121
________ 109 ________ 306
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0656
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
192 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
109 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
02 Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
211
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0666
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
218
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____19376
________ 109 ________ 306
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0675
PHP



def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0676
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0677
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
102
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
107
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
108
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
232 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
03____10683____3001def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0685function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
129
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0689
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0691
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19____10685 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0696
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0700function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
00/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
03/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
04
________ 109 ________ 306
 
________ 109
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0710 ________ 3081def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0712 _______ 10713
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
06 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0717 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0718def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0717 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0720def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0685 /*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
04def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0717def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0724
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0729
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____10731
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____10733
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0735
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0683def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
005def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0717def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0742def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0710function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
129
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0712 /*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0710/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
04
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0710 /*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0683def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
005def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0717def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93829
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0762
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____10764
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0766
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0768
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93551 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0683def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
005def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0717def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0742def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0712 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0778
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
066def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0683def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
005def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0717def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0783def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0710function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
129
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0712 /*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0683def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
005def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0717def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93829
________ 109 ________ 306
________ 109
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 ________ 219____10712 _______ 10799
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0700function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9358/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93551
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0700function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
273 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0811def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0712 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0811def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0814/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0656
________ 10683 ________ 3081
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0820 ________ 10821
________ 10822 ________ 10823 ________ 10683 ________ 301
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
03def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0683/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0822/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0831
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0832
Javascript



Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
225
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
028
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
226
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
102
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118
_______109____5230
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
232 Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
233
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____10056
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____10058
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____5238
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
16
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
243/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
00/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
_______523____303____304
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
118
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0076
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
06 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0094
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0082
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
203def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0873
_______5203____10875
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93551 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0881
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
203def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0099
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
028
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0107
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
243____5285/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
01
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93551def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
08
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
243____5273 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0121
_______5203____303____304
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09
 
________ 109 ________ 5291
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
028
________ 109 ________ 5293
________ 109 ________ 5295
________ 109 ________ 19376
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
028def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0925
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
028
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93500
Đầu ra
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0
Phân tích độ phức tạp
Độ phức tạp về thời gian. Trên]. 
Chỉ cần một lần duyệt mảng. 
Không gian phụ trợ. Ô[1]. 
Vì không cần thêm dung lượng. 
Một cách tiếp cận khác để tìm lớn thứ hai bằng cách sử dụng cấu trúc dữ liệu bản đồ
Bước 1. Khởi tạo dữ liệu bản đồ
Bước 2. Lưu trữ các phần tử của mảng với số lượng của chúng trong bản đồ và cấu trúc dữ liệu bản đồ luôn sắp xếp các phần tử theo thứ tự tăng dần của chúng
Bước 3. Nếu kích thước bản đồ lớn hơn 1 thì tồn tại lớn thứ hai nếu không tồn tại
Bước 4. Nếu kích thước lớn hơn 1 thì lấy khóa cuối cùng thứ hai từ cuối bằng cách sử dụng rbegin[] của cấu trúc dữ liệu bản đồ vì mọi khóa sẽ khác biệt.  
Bước 5. Cuối cùng in lớn thứ hai.  
Hãy xem cách triển khai thuật toán trên. –
C++



def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
936
 
________ 1937 ________ 1938 ________ 100
 
________ 102 ________ 193507______104 _______ 10935 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0937
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0939
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0942
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93583def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0945/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
04
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
03/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
04
________ 109 ________ 306
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0953def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04____3001def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0957
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
06____219def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0962
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____10964
________ 109 ________ 306
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0968
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0970
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0972
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15____10975
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93583def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0978/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
04
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
03/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
04
________ 109 ________ 306
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0987
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
06____219def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0991 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0992
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____215____10995
_______ 523____193583 _______ 10998 ________ 10999
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1001/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
04
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17____21006
________ 109 ________ 306
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1010
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93565
________ 109 ________ 21015 ________ 104 ________ 21017
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1019
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
03 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
9379
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
06
Python3



________ 21024 ________ 21025 ________ 2103 ________ 21027
 
/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
024 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1029
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1031
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1034function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
128def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93796
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
039function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0945function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
129
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
03
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1045/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1047def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
04function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
129
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
06 /*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
059____3060 /*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
061function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1055
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1057____2172/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
165
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1062
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1064
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1066
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
020function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1070/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
165def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93796
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
039function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
0978function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
129
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
03
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1083
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1085/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1087function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1088/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1090 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1091function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
154function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1093/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1095function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
129
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1098/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1100
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
06 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1103/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
060 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1105function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1106
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 /*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
059____3081/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
165def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93796
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1098/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1117
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
23____21001
 
def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
09function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
15 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1098function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1123 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1124 function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1100def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
93796
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
17/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
039function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
19function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1130function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1131
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1132/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
081 def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
005/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
000/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
002/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
165/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
006/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
008/*
* C Program to find second maximum element in an array
*/
#include 
#include 
#include 

int main[]{
    int inputArray[500], elementCount, counter;
    int maxElement, secondMaxElement;
    
    printf["Enter number of elements in array: "];
    scanf["%d", &elementCount];
    if[elementCount < 2]{
        printf["Number of elements should be more \
            than or equal to two"];
        return 0;
    }
        
    printf["Enter %d numbers \n", elementCount];
    for[counter = 0; counter < elementCount; counter++]{
        scanf["%d", &inputArray[counter]];
    }
    /* Initialize maxElement and secondMaxElement 
       with INT_MIN */
    
    maxElement = secondMaxElement = INT_MIN;
    
    for[counter = 0; counter < elementCount; counter++]{
        if[inputArray[counter] > maxElement]{
            secondMaxElement = maxElement;
            maxElement = inputArray[counter];
        } else if [inputArray[counter] > secondMaxElement 
            && inputArray[counter] != maxElement]{
            secondMaxElement = inputArray[counter];
        }
    }
    /* Print Second Maximum element */
    printf["Second Maximum element: %d", secondMaxElement];
        
    getch[];
    return 0;
}
001function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
165def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
017
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1147def second_largest[arr]:
    arr.sort[]
    for i in range[len[arr]-2, 0, -1]:
        if arr[i] != arr[i - 1]:
            return arr[i]
      
arr = [4, 2, 1, 3, 5]
print["The second largest element is: {0}".format[[second_largest[arr]]]]
020function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1149
 
function secondLargest[arr] {
  arr.sort[];
  for [let i = arr.length - 2; i >= 0; i--] {
    if [arr[i] != arr[i - 1]] {
      return arr[i];
    }
  }
}
            
arr = [4, 2, 1, 3, 5];
console.log[`The second largest element is: ${secondLargest[arr]}`];
1150
Đầu ra
Enter number of elements in array: 5
Enter 5 numbers
0 1 0 0 1
Second Maximum element: 0
2
Độ phức tạp về thời gian. O[n], trong đó n = kích thước của mảng
Không gian phụ. O[n]
Bài viết liên quan. 
Phần tử nhỏ nhất và nhỏ thứ hai trong mảng
Bài viết này được đóng góp bởi Harsh Agarwal. Nếu bạn thích GeeksforGeeks và muốn đóng góp, bạn cũng có thể viết một bài báo bằng cách sử dụng write. chuyên viên máy tính. org hoặc gửi bài viết của bạn tới review-team@geeksforgeeks. tổ chức. Xem bài viết của bạn xuất hiện trên trang chính của GeeksforGeeks và trợ giúp các Geeks khác.  
 
			Làm cách nào để tìm số lớn nhất và thứ hai trong mảng mà không cần sắp xếp Java?
			Tìm số lớn thứ 2 trong mảng bằng cách sử dụng mảng . 
 nhập java. sử dụng. Mảng;
 lớp công khai SecondLargestInArrayExample1{
 public static int getSecondLargest[int[] a, int total]{
 Mảng. sắp xếp[a];
 trả về [tổng-2];
 public static void main[String args[]]{
 int a[]={1,2,5,6,3,2};
 
		
			Làm cách nào để tìm số lớn thứ hai trong mảng mà không cần sắp xếp trong javascript?
			Tìm phần tử lớn thứ hai trong một mảng trong Javascript . 
 Khởi tạo hai biến thứ nhất và thứ hai thành INT_MIN là. thứ nhất = thứ hai = INT_MIN
 Bắt đầu duyệt qua mảng, a] Nếu phần tử hiện tại trong mảng cho biết arr[i] lớn hơn. hơn đầu tiên. Sau đó cập nhật thứ nhất và thứ hai dưới dạng, thứ hai = thứ nhất.  .  
 Trả về giá trị được lưu trữ trong giây
 
		
			Làm cách nào để tìm số nhỏ thứ hai trong mảng mà không cần sắp xếp?
			Cách 2 tìm phần tử nhỏ thứ hai trong mảng . 
 Khai báo mảng và nhập các phần tử của mảng
 Tìm phần tử nhỏ nhất [first_smallest] trong mảng ở lần duyệt đầu tiên
 Tìm phần tử nhỏ nhất [second_smallest] bằng cách bỏ qua phần tử first_smallest
 Hiển thị thứ hai_nhỏ nhất
 
		
			Cách tìm phần tử lớn thứ hai trong mảng trong C?
			Thuật toán . 
 Bước 1 - Khai báo và đọc số phần tử
 Bước 2 - Khai báo và đọc kích thước mảng khi chạy
 Bước 3 - Nhập các phần tử mảng
 Bước 4 – Sắp xếp các số theo thứ tự giảm dần
 Bước 5 - Sau đó, tìm số lớn thứ hai và nhỏ thứ hai bằng cách sử dụng chỉ số


				
					

                 
	Bài Viết Liên Quan
	
	 	
		
		   
		   
		   
		
		
			Tải xuống wordpress 5.8.4

		
	

		
		
		   
		   
		   
		
		
			Việc xóa bộ nhớ cache có xóa bộ nhớ phiên không?

		
	

		
		
		   
		   
		   
		
		
			Cách kiểm tra bất kỳ giá trị tồn tại trong mảng trong javascript

		
	

		
		
		   
		   
		   
		
		
			Concerts Tokyo January 2023

		
	

		
		
		   
		   
		   
		
		
			Chạy ARIMA bằng Python

		
	

		
		
		   
		   
		   
		
		
			Liên kết trong HTML là gì

		
	

		
		
		   
		   
		   
		
		
			Cách lấy id từ một trang php khác?

		
	

		
		
		   
		   
		   
		
		
			70ml bằng bao nhiêu mg

		
	

		
		
		   
		   
		   
		
		
			Ai là thống đốc tiếp theo của Plateau State 2023?

		
	

		
		
		   
		   
		   
		
		
			Lập trình Python và phương pháp số GitHub

		
	

		
		
		   
		   
		   
		
		
			Định dạng ngày tháng php với t và z

		
	

		
		
		   
		   
		   
		
		
			Làm cách nào để kiểm tra xem một chuỗi chỉ chứa một số ký tự nhất định trong Python?

		
	

		
		
		   
		   
		   
		
		
			Os về Python

		
	

		
		
		   
		   
		   
		
		
			When does FAU application open for fall 2023

		
	

		
		
		   
		   
		   
		
		
			Laravel truncate table trước khi seed

		
	

		
		
		   
		   
		   
		
		
			Thêm khóa mul MySQL

		
	

		
		
		   
		   
		   
		
		
			Làm thế nào để bạn tìm thấy giá trị ascii của a trong php?

		
	

		
		
		   
		   
		   
		
		
			Cau lenh đặt ip trong linux

		
	

		
		
		   
		   
		   
		
		
			What days is october 31 2023?

		
	

		
		
		   
		   
		   
		
		
			Viết hàm tính diện tích và chu vi hình chữ nhật trong python

		
	

	
	




Toplist mới

 
	
	 
		#1
		
			Top 9 tập bản đồ lớp 8 bài 31 2023
			7 tháng trước
		
	



	
	 
		#2
		
			Top 6 kết quả thi hsg đà nẵng 2022 2023
			7 tháng trước
		
	



	
	 
		#3
		
			Top 9 tủ nhựa đài loan 4 cánh 3d 2023
			7 tháng trước
		
	



	
	 
		#4
		
			Top 9 chất khí có thể làm mất màu dung dịch nước brom là: a. so2. b. co2. c. o2. d. hcl. 2023
			7 tháng trước
		
	



	
	 
		#5
		
			Top 8 tìm việc làm tiện, phay bảo q7 2023
			7 tháng trước
		
	



	
	 
		#6
		
			Top 3 tôi xuyên thành tiểu kiều the của lão đại phản 2 2023
			7 tháng trước
		
	



	
	 
		#7
		
			Top 9 đổi mới phong cách, thái độ phục vụ của cán bộ y tế hướng tới sự hài lòng của người bệnh 2023
			7 tháng trước
		
	



	
	 
		#8
		
			Top 2 bài the dục phát triển chung lớp 6 2022 2023
			7 tháng trước
		
	



	
	 
		#9
		
			Top 3 bài giảng vũ điệu sắc màu (lớp 4) 2023
			7 tháng trước
		
	






		


	Bài mới nhất
	
	 	
		
		   
		   
		   
		
		
			Bài toán liên quan tới mức cường độ âm năm 2024

		
	

		
		
		   
		   
		   
		
		
			Trung tâm thực tại y khoa bình hòa tp hcm năm 2024

		
	

		
		
		   
		   
		   
		
		
			Khi nào đăng ký nguyện vọng đại học 2023 năm 2024

		
	

		
		
		   
		   
		   
		
		
			Top 5 em gái đồng phim sex đẹp nhất năm 2024

		
	

		
		
		   
		   
		   
		
		
			Giải bài tập hệ phương trình tuyến tính năm 2024

		
	

		
		
		   
		   
		   
		
		
			Cách hủy thông báo phát hành hóa đơn điện tử năm 2024

		
	

		
		
		   
		   
		   
		
		
			Bài 7 sgk toán lớp 9 trang 69 năm 2024

		
	

		
		
		   
		   
		   
		
		
			2 bài toán cơ bán của định vị vệ tinh năm 2024

		
	

		
		
		   
		   
		   
		
		
			Top and bottom margins in word not showing năm 2024

		
	

		
		
		   
		   
		   
		
		
			Bảo hiểm hàng không trụ sở lê văn lương năm 2024

		
	

	
	
                 
	Chủ Đề
	
	
	
		  programming
		  Hỏi Đáp
		  Toplist
		  Là gì
		  Mẹo Hay
		  Địa Điểm Hay
		  mẹo hay
		  Học Tốt
		  Công Nghệ
		  Nghĩa của từ
		  Khỏe Đẹp
		  Bao nhiêu
		  đánh giá
		  Top List
		  bao nhieu
		  bao nhiêu
		  hướng dẫn
		  Xây Đựng
		  Bài tập
		  So Sánh
		  Tiếng anh
		  So sánh
		  Sản phẩm tốt
		  Ngôn ngữ
		  Bài Tập
		  javascript
		  Thế nào
		  Ở đâu
		  Hướng dẫn
		  Dịch 
		  Máy tính
		  Tại sao
		  Đại học
		  Món Ngon
		  Khoa Học