Day4

Is even

if (input1%2==0)
{
return 2;
}
else
{
return 1;
}

Is odd

if (input1%2!=0)
{
return 2;
}
else
{
return 1;
}

Return last digit

input1=[Link](input1);
if(input1<10)
{
return input1;
}
else
{
return input1%10;
}
Return second last digit
input1=[Link](input1);
if(input1<10)
{
return -1;
}
else
{

input1=input1/10;
return(input1%10);
}
Sum of last two digits

input1=[Link](input1%10);
input2=[Link](input2%10);
return (input1+input2);

Day5

Exact multiple of m?

if(input1==0||input2==0)
{
return 3;
}
else if((input1%input2)!=0)
{
 return 1;
}
else
{
return 2;
}

How many is even in given 5 numbers

int count=0;
if(input1%2==0)
{
count++;
}
if(input2%2==0)
count++;
{
}
if(input3%2==0)
{
count++;
}
if(input4%2==0)
{
count++;
}
if(input5%2==0)
{
count++;
}
return count;
OR

int arr[]={input1,input2,input3,input4,input5};
int count=0;
for(int i:arr)
{
if(i%2==0)
{
count++;
}
}
return count;

How many is odd in given 5 numbers

int arr[]={input1,input2,input3,input4,input5};
int count=0;
for(int i:arr)
{
if(i%2!=0)
{
count++;
}
}
return count;

How many are even or odd

int arr[]={input1, input2,input3,input4,input5};

int ecount=0;
int ocount=0;
for(int i : arr)
{
if(i%2==0)
{
ecount++;
}
 else
{
ocount++;
}
}
if([Link]("even"))
{
return ecount;
}
else
{
return ocount;
}

Day 6

Is prime

for(int i=2;i<input1;i++)
{
if(input1%i==0)
{
return 1;
}

}
return 2;

Factorial of number

int result=1;
for(int i=1;i<=input1;i++)
{
result*=i;
}
return result;

OR
int result=1;
while(input1>0)
{
result*=input1;
input1--;
}
return result;

Nth fibonacci
int a=1;
int b=0;
int c=0;
if(input1>1)
{
for(int i=2;i<=input1;i++)
{
c=a+b;
a=b;
b=c;
}
return c;
}
else
{
return 0;
}

Nth prime
int c=0;
for(int num=2; ;num++)
{
if(isprime(num))
{
c++;
}
if(c==input1)
{
 return num;
}

}
}

boolean isprime(int num)

