climbingLeaderBoard * needs: * supply *fixed lead

package com.microsoft.controller;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.UUID;

public class MicrosoftController {

	public static void main(String[] args) {
		System.out.println("Hello World!");
		List<Integer> ranked=new ArrayList<Integer>();
		ranked.add(100);
		ranked.add(90);
		ranked.add(90);
		ranked.add(80);
		System.out.println(ranked);
		List<Integer> player=new ArrayList<Integer>();
		player.add(70);
		player.add(80);
		player.add(105);
		List<Integer> indexList=climbingLeaderBoard(ranked,player);
		System.out.println(indexList);
	}
	
	/**
	 * climbingLeaderBoard
	 * needs:
	 * supply
	 * fixed leaderBoard score array is descending rank: [100,90,90,80]
	 * new player score array is ascending rank: [70,80,105]
	 * return a new array contains index position which new player fit to be right position
	 * new players should be came to the leaderBoared score array
	 * attention: American need be the first position and next position is next step rank player score
	 * constrains:
	 * n is number size means leaderBoared score array size
	 * m is number size means player score array size
	 * 1<=n<=10to5
	 * 1<=m<=10to5
	 * 0<=ranked[i]<=10to9 while 0<=i<n
	 * 0<=player[j]<=10to9 while 0<=j<m
	 * The existing leaderboard, ranked, is in descending order
	 * The player's scores, player, is in ascending order 
	 * Subtask
	 * For 60% of the maximum score:
	 * 1<=n<=200
	 * 1<=m<=200
	 * @param ranked
	 * @param player
	 * @return
	 */
	public static List<Integer> climbingLeaderBoard(List<Integer> ranked,List<Integer> player){
		if(!checkClimbingLeaderBoardData(ranked, player)) {
			return null;
		}
		List<CustIntArrEle> custIntArrEleList=buildNewOrderedLeaderBoard(ranked, player);
		List<Integer> retIntArrChangedIndexList=new ArrayList<Integer>();
		custIntArrEleList.forEach(e->{
			Boolean positionIndexChangedFlag=e.getIsChangedPositionIndexFlag();
			if(positionIndexChangedFlag) {
				int retNewOrderdPositionIndex=e.getIntArrEleIndexPositionTo();
				retIntArrChangedIndexList.add(retNewOrderdPositionIndex-1);
			}
		});
		return retIntArrChangedIndexList;
	}
	
	/**
	 * check climbingLeanderBoard data is right data
	 * constraints check
	 * @param ranked
	 * @param player
	 * @return
	 */
	public static Boolean checkClimbingLeaderBoardData(List<Integer> ranked,List<Integer> player) {
		if(ranked==null) {
			return false;
		}
		if(ranked.isEmpty()) {
			return false;
		}
		if(player==null) {
			return false;
		}
		int valRet=1;
		for (int i = 0; i < 5; i++) {
			valRet*=10;
		}
		int size = ranked.size();
		if(size<1 || size>valRet) {
			return false;
		}
		if(player.size()<1 || player.size()>valRet) {
			return false;
		}
		int valRet1=1;
		for (int i = 0; i < 9; i++) {
			valRet1*=10;
		}
		int rankedSize=ranked.size();
		for (int i = 0; i < rankedSize; i++) {
			int rankedEle=ranked.get(i);
			if(rankedEle<1 || rankedEle>valRet1) {
				return false;
			}
		}
		for (int i = 0; i < player.size(); i++) {
			int playerEle=player.get(i);
			if(playerEle<1 || playerEle>valRet1) {
				return false;
			}
		}
		if(!checkArrIsOrderedDesc(ranked)) {
			return false;
		}
		if(checkArrIsOrderedDesc(player)) {
			return false;
		}
		if(!checkArrEleIsRankedVolumn(ranked)) {
			return false;
		}
		if(!checkArrEleIsRankedVolumn(player)) {
			return false;
		}
		return true;
	}
	
	/**
	 * build new ordered leader board 
	 * @param ranked
	 * @param player
	 * @return
	 */
	public static List<CustIntArrEle> buildNewOrderedLeaderBoard(List<Integer> ranked,List<Integer> player){
		List<CustIntArrEle> concatnateIntArr = concatnateIntArr(ranked, player);
		for (int i = 0; i < concatnateIntArr.size(); i++) {
			CustIntArrEle custIntArrEle=concatnateIntArr.get(i);
			for (int j = 0; j < concatnateIntArr.size(); j++) {
				CustIntArrEle custIntArrEle1=concatnateIntArr.get(j);
				if(!(custIntArrEle.getIntArrEle()>custIntArrEle1.getIntArrEle())) {
					if(!checkIsAmericanNameList(null)) {
						custIntArrEle.setIsChangedPositionIndexFlag(true);
						custIntArrEle.setIntArrEleIndexPositionTo(custIntArrEle.getIntArrEleIndexPositionTo()+1);
					}
				}
			}
		}
		return concatnateIntArr;
	}
	
	
	/**
	 * check is in American name list
	 * @param nameList
	 * @return
	 */
	public static Boolean checkIsAmericanNameList(List<String> nameList) {
		return true;
	}
	
