CareerCup

Mayn't be well optimized but should work.

/**
	 * Replace each number with the next bigger number from right side of current index.
	 * If no bigger number found, print the no itself.
	 * E.g.
	 * input;  2,5,9,6,3,4,8,15,12
	 * output: 3,6,12,8,4,8,12,15,12
	 */
	public static void nextBiggerNumber() {
		int in[] = {2,5,9,6,3,4,8,15,12};
		int out[] = new int[in.length];
		int nextBigNo;
		boolean found = false;
		
		
		//Find the next big no for all n-1 elements
		for (int j=0; j<in.length-1; j++) {
			
			found = false;
			nextBigNo = in[j];
			
			for (int k=j+1; k<in.length; k++) {
				if (in[k] > in[j]) {
					if (!found) {
						nextBigNo = in[k];
						found = true;
					}else {
						if (in[k] < nextBigNo) 
							nextBigNo=in[k];
					}				
					
				}
			}
			
			out[j]=nextBigNo;
			
		}
		
		//Copy the last element
		out[in.length -1] = in[in.length-1]; 
		
		for (int i=0; i<out.length; i++) {
			System.out.print(out[i] + ", ");
		}
	}

# Replace each number with the next bigger number from right side of current index.
# program is in python version 3...
arr_input = [2,5,9,6,3,4,8,15,12];#input array......
arr_result = arr_input;#result or output of our input....
print(arr_input)
for i in range(len(arr_input)):
    temp = arr_input[i]
    remainingelements = sorted(arr_input[i:])#make a sorted array of remaining elements on right side
    for j  in range(len(remainingelements)):
         if(remainingelements[j]>temp):#check for greatest element on the right side....
             arr_result[i] = remainingelements[j]#insert to the output
             break

# print the output
print(arr_result)

# Replace each number with the next bigger number from right side of current index.
# program is in python version 3...
arr_input = [2,5,9,6,3,4,8,15,12];#input array......
arr_result = arr_input;#result or output of our input....
print(arr_input)

for i in range(len(arr_input)):
    temp = arr_input[i]
    remainingelements = sorted(arr_input[i:])#make a sorted array of remaining elements on right side

    for j  in range(len(remainingelements)):

         if(remainingelements[j]>temp):#check for greatest element on the right side....
             arr_result[i] = remainingelements[j]#insert to the output
             break

# print the output
print(arr_result)

~ replace each number in a list by its next bigger number.
~ No replacing if the number is the biggest or at the end of the list.
~ code in Phyton 3

def fun (lst):
    work = lst
    for i in range(0,len(work)):
        if work[i] == max(work) or i == len(work)-1:
            continue
        else:
            temp = [x for x in work if x > work[i]]
            work[i] = min(temp)
    return work

import java.util.Arrays;
class replaceNumbers{ 
	public static void main(String[] args) {
		int in[] = {2,5,9,6,3,4,8,15,12};		
		System.out.println(Arrays.toString(nextBigNumbers(in)));
	}

	public static int[] nextBigNumbers(int[] in) {
		int out[] = new int[in.length];	
		int k=0;
		int num=0;
		boolean[] check = new boolean[in.length];
		for(int i=0;i<in.length;i++){
			int diff=Integer.MIN_VALUE;
			int mindiff=Integer.MAX_VALUE;
			for(int j=i+1;j<in.length;j++){
				diff = (in[j] - in[i]);
				if(diff > 0 && diff < mindiff){
					mindiff = diff;
					num = in[j];
					check[i] = true;
				}				
			}
		
			if(check[i]){
				out[k++] = num;
			}else{
				out[k++] = in[i];
			}
		}	
		return out;
	}	
}

public class Test20_ArrayNextBiggerElement {
	public void addNextBigger(int[] arr) {
		int min = 0;
		for (int i = 0; i < arr.length; i++) {
			min = Integer.MAX_VALUE;
			for (int j = i + 1; j < arr.length; j++)
				if (arr[j] > arr[i])
					min = Math.min(min, arr[j]);
			if (min != Integer.MAX_VALUE)
				arr[i] = min;
		}
	}

	public static void main(String[] args) {
		int[] arr = { 2, 5, -9, 6, 3, -4, 8, 1, 15, 12 };
		Test20_ArrayNextBiggerElement obj = new Test20_ArrayNextBiggerElement();
		obj.addNextBigger(arr);
		for (int num : arr) {
			System.out.print(num + " ");
		}
	}
}

public class Test20_ArrayNextBiggerElement {
	public void addNextBigger(int[] arr) {
		int min = 0;
		for (int i = 0; i < arr.length; i++) {
			min = Integer.MAX_VALUE;
			for (int j = i + 1; j < arr.length; j++)
				if (arr[j] > arr[i])
					min = Math.min(min, arr[j]);
			if (min != Integer.MAX_VALUE)
				arr[i] = min;
		}
	}