{
for(int i=2;i<num;i++)
{
if(num%i==0)
{
return false;
}
}
return true;

Day 7

Numbers of prime in specified range

int c=0;
for(int num=input1;num<=input2;num++)
{
if(isprime(num))
{
c++;
}
}

return c;

boolean isprime(int N)
{
for(int i=2;i<N;i++)
{
if(N%i==0)
{
return false;
 }
}
return true;

All digits count

int count=0 ;
while(input1>0)
{
input1=input1/10;
count++;
}
return count;

OR
String str=[Link](input1);
return [Link]();

OR
LinkedList<Integer> list=new LinkedList();
while(input1!=0)
{
[Link](input1%10);
input1/=10;
}
return [Link]();

3:unique digits count

int arr[]=new int[10];
while(input1!=0)
{
int val=input1%10;
arr[val]++;
input1/=10;
}
int count=0;
for(int i=0;i<10;i++)
{
if(arr[i]!=0)
{
 count++;
}

}
return count;

OR
TreeSet<Integer> tset = new TreeSet<Integer>();
while(input1!=0)
{
[Link](input1%10);
input1/=10;
}
return [Link]();

Non repeated digits count:

int arr[]=new int[10];

while(input1!=0)
{
int val=input1%10;
arr[val]++;
input1/=10;
}
int count=0;
for(int i=0;i<10;i++)
{
if(arr[i]==1)
{
count++;
}

}
return count;

OR
LinkedList <Integer> list=new LinkedList <Integer> ();
while(input1!=0)
{
[Link](input1%10);
input1/=10;
}
int count=0;
 for(int i:list)
{
int freq=[Link](list,i);
if(freq==1)
{
count++;
}
}
return count;

Day8

[Link]: sum of all digits in N:

int flag=0;
if(input1<0)
{
flag=1;
input1=[Link](input1);
}
while(input1>9)
{
input1=makeSingle(input1);
}
return (flag==0)?input1:-input1;

}
int makeSingle(int num)
{
int sum=0;
while(num!=0)
{
sum+=num%10;
num/=10;
}
return sum;

OR

int flag=0;
 if(input1==0)
{
retrun 0;
}

if(input1<0)
{
flag=1;
input1=[Link](input1);
}
input1=input1%9;
input1=(input1==0)?9:input1;
Return (flag==1)?-input1:input1

digitsum even: sum of even digits in N:

int sum=0, a;
while(input1!=0)
{
a=input1%10;
if(a%2==0)
{
sum+=a;
}
input1=input1/10;
}
return sum;

digitsum odd: sum of odd digits in N:

int sum=0, a;
while(input1!=0)
{
a=input1%10;
if(a%2!=0)
{
sum+=a;
}
input1=input1/10;
}
return sum;
digitsum odd or even: sum of odd or even digits in N:
int ocount=0,ecount=0, num;
while(input1!=0)
{
num=input1%10;
if(num%2!=0)
{
ocount+=num;
}
else
{
ecount+=num;
}

input1=input1/10;
}
if([Link]("even"))
{
return ecount;
}
else
{
return ocount;
}

DAY9

Is palindrome
String str=[Link](input1);
StringBuffer sb=new StringBuffer(str);
[Link]();
String str2=[Link](sb);
if([Link](str2))
{
return 2;
}
else
{
 return 1;
}

Is palindrome possible
int arr[]= new int[10];
int count=0;
while(input1!=0)
{
arr[input1%10]++;
input1/=10;
}
for(int i=0;i<10;i++)
{
if(arr[i]%2!=0)
{
if(count!=0)
{
return 1;
}
count++;
}
}
return 2;

[Link] pin using alpha, beta, gamma :

int u1=input1%10,u2=input2%10,u3=input3%10;
int t1=(input1/10)%10,t2=(input2/10)%10,t3=(input3/10)%10;
int h1=input1/100,h2=input2/100,h3=input3/100;
int u=[Link](u1,[Link](u2,u3));
int t=[Link](t1,[Link](t2,t3));
int h=[Link](h1,[Link](h2,h3));
int th=[Link](u1,[Link](u2,[Link](u3,[Link](t1,[Link](t2,
[Link](t3,[Link](h1,[Link](h2,h3))))))));
int num=th*1000+h*100+t*10+u;
return num;

OR

int u1[]={(input1%10),(input2%10),(input3%10)};
 int t1[]={(input1/10)%10,(input2/10)%10,(input3/10)%10};
int h1[]={(input1/100),(input2/100),(input3/100)};
[Link](u1);
[Link](t1);
[Link](h1);
int th[]={u1[2],t1[2],h1[2]};
[Link](th);
int num=th[2]*1000+h1[0]*100+t1[0]*10+u1[0];
return num;

[Link] of a hill pattern :

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

sum+=input2;

}
input2+=input3;
}
return sum;

DAY 10
1. return second word in uppercase :

String stra[];
stra=[Link](" ");
if([Link]<=1)
{
return "LESS";
}
else
{
 String a=stra[1];
a=[Link]();
return a;
}

OR
String stra[];
stra=[Link](" ");
if([Link]<=1)
{
return "LESS";
}
else
{
return str[1].toUpperCase();
}
is palindrome(string) :

StringBuffer sb=new StringBuffer(input1);

[Link]();
String str=[Link](sb);
if([Link](str))
{
return 2;
}
else
{
return 1;
}

weight of string:

int sum=0;
input1=[Link]();

