int nextPerfectSquare(int n){

int nextPerfectSquare=0;

for(int i=n;nextPerfectSquare==0;i++){

for(int j=1;j<=i&&(j*j)<=i;j++){

if((j*j)==i)

nextPerfectSquare=i;

break;

return nextPerfectSquare;

//

int n_upCount(int[] a, int n){

int upCount=0,preSum=0;

for(int i=0;i<a.length;i++){

int newSum=0;

for(int j=0;j<=i;j++){

newSum+= a[j];

if(preSum<=n&&newSum>n){

upCount++;

preSum=newSum;
 }

return upCount;

//

int primeCount(int start, int end){

int primeCount=0;

if(start<0)

start=2;

for(;start<=end;start++){

boolean isPrime=true;

for(int j=2;j<start;j++){

if(start%j==0){

isPrime=false;

break;

if(isPrime){

primeCount++;

return primeCount;

//
int isMadhavArray(int[ ] a){

int j=0;

int num=a[j];

for(int i=1;j<a.length;i++)

int sum=0;

for(int l=1;l<=i;l++){

if(j>=a.length)

break;

sum+=a[j];

j++;

if(num!=sum)

return 0;

return 1;

//

int isInertial(int[] a){

int maxIndex=0;

Boolean noOdd=true;

for(int i=0;i<a.length;i++){

if(noOdd&&a[i]%2!=0)

noOdd=false;

if(a[i]>a[maxIndex])

maxIndex=i;
}

for(int i=0;i<a.length;i++){

if(a[i]%2==0)

continue;

for(int j=0;j<a.length;j++){

if(a[j]%2!=0)

continue;

else if(a[i]<=a[j]&&a[j]<a[maxIndex])

return 0;

return 1;

//

int isPerfectSquear(int n){

for(int i=1;i<n&&(i*i)<=n;i++){

if((i*i)==n)

return 1;

return 0;

int countSquarePairs(int[ ] a){

int countPerfectSquare=0;

for(int i=0;i<a.length;i++){

if(a[i]<=0)
 {continue;}

for(int j=(i+1);j<a.length;j++){

if(a[j]<=0)

continue;

if(isPerfectSquear(a[i]+a[j])==1&&a[i]!=a[j])

countPerfectSquare++;

return countPerfectSquare;

//

int PorcupineNumber(int n){

Boolean isPorcupineNumber=false;

int PorcupineNumber=0;

for(int i=(n+1);(! isPorcupineNumber);i++)

boolean isPrime=true;

for(int j=2;j<i;j++){

if(i%j==0){

isPrime =false;

if (isPrime&&i%10==9){

if(PorcupineNumber!=0){

isPorcupineNumber=true;
 break;

else{

PorcupineNumber=i;

else if(isPrime&&i%10!=9){

PorcupineNumber=0;

return PorcupineNumber;

//

int isGuthrieSequence(int[ ] a){

if(a[a.length-1]!=1)

return 0;

int num=a[0];

for(int i=1;i<a.length;i++)

if(num%2==0)

num=num/2;

else{

num=num*3+1;
 }

if(a[i]!=num)

return 0;

if(num==1&&(i+1)!=a.length)

return 0;

return 1;

//

int stantonMeasure(int[ ] a){

int stantonMesure=0,onceCount=0;

for(int i=0;i<a.length;i++){

if(a[i]==1)

onceCount++;

for(int i=0;i<a.length;i++){

if(a[i]==onceCount)

stantonMesure++;

return stantonMesure;

//

int sumFactor(int[ ] a){

int sumFactor=0,sum=0;

for(int i=0;i<a.length;i++){
 sum+=a[i];

for(int i=0;i<a.length;i++){

if(a[i]==sum)

sumFactor++;

return sumFactor;

//

int guthrieIndex(int n){

int guthrieIndex=0;

for(int i=n;i>1;)

if(i%2==0){

i=i/2;

else {

i=i*3+1;

guthrieIndex++;

return guthrieIndex;

//

int[ ] solve10(){
int fact10=1;

int[] factSum=new int[2];

for(int i=2;i<=10;i++)

fact10 *=i;

for(int X=1;X<10;X++){

int factX=1;

for(int findFact=2;findFact<=X;findFact++)

factX *=findFact;

for(int Y=X;Y<10;Y++)

int factY=1;

for(int findFact=2;findFact<=Y;findFact++)

factY *=findFact;

if((factX+factY)==fact10)

factSum[0]=X;

factSum[1]=Y;

return factSum;

return factSum;

//

int repsEqual(int[ ] a, int n){

for(int i=(a.length-1);i>=0;i--)

{
 if(a[i]!=n%10)

return 0;

n /=10;

return 1;

//

int isCentered15(int[ ] a){

int nc=0,pc=0,middle=0;

if(a.length%2==0){

nc=a.length/2;

pc=a.length/2-1;

else {

middle=a.length/2;

if(a[middle]==15)

return 1;

else{

nc=middle+1;

pc=middle-1;

for(;pc>=0&&nc<a.length;pc--,nc++){

int sum=0;

for(int i=pc;i<=nc;i++)

sum+=a[i];
 }

if(sum==15)

return 1;

return 0;

//

int henry (int i, int j){

int perfectCount=0,perfectSum=0,big=0;

if(i>j)

big=i;

else

big=j;

for(int x=2;perfectCount<big;x++){

int psum=1;

for(int k=2;k<x;k++){

if(x%k==0)

psum+=k;

if(psum==x){

perfectCount++;

if(perfectCount==1||perfectCount==j)

perfectSum+=x;

}
 }

return perfectSum;

//

int isDivisible(int [ ] a, int divisor){

for(int i=0;i<a.length;i++){

if(a[i]%divisor!=0)

return 0;

return 1;

//

int isNUnique(int[ ] a, int n){

int countSum=0;

for(int i=0;i<(a.length-1);i++){

for(int j=(i+1);j<a.length;j++){

if((a[i]+a[j])==n){

countSum++;

if(countSum>1)

break;

if(countSum>1)

break;
 }

if(countSum==1)

return 1;

else

return 0;

//

int isSquare(int n){

for(int i=2;i<n&&(i*i)<=n;i++){

if((i*i)==n)

return 1;

return 0;

//

int isLegalNumber(int[ ] a, int base){

for(int i=0;i<a.length;i++){

if(a[i]>=base)

return 0;

return 1;

int convertToBase10(int[ ] a, int base){

if(isLegalNumber(a,base)==0)

return -1;

for(int i=(a.length-1),power=0;i>=0;i--,power++){

number+=a[i]*Math.pow(base,power);

return number;

//

int haseNoZeroes(int[] a){

for(int i=0;i<a.length;i++){

if(a[i]==0)

return 0;

return 1;

//

int computerDepth(int n){

int depth=0;

int[] nums={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};

int count=0;

for(int i=1;count<nums.length;i++,depth++){

for(int mult=n*i;mult>0;mult/=10){

int digit=mult%10;

if(nums[digit]==-1){
 nums[digit]=digit;

count++;

return depth;

//

int matches(int[ ] a, int[ ] p){

int max=0;

int j=0;

for(int i=0;i<p.length;i++){

Boolean isNegative=false;

if(p[i]<0)

{isNegative=true;}

max+=Math.abs(p[i]);

if(max>a.length)

{return 0;}

for(;j<max;j++)

if(isNegative&&a[j]>0)

return 0;

else if((!isNegative)&&a[j]<0)

return 0;

}
return 1;

//

int isStacked(int n){

int sum=0;

for(int i=1;i<n&&sum<n;i++){

sum+=i;

if(sum==n)

return 1;

else

return 0;

//

int isSumSafe(int[ ]a){

int sum=0;

for(int i=0;i<a.length;i++){

sum+=a[i];

for(int i=0;i<a.length;i++){

if(a[i]==sum)

return 0;

return 1;
}

//

int isIsolated(long n){

if(n<0||n>2097151)

return -1;

long[] squareDigits={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};

long sq=n*n;

long qu=n*n*n;

for(long i=sq;i>0;i/=10){

int digit=(int)i%10;

squareDigits[digit]=digit;

for(long i=qu;i>0;i/=10){

int digit=(int)i%10;

if(squareDigits[digit]==digit)

return 0;

double a=45;

return 1;

//

int isVanilla(int[ ] a){

if(a.length<1)

return 0;

int digit=Math.abs(a[0]);
 for(int i=0;i<a.length;i++){

for(int j=Math.abs(a[i]);j>0;j/=10){

if(j%10!=digit)

return 0;

return 1;

//

int isTrivalent (int[ ] a){

if(a.length<1)

return 0;

boolean fe=true,se=false,te=false;

int fv=a[0],sv=a[0],tv=a[0];

for(int i=0;i<a.length;i++)

if(te&&a[i]!=fv&&a[i]!=sv&&a[i]!=tv)

return 0;

else if(se&&a[i]!=fv&&a[i]!=sv)

te=true;

tv=a[i];

else if(fe&&a[i]!=fv)

se=true;
 sv=a[i];

if(fe&&se&&te)

return 1;

else

return 0;

//

int isSequentiallyBounded(int[ ] a){

for(int i=0;i<a.length;i++)

int count=0;

for(int j=i;j<a.length;j++)

if(a[i]==a[j])

count++;

else if(a[j]<a[i])

return 0;

if(count>=a[i])

return 0;

return 1;

}
//

int isMinMaxDisjoint(int[ ] a){

if(a.length<3)

return 0;

int min=0,max=0,minOccur=0,maxOccur=0;

for(int i=0;i<a.length;i++){

if(a[i]<=a[min]){

if(a[i]==a[min]){

minOccur++;

else{

min=i;

minOccur=1;

else if(a[i]>=a[max]){

if(a[i]==a[max])

maxOccur++;

else{

maxOccur=1;

max=i;

if(a[max]==a[min]||(min-1)==max||(max-1)==min||maxOccur>1||minOccur>1)
 return 0;

else return 1;

//

int smallest(int n){

int j=1,i=1;

for(;j<=n;i++){// the loop should exit once all the condtion in j are tested

for(j=1;j<=n;j++){

int num=i*j;

boolean exist2=false;

for(int l=num;l>0;l/=10){

if(l%10==2){

exist2=true;

break;

if(!exist2){

break;//if not exist break before j is greater than n

return (i-1);

//

int[ ] clusterCompression(int[ ] a){

return new int[]{};

int clusterSize=1;

for(int i=0;i<(a.length-1);i++){

if(a[i]!=a[i+1])

clusterSize++;

int[] clustor=new int[clusterSize];

clustor[0]=a[0];

for(int i=0,ci=1;i<(a.length-1);i++){

if(a[i]!=a[i+1])

clustor[ci]=a[i+1];

ci++;

return clustor;

//

int isRailroadTie(int[ ] a){

if(a.length<2)

return 0;

else if(a[0]==0||a[1]==0)

return 0;

else if(a[a.length-1]==0||a[a.length-2]==0)

return 0;

for(int i=1;i<=(a.length-2);i++){
 if(a[i]==0){

if(a[i-1]==0||a[i+1]==0)

return 0;

else {

if(a[i-1]==0&&a[i+1]==0)

return 0;

else if(a[i-1]!=0&&a[i+1]!=0)

return 0;

return 1;

//

int fullnessQuotient(int n){

int count=0;

for(int base=2;base<10;base++){

boolean noZero=true;

for(int num=n;num>0;num/=base){

if(num%base==0)

noZero=false;

break;

if(noZero)
 count++;

return count;

//

int isPacked(int[ ] a){

for(int i=0;i<a.length;i++){

int found=0,count=0;

for(int j=0;j<a.length;j++){

if(a[i]<0)

return 0;

else if(found==1&&a[i]!=a[j])

found=2;

else if(found==2&&a[i]==a[j])

return 0;

else if(a[j]==a[i])

found=1;

count++;

if(count!=a[i])

return 0;

return 1;

}
//

int isOddHeavy(int[ ] a){

boolean odd=false;

for(int i=0;i<a.length;i++){

if(a[i]%2==0)

continue;

for(int j=0;j<a.length;j++){

if(a[j]%2!=0)

continue;

else if(a[i]<=a[j])

return 0;

odd=true;

if(odd)

return 1;

else

return 0;

//

int getExponent(int n, int p){

int num=0;
for(int x=1;x<n&&Math.pow(p,x)<=n;x++){

if(n%Math.pow(p,x)==0)

num=x;

return num;

//

int is121Array(int[ ] a){

int begin1=0,end1=0,middle2=0;

for(int i=0;i<a.length;i++){

if(middle2==0&&a[i]==1)

begin1++;

else if(end1==0&&a[i]==2)

middle2++;

else if(middle2!=0&&a[i]==1)

end1++;

else return 0;

if(begin1!=end1||middle2==0)

return 0;

return 1;

//
int[ ] filterArray(int[ ] a, int n){

int arraySize=0;

int index=0;

for(int num=n;num>0;num/=2){

if(num%2!=0)

arraySize++;

int[] repArray=new int[arraySize];

for(int num=n,i=0;num>0;num/=2,i++){

if(i>=a.length)

return new int[]{};

if(num%2!=0){

repArray[index]=a[i];

index++;

return repArray;

//

int largestAdjacentSum(int[ ] a){

int adjacentS=a[0]+a[1];

for(int i=1;i<(a.length-1);i++){

if(a[i]+a[i+1]>adjacentS)

adjacentS=a[i]+a[i+1];

}
return adjacentS;

//

int checkConcatenatedSum(int n, int catlen){

int sum=0;

for(int i=n;i>0;i/=10)

int num=i%10;

int termSum=0;

int digitize=1;

for(int j=1;j<=catlen;j++){

termSum+=num*digitize;

digitize*=10;

sum+=termSum;

if(sum==n)

return 1;

else

return 0;

//

int isSequencedArray(int[ ] a, int m, int n){

if(a[0]!=m||a[a.length-1]!=n)

return 0;
for(int i=0;i<(a.length-1);i++){

if(a[i]!=a[i+1]&&a[i+1]-a[i]!=1)

return 0;

return 1;

//

int largestPrimeFactor(int n){

int largestPrime=0;

if(n%2==0)

largestPrime=2;

for(int i=3;i<n;i+=2){

if(n%i==0){

boolean isPrime=true;

for(int j=2;j<i;j++){

if(i%j==0)

isPrime=false;

break;

if(isPrime){

largestPrime=i;

return largestPrime;
}

//

int[ ] encodeNumber(int n){

int arraySize=0;

for(int i=2,num=n;i<=n&&num>0;i++){

if(num%i==0){

boolean isPrime=true;

for(int j=2;j<i;j++){

if(i%j==0)

isPrime=false;

break;

if(isPrime){

num=num/i;

arraySize++;

i--;

int[] primeArray=new int[arraySize];

for(int i=2,index=0,num=n;i<=n&&num>0;i++){

if(num%i==0){

boolean isPrime=true;

for(int j=2;j<i;j++)

{
 if(i%j==0){

isPrime=false;

break;

if(isPrime){

num=num/i;

primeArray[index]=i;

index++;

i--;

return primeArray;

//

static int matchPattern(int[] a, int len, int[] pattern, int patternLen) {

// len is the number of elements in the array a, patternLen is the number of elements in the pattern.

int i=0; // index into a

int k=0; // index into pattern

int matches = 0; // how many times current pattern character has been matched so far

for (i=0; i<len; i++) {

if (a[i] == pattern[k])

matches++; // current pattern character was matched

else if (matches == 0 || k == patternLen-1)

return 0; // if pattern[k] was never matched (matches==0) or at end of pattern (k==patternLen-1)

else // advance to next pattern character

if(a[i]==pattern[k+1])

k++;

else

return 0;

} // end of else

} // end of for

// return 1 if at end of array a (i==len) and also at end of pattern (k==patternLen-1)

if (i==len && k==patternLen-1) return 1; else return 0;

//

void doIntegerBasedRounding(int[ ] a, int n){

for(int i=0;i<a.length;i++){

if(a[i]<0)

continue;

else if(a[i]==n)

a[i]=n;

else if(a[i]<n){

int preC=0,forC=0;

for(int j=0;j<=n;j++){

if(j<a[i])

preC++;

else if(j>a[i])

forC++;

a[i]=preC<forC?0:n;

}
 else {

int mult=1;

int R=n;

for(;mult<a[i];R++){

mult=R*2;

int preC=0,forC=0;

for(int l=n;l<=mult;l++){

if(l<a[i])

preC++;

else if(l>a[i])

forC++;

a[i]=preC<forC?n:mult;

for(int element: a){

System.out.println(element);

//

int isCubePowerful(int n){

if(n<=0)

return 1;

int sum=0;
for(int i=n;i>0;i/=10){

int num=i%10;

sum+=Math.pow(num,3);

if(sum==n)

return 1;

else

return 0;

//

int decodeArray(int[ ] a){

int numRep=0,digitize=1;

for(int i=(a.length-1);i>0;i--){

int num=Math.abs(a[i-1]-a[i])*digitize;

numRep+=num;

digitize*=10;

if(a[0]<0)

numRep*=-1;

return numRep;

//

int isZeroPlentiful(int[ ] a){

boolean counting0=false;

int count=0,zeroRound=0;
for(int i=0;i<a.length;i++){

if(a[i]==0){

counting0=true;

count++;

if(i==(a.length-1)){

if(count<4)

return 0;

else

zeroRound++;

else if(counting0&&a[i]!=0){

counting0=false;

if(count<4)

return 0;

count=0;

zeroRound++;

return zeroRound;

//

int isDigitIncreasing(int n){

for(int i=1;i<10;i++){

int sum=0;
 int cSum=0;

for(int digitize=1;cSum<n;digitize*=10){

sum+=i*digitize;

cSum+=sum;

if(cSum==n)

return 1;

return 0;

//

int decodeArray2(int[ ] a){

int num=0,digitize=1;

for(int i=0;i<a.length;i++){

if(a[i]==1)

digitize*=10;

digitize/=10;//to reverse one wrong digit place

int zeroCount=0;

for(int i=0;i<a.length;i++){

if(a[i]==0)

zeroCount++;

else if(a[i]==1)

num+=zeroCount*digitize;

digitize/=10;

zeroCount=0;
 }

if(a[0]==-1)

num*=-1;

return num;

//

int isOnionArray(int[ ] a){

int j=a.length/2-1,k=0;

if(a.length%2==0)

k=a.length/2;

else {

k=a.length/2+1;

for(;j>=0&&k<a.length;j--,k++){

if(a[j]+a[k]>10)

return 0;

return 1;

//

int isPrimeHappy(int n){

for(int i=2;i<n;i++)

boolean isPrime=true;

for(int j=2;j<i;j++)

if(i%j==0)

isPrime=false;

break;

if(isPrime){

sum+=i;

if(sum==0||sum%n!=0)

return 0;

else

return 1;

//

int[] encodeArray(int n){

int size=0;

for(int i=Math.abs(n);i>0;i/=10){

size+=(i%10)+1;
}

if(n<0)

size++;

int[] encode=new int[size];

int j=encode.length-1;

for(int i=Math.abs(n);i>0;i/=10){

int num=i%10;

encode[j]=1;

j--;

for(int k=0;k<num;k++){

encode[j]=0;

j--;

if(n<0)

encode[j]=-1;

return encode;

//

int isSystematicallyIncreasing(int[ ] a){

if(a[0]!=1)

return 0;

int lastTop=a[a.length-1];

boolean check=false;

for(int i=(a.length-1);i>=0;i--){

if(check){

if(lastTop-a[i]!=1)
 return 0;

lastTop=a[i];

check=false;

else if(a[i]==1){

check=true;

else if(a[i-1]-a[i]!=-1)

return 0;

return 1;

//

int isFactorialPrime(int n){

for(int i=2;i<n;i++){

if(n%i==0)

return 0;

int fact=1;

for(int j=1;(fact+1)<n;j++){

fact=1;

for(int k=1;k<=j;k++)

fact*=k;

if((fact+1)==n)

return 1;
else

return 0;

//

int largestDifferenceOfEvens(int[ ] a){

int largestD=-1;

for(int i=0;i<a.length;i++){

if(a[i]%2!=0)

continue;

for(int j=0;j<a.length;j++){

if(a[j]%2!=0)

continue;

else if(a[i]-a[j]>largestD&&i!=j)

largestD=a[i]-a[j];

return largestD;

//

int isHodder(int n){

for(int j=2;j<n;j++){

if(n%j==0)

return 0;

int hooder=2;
 for(int k=1;(hooder-1)<n;k++)//exit the loop the moment it realize its true or false

hooder=(int)Math.pow(2,k);

if((hooder-1)==n)// check if the loop exit because it becomes equal

return 1;

return 0;

//

int areAnagrams(char [ ] a1, char [ ] a2){

if(a1.length!=a2.length)

return 0;

char[] check=a2;

for(int i=0;i<a1.length;i++){

boolean found=false;

for(int k=0;k<check.length;k++){

if(a1[i]==check[k])

check[k]=00;

found=true;

break;

if(!found){

return 0;

return 1;

}
//

int closestFibonacci(int n){

int n1=1,n2=1,cf=0;

for(int i=0;cf<n;i++){

int temp=n2;

n2=n1+n2;

n1=temp;

cf=n1+n2;

return n2;

//

int minDistance(int n){

int diff=0,pf=1;

for(int i=2;i<=n;i++){

if(n%i==0){

if(diff==0){

diff=i-pf;

else if((i-pf)<diff) {

diff=i-pf;

pf=i;

}
 if(diff==1)

return diff;

return diff;

int isWave (int [ ] a){

boolean odd=a[0]%2!=0?true:false;

for(int i=1;i<a.length;i++){

if(odd&&a[i]%2!=0)

return 0;

else if((!odd)&&a[i]%2==0)

return 0;

odd=(!odd);

return 1;

//

boolean sumIsPower(int[] arr) {

int sum=0;

for(int i=0;i<arr.length;i++){

sum+=arr[i];

int pow=0;

for(int i=0;i<sum&&pow<sum;i++){
pow=(int)Math.pow(2,i);

return pow==sum;

int isVesuvian(int n){

for(int i=1;(i*i)<n;i++){

int sq=i*i;

int sumSq=0;

for(int k=1;sumSq<n;k++)

sumSq=sq+(k*k);

if(sumSq==n)

return 1;

return 0;

//

int isOneBalanced(int[ ] a){

int begin1=0,end1=0,oNum=0;

for(int i=0;i<a.length;i++){

if(end1!=0&&a[i]!=1)

return 0;

else if(a[i]==1&&oNum==0)

begin1++;

else if(a[i]!=1)
 oNum++;

else if(oNum!=0&&a[i]==1)

end1++;

if((begin1+end1)!=oNum)

return 0;

else

return 1;

//

int isFibonacci(int n){

int temp=1;

int ff=1,sf=1,nf=ff+sf;

for(; nf<n;temp=sf){

sf=ff+sf;

ff=temp;

nf=ff+sf;

if(n==nf)

return 1;

else

return 0;

//

int isTriangular(int n){

for(int i=1;sum<n;i++)

sum+=i;

if(sum==n)

return 1;

else

return 0;

//

int isMercurial(int[ ] a){

boolean is3found=false;

int begin1=0;

for(int i=0;i<a.length;i++){

if(a[i]==1&&(!is3found))

begin1++;

else if(a[i]==3&&begin1!=0)

is3found=true;

else if(a[i]==1&&is3found)

return 0;

return 1;

//

int is235Array(int[ ] a){

int dby2=0,dby3=0,dby5=0,ndby235=0;
 for(int i=0;i<a.length;i++){

if(a[i]%2!=0&&a[i]%3!=0&&a[i]%5!=0)

ndby235++;

else {

if(a[i]%2==0)

dby2++;

if(a[i]%3==0)

dby3++;

if(a[i]%5==0)

dby5++;

if((dby2+dby3+dby5+ndby235)==a.length)

return 1;

else

return 0;

int[] computeHMS(int seconds){

int second=seconds%60;

int minute=seconds/60;

int hour=minute/60;

minute=minute%60;

return new int[]{hour,minute,second};

//

int isMartian(int[ ] a){

for(int i=0;i<a.length;i++){

if(a[i]==1)

no1++;

else if(a[i]==2)

no2++;

if(i==(a.length-1))

break;

else if(a[i]==a[i+1])

return 0;

if(no1>no2)

return 1;

else

return 0;

//

int isPairedN(int[ ] a, int n){

if(a.length-1+a.length-2<n||a.length<2)

return 0;

for(int i=0;i<a.length&&i<=n;i++){

if(a[i]>n)

continue;

for(int k=0;k<a.length&&k<=n;k++){

if(k!=i&&k+i==n&&a[i]+a[k]==n)

return 1;

}
}

return 0;

//

int isNPrimeable(int[ ] a, int n){

for(int i=0;i<a.length;i++){

int num=a[i]+n;

for(int k=2;k<num;k++){

if(num%k==0)

return 0;

return 1;

//

int is121Array(int[ ] a){

if(a[0]!=1||a[a.length-1]!=1)

return 0;

int begin1=0,end1=0,twos=0;

for(int i=0;i<a.length;i++){

if(a[i]==1&&twos==0)

begin1++;

else if(a[i]==2&&begin1!=0&&end1==0)

twos++;

else if(a[i]==1&&twos!=0&&begin1!=0)
 end1++;

else

return 0;

if(begin1!=end1)

return 0;

else return 1;

//

int[ ] pairwiseSum(int[ ] a){

if(a.length%2!=0||a.length<2)

return null;

int[] pair=new int[a.length/2];

for(int i=0,j=0;i<a.length;i+=2,j++){

pair[j]=a[i]+a[i+1];

return pair;

//

int isSquare(int n){

int i=1;

for(;(i*i)<n;i++){

if((i*i)==n)

return 1;
else

return 0;

//

int isComplete(int[ ] a){

if(a.length<2)

return 0;

boolean even=false;

boolean perfectS=false;

boolean sum8=false;

for(int i=0;i<a.length;i++){

if(!even&&a[i]%2==0)

even=true;

if(!perfectS){

int ps=1;

for(int k=1;ps<a[i];k++)

ps=k*k;

if(ps==a[i])

perfectS=true;

if(!sum8){

for(int l=i;l<a.length;l++){

if(a[i]+a[l]==8&&i!=l)

sum8=true;

if(even&&perfectS&&sum8)

return 1;
}

return 0;

//

int loopSum(int[ ] a, int n){

int sum=0;

for(int i=0;n>0;i++){

if(i==a.length)

i=0;

sum+=a[i];

n--;

return sum;

//

int allValuesTheSame(int[ ] a){

int val=a[0];

for(int i=0;i<a.length;i++)

if(a[i]!=val)

return 0;

return 1;

//
int hasNValues(int[ ] a, int n){

int[] clone=new int[a.length];

int count=0;

boolean isZeroCount=false;

for(int i=0;i<a.length;i++){

if(a[i]==0){

if(!isZeroCount)

count++;

isZeroCount=true;

else {

boolean beenCount=false;

for(int k=0;k<clone.length;k++){

if(clone[k]==a[i])

beenCount=true;

if(!beenCount)

count++;

clone[i]=a[i];

if(count>n)

return 0;

}
}

if(count==n)

return 1;

else

return 0;

//

int sameNumberOfFactors(int n1, int n2){

if(n1<0||n2<0)

return -1;

int fact1=0,fact2=0;

for(int i=1;i<=n1||i<=n2;i++){

if(n1%i==0)

fact1++;

if(n2%i==0)

fact2++;

if(fact1==fact2)

return 1;

else

return 0;

//

double eval(double x, int[ ] a){

int sum=0,pow=0;
for(int i=0;i<a.length;i++,pow++){

sum+=a[i]*Math.pow(x,i);

return sum;

//

int isAllPossibilities(int[ ] a){

for(int i=0;i<a.length;i++){

boolean found=false;

for(int k=0;k<a.length;k++){

if(a[k]==i){

found=true;

break;

if(!found)

return 0;

return 1;

//

int isLayered(int[ ] a){

if(a.length<2||a[0]!=a[1]||a[a.length-1]!=a[a.length-2])

return 0;

for(int i=0;i<(a.length-1);i++){
 int count=1;

boolean otherElement=false;

for(int j=(i+1);j<a.length;j++){

if(a[i]==a[j]&&(!otherElement))

count++;

i++;

else if(a[j]<a[i])

return 0;

else

otherElement=true;

if(count<2)

return 0;

return 1;

int[] updateMileageCounter(int[ ] a, int miles){

int div=miles;

for(int i=0;i<a.length&&div>0;i++){

int mod=(a[i]+div)%10;

div=(a[i]+div)/10;

a[i]=mod;

return a;// method suppose to be void but for the sec of simplicity i make it int[]

}
//

int isHollow(int[ ] a){

if(a.length<3)

return 0;

int middle=a.length/2;

int i=middle-1;

int j=middle+1;

if(a.length%2==0)

{j=middle;}

boolean otherNumber=false;

if(a[i]!=0||a[j]!=0||a[middle]!=0)

return 0;

i--;

j++;

for(;i>=0&&j<a.length;i--,j++){

if(otherNumber&&(a[i]==0||a[j]==0))

return 0;

else if((a[i]==0||a[j]==0)&&a[i]!=a[j])

return 0;

else if(a[i]!=0&&a[j]!=0)

otherNumber =true;

return 1;

//

int isConsectiveFactored(int n){

if(n%i==0)

int j=i+1;

if(n%j==0)

return 1;

return 0;

//

int isTwinPrime(int n){

boolean m2=true,p2=true;

for(int i=2;i<(n+2);i++){

if(i>=n&&m2)

return 1;

else if(n%i==0&&i!=n)

return 0;

if((n-2)%i==0&&i!=(n-2))

m2=false;

if((n+2)%i==0)// the loop will terminate before it touch this so no need for "i!=(n+2)"

p2=false;

if(!m2&&!p2)

return 0;

}
return 1;

//

int largestAdjacentSum2(int[ ] a){

int adjacentS=a[0]+a[1];

for(int i=1;i<(a.length-1);i++){

if(a[i]+a[i+1]>adjacentS)

adjacentS=a[i]+a[i+1];

return adjacentS;

//

int isZeroBalanced(int[ ] a){

int sum=0;

for(int i=0;i<a.length;i++){

if(a[i]==0)

continue;

sum+=a[i];

boolean inverse=false;

for(int k=0;k<a.length;k++){

if(a[i]+a[k]==0){

inverse=true;

}
 if(!inverse)

return 0;

if(sum==0)

return 1;

else return 0;

//

int findSmallestBEQnumber( ){

int BEQ=0;

for(int i=11;BEQ==0;i++){

int num=i*i*i;

int sixCount=0;

for(int k=num;k>0;k/=10){

if(k%10==6)

sixCount++;

if(sixCount==4){

BEQ=i;

return BEQ;

//

int isZeroLimited(int[ ] a){

if(i==(3*n+1)){

if(a[i]!=0)

return 0;

n++;

else if(a[i]==0)

return 0;

return 1;

int isCubePerfect(int[ ] a){

outerLoop:for(int i=0;i<a.length;i++){

int cub=0;

for(int j=0;cub<=Math.abs(a[i]);j++){

cub=(j*j*j);

if(cub==Math.abs(a[i]))

continue outerLoop;

return 0;

return 1;

//

int countOnes(int n){

int once=0;
for(int i=n;i>0;i/=2){

if(i%2!=0)

once++;

return once;

//

int isDaphne (int[ ] a){

int odd=0,even=0;

for(int i=0;i<a.length;i++){

if(a[i]%2==0)

even++;

else

odd++;

if(odd!=0&&even!=0)

return 0;

return 1;

//

int isOddValent (int[ ] a){

boolean odd=false;

boolean more=false;

for(int i=0;i<a.length;i++){

if(a[i]%2!=0)
 odd=true;

if(!more){

int count=0;

for(int j=i;j<a.length;j++){

if(a[i]==a[j]){

count++;

if(count>2){

more=true;

break;

if(more&&odd)

return 1;

return 0;

//

int isNormal(int n){

int maxFact=(n/2);

for(int i=3;i<=maxFact;i++){

if(i%2!=0&&n%i==0)

return 0;

return 1;

}
//

int isAllPossibilities2(int[ ] a){

outerLoop:for(int i=0;i<a.length;i++){

for(int j=0;j<a.length;j++){

if(a[j]==i){

continue outerLoop;

return 0;

return 1;

//

int isFilter(int[ ] a){

outerLoop:for(int i=0;i<a.length;i++){

if(a[i]!=9&&a[i]!=7)

continue;

for(int k=0;k<a.length;k++){

if(a[i]==7&&a[k]==13)

return 0;

else if(a[i]==9&&a[k]==11)

continue outerLoop;

if(a[i]==9)

return 0;
}

return 1;

//

int isDigitSum(int n, int m){

int sum=0;

for(int i=n;i>0;i/=10){

sum+=(i%10);

if(sum<m)

return 1;

else

return 0;

//

//helper function

int isPrime(int n){

for(int i=2;i<n;i++){

if(n%i==0)

return 0;

return n>1?1:0;

int isFineArray (int [ ] a){

outerLoop:for(int i=0;i<a.length;i++){

if(isPrime(a[i])==1){
 Boolean isPm2=isPrime(a[i]-2)==1;

Boolean isPp2=isPrime(a[i]+2)==1;

if(!(isPm2)&&!(isPp2))

{return 0;}

for(int k=0;k<a.length;k++){

if(isPm2&&a[k]==(a[i]-2))

continue outerLoop;

else if(isPp2&&a[k]==(a[i]+2))

continue outerLoop;

return 0;

return 1;

//

int isBalanced(int [ ] a){

outerLoop:for(int i=0;i<a.length;i++){

for(int k=0;k<a.length;k++){

if(a[i]+a[k]==0)

continue outerLoop;

return 0;

return 1;

}
//

int isEvens(int n) {

for(int i=n;i>0;i/=10){

if((i%10)%2!=0)

return 0;

return 1;

//

int isMagicArray (int[ ] a) {

int sum=0;

for(int i=0;i<a.length&&sum<=a[0];i++){

if(isPrime(a[i])==1){

sum+=a[i];

if(sum==a[0])

return 1;

else

return 0;

//
int isComplete2 (int[ ] a) {

int min=0,max=0;

Boolean even=false;

for(int i=0;i<a.length;i++){

if(a[i]%2!=0)

continue;

else if((! even)){

even=true;

min=i;

max=i;

if(a[i]<a[min])

min=i;

else if(a[i]>a[max])

max=i;

if((!even)||a[min]==a[max])

{return 0;}

outerLoop:for(int I=a[min];I<=a[max];I++){

for(int j=0;j<a.length;j++){

if(I==a[j])

continue outerLoop;

return 0;

return 1;

}
//

int isPrimeProduct(int n){

for(int i=2;i<n;i++){

if(isPrime(i)==1){

int product=0;

for(int j=i;i<n&&product<n;i++){

if(isPrime(j)==1){

product=i*j;

if(product==n)

return 1;

return 0;

//

int isBalanced2(int[ ] a){

for(int i=0;i<a.length;i++){

if(i%2==0&&a[i]%2!=0)

return 0;

else if(i%2!=0&&a[i]%2==0)

return 0;

return 1;
}

//

int isCentered(int[ ] a){

if(a.length%2==0)

return 0;

int middle=a.length/2;

for(int i=0;i<a.length;i++){

if(a[i]<=a[middle]&&i!=middle)

return 0;

return 1;

//

boolean hasKSmallFactors(int k, int n){

for(int i=1;i<k;i++){

int fact=0;

for(int j=i;j<k&&fact<n;j++){

fact=i*j;

if(fact==n)

return true;

return false;

}
//

int[ ] fill(int[ ] arr, int k, int n){

if(k<=0||n<0)

return null;

int[] arr2=new int[n];

for(int i=0,p=0;i<n;i++,p++){

if(p==k)

p=0;

arr2[i]=arr[p];

return arr2;

int isHollow2(int[ ] a){

if(a.length<3)

return 0;

int beforeZ=0,zero=0,afterZ=0;

for(int i=0;i<a.length;i++){

if(afterZ!=0&&a[i]==0)

return 0;

else if(a[i]!=0&&zero==0)

beforeZ++;

else if(a[i]==0&&afterZ==0)

zero++;

else if(a[i]!=0&&zero!=0)

afterZ++;

else
 return 0;

if(beforeZ==afterZ&&zero>2)

return 1;

else

return 0;

//

int isConsectiveFactored2(int n){

for(int i=2;i<n;i++)

if(n%i==0&&n%(i+1)==0)

return 1;

return 0;

//

int isTwinPrime2(int n){

boolean NMinus2=true,N=true,NPlus2=true;

for(int i=2;i<(n-2);i++){

if((n-2)%i==0){

NMinus2=false;

break;

for(int i=2;i<n;i++){
 if(n%i==0){

N=false;

break;

if(NMinus2&&N)

return 1;

for(int i=2;i<(n+2);i++){

if((n+2)%i==0){

NPlus2=false;

break;

if(N&&NPlus2)

return 1;

else

return 0;

//

int largestAdjacentSum3(int[ ] a){

int largestA=a[0]+a[1];

for(int i=1;i<(a.length-1);i++){

if(a[i]+a[i+1]>largestA)

largestA=a[i]+a[i+1];

return largestA;

}
//

int isZeroBalanced2(int[ ] a){

if(a.length<1)

return 0;

int sum=0;

outerLoop:for(int i=0;i<a.length;i++){

sum+=a[i];

for(int j=0;j<a.length;j++){

if(a[i]+a[j]==0)

continue outerLoop;

return 0;

if(sum==0)

return 1;

else

return 0;

//

int findSmallestBEQnumber2( ){

/* since we know the smallest number with four digit in its qube is 10*10*10=1000

we can start i from 10*/

int i=0;boolean smallest=false;

for(;!smallest;i++){

int j=i*i*i,count=0;
 for(;j>10;j/=10){

if(j%10==6)

count++;

if(count==4){

smallest=true;

return i-1;

//

int isZeroLimited2(int[ ] a){

for(int i=0,n=0;i<a.length;i++){

if(i==(3*n+1)){

if(a[i]!=0){

return 0;

else

n++;

else if(a[i]==0)

return 0;

return 1;

}
//

int isOddValent2(int[ ] a){

boolean odd=false,occureMore=false;

for(int i=0;i<a.length;i++){

if((!odd)&&a[i]%2!=0)

odd=true;

if(!occureMore){

int count=0;

for(int k=i;k<a.length;k++){

if(a[i]==a[k]){

count++;

if(count>1){

occureMore=true;

break;

if(odd&&occureMore)

return 1;

return 0;

//
int isNormal2(int n){

for(int i=3;i<n;i+=2){

if(n%i==0)

return 0;

return 1;

//

int isFineArray2(int [ ] a){

for(int i=0;i<a.length;i++){

if(isPrime(a[i])==1){

if(isPrime(a[i]-2)==1||isPrime(a[i]+2)==1)

continue;

else

return 0;

return 1;

//

int minDistance(int n){

int diff=0,pf=1;

for(int i=2;i<=n;i++){
 if(n%i==0){

if(diff==0){

diff=i-pf;

else if((i-pf)<diff) {

diff=i-pf;

pf=i;

if(diff==1)

return diff;

return diff;

int isWave (int [ ] a){

boolean odd=a[0]%2!=0?true:false;

for(int i=1;i<a.length;i++){

if(odd&&a[i]%2!=0)

return 0;

else if((!odd)&&a[i]%2==0)

return 0;

odd=(!odd);

return 1;

//
int isBean (int[ ] a){

boolean n7=false,n9=false,n13=false,n16=false;

for(int i=0;i<a.length;i++){

if(a[i]==7)

n7=true;

else if(a[i]==9)

n9=true;

else if(a[i]==13)

n13=true;

else if(a[i]==16)

n16=true;

if(n7&&n16)

return 0;

if(n9){

if(n13)

return 1;

else

return 0;

else

return 1;

int countDigit(int n, int digit){

int count=0;

for(int i=n;i>0;i/=10){

if(i%10==digit)

count++;
}

return count;

//

int isBunkerArray(int [ ] a){

boolean previousOdd=a[0]%2!=0?true:false;

for(int i=1;i<a.length;i++){

if(previousOdd){

if(isPrime(a[i])==1)

return 1;

if(a[i]%2!=0)

previousOdd=true;

else

previousOdd=false;

return 0;

int isMeera(int [ ] a){

for(int i=0;i<a.length;i++){

int n=a[i];

for(int k=0;k<a.length;k++){

if(a[k]==2*n)

return 0;

return 1;
}

//

int isMeera(int n){

int count=0;

for(int i=2;i<n;i++){

if(n%i==0)

count++;

if(count==0||n%count!=0)

return 0;

else

return 1;

//

int isPrime(int n){

for(int i=2;i<n;i++){

if(n%i==0)

return 0;

return n>1? 1:0;

int isBunker(int [ ] a){

boolean prime=false,one=false;

for(int i=0;i<a.length;i++){

if(a[i]==1)

one=true;
 else if(isPrime(a[i])==1)

prime=true;

if(prime&&one)

return 1;

if(!prime&&!one)

return 1;

else

return 0;

//

int isNice(int[ ] a){

outerLoop:for(int i=0;i<a.length;i++){

for(int J=0;J<a.length;J++){

if(a[J]==(a[i]-1)||a[J]==(a[i]+1))

continue outerLoop;

return 0;

return 1;

//

int isContinuousFactored(int n){

for(int i=2;i<n;i++){

if(n%i==0)

arraySize++;

int[] rep=new int[arraySize];

int index=0;

for(int i=2;i<n;i++){

if(n%i==0){

rep[index]=i;

int product=1;

for(int j=index;j>=0;j--){

product*=rep[j];

if(product==n)

return 1;

else if(j==0||rep[j-1]!=(rep[j]-1))// exit the loop if the next is element not a continues factor

break;

index++;

return 0;

//

int isSetEqual(int[ ] a, int[ ] b){

for(int k=0;k<b.length;k++){

if(a[i]==b[k])

continue outerLoop;

return 0;

outerLoop:for(int i=0;i<b.length;i++){

for(int k=0;k<a.length;k++){

if(b[i]==a[k])

continue outerLoop;

return 0;

return 1;

//

int isSmart(int n){

int smart=1;

for(int i=0;smart<n;i++){

smart+=i;

if(smart==n)

return 1;

else
 return 0;

//

int isNiceArray (int[ ] a){

int sum=0;

for(int i=0;i<a.length;i++){

if(a[i]<0)

continue;

if(isPrime(a[i])==1)

sum+=a[i];

if(a.length<1||sum!=a[0])

return 0;

else

return 1;

//

int isComplete (int[ ] a){

int maxE=-1;

for(int i=0;i<a.length;i++){

if(a[i]<=0)
 return 0;

else if(a[i]%2==0&&maxE==-1)

maxE=i;

else if(a[i]%2==0&&a[i]>a[maxE])

maxE=i;

outerLoop:for(int i=a[maxE];i>0;i-=2){

for(int k=0;k<a.length;k++){

if(a[k]==i)

continue outerLoop;

return 0;

return 1;

//

int factorEqual(int n, int m){

int max=n>m? n:m;

int countn=0,countm=0;

for(int i=2;i<=max;i++){

if(n%i==0)

countn++;

if(m%i==0)

countm++;

if(countn==countm)
 return 1;

else

return 0;

//

int isMeera2 (int[ ] a){

int sum=0;

for(int i=0;i<a.length;i++){

if(a[i]>=i)

return 0;

sum+=a[i];

if(sum==0)

return 1;

else

return 0;

//

int isFibonacci2 (int n){

int pp=1,mm=1,fab=0;
for(int k=1;k<n&&fab<n;k++){

fab=pp+mm;

pp=mm;

mm=fab;

if(n==fab)

return 1;

else

return 0;

//

int isMeera3(int [ ] a){

boolean prime=false,zero=false;

for(int i=0;i<a.length;i++){

if(a[i]==0)

zero=true;

if(isPrime(a[i])==1)

prime=true;

if(prime&&zero)

return 1;

if(((!prime)&&zero)||prime&&(!zero)){

System.out.println(" this ");

return 0;
}

else

return 1;

//

int isBean(int[ ] a){

outerLoop:for(int i=0;i<a.length;i++){

for(int k=0;k<a.length;k++){

if(a[k]==(a[i]-1)||a[k]==(a[i]+1))

continue outerLoop;

return 0;

return 1;

//

int isFancy(int n){

int n1=1,n2=1,n3=1;

for(;n3<n;){

int temp=n3;

n3=(n2*2)+(n3*3);
 n2=temp;

if(n3==n)

return 1;

else

return 0;

//

int isMeera4(int [ ] a){

boolean nine=false,one=false;

for(int i=0;i<a.length;i++){

if(a[i]==1)

one=true;

else if(a[i]==9)

nine=true;

if(nine&&one)

return 1;

if((!nine)&&(!one))

return 1;

else return 0;

//
int isBean2(int[ ] a){

outerLoop:for(int i=0;i<a.length;i++){

for(int k=0;k<a.length;k++){

if(a[k]==(2*a[i])||a[k]==(2*a[i]+1)||a[k]==(a[i]/2))

continue outerLoop;

return 0;

return 1;

//

int isBunker2(int n){

int banck=1;

for(int i=0;i<n&&banck<n;i++){

banck+=i;

if(banck==n)

return 1;

else

return 0;

}
//

int isDual(int[ ] a){

for(int i=0;i<a.length;i++){

int count=0;

for(int k=0;k<a.length;k++){

if(a[k]==a[i])

count++;

if(count!=2)

return 0;

return 1;

//

int isDual2(int[ ] a){

if(a.length%2!=0||a.length<2)

return 0;

int sum=a[0]+a[1];

for(int i=2;i<a.length;i+=2){

if(sum!=(a[i]+a[i+1]))

return 0;

return 1;
}

//

int factorTwoCount(int n){

int i=0;

for(;n>0;i++,n/=2){

if(n%2!=0)

return i;

return i;

//

int isDaphne (int[ ] a){

int endOne=0,beginOne=0;

boolean beginEven=true,endEven=true,odd=false;

int i=0,J=a.length-1;

for(;i<J&&J>i;J--,i++){

if(a[i]%2==0&&beginEven)

beginOne++;

if(a[J]%2==0&&endEven)

endOne++;

if(a[i]%2!=0){
 odd=true;

beginEven=false;

if(a[J]%2!=0){

odd=true;

endEven=false;

if((!beginEven)&&(!endEven))

break;

if(beginOne==endOne&&odd)

return 1;

else

return 0;

//

int goodSpread (int[ ] a){

for(int i=0;i<a.length;i++){

int count=0;

for(int k=0;k<a.length;k++){

if(a[k]==a[i])

count++;

if(count>3)
 return 0;

return 1;

//

int sumDigits (int n){

int sum=0;

for(;n>0;n/=10){

sum+=(n%10);

return sum;

//

int isGuthrie (int n){

int num=1;

for(int i=0;i<n&&num<n;i++)

num+=i;

if(num==n)

return 1;

else
 return 0;

//

int minDistance2(int n){

int f=1,pf=1,diff=n-1;

for(int i=2;i<n&&diff!=1;i++){

if(n%i==0){

pf=f;

f=i;

if((f-pf)<diff){

diff=f-pf;

return diff;

//

int isWave2(int [ ] a){

boolean odd=a[0]%2!=0? true:false;

for(int i=0;i<a.length;i++){

if(odd){
 if(a[i]%2==0)

return 0;

else {

if(a[i]%2!=0)

return 0;

odd=(!odd);

return 1;

//

int minDistance3(int n){

int diff=n-1,pf=1,f=1;

for(int i=2;i<n&&diff>1;i++){

if(n%i==0){

pf=f;

f=i;

if((f-pf)<diff){

diff=f-pf;

return diff;

}
//

int isHollow3(int[ ] a){

int countZ=0,beginOne=0,endOne=0;

int i=0;

for(;i<a.length&&a[i]!=0;i++)

beginOne++;

for(;i<a.length&&a[i]==0;i++){

countZ++;

for(;i<a.length&&a[i]!=0;i++)

{endOne++;}

if(endOne==beginOne&&countZ>2)

return 1;

else

return 0;