EXPANION PROGRAMS :
1. LL - Dup Element
C :-
#include "common.h"
#include
char func(struct SchNode * head){
char ch = '\0';
// WRITE YOUR CODE HERE
if(head==NULL)
return NULL;
struct SchNode* ptr=head;
while(ptr!='\0')
{
struct SchNode* next=ptr->nextNode;
while(next!='\0')
{
if(ptr->ch==next->ch)
{
return ptr->ch;
}
next=next->nextNode;
}
ptr=ptr->nextNode;
}
return ch;
}
2. LL - Insert Element
C:-
#include "common.h"
#include "ExpCUtils.h"
struct SchNode * func(struct SchNode * head, int index, char ch) {
// WRITE YOUR CODE HERE
if(head==NULL)
{
return NULL;
}
else
{
struct SchNode * prev=head;
struct SchNode * next=NULL;
struct SchNode * head1;
head1=(struct SchNode*)malloc(sizeof(struct SchNode));
head1->ch=ch;
head1->nextNode=NULL;
int i=1;
if(index==1)
{
head1->nextNode=head;
head=head1;
}
else
{
while(index!=i)
{
if(prev==NULL)
return head;
else
{
i++;
next=prev;
prev=prev->nextNode;
}
}
next->nextNode=head1;
head1->nextNode=prev;
return head;
}}
}
3. LL - Intersection Elements
JAVA:
import com.expanion.code.evalution.*;
public class Answer implements QuestionInterface {
@Override
public SchNode func(SchNode head1, SchNode head2)
{
// write your code here
if(head1==null&&head2==null)
return null;
if(head1==null)
return null;
if(head2==null)
return null;
SchNode t=null;
SchNode r=null;int i=0,j=0;
SchNode temp1=head1;
SchNode temp2=head2;
while(temp1!=null)
{
j=0;
temp2=head2;
while(temp2!=null)
{
if(i==0&&temp1.ch==temp2.ch)
{ char c=temp1.ch;
t=new SchNode(c);
//t.ch=temp1.ch;
t.nextNode=null;
temp2.ch='@';
i=1;
r=t;
break;
}
else if(temp1.ch==temp2.ch)
{
j=1;
temp2.ch='@';
break;
}
temp2=temp2.nextNode;
}
if(i==1&&j==1)
{
char c=temp1.ch;
SchNode y=new SchNode(c);
y.nextNode=null;
t.nextNode=y;
t=y;
}
temp1=temp1.nextNode;
}
return r;
}
}
4. LL - Jumper Sequence
JAVA:-
import com.expanion.code.evalution.*;
public class Answer implements QuestionInterface {
@Override
public boolean func(SintNode head)
{
if(head==null)
return false;
SintNode t=head;
int c=0,j=0;
while(t.nextNode!=null)
{
c++;
if(((t.num-t.nextNode.num)==1)||(t.num-t.nextNode.num)==-1)
j++;
t=t.nextNode;
}
if(j==c)
return true;
else
return false;
}
}
5. LL - Least Surpasser
JAVA:-
import com.expanion.code.evalution.*;
public class Answer implements QuestionInterface {
@Override
public SintNode func(SintNode head)
{
if(head==null)
return null;
SintNode t=head,tt=head;
int j=0;
int min=9999;
while(t!=null)
{
min=9999;
SintNode t1=t;
while(t1!=null)
{
if(t.num
{
if(min>t1.num)
min=t1.num;
}
t1=t1.nextNode;
}
if(min!=9999)
t.num=min;
t=t.nextNode;
}
return head;
}
}
6. LL - Majority Element
JAVA:-
import com.expanion.code.evalution.*;
public class Answer implements QuestionInterface {
@Override
public char func(SchNode head)
{
char c='\0';
if(head==null)
return c;
SchNode tr=head;
SchNode trr=null;
char chh=0;
int i=0;
while(tr!=null)
{int min=0;
trr=tr;
while(trr!=null)
{
if(tr.ch==trr.ch)
{
min++;
}
if(min>i){chh=tr.ch;
i=min;}
trr=trr.nextNode;
}
tr=tr.nextNode;
}
// write your code here
return chh;
}
}
7. LL - Number Addition
C:-
#include "common.h"
#include "ExpCUtils.h"
struct SintNode * func(struct SintNode * head1, struct SintNode * head2)
{
// WRITE YOUR CODE HERE
struct SintNode *temp2,*temp1,*nn,*temp3;
nn=(SintNode*)malloc(sizeof(SintNode));
long int carry=0,sum=0,n1=0,n2=0,f=0;
temp1=head1;
temp2=head2;
while(temp1!=NULL)
{
n1=temp1->num+(10*n1);
temp1=temp1->nextNode;
}
while(temp2!=NULL)
{
n2=(n2*10)+temp2->num;
temp2=temp2->nextNode;
}
sum=n1+n2;
if(sum==0)
{
temp3=(SintNode*)malloc(sizeof(SintNode));
temp3->num=0;
temp3->nextNode=NULL;
}
while(sum)
{
carry=sum%10;
if(f==0)
{
temp3=(SintNode*)malloc(sizeof(SintNode));
temp3->num=carry;
temp3->nextNode=NULL;
f=1;
}
else
{
nn=(SintNode*)malloc(sizeof(SintNode));
nn->num=carry;
nn->nextNode=temp3;
temp3=nn;
}
sum=sum/10;
}
return temp3;
}
8. LL - Pair Sum Count
C:-
#include "common.h"
#include
#include "ExpCUtils.h"
int func(struct SintNode * input, int sum){
int num = 0,count=0;
struct SintNode* n=input;
while(n->nextNode!='\0')
{
struct SintNode *n1=n->nextNode;
while(n1!='\0')
{
if((n->num+n1->num)==sum)
{
count++;
}
n1=n1->nextNode;
}
n=n->nextNode;
}
return count;
}
9. LL - Remove Dup Chars
JAVA:-
import com.expanion.code.evalution.*;
public class Answer implements QuestionInterface {
@Override
public SchNode func(SchNode head){
if(head==null)
return null;
SchNode t=head;
SchNode t1=null,m=null,r=null,b=head,c=null,tq=null;
while(t.nextNode!=null)
{
m=t.nextNode;
while(m!=null)
{
if((t.ch==m.ch)&&(t.ch!='*'))
{
m.ch='*';
}
m=m.nextNode;
}
t=t.nextNode;
}
while(b!=null)
{
if(b.ch!='*')
{
if(c==null){
SchNode anil=new SchNode(b.ch);
anil.nextNode=null;
c=anil;
tq=c;
}
else
{
SchNode anil=new SchNode(b.ch);
anil.nextNode=null;
c.nextNode=anil;
c=anil;
}
}
b=b.nextNode;
}
return tq;
}
}
10. LL - Remove Given Char
C:-
#include "common.h"
#include "ExpCUtils.h"
struct SchNode * func(struct SchNode * head, char ch) {
struct SchNode *x=head,*temp1,*n;
int f=0;
while(x!=NULL)
{
if((x->ch)!=ch)
{
if(f==0){
temp1=(SchNode*)malloc(sizeof(SchNode));
temp1->ch=x->ch;
f=1;
n=temp1;
}
else
{
SchNode*N=(SchNode*)malloc(sizeof(SchNode));
N->ch=x->ch;
n->nextNode=N;
n=N;
}
}
x=x->nextNode;
}
if(f==0)
return NULL;
else
return temp1;
}
11. Message from Cybertron!!!
C:-
#include "common.h"
#include
#include "ExpCUtils.h"
struct SchNode * func(struct SchNode * head1, struct SchNode * head2){
struct SchNode *temp1,*n,*x,*y;
x=head1;
y=head2;
int f=0;
while(x!=NULL)
{
y =head2;
while(y!=NULL)
{
if((x->ch)==(y->ch))
{
x->ch='#';
}
y=y->nextNode;
}
x=x->nextNode;
}
x=head1;
while(x!=NULL)
{
if(x->ch!='#')
{
if(f==0){
temp1=(SchNode*)malloc(sizeof(SchNode));
temp1->ch=x->ch;
f=1;
n=temp1;
}
else
{
SchNode*N=(SchNode*)malloc(sizeof(SchNode));
N->ch=x->ch;
n->nextNode=N;
n=N;
}
}
x=x->nextNode;
}
if(f==0)
return NULL;
else
return temp1;
}
12. LL - Reverse
C:-
#include "common.h"
#include "ExpCUtils.h"
struct SchNode * func(struct SchNode * head){
struct SchNode *temp1=NULL,*temp2=head,*temp3,*head1;
while(temp2!=NULL)
{
temp3=temp2->nextNode;
temp2->nextNode=temp1;
temp1=temp2;
temp2=temp3;
}
temp2=head1;
return head1;
}
13. LL - Reverse Group
C:-
#include "common.h"
#include "ExpCUtils.h"
struct SchNode * func(struct SchNode * head, int size) {
if(size==0)
return head;
else if(head==NULL)
return NULL;
else
{
struct SchNode* current = head;
struct SchNode* next = NULL;
struct SchNode* prev = NULL;
int count = 0;
while (current != NULL && count < size)
{
next = current->nextNode;
current->nextNode = prev;
prev = current;
current = next;
count++;
}
if (next != NULL)
head->nextNode = func(next, size);
return prev;
}
}
14. LL - Rotation:
C:-
#include "ExpCUtils.h"
struct SchNode * func(struct SchNode * head, int n)
{
if(head==NULL)
{
return NULL;
}
else
{
struct SchNode *temp,*pre=NULL;int i;
for(i=0;i
temp=head;
while(temp->nextNode!=NULL)
{
pre=temp;
temp=temp->nextNode;
}
temp->nextNode=head;
pre->nextNode=NULL;
head=temp;
}}return head;
}
15. LL - Run Length Decoding
C:-
#include "common.h"
#include "ExpCUtils.h"
#include
struct SchNode * func(struct SchNode * str){
SchNode *temp,*head,*n1,*t2;
temp=str;
int n,f=0;
char t;
while(temp!=NULL){
t2=temp->nextNode;
if(isdigit(temp->ch)){
if(t2!=NULL&&isdigit(t2->ch))
n=((temp->ch)-48)*10+(t2->ch)-48;
else
n=int(temp->ch)-48;
}
if(isalpha(temp->ch))
{
if(f==0){
head=(SchNode*)malloc(sizeof(SchNode));
head->ch=temp->ch;
n1=head;
f=1;
t=temp->ch;
}
else
{
SchNode *newNode=(SchNode*)malloc(sizeof(SchNode));
newNode->ch=temp->ch;
n1->nextNode=newNode;
n1=newNode;
t=temp->ch;
}
}
while(n>1){
SchNode *newNode=(SchNode*)malloc(sizeof(SchNode));
newNode->ch=t;
n1->nextNode=newNode;
n1=newNode;
n--;
}
temp=temp->nextNode;
}
return head;
}
16. LL - Run Length Encoding
JAVA:
import com.expanion.code.evalution.*;
public class Answer implements QuestionInterface {
@Override
public SchNode func(SchNode str){
SchNode temp;
char ch;
int count=0,c=0;
temp=str;
SchNode v=null,u=null,t=null;
while(temp!=null)
{
count=1;
ch=temp.ch;
if(c==0)
{
v=new SchNode(temp.ch);
v.ch=temp.ch;
t=v;
c=1;
}
else
{
u=new SchNode(temp.ch);
u.ch=temp.ch;
t.nextNode=u;
t=u;
}
while(temp.nextNode!=null&&temp.nextNode.ch==ch)
{
count++;
temp=temp.nextNode;
}
if(count>9)
{
u=new SchNode(temp.ch);
u.ch=(char)(count/10+48);
t.nextNode=u;
t=u;
u=new SchNode(temp.ch);
u.ch=(char)(count%10+48);
t.nextNode=u;
t=u;
}
else if(count!=1)
{
u=new SchNode(temp.ch);
u.ch=(char)(count+48);
t.nextNode=u;
t=u;
}
temp=temp.nextNode;
}
return v;
}
}
17. LL - Second Largest Number
C:-
#include "common.h"
#include "ExpCUtils.h"
#include
int func(struct SintNode * input){
struct SintNode *a=input;
struct SintNode *a1=NULL;int temp=0;
while(input!='\0')
{
a1=input->nextNode;
while(a1!='\0')
{
if(input->numnum)
{
temp=input->num;
input->num=a1->num;
a1->num=temp;
}
a1=a1->nextNode;
}
input=input->nextNode;
}
return a->nextNode->num;
}
18. LL - Shuffle Merge
C:-
#include "common.h"
#include "ExpCUtils.h"
struct SchNode * func(struct SchNode*head1, struct SchNode*head2) {
if(head1==NULL&&head2==NULL)
return NULL;
else if(head1!=NULL&&head2==NULL)
return head1;
else if(head1==NULL&&head2!=NULL)
return head2;
else
{
struct SchNode *t1=head1;
struct SchNode *t2=head2;
struct SchNode *head=NULL;
struct SchNode *last=NULL;
while(t1!=NULL||t2!=NULL)
{
if(t1!=NULL)
{
struct SchNode *n=(struct SchNode *)malloc(sizeof(struct SchNode));
n->ch=t1->ch;
if(head==NULL)
{
head=n;
last=n;
}
else
{
last->nextNode=n;
last=n;
}
t1=t1->nextNode;
}
if(t2!=NULL)
{
struct SchNode *n=(struct SchNode *)malloc(sizeof(struct SchNode));
n->ch=t2->ch;
if(head==NULL)
{
head=n;
last=n;
}
else
{
last->nextNode=n;
last=n;
}
t2=t2->nextNode;
}}
return head;
} }
19. LL - Split Reverse
C:-
#include "common.h"
#include "ExpCUtils.h"
struct SchNode * func(struct SchNode * str)
{
//WRITE CODE HERE
if(str==NULL)
{
return NULL;
}
SchNode *tor,*har,*tmp;
int cnt;
tmp=str;
tor=str;
har=tor->nextNode;
SchNode *ptr1,*prev=NULL,*next=NULL,*head=NULL,*prev1=NULL,*next1,*head1=NULL,*fin=NULL,*ptr2;
SchNode *next3,*prev3=NULL;
int c=0;
while(tmp!=NULL)
{
tmp=tmp->nextNode;
c++;
}
tmp=str;
if(c==1)
return str;
if(c%2==0)
{
while(har && har->nextNode)
{
tor=tor->nextNode;
har=har->nextNode->nextNode;
}
ptr1=tor->nextNode;
tor->nextNode='\0';
har=ptr1;
while(har!=NULL)
{
next=har->nextNode;
har->nextNode=prev;
prev=har;
har=next;
}
head=prev;
tor=str;
while(tor!=NULL)
{
next1=tor->nextNode;
tor->nextNode=prev1;
prev1=tor;
tor=next1;
}
head1=prev1;
fin=head1;
while(fin->nextNode!=NULL)
{
fin=fin->nextNode;
}
fin->nextNode=head;
fin->nextNode=head;
return head1;
}
else if(c%2!=0)
{
while(har && har->nextNode)
{
tor=tor->nextNode;
har=har->nextNode->nextNode;
}
ptr2=tor;
ptr1=tor->nextNode;
tor->nextNode='\0';
har=ptr1;
while(har!=NULL)
{
next=har->nextNode;
har->nextNode=prev;
prev=har;
har=next;
}
head=prev;
tor=str;
while(tor->nextNode!=NULL)
{
next1=tor->nextNode;
tor->nextNode=prev1;
prev1=tor;
tor=next1;
}
head1=prev1;
fin=head1;
while(fin->nextNode!=NULL)
{
fin=fin->nextNode;
}
fin->nextNode=ptr2;
ptr2->nextNode=head;
return head1;
}
}
20. LL - Surpasser Count
C:-
#include "common.h"
#include "ExpCUtils.h"
struct SintNode * func(struct SintNode * input)
{
struct SintNode *ptr1,*ptr2;
int max, count=0;
ptr1=input;
while(ptr1!=NULL)
{
count=0;
max=ptr1->num;
ptr2=ptr1;
while(ptr2!=NULL)
{
if(ptr2->num>max)
{
count++;
}
ptr2=ptr2->nextNode;
}
ptr1->num=count;
ptr1=ptr1->nextNode;
}
return input;
}