if(input2==0)
{
input1=[Link]("[AEIOU]","");
}
int len=[Link]();
for(int i=0;i<len;i++)
 {
char ch=[Link](i);
if([Link](ch))
{
sum+=ch-64;
}
}
return sum;

[Link] frequent digit:

int arr[]=new int[10];

int input[]={input1,input2,input3,input4};
for(int inval:input)
{
if(inval==0)
{
arr[0]++;
}
while(inval!=0)
{
int val=inval%10;
arr[val]++;
inval/=10;
}
}
int max=0,ans=0;;
for(int i=0;i<10;i++)
{
if(max<=arr[i])
{
max=arr[i];
ans=i;
}
}
return ans;

OR

int arr[]={input1,input2,input3,input4};
LinkedList<Integer> list1=new LinkedList();
int maxfreq=0,ans=0;
for(int i:arr)
{ if(i==0)
{
[Link](i);
}
while(i!=0)
{
[Link](i%10);
i/=10;
}
}
[Link](list1);
for(int i:list1)
{
int freq=[Link](list1,i);

if(freq>=maxfreq)
{
maxfreq=freq;
ans=i;
}
}
return ans;
 METTL-2

M2 (A)

String based programs (part1)

1. Find string code:
input1=[Link]();
String stra[]=[Link](" ");
String ans="";

for( String str:stra)

{
int sum=0;
int len=[Link]();
for(int i=0;i<len/2;i++)
{
int temp=([Link](i)-64)-([Link](len-1-i)-64);
sum+=[Link](temp);
}
if(len%2!=0)
{
sum+=[Link](len/2)-64;
}
ans+=sum;
}
return [Link](ans);

2. get code through Strings:

String str[]=[Link](" ");
int len=0;
for(int i=0;i<[Link];i++)
{
len+=str[i].length();
}
int sum=0;
while(len>10)
{
while(len!=0)
{
sum+=len%10;
len/=10;
}
}
return sum;

//OR//

input1=[Link](" ","");
int len=[Link]();
int sum=0;
while(len!=0)
{
sum+=len%10;
len/=10;

if(sum>10)
{
len=sum;
sum=0;
}
}

return sum;
[Link] using Strings

BigInteger big1=new BigInteger(input1);

BigInteger big2=new BigInteger(input2);
big1=[Link](big2);
return [Link](big1);

Array based programs

[Link] encoded array:

int sum=input1[input2-1];
for(int i=input2-2;i>=0;i--)
{
input1[i]=input1[i]-input1[i+1];
sum+=input1[i];
}
Result obj=new Result(input1[0],sum);
return obj;

OR

int sum=input1[input2-1];
LinkedList<Integer> list=new LinkedList();

[Link](input1[input2-1]);
for(int i=input2-2;i>=0;i--)
{
[Link](input1[i]-[Link]());
sum+=[Link]();
}
Result obj=new Result([Link](),sum);
return obj;
[Link] sequence:

int count=0,result1=0,result2=0;

for(int i=0;i<input2-1;i++)

if(input1[i]>input1[i+1])

count++;

else

if(count>0)

result1++;

count=0;

if(result2<count)

result2=count;

if(count!=0)

{
 result1++;

if(result2>0)

result2++;

Result ob=new Result(result1,result2);

return ob;

OR

LinkedList<Integer>list=new LinkedList<Integer>();
int count=1,seq=0;
[Link](0);
for(int i=0;i<input2-1;i++)
{
if(input1[i]>input1[i+1])
{
count++;
}
else if(count>1)
{
[Link](count);
seq++;
count=1;
}
}
if(count>1)
{
[Link](count);
seq++;
}
return new Result(seq,[Link](list));
 [Link] frequent digit in array

LinkedList <Integer> list=new LinkedList();

int maxfreq=0,ans=0;
for(int i:input1)
{
while(i!=0)
{
[Link](i%10);
i/=10;
}
}
[Link](list);
for(int i:list)
{
int freq=[Link](list,i);

if(freq>=maxfreq)
{
maxfreq=freq;
ans=i;
}
}
return ans;

Number based programs

[Link] OF power digits

int sum=0, value1=0,value2=0;

Double base,power ,square_root;
while(input1>0)
{
value1=input1%10;
base=[Link](value1);
power=[Link](value2);
square_root=[Link](base,power);
sum+=square_root;
value2=value1;
input1/=10;
 }
return sum;
}
}
/* or*/

