initial commit

Author: Pythonista7

BFAlgo.java

@@ -0,0 +1,88 @@
+//Write a program to find the shortest path between vertices using bellman-ford algorithm.
+
+import java.util.*;
+import java.io.*;
+import java.math.*;
+
+class BFAlgo
+{
+	public static void main(String args[])
+	{
+		Scanner s=new Scanner(System.in);
+
+		//Input the number of nodes in the graph
+		System.out.println("Enter the number of nodes: ");
+		int n=s.nextInt();
+		
+		//Input source and destination node numbers
+		System.out.println("Enter Source node number :");
+		int source=s.nextInt();
+
+		System.out.println("Enter Destination node number :");
+		int dest=s.nextInt();
+
+		//create distance array
+		int[] dist=new int[n];
+		for(int i=0;i<n;i++)
+			//Initialize the array with a maximum value which is assumed to be far greater then any edge weight
+			dist[i]=999;
+
+		//create adj matrix
+		int[][] adj_mat=new int[n][n];
+		System.out.println("Enter adj matrix :");
+		
+		//Input the adj_matrix
+		for(int i=0;i<n;i++)
+		{
+			for(int j=0;j<n;j++)
+			{
+				
+				adj_mat[i][j]=s.nextInt();
+		
+			}
+		}
+
+		//display adj_mat
+		System.out.println("\n\nEntered ADJ MATRIX IS:");
+		disp(adj_mat);
+		dist[source]=0;
+
+		//loop through all the nodes
+		for(int k=0;k<n-1;k++)
+		{
+			for(int i=0;i<n;i++)
+			{
+				//for each node as the souce update the cost in adj_matrix
+				for(int j=0;j<n;j++)
+				{
+					//if there is a direct path between nodes i and j
+					if(adj_mat[j][i]!=999)
+					{
+					  //then check if the direct path is shorter than an alternate path through another node
+					  //choose the shortest dist and update the distance array
+						if(dist[i]>dist[j]+adj_mat[j][i])
+							dist[i]= dist[j]+adj_mat[j][i];
+					}
+				}
+			
+		
+			}
+		}		
+
+		//display statements
+		for(int i=0;i<n;i++)
+			System.out.println(source+"-->"+i+" = "+dist[i]);
+	}
+
+	//helper function for 2D matrix	
+	public static void disp(int arr[][])
+	{
+		for(int[] x : arr)
+		{	for(int y : x)				
+				System.out.print(y);
+			System.out.println();
+		}
+	}
+
+
+}

Bucket.java

@@ -0,0 +1,70 @@
+//Write a program for congestion control using leaky bucket algorithm.
+
+import java.security.SecureRandom;
+import java.util.*; 
+import java.io.*;
+
+class Bucket
+{
+	public static void main(String args[])
+	{
+		Random r=new Random();
+		Scanner s = new Scanner(System.in);
+		 
+		System.out.println("Enter the input rate: ");
+		int n=s.nextInt();
+
+		System.out.println("Enter the Bucket Size: ");
+		int bucket_size=s.nextInt();
+
+		System.out.println("Enter the Output Rate: ");
+		int out_rate=s.nextInt();
+
+		System.out.println("Enter packet data: ");
+		int[] input_arr=new int[n];
+
+		for(int i=0;i<n;i++)
+		{
+			input_arr[i]=r.nextInt(127);//s.nextInt(); here we'll be auto populating the array instead of inputting n numbers
+		}
+		
+		int bc=0;//bucket_content=0
+
+		//loop through for each packet in input_arr[]
+		for(int i=0;i<n;i++)
+		{
+			//check if the new packet fits into the bucket at the current instance 
+			if(bc+input_arr[i]<=bucket_size)
+			{	//if new packet can be fit then insert it into the bucket
+				bc=bc+input_arr[i];
+				System.out.print(i+"\tPacket: "+input_arr[i]+"\tBucket Content: "+bc+"\tStatus: Accepted\tRemaining: ");		
+				//after processing(displaying) the status display remove bucket content equal to out_rate 	
+				bc=bc-out_rate;
+
+				//note - removal of element must not cause negative bucket capacity.
+				if(bc<=0)//bc=bc<=0?0:bc;
+				{
+					bc=0;
+				}
+				System.out.println(bc);//Display remaining capacity 
+			}
+			//If the packet does not fit into current bucket then simply drop the packet and continue to out_rate
+			else
+			{
+				System.out.print(i+"\tPacket: "+input_arr[i]+"\tBucket Content: "+bc+"\tStatus: Rejected\tRemaining: ");		
+				//remove outrate from bc as normal cycle
+				bc=bc-out_rate;
+				if(bc<=0)//dont let the bucket capacity assume negative values
+				{
+					bc=0;
+				}
+				System.out.println(bc);
+			}
+
+
+			
+		}
+		
+	}
+
+}

