January 2014

Thursday 30 January 2014

Program to print Binary Numbers where adjacent bits are not 1 [Java]

Ajith KP January 30, 2014

This was the interview question asked to my teacher when she attend an interview.
I have created a Java program to demonstrate it.

Eg.
1010 - Valid.
1101 - Not Valid because two 1's are in adjacent positions.

/*
        #       #####  ###  ########  ###   ### TM    
      #   #       #     #   #  #   #   #     # 
     #     #      #     #      #       #     #
     #     #      #     #      #       #######     
     #######      #     #      #       #     #
     #     #   #  #     #      #       #     #
    ###   ###  ####    ###    ###     ###   ###

*/
import java.util.*;
public class BinaryX 
{
    public static void main(String[] args) 
    {
        String bin;
        int n, i, j, k, flag;
        char[] bn;
        Scanner sc = new Scanner(System.in);
        StringBuilder bld;
        System.out.print("Enter Digit: ");
        n = sc.nextInt();
        if(n==1)
        {
            for(i=0;i<2;i++)
            {
                flag = 0;
                bin = binary(i);
                bld = new StringBuilder(bin);
                bn = bin.toCharArray();
                for(j=0;j<bn.length-1;j++)
                {
                    if(bn[j]==bn[j+1]&&bn[j]=='1')
                    {
                        flag = 1;
                    }
                }
                if(flag==0)
                {
                    System.out.println(i+" : "+bld.reverse());
                }
            }
        }
        else
        {
            //System.out.println(square(n-1)+" : "+square(n));
            for(i=_2rised(n-1);i<_2rised(n);i++)
            {
                flag = 0;
                bin = binary(i);
                bld = new StringBuilder(bin);
                bn = bin.toCharArray();
                for(j=0;j<bn.length-1;j++)
                {
                    if(bn[j]==bn[j+1]&&bn[j]==49)
                    {
                        flag = 1;
                        //System.out.print("Found");
                    }
                }
                if(flag==0)
                {
                    System.out.println(i+" : "+bld.reverse());
                }
            }
        }
    } 
    
    static int _2rised(int n)
    {        
        return 2<<(n-1);      
    }
    
    static String binary(int n)
    {
        String bx = "";
        if(n==0)
        {
            return("0");
        }
        for(int y=0;n!=0;y++)
        {
            bx+=(n%2);
            n/=2;
        }
        return bx;
    }
}

Sunday 5 January 2014

Skillen( :p )_Questions(+2)

Search - Linear search and Binary search [CPP]

Ajith KP January 05, 2014

Search is a technique to find an item from group of item whose value equal to key value.

Source Code

#include <iostream>
using namespace std;
class search
{
 int n, a[100], i, j, k, t, m;
 public:
 void read()
 {
  cout<<"Enter the limit: ";
  cin>>n;
  cout<<"Enter "<<n<<" Numbers: ";
  for(i=0;i<n;i++)
  {
   cin>>a[i];
  }
  cout<<"Enter key: ";
  cin>>k;
  for(i=0;i<n;i++)
  {
   for(j=i+1;j<n;j++)
   {
    if(a[j]<a[i])
    {
     t=a[i];
     a[i]=a[j];
     a[j]=t;
    }
   }
  }
  cout<<"Linear search result: ";
  linear();
  cout<<"Binary search result: ";
  binary(0, n);
 }
 void linear()
 {
  t=0;
  for(i=0;a[i]<=k;i++)
  {
   if(a[i]==k)
   {
    cout<<"Key "<<k<<" Found at position "<<i+1<<"\n";
    t=1;
   }
  }
  if(t==0)
  {
   cout<<"Key "<<k<<" Not Found\n";
  }
 }
 void binary(int l, int u)
 {
  if(l>u)
  {
   cout<<"Key "<<k<<" Not found\n";
  }
  else
  {
   m=(l+u)/2;
   if(a[m]==k)
   {
     cout<<"Key "<<k<<" Found at position "<<m+1<<"\n";
   }
   else if(k<a[m])
   {
     binary(l, m-1);
   }
   else
   {
     binary(m+1, n);   
   }
  }
 }
};

int main()
{
 search s;
 s.read();
}