LinkedList<Integer>list=new LinkedList();
int sum=1;
while(input1!=0)
{
[Link](input1%10);
input1/=10;
}
for(int i=0;i<[Link]()-1;i++)
{
sum+=[Link]([Link](i),[Link](i+1));

}
return sum;

[Link] of sums of digits in cyclic order

LinkedList<Integer> list=new LinkedList();

int sum=0;
while(input1!=0)
{
[Link](input1%10);
input1/=10;
}
for(int i=0;i<[Link]();i++)
{
for(int j=i;j<[Link]();j++)
{
sum+=[Link](j);
}
}
return sum;

String based programs (part2)

[Link] possible words:

String arr[]=[Link](":");
input1=[Link]();
String out="";
for(String temp :arr)
{ temp=[Link]();
int count=0;
if([Link]()==[Link]())
{
for(int i=0;i<[Link]();i++)
{
if([Link](i)!='_')
{
if([Link](i)==[Link](i))
{
count++;
}
}
}
if(count==[Link]()-1)
{
out+= temp +":";
}

}
}
if(out=="")
{
return "ERROR-009";
}
return [Link](0,[Link]()-1);

OR
 String arr[]=[Link](":");
input1=[Link]();
int idx=[Link]("_");
input1=[Link]("_","");
String out="";
for(String temp :arr)
{
temp=[Link]();
if([Link]()-1==[Link]())
{
String str=[Link](0,idx)+[Link](idx+1);
if([Link](str))
{
out+=temp+":";
}
}
}
if(out=="")
{
return "ERROR-009";
}
return [Link](0,[Link]()-1);

[Link] three strings:

String out1="",out2="",out3="";
int sep=0;
String []arr={input1,input2,input3};
for(String str:arr)
{
if([Link]()%3==0)
{
sep=[Link]()/3;
out1+=[Link](0,sep);
out2+=[Link](sep,2*sep);
out3+=[Link](2*sep);
}
else if([Link]()%3==1)
 {
sep=[Link]()/3;
out1+=[Link](0,sep);
out2+=[Link](sep,2*sep+1);
out3+=[Link](2*sep+1);
}
else
{
sep=[Link]()/3;
out1+=[Link](0,sep+1);
out2+=[Link](sep+1,2*sep+1);
out3+=[Link](2*sep+1);
}
}
String out3_="";
for(int i=0;i<[Link]();i++)
{

if([Link]([Link](i)))
{
out3_+=[Link]([Link](i));
}
else
{
out3_+=[Link]([Link](i));

}
}
Result obj=new Result(out1,out2,out3_);
return obj;
 OR

LinkedList<String> list1=new LinkedList();

String arr[]={input1,input2,input3};
for(String str:arr)
{
int len=[Link]();
int sep=len/3;
if(len%3==0)
{

[Link]([Link](0,sep));
[Link]([Link](sep,2*sep));
[Link]([Link](2*sep));
}
else if(len%3==1)
{
[Link]([Link](0,sep));
[Link]([Link](sep,2*sep+1));
[Link]([Link](2*sep+1));
}
else
{
[Link]([Link](0,sep+1));
[Link]([Link](sep+1,2*sep+1));
[Link]([Link](2*sep+1));
}
}
String out1=[Link](0)+[Link](3)+[Link](6);
String out2=[Link](1)+[Link](4)+[Link](7);
String out=[Link](2)+[Link](5)+[Link](8);
String out3="";
for(int i=0;i<[Link]();i++)
{
if([Link]([Link](i)))
{
out3+=[Link]([Link](i));
}
else
 {
out3+=[Link]([Link](i));
}
}
return new Result(out1,out2,out3);