ED.java

@@ -0,0 +1,113 @@
+import java.math.*;
+import java.io.*;
+import java.security.*;
+/*
+	ALGORITHM
+	==========
+	STEP 1 > pick 2 large prime numbers , say 'p' and 'q' 
+
+	STEP 2 > Compute their product, say n = p * q
+
+	STEP 3 > Compute PHI(n) as PHI(n) = (p-1) * (q-1)
+
+	STEP 4 > pick a value 'e' such that GCD(e,PHI(n))=1 , here 'e' is the encrytion key
+
+	STEP 5 > calculate 'd' as d = e^(-1) mod PHI(n) , here 'd' is the decryption key
+
+	STEP 6 > now we have our PublicKey=(e,n) and PrivateKey=(d,n) 
+
+	STEP 7 > Encryption : CipherText = (Message)^e mod n
+
+	STEP 8 > Decryption : PlainMsg = (CipherText)^d mod n
+  
+*/
+
+class ED_helper
+{
+	private int bitlen,r;
+	private BigInteger p,q,n,phi,e,d;
+	
+	ED_helper(int bit)
+	{
+		bitlen=bit;//number of bits strong we want our encryption to be 
+		SecureRandom r=new SecureRandom();//we use this because its a 128bit rand_generator,hence low chances of repeats.
+		
+		//<================================<  STEP 1 >======================================>
+	
+		//SYNTAX
+		//BigInteger(int bitLength, int certainty, Random rnd)
+		
+		//we want to generate encryption keys as a product of p and q hence each of p and q much contain half as many digits
+		//as bitlen.And the second value to the BigInt tells us we want to generate primes with 100% certainity using 'r'
+		p=new BigInteger(bitlen/2,100,r);
+		q=new BigInteger(bitlen/2,100,r);
+		
+		System.out.println("P value :"+p+"\n\n\n "+"Q value="+q);
+	
+		//<================================<  STEP 2 >======================================>	
+		n=p.multiply(q);//BigInteger Multiplication
+		
+		//<================================<  STEP 3 >======================================>
+		phi=p.subtract(BigInteger.ONE).multiply(q.subtract(BigInteger.ONE));
+		
+		//<================================<  STEP 4 >======================================>
+		e=new BigInteger(bitlen/2,100,r);//BigInteger will take care of GCD() <UNDERATED STEP>
+		
+		//<================================<  STEP 5 >======================================>
+		d=e.modInverse(phi);//e^-1 then % phi
+		
+		//<================================<  STEP 6 >======================================>
+		System.out.println("\n\n\nValue of D :"+d+"\n\n\nValue of E : "+e);//Displaying keys
+		
+	}
+	
+
+	//<================================<  STEP 7 >======================================>
+	public BigInteger encrypt(BigInteger Msg)
+	{
+		//CipherText = (Msg)^e mod n 
+		return(Msg.modPow(e,n));
+		
+	}
+	
+	//<================================<  STEP 8 >======================================>
+	public BigInteger decrypt(BigInteger Msg)
+	{
+		//DecodedMsg = (Ciphext)^d mod n
+		return(Msg.modPow(d,n));
+		
+	}
+
+
+}
+
+//Main Driver Class to demonstrate functionalities implemented by the above class
+class ED
+{
+	
+	public static void main(String args[]) throws IOException
+	{
+		//Create object and pass the bit length 
+		ED_helper rsa=new ED_helper(1200);
+		
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		
+		String text1,text2;
+		BigInteger Pt,Ct;
+		
+		//Input Message from user
+		System.out.println("\n\nEnter Plaintext :");
+		text1=br.readLine();
+		
+		//pass the input message to the encrypt method to obtain cipher text
+		Pt=new BigInteger(text1.getBytes());
+		Ct=rsa.encrypt(Pt);
+		System.out.println("\n\nCiperText is : "+Ct);
+		
+		//Pass the CipherText to the decrypt method to obtain original message
+		Pt=rsa.decrypt(Ct);
+		text2=new String(Pt.toByteArray());
+		System.out.println("\n\n\nData after decrypt :"+text2);
+	}
+
+}