	public static void main(String[] args) {
		int[] arr = { 2, 5, -9, 6, 3, -4, 8, 1, 15, 12 };
		Test20_ArrayNextBiggerElement obj = new Test20_ArrayNextBiggerElement();
		obj.addNextBigger(arr);
		for (int num : arr) {
			System.out.print(num + " ");
		}
	}
}

public class Test20_ArrayNextBiggerElement {
	public void addNextBigger(int[] arr) {
		int min = 0;
		for (int i = 0; i < arr.length; i++) {
			min = Integer.MAX_VALUE;
			for (int j = i + 1; j < arr.length; j++)
				if (arr[j] > arr[i])
					min = Math.min(min, arr[j]);
			if (min != Integer.MAX_VALUE)
				arr[i] = min;
		}
	}

	public static void main(String[] args) {
		int[] arr = { 2, 5, -9, 6, 3, -4, 8, 1, 15, 12 };
		Test20_ArrayNextBiggerElement obj = new Test20_ArrayNextBiggerElement();
		obj.addNextBigger(arr);
		for (int num : arr) {
			System.out.print(num + " ");
		}
	}
}

List<Integer>  li = new ArrayList();
    Integer[] arr = {2,5,9,6,3,4,8,15,12};
    li=  Arrays.asList(arr);
    List<Integer>  li2 =  new ArrayList();
    for(int i=0;i<arr.length;i++) {
      li2.add(arr[i]);
    }   
    System.out.println(li2);
    List<Integer>  li3 = new ArrayList();
    List<Integer>  li4 = new ArrayList();
    for(int i=0;i<li.size();i++) {
         li2.remove(li2.indexOf(li.get(i)));
        li3.clear();
        li3.addAll(li2);
        Collections.sort(li3);
        if(li3.isEmpty()) {
            li4.add(li.get(i));
        }
        for(int j=0;j<li3.size();j++) {
                if(li.get(i) < li3.get(j))  {
                    li4.add(li3.get(j));
                    break;
                }
            
                if(j==li3.size()-1) {
                    li4.add(li.get(i));
                }
    }
    }
    System.out.println(li4);

List<Integer>  li = new ArrayList();
    Integer[] arr = {2,5,9,6,3,4,8,15,12};
    li=  Arrays.asList(arr);
    List<Integer>  li2 =  new ArrayList();
    for(int i=0;i<arr.length;i++) {
      li2.add(arr[i]);
    }   
    System.out.println(li2);
    List<Integer>  li3 = new ArrayList();
    List<Integer>  li4 = new ArrayList();
    for(int i=0;i<li.size();i++) {
         li2.remove(li2.indexOf(li.get(i)));
        li3.clear();
        li3.addAll(li2);
        Collections.sort(li3);
        if(li3.isEmpty()) {
            li4.add(li.get(i));
        }
        for(int j=0;j<li3.size();j++) {
                if(li.get(i) < li3.get(j))  {
                    li4.add(li3.get(j));
                    break;
                }
            
                if(j==li3.size()-1) {
                    li4.add(li.get(i));
                }
    }
    }
    System.out.println(li4);

class NextBigIntArray{
public static void updateArray(int[] arr){
int d, cd, nextInt;

for(int i=0;i<arr.length;++i){
d=0;
nextInt=arr[i];
for(int j=i+1;j<arr.length;++j){
cd=arr[j]-arr[i];

if(0<cd && (0==d || d>cd)){
nextInt=arr[j];
d=cd;
}
}
arr[i]=nextInt;
}
}

public static void main(String[] args){
int[] arr = {8, 7, 9, 1, 10, 12, 5, 4};
// int[] arr = {-6, -3, -1, -2};

updateArray(arr);

for(int i:arr)
System.out.print(i);
}
}

class NextBigIntArray{
	public static void updateArray(int[] arr){
		int d, cd, nextInt;

		for(int i=0;i<arr.length;++i){
			d=0;
			nextInt=arr[i];
			for(int j=i+1;j<arr.length;++j){
				cd=arr[j]-arr[i];

				if(0<cd && (0==d || d>cd)){
					nextInt=arr[j];
					d=cd;
				}
			}
			arr[i]=nextInt;
		}
	}

	public static void main(String[] args){
		int[] arr = {8, 7, 9, 1, 10, 12, 5, 4};
		// int[] arr = {-6, -3, -1, -2};

		updateArray(arr);

		for(int i:arr)
			System.out.print(i);
	}
}

I think its time and space complexity it O(n)