Skillen( :p )_Questions(+2)

Tower Of Hanoi Solving [CPP]

Ajith KP January 05, 2014

Tower of Hanoi is a disk transferring problem.
I hope the seeker knows the rules of transferring disks from source to destination.

Source Code

Skillen( :p )_Questions(+2)

Quick Sort [CPP]

Ajith KP January 05, 2014

Quick sort is a sorting method. This method uses divided and conquer method to sort.

Source Code

#include <iostream>
using namespace std;
class quick
{
    int a[100], n, i, j;
    public:
        void read()
        {
            cout<<"Enter the limit: ";
            cin>>n;
            cout<<"Enter "<<n<<" Elements: ";
            for(i=0;i<n;i++)
            {
                cin>>a[i];
            }
            quick_sort(0, n);
            cout<<"Sorted List: ";
            for(i=0;i<n;i++)
            {
                cout<<a[i]<<" ";
            }
            cout<<"\n";
        }
        
        void quick_sort(int f, int l)
        {
            int j;
            if(f<l)
            {
                j = partition(f, l);
                quick_sort(f, j);
                quick_sort(j+1, l);
            }
        }
        int partition(int f, int l)
        {
            int pivot, i, j, tmp;
            pivot = a[f];
            i = f;
            j = l;
            while(1)
            {
                do
                {
                    ++i;
                }
                while(a[i]<=pivot&&i<=l);
                do
                {
                    --j;
                }
                while( a[j] > pivot );
                if( i >= j )
                {
                    break;
                }
                swap(i, j);
            }
            swap(f, j);
            return j;
        }
        void swap(int i, int j)
        {
            int tmp;
            tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }
};
int main()
{
    quick q;
    q.read();
    cin.get();
}

Programming Languages Theory

JavaFX - Impress your lover [juZt 4 fUn] V.2.0

Ajith KP January 05, 2014

V.1.0 => http://terminalcoders.blogspot.in/2013/06/javafx-impress-your-lover-juzt-4-fun.html

I have added a simple animation to my previous post.

Source Code

/*
 *
 *
 * http://www.terminalcoders.blogspot.in
 *
 * Amsteck Arts & Science College
 * Ajith Kp [ajithkp560]
 *
 */

package javafx_11;

import java.util.*;
import javafx.animation.FillTransition;
import javafx.animation.ParallelTransition;
import javafx.animation.RotateTransition;
import javafx.animation.ScaleTransition;
import javafx.animation.Timeline;
import javafx.animation.TranslateTransition;
import javafx.application.*;
import javafx.scene.*;
import javafx.scene.effect.Reflection;
import javafx.scene.paint.Color;
import javafx.scene.text.*;
import javafx.stage.*;
import javafx.util.Duration;

