check if this inputs two days is beautiful days

package com.microsoft.controller;

import java.util.UUID;

public class MicrosoftEuropeanController {
	public static void main(String[] args) {
		System.out.println("Hello World!");
	}
	
	/**
	 * check if this inputs two days is beautiful days:
	 * inputs seperated 3 numbers:
	 * two days is : integer i,integer j
	 * key index is : over factor(formular divided factor)
	 * more detail rule formaular is : 
	 * compute this difference abstract number: 
	 * American number concurrency is compute by using this  math formular: |integer index i-(reverse(integer index i))|
	 * get this positive abstract valuable data difference : abstractValuableDataDiff
	 * result is:
	 * ( abstractValuableDataDiff/ (integer key index : k))=retValueData
	 * check if this retValueData is a safe integrated positive number
	 * constraints:
	 * 1<= i <= j <=10to6
	 * 1<= k <=10to9
	 * (Asia China is concurrency normal government transfer information interchange for transaction: 
	 * 10% (with America concurrency))
	 * @param i
	 * @param j
	 * @param k
	 * @return
	 */
	public static int beautifulDays(int i, int j, int k) {
		Boolean checkInputsFlag=dataInputsCheckForInt(i, j, k);
		if(!checkInputsFlag) {
			return 0;
		}
		//build customerBeautifulDays data: American concerrency
		CustomerBeautifulDays custBeautifulDays=new CustomerBeautifulDays();
		custBeautifulDays.setId(UUID.randomUUID().toString());
		custBeautifulDays.setName("");
		custBeautifulDays.setIsAmericanDollar(true);
		custBeautifulDays.setFirstDayIntConcurrency(i);
		custBeautifulDays.setSecondayIntConcurrency(j);
		custBeautifulDays.setKeyFactorForDividedFormular(k);
		//using formular to compute this check inputs data i
		int[] reverseDataInt = reverseDataInt(i, j, k);
		int firstDayInputsReverse = reverseDataInt[0];
		int abstractVal=i-firstDayInputsReverse;
		if(abstractVal<0) {
			abstractVal = Math.abs(abstractVal);
		}
		int l = abstractVal/k;
		Boolean booleanFlag=checkDataDividedIsOk(l, j, k);
		int[] intArr=new int[] {0,0};
		if(!booleanFlag) {
			intArr=new int[] {0,0};
			return 0;
		}
		// j data inputs data check
		int secondDayInputsReverse = reverseDataInt[1];
		int abstractVal1=j-secondDayInputsReverse;
		if(abstractVal1<0) {
			abstractVal1 = Math.abs(abstractVal1);
		}
		int l1 = abstractVal1/k;
		Boolean booleanFlag1=checkDataDividedIsOk(l, j, k);
		int[] intArr1=new int[] {0,0};
		if(!booleanFlag1) {
			intArr1=new int[] {0,0};
			return 0;
		}
		int[] intArr2=new int[]{l,l1};
		return 2;
	}
	
	/**
	 * check data divided is ok and
	 * the result is a integrated Ok result that can't take any float or double factor
	 * @param i
	 * @param j
	 * @param k
	 * @return
	 */
	public static Boolean checkDataDividedIsOk(int i, int j, int k) {
		Boolean checkInputsDataFlag=dataInputsCheckForInt(i, j, k);
		if(!checkInputsDataFlag) {
			return false;
		}
		int result=i/k;
		int dosents=i;
		int retSumary=0;
		for(int iIndex=0;iIndex<result;iIndex++) {
			dosents*=k;
			retSumary+=dosents;
		}
		if(retSumary>i) {
			return false;
		}
		return true;
	}
	
	/**
	 * data inputs for int data check
	 * constriant:
	 * 1<= i <= j <=10to6
	 * 1<= k <=10to9
	 * @param i
	 * @param j
	 * @param k
	 * @return
	 */
	public static Boolean dataInputsCheckForInt(int i,int j, int k) {
		if(i>j) {
			return false;
		}
		int valInt=1;
		for(int iIndex=0;iIndex<6;iIndex++) {
			valInt*=10;
		}
		if(i<1 || i>valInt) {
			return false;
		}
		if(j<1 || j > valInt) {
			return false;
		}
		int intValForLoop=1;
		for(int iIndex=0;iIndex<9;iIndex++) {
			intValForLoop*=10;
		}
		if(k<1 || k>intValForLoop) {
			return false;
		}
		return true;
	}
	
	/**
	 * int data number reverse to another number 
	 * @param i
	 * @return
	 */
	public static int[] reverseDataInt(int i,int j, int k) {
		Boolean inputDataCheckFlag=dataInputsCheckForInt(i, j, k);
		if(!inputDataCheckFlag) {
			int[] intArr=new int[] {0,0};
			return intArr;
		}
		// first time to reverse data i
		String valueOf = String.valueOf(i);
		StringBuilder strBuilder=new StringBuilder();
		for (int lIndex = valueOf.length()-1; lIndex <= 0; lIndex--) {
			strBuilder.append(valueOf.charAt(lIndex));
		}
		String strBuilder2Str=strBuilder.toString();
		Integer intNewReverseDataInt=Integer.valueOf(strBuilder2Str);
		// second time to reverse data j
		String valueOf1 = String.valueOf(i);
		StringBuilder strBuilder1=new StringBuilder();
		for (int lIndex = valueOf1.length()-1; lIndex <= 0; lIndex--) {
			strBuilder1.append(valueOf1.charAt(lIndex));
		}
		String strBuilder2Str1=strBuilder1.toString();
		Integer intNewReverseDataInt1=Integer.valueOf(strBuilder2Str1);
		int[] intArr1=new int[] {intNewReverseDataInt,intNewReverseDataInt1};
		return intArr1;
	}
}

class CustomerBeautifulDays{
	private String id;
	private String name;
	private Integer firstDayIntConcurrency;
	private Integer secondayIntConcurrency;
	private Boolean isAmericanDollar;
	private Boolean isAsialChinaConcurrency;
	private Integer keyFactorForDividedFormular;
	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 getFirstDayIntConcurrency() {
		return firstDayIntConcurrency;
	}
	public void setFirstDayIntConcurrency(Integer firstDayIntConcurrency) {
		this.firstDayIntConcurrency = firstDayIntConcurrency;
	}
	public Integer getSecondayIntConcurrency() {
		return secondayIntConcurrency;
	}
	public void setSecondayIntConcurrency(Integer secondayIntConcurrency) {
		this.secondayIntConcurrency = secondayIntConcurrency;
	}
	public Boolean getIsAmericanDollar() {
		return isAmericanDollar;
	}
	public void setIsAmericanDollar(Boolean isAmericanDollar) {
		this.isAmericanDollar = isAmericanDollar;
	}
	public Boolean getIsAsialChinaConcurrency() {
		return isAsialChinaConcurrency;
	}
	public void setIsAsialChinaConcurrency(Boolean isAsialChinaConcurrency) {
		this.isAsialChinaConcurrency = isAsialChinaConcurrency;
	}
	public Integer getKeyFactorForDividedFormular() {
		return keyFactorForDividedFormular;
	}
	public void setKeyFactorForDividedFormular(Integer keyFactorForDividedFormular) {
		this.keyFactorForDividedFormular = keyFactorForDividedFormular;
	}
	
}

#牛客AI配图神器#