METTL -3

Number based programs

[Link] series and find Nth element:

int diff=0,next=0;
for(inti=4;i<=input4;i++)
{
diff=input2-input1;
next=input3+diff;
input1=input2;
input2=input3;
input3=next;
}
return next;

OR

int d=0;
for(int i=1;i<=input4-3;i++)
{
d=input3+(input2-input1);
input1=input2;
input2=input3;
input3=d;
}
return d;

[Link] result after alternate add_sub on N:

int result=0;
if(input2==1)
{
for(int i=0;i<=input1;i++)
{
if(i%2==0)
{
result+=input1-i;
}
else
{
result-=input1-i;
}
}
}
else
{
for(int i=0;i<=input1;i++)
{
if(i%2==0&&i!=0)
{
result-=input1-i;
}
else
{
result+=input1-i;
}
}
}
return result;

[Link] password( stable unstable)

intarr[]={input1,input2,input3,input4,input5};
LinkedList<Integer> list=newLinkedList();
int stable=0,unstable=0;
 Set<Integer> set=newTreeSet();
for(intnum:arr)
{
int temp=num;
while(num!=0)
{
[Link](num%10);
num/=10;
}
for(int i:list)
{
intfreq=[Link](list,i);
[Link](freq);
}
if([Link]()==1)
{
stable+=temp;
}
else
{
unstable+=temp;
}
[Link]();
[Link]();
}
return stable-unstable;

[Link] sum of non-prime index values:

int sum= input1[0]+input1[1];
int index=3;
while(index<input2)
{
int count=0;
for(int j=2;j<index;j++)
{
if(index%j==0)
{
count++;
}
 }
if(count!=0)
{
sum+=input1[index];
}
index++;
}
return sum;

[Link] the one digit to be removed to form palindrome:

String input=[Link](input1);
intarr[]=newint[[Link]()];
ArrayList<Integer>list=newArrayList();
intccnt=0,result=0,max=0;
for(inti=0;i<[Link]();i++)
{
arr[i]=[Link]([Link](i));
[Link](arr[i]);
}
for(intin:list)
{
ccnt=[Link](list, in);
if(ccnt==1)
{

max=in;
if(result<max)
{
result=max;
}
}

}
if(result==0)
{
result=-1;
}
if([Link]()==1)
{
 result=-1;
}
return result;

String Based Programs

[Link] id generation:

int len1=[Link]();
int len2=[Link]();
String longer="";
String smaller="";
String output="";
if(len1==len2)
{
if([Link](input2)>0)
{
longer=input1;
smaller=input2;
}
else
{
longer=input2;
smaller=input1;
}
}
elseif(len1>len2)
{
longer=input1;
smaller=input2;
}
else
{
longer=input2;
smaller=input1;
}
String small=[Link]([Link]()-1);
String pin=[Link](input3);
String output1=small+longer+[Link](input4-1)+[Link]([Link]()-
input4);
for(inti=0;i<[Link]();i++)
 {
if([Link]([Link](i)))
{
output+=[Link]([Link](i));
}
else
{
output+=[Link]([Link](i));
}
}
return output;

Message controlled Robet movement:

String path[]=[Link]("-");
int x=[Link](path[0]);
int y=[Link](path[1]);
String dir=path[2];
String arr[]=[Link](" ");
int err=0;
String ans="";
for(String str:arr)
{
if([Link]("R"))
{
if([Link]("E"))
{
dir="S";
}
elseif([Link]("S"))
{
dir="W";
}
elseif([Link]("W"))
{
dir="N";
}
else
{
dir="E";
}
}
elseif([Link]("L"))
{
if([Link]("E"))
{
dir="N";
}
elseif([Link]("S"))
{
dir="E";
}
elseif([Link]("W"))
{
dir="S";
}
else
{
dir="W";
}
}
else
{
if([Link]("E"))
{
if(x<input1)
{
x++;
}
else
{
err++;
}
}
elseif([Link]("W"))
{
if(x>0)
{
x--;
}
else
{
err++;
}
}
elseif([Link]("S"))
{
 if(y>0)
{
y--;
}
else
{
err++;
}
}
else
{
if(y<input1)
{
y++;
}
else
{
err++;
}
}
}
}
if(err==0)
{
ans=x+"-"+y+"-"+dir;
}
else
{
ans=x+"-"+y+"-"+dir+"-"+"ER";
}
return ans;

OR
String Dir[]={"NW","N","NE","E","SE","S","SW","W","NW","N","NE"};
String temp[]=[Link]("-");
int x=[Link](temp[0]);
int y=[Link](temp[1]);
String D=temp[2];
int flag=0;

String robo[]=[Link](" ");

for(String mov : robo)
{
if([Link]("R")|| [Link]("r"))
{
for(int i=0;i<[Link];i++)
{
 if([Link](Dir[i]))
{
D=([Link]("R"))?Dir[i+2]:Dir[i+1];
break;
}

}
}
if([Link]("L")|| [Link]("l"))
{
for(int i=[Link]-1;i>=0;i--)
{
if([Link](Dir[i]))
{
D=([Link]("L"))?Dir[i-2]:Dir[i-1];
break;
}

}
}
if([Link]("m"))
{
if([Link]("N")&&(y+1<=input2))
{
y=y+1;
}
elseif([Link]("S")&&(y-1<=input2)&&(y-1>=0))
{
y=y-1;
}
elseif([Link]("W")&&(x-1<=input1)&&(x-1>=0))
{
x=x-1;
}
elseif([Link]("E")&&(x+1<=input1))
{
x=x+1;
}
elseif([Link]("NE")&&(x+1<=input1)&&(y+1<=input2))
{
x=x+1; y=y+1;
}
elseif([Link]("SE")&&(x+1<=input1)&&(y-1>=0))
{
x=x+1; y=y-1;
}
elseif([Link]("SW")&&(x-1>=0)&&(y-1>=0))
{
x=x-1; y=y-1;
}
elseif([Link]("NW")&&(x-1>=0)&&(y+1<=input2))
{
x=x-1;y=y+1;
}
 else
{
flag=1;
break;
}

}
if([Link]("M"))
{
if([Link]("N")&&(y+2<=input2))
{
y=y+2;
}
elseif([Link]("S")&&(y-2<=input2)&&(y-2>=0))
{
y=y-2;
}
elseif([Link]("W")&&(x-2<=input1)&&(x-2>=0))
{
x=x-2;
}
elseif([Link]("E")&&(x+2<=input1))
{
x=x+2;
}
elseif([Link]("NE")&&(x+2<=input1)&&(y+2<=input2))
{
x=x+2; y=y+2;
}
elseif([Link]("SE")&&(x+2<=input1)&&(y-2>=0))
{
x=x+2; y=y-2;
}
elseif([Link]("SW")&&(x-2>=0)&&(y-2>=0))
{
x=x-2; y=y-2;
}
elseif([Link]("NW")&&(x-2>=0)&&(y+2<=input2))
{
x=x-2;y=y+2;
}
else
{
flag=1;
break;
}
}
}
if(flag==1)
{
return x+"-"+y+"-"+D+"-"+"ER";
}
else
{
return x+"-"+y+"-"+D;
}

Nambiar Number

int num=0,sum=0,face=-1;
String ans="";
for(int i=0;i<[Link]();i++)
{
num=[Link](i)-48;
sum+=num;
if(face==-1)
{
face=(num%2==0)?2:1;
}
if((face==2&&sum%2==1)||(face==1&&sum%2==0))
{
ans+=sum;
face=-1;
sum=0;
}
}

if(face!=-1)
{
ans+=sum;
}
return [Link](ans);