	/**
	 * concatnate two int arr by using oop design 
	 * wrapped to CustIntArrEle
	 * @param ranked
	 * @param player
	 * @return
	 */
	public static List<CustIntArrEle> concatnateIntArr(List<Integer> ranked,List<Integer> player){
		if(!checkClimbingLeaderBoardData(ranked, player)) {
			return null;
		}
		List<CustIntArrEle> newRankedConcatnateList=new ArrayList<CustIntArrEle>();
		for (int i = 0; i < ranked.size(); i++) {
			int intEle=ranked.get(i);
			CustIntArrEle custIntArrEle=new CustIntArrEle();
			custIntArrEle.setId(UUID.randomUUID().toString());
			custIntArrEle.setIntArrEle(intEle);
			custIntArrEle.setIntArrEleIndexPositionFro(i);
			newRankedConcatnateList.add(custIntArrEle);
		}
		for (int i = 0; i < player.size(); i++) {
			int intEle=player.get(i);
			CustIntArrEle custIntArrEle=new CustIntArrEle();
			custIntArrEle.setId(UUID.randomUUID().toString());
			custIntArrEle.setIntArrEleIndexPositionFro(i);
			newRankedConcatnateList.add(custIntArrEle);
		}
		return null;
	}
	
	/**
	 * check int array ele is ordered asc or desc
	 * @param intList
	 * @return
	 */
	public static Boolean checkArrIsOrderedDesc(List<Integer> intList) {
		if(intList==null) {
			return null;
		}
		if(intList.isEmpty()) {
			return null;
		}
		for (int i = 0; i < intList.size(); i++) {
			int intEle=intList.get(i);
			for (int j = 0; j < intList.size(); j++) {
				int intEle1=intList.get(j);
				if(!(intEle>intEle1)) {
					return false;
				}
			}
		}
		return true;
	}
	
	/**
	 * check int arr ele is in encloure 200
	 * and this intArrEle appearence frequency percentege equals 60%
	 * @param intList
	 * @return
	 */
	public static Boolean checkArrEleIsRankedVolumn(List<Integer> intList) {
		if(intList==null) {
			return null;
		}
		if(intList.isEmpty()) {
			return null;
		}
		Random random=new Random();
		int statisticCount=0;
		int count=0;
		while(true) {
			for (int i = 0; i < intList.size(); i++) {
				int intListRandomIndex=random.nextInt(intList.size());
				int randomIntEle=intList.get(intListRandomIndex);
				for (int j = 0; j < 200; j++) {
					int intEle=intList.get(j);
					if(randomIntEle==intEle) {
						statisticCount++;
					}
				}
			}
			if(count>1000000) {
				break;
			}
			count++;
		}
		BigDecimal intEleAppearenceFre=new BigDecimal("0.00");
		BigDecimal intEleAppearenceFreData=intEleAppearenceFre.multiply(new BigDecimal("100.00"));
		if(!(intEleAppearenceFreData.equals(new BigDecimal("60.00")))) {
			return false;
		}
		return true;
	}
}

class CustIntArrEle{
	private String id;
	private String name;
	private Integer intArrEleIndexPositionFro=1;
	private Integer intArrEleIndexPositionTo=1;
	private Integer intArrEle;
	private Boolean isAmerican=true;
	private Boolean isChangedPositionIndexFlag=false;
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getIntArrEleIndexPositionFro() {
		return intArrEleIndexPositionFro;
	}
	public void setIntArrEleIndexPositionFro(Integer intArrEleIndexPositionFro) {
		this.intArrEleIndexPositionFro = intArrEleIndexPositionFro;
	}
	public Integer getIntArrEleIndexPositionTo() {
		return intArrEleIndexPositionTo;
	}
	public void setIntArrEleIndexPositionTo(Integer intArrEleIndexPositionTo) {
		this.intArrEleIndexPositionTo = intArrEleIndexPositionTo;
	}
	public Integer getIntArrEle() {
		return intArrEle;
	}
	public void setIntArrEle(Integer intArrEle) {
		this.intArrEle = intArrEle;
	}
	public Boolean getIsAmerican() {
		return isAmerican;
	}
	public void setIsAmerican(Boolean isAmerican) {
		this.isAmerican = isAmerican;
	}
	public Boolean getIsChangedPositionIndexFlag() {
		return isChangedPositionIndexFlag;
	}
	public void setIsChangedPositionIndexFlag(Boolean isChangedPositionIndexFlag) {
		this.isChangedPositionIndexFlag = isChangedPositionIndexFlag;
	}
	
}