void nextgreat(vector<int>& nums){
    set<int> my_set;
    set<int>:: iterator it;
    int i = nums.size()-1;
    while(i > -1){
        my_set.insert(nums[i]);
        it = my_set.find(nums[i]);
        ++it;
        if(it != my_set.end()) nums[i] = (*it);
        i--;
    }
}

public class ReplaceNumByItsNextBiggestNum {

public static void main(String[] args)
{
ReplaceNumByItsNextBiggestNum obj = new ReplaceNumByItsNextBiggestNum();
obj.replaceNumbers(new int[] {2,5,9,6,3,4,8,15,12});
}

private void replaceNumbers(int[] input)
{
int nextMaxNum = Integer.MAX_VALUE;

for(int i = 0; i < input.length; i++)
{
nextMaxNum = Integer.MAX_VALUE;
for(int j = i +1; j < input.length; j++)
{
if(input[i] < input[j] && input[j] < nextMaxNum)
nextMaxNum = input[j];
}
if(nextMaxNum == Integer.MAX_VALUE)
nextMaxNum = input[i];
System.out.print(nextMaxNum + " ");
}
}
}

Please find below javascript solution

var arr = [2,5,9,6,3,4,8,15,12];
var arrCopy = [...arr];
var original = [...arr];
arr = Array.from(new Set(arr.sort((a,b) => a-b)));
for(let i=0;i<original.length;i++) {
    let val = arr[arr.indexOf(original[i]) + 1];
    if(val > arrCopy[i] && original.lastIndexOf(val) > i) {
        arrCopy[i] = arr[arr.indexOf(arrCopy[i]) + 1];
    } else {
        for (let j=arr.indexOf(original[i]) + 1;j<arr.length;j++) {
            if (arr[j] > arrCopy[i] && original.lastIndexOf(arr[j]) > i) {
                arrCopy[i] = arr[j];
                break;
            }
        }
    }
}

console.log(arrCopy);

var arr = [2,5,9,6,3,4,8,15,12];
var arrCopy = [...arr];
var original = [...arr];
arr = Array.from(new Set(arr.sort((a,b) => a-b)));
for(let i=0;i<original.length;i++) {
    let val = arr[arr.indexOf(original[i]) + 1];
    if(val > arrCopy[i] && original.lastIndexOf(val) > i) {
        arrCopy[i] = arr[arr.indexOf(arrCopy[i]) + 1];
    } else {
        for (let j=arr.indexOf(original[i]) + 1;j<arr.length;j++) {
            if (arr[j] > arrCopy[i] && original.lastIndexOf(arr[j]) > i) {
                arrCopy[i] = arr[j];
                break;
            }
        }
    }
}

console.log(arrCopy);

{{public class ReplaceBiggerNumber {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int count=0;
int n1[]=new int[n];
for(int i=0;i<n;i++)
{
n1[i]=sc.nextInt();
}
for(int i=0;i<n;i++)
{
int min=100000;
for(int j=i+1;j<n;j++)
{
if(n1[j]<min && n1[j]>n1[i] && n1[i]!=n1[j])
{
min=n1[j];
count=1;
}
}
if(count==1)
{
n1[i]=min;
count=0;
}
}
for(int i=0;i<n;i++)
{
System.out.println(n1[i]);
}
}}
}}

{{
public class ReplaceBiggerNumber {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int count=0;
int n1[]=new int[n];
for(int i=0;i<n;i++)
{
n1[i]=sc.nextInt();
}
for(int i=0;i<n;i++)
{
int min=100000;
for(int j=i+1;j<n;j++)
{
if(n1[j]<min && n1[j]>n1[i] && n1[i]!=n1[j])
{
min=n1[j];
count=1;
}
}
if(count==1)
{
n1[i]=min;
count=0;
}
}
for(int i=0;i<n;i++)
{
System.out.println(n1[i]);
}
}}
}}

var arr = [2,5,9,6,3,4,8,15,12];
// output: 3,6,12,8,4,8,12,15,12


function nextBiggerNumber() {
    var newArr = [];
    for (var i=0; i<arr.length; i++) {
        newArr.push(findNextNumber(i));
    }
    return newArr;
}

function findNextNumber(currentIndex) {
    var counter = 1;
    var ele = null;
    while (true) {
        for (var j=currentIndex+1;j<arr.length;j++) {
            if (arr[currentIndex]+counter === arr[j]) {
                ele =  arr[j];
                break;
            }
        }
        if (ele === arr[currentIndex] + counter || counter === arr.length -1) {
            break;
        } else {
            counter++;
        }
    }
    if (ele === null) {
        return arr[currentIndex];
    } else {
        return ele;
    }
}

console.log(nextBiggerNumber());