public class JavaFX_11 extends Application 
{
    Random rand = new Random(System.currentTimeMillis());
    @Override
    public void start(Stage stage) 
    {
        Text t = new Text("I Love You, By Ajith Kp");
        Text[] bg = new Text[300]; 
        int[] sign = {-1, 1};
        t.setFont(Font.font("Comic Sans MS", 40));
        Reflection r = new Reflection();
        r.setFraction(0.90f);
        t.setFill(Color.rgb(0, 255, 0, .8));
        t.setCache(true);
        t.setTranslateY(0);//160
        t.setTranslateX(0);//55
        t.setEffect(r);
        Group root=new Group();
        Scene scene = new Scene(root, 800, 360, Color.BLACK);
        stage.setTitle("I Love You");              
        root.getChildren().add(t);
        for(int i=0; i<200; i++)
        {
            int x=rand.nextInt((int) scene.getWidth());
            int y=rand.nextInt((int) scene.getHeight());
            int si = rand.nextInt(2);
            int xx=rand.nextInt((x+20));
            xx = xx*sign[si];
            int yy=rand.nextInt((y+20));
            yy = yy*sign[si];
            int rro=rand.nextInt(360);
            
            int size=rand.nextInt(25);
            int rot=rand.nextInt(360);
            Font fnd=Font.font("SandSerif", size);
            bg[i] = new Text(x, y,"I Love You");
            bg[i].setRotate(rot);
            int red=rand.nextInt(255);
            int green=rand.nextInt(255);
            int blue=rand.nextInt(255);
            bg[i].setFont(fnd);
            bg[i].setFill(Color.rgb(red, green, blue, 0.3));  
            
            TranslateTransition tra = new TranslateTransition(Duration.millis((10000)));
            tra.setToX(xx);//360
            tra.setToY(yy);//160
            FillTransition f = new FillTransition(Duration.millis(10000));
            f.setToValue(Color.RED);
            RotateTransition rr = new RotateTransition(Duration.millis(10000));
            rr.setToAngle(rro);
            ScaleTransition s = new ScaleTransition(Duration.millis(10000));
            s.setToX(0.1);
            s.setToY(0.1);
            ParallelTransition pp = new ParallelTransition(bg[i],tra,f,rr,s);
            pp.setCycleCount(Timeline.INDEFINITE);
            pp.setAutoReverse(true);
            tra.setCycleCount(Timeline.INDEFINITE);
            tra.setAutoReverse(true);        
            tra.play();        
            stage.setScene(scene);
            stage.show();
            
            
            root.getChildren().add(bg[i]);
        }
        
        
        TranslateTransition tra = new TranslateTransition(Duration.millis((4000)));
        tra.setToX((int) scene.getWidth());//360
        tra.setToY((int) scene.getHeight());//160
        FillTransition f = new FillTransition(Duration.millis(4000));
        f.setToValue(Color.RED);
        RotateTransition rr = new RotateTransition(Duration.millis(4000));
        rr.setToAngle(360);
        ScaleTransition s = new ScaleTransition(Duration.millis(4000));
        s.setToX(0.1);
        s.setToY(0.1);
        ParallelTransition pp = new ParallelTransition(t,tra,f,rr,s);
        pp.setCycleCount(Timeline.INDEFINITE);
        pp.setAutoReverse(true);
        tra.setCycleCount(Timeline.INDEFINITE);
        tra.setAutoReverse(true);        
        tra.play();        
        stage.setScene(scene);
        stage.show();
    }
    
    public static void main(String[] args) 
    {
        launch(args);
    }
}

Skillen( :p )_Questions(+2)

Merge Sort [CPP]

Ajith KP January 05, 2014

Merge sort is sorting technique used to merge and sort two sorted lists.
If the two lists are not sorted we have to sort it before merge.

Merge Sort

Source Code

#include <iostream>
using namespace std;
class merge
{
    public:
        void read()
        {
            long int a[100], b[100], c[100], i, j, t, n1, n2;
            cout<<"Enter Limit of 1st List: ";
            cin>>n1;
            cout<<"Enter Elements: ";
            for(i=0;i<n1;i++)
            {
                cin>>a[i];
            }
            cout<<"Enter Limit of 2nd List: ";
            cin>>n2;
            cout<<"Enter Elements: ";
            for(i=0;i<n2;i++)
            {
                cin>>b[i];
            }
            for(i=0;i<n1;i++)
            {
                for(j=i+1;j<n1;j++)
                {
                    if(a[i]>a[j])
                    {
                        t=a[i];
                        a[i]=a[j];
                        a[j]=t;
                    }
                }
            }
            for(i=0;i<n2;i++)
            {
                for(j=i+1;j<n2;j++)
                {
                    if(b[i]>b[j])
                    {
                        t=b[i];
                        b[i]=b[j];
                        b[j]=t;
                    }
                }
            }
            j=0;
            t=0;
            for(i=0;i<n1+n2;)
            {
                if(a[j]<b[t])
                {
                    c[i++]=a[j++];
                }
                else
                {
                    c[i++]=b[t++];
                }
                if(j==n1||t==n2)
                {
                    break;
                }
            }
            for(;j<n1;)
            {
                c[i++]=a[j++];
            }
            for(;t<n2;)
            {
                c[i++]=b[t++];
            }
            cout<<"Sored List: ";
            for(i=0;i<n1+n2;i++)
            {
                cout<<c[i]<<" ";
            }
            cout<<"\n";
        }    
};
int main()
{
    merge m;
    m.read();
    cin.get();
}