tcpClient.java

@@ -0,0 +1,34 @@
+import java.net.*;
+import java.io.*;
+
+class tcpClient
+{
+	public static void main(String args[]) throws IOException
+	{
+		//Establish a connection at the given IP and port number. "localhost" refers to this computer
+		Socket sock=new Socket("localhost",5050);
+
+		//Input the file name to be retrived from the server
+		System.out.println("Enter filename :");
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		String fname=br.readLine();
+	
+		//create output stream to send data to outstream
+		OutputStream ostream=sock.getOutputStream();
+		PrintWriter pw = new PrintWriter(ostream,true);
+		//send filename to the server by writing to outstream using PrintWriter
+		pw.println(fname);
+
+		//Setup input strem to recieve file contents from the server
+		InputStream istream=sock.getInputStream();
+		BufferedReader sockread=new BufferedReader(new InputStreamReader(istream));
+		String msg;
+	
+		//Store and print out each line that was read from the inputstream 
+		while((msg=sockread.readLine())!=null)
+		{
+			System.out.println(msg);
+		}
+		
+	}
+}

tcpServer.java

@@ -0,0 +1,51 @@
+//TCP Server
+
+import java.net.*;
+import java.io.*;
+
+class tcpServer
+{
+	
+	public static void main(String args[]) throws IOException
+	{
+		//setup a server socket on a port no(needs to be greater than 1023) , say 5050
+		ServerSocket sersock=new ServerSocket(5050);
+		System.out.println("Server Started");
+		
+		//Once a client tries to connect to the server we accept the connection
+		Socket sock=sersock.accept();
+		System.out.println("Server ready");
+		
+		//Create an input stream to read the information sent by the client 
+		InputStream istream=sock.getInputStream();
+
+		//Use a BufferedReader to read the contents from the above created input stream
+		BufferedReader br=new BufferedReader(new InputStreamReader(istream));
+
+		//read and store the contents from the istream into a string variable 'filename'
+		String fname=br.readLine();
+
+		//the contents of the specified filename passed by the client is read here(at the server) using another bufferedReader
+		BufferedReader ContentReader=new BufferedReader(new FileReader(fname));
+
+		//An output stream is created so as to realy the data the client had requested for
+		OutputStream ostream=sock.getOutputStream();
+
+		//create a PrintWriter class to write the contents of the requested file into the outstream
+		PrintWriter pr=new PrintWriter(ostream,true);//SYNTAX : PrintWriter(Writer out, boolean autoFlush
+
+		//msg is a temporary variable to store and send data to the outstream via printwriter 		
+		String msg;
+		System.out.println("Sending contents of "+fname);
+		//Keep sending data from file to outstream until EOF/Null is encountered
+		while((msg=ContentReader.readLine()) != null)
+		{
+			pr.println(msg);
+		}
+		
+		sock.close();
+	}
+
+
+
+}