ASSIGNMENT
Name : D.K.Karthik Varma
Roll no : 421132
1) Construct a TCP client-server system to allow client programs to get the system date and time from
the server. When a client connects to the server, the server gets the local time on the machine and
sends it to the client. The client displays the date and time on the screen and terminates.
Server1.java
import java.io.*;
import
java.net.*;
import
java.text.SimpleDateFormat;
import java.util.Date;
public class Server1 {
public static void main(String[] args) {
try {
// Create a server socket
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("Server is running and waiting for
connections...");
while (true) {
// Wait for a client connection
Socket clientSocket = serverSocket.accept();
System.out.println("Connection from: " +
clientSocket);
// Get the current date and time
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd
HH:mm:ss");
Date currentDate = new Date();
String currentTime = dateFormat.format(currentDate);
// Send the current time to the client
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(),
true); out.println(currentTime);
// Close the
connection
clientSocket.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
Client1.java
import java.io.*;
import
java.net.*;
public class Client1 {
public static void main(String[] args) {
try {
// Create a socket to connect to the server
Socket socket = new Socket("localhost",
9999);
// Receive the date and time from the server
BufferedReader in = new BufferedReader(new
InputStreamReader(socket.getInputStream()))
; String currentTime = in.readLine();
System.out.println("Received date and time from server: " + currentTime);
// Close the connection
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
2) Construct client-server programming: The client has a list of words (at least 20 words) and the
server has a dictionary (at least 15 entries). The client picks up a random word from its list and sends it
to the server. The server responds with its meaning, if found else adds this entry to its dictionary with
its meaning.
Server2.java
import java.io.*;
import java.net.*;
import java.util.*;
public class Server {
private static Map<String, String> dictionary = new HashMap<>();
static {
// Initialize dictionary with some entries
dictionary.put("apple", "a fruit");
dictionary.put("banana", "an elongated curved
fruit");
dictionary.put("carrot", "a long pointed orange vegetable");
}
public static void main(String[] args) {
try {
// Create a server socket
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("Server is running and waiting for
connections...");
while (true) {
// Wait for a client connection
Socket clientSocket = serverSocket.accept();
System.out.println("Connection from: " +
clientSocket);
// Handle client request
handleClientRequest(clientSocket);
// Close the
connection
clientSocket.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
private static void handleClientRequest(Socket clientSocket) throws IOException {
// Receive word from client
BufferedReader in = new BufferedReader(new
InputStreamReader(clientSocket.getInputStream()))
;
String word = in.readLine();
// Look up the meaning in the dictionary
String meaning = dictionary.get(word);
// If meaning not found, add to dictionary
if (meaning == null) {
meaning = "Meaning not found";
addToDictionary(word,
meaning);
}
// Send meaning to client
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(),
true); out.println(meaning);
}
private static void addToDictionary(String word, String meaning)
{ dictionary.put(word, meaning);
System.out.println("Added new word to dictionary: " + word + " - " + meaning);
}
}
Client2.java
import java.io.*;
import java.net.*;
import java.util.*;
public class Client {
private static final List<String> wordList = Arrays.asList(
"apple", "banana", "carrot", "dog", "cat", "house", "tree", "book", "computer",
"table", "chair", "phone", "pen", "paper", "lamp", "flower", "river", "mountain",
"sky", "sun"
);
public static void main(String[] args) {
try {
// Create a socket to connect to the server
Socket socket = new Socket("localhost",
9999);
// Select a random word from the list
Random random = new Random();
String randomWord = wordList.get(random.nextInt(wordList.size()));
// Send the random word to the server
PrintWriter out = new PrintWriter(socket.getOutputStream(),
true); out.println(randomWord);
// Receive the meaning from the server
BufferedReader in = new
BufferedReader(new
InputStreamReader(socket.getInputStream()))
; String meaning = in.readLine();
System.out.println("Meaning of '" + randomWord + "': " + meaning);
// Close the connection
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
3) Construct a Java program using client-server socket programming: The client will enter an integer
number and the server will return its factorial.
Server3.java
import java.io.*;
import
java.net.*;
public class Server3 {
public static void main(String[] args) {
try {
// Create a server socket
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("Server is running and waiting for
connections...");
while (true) {
// Wait for a client connection
Socket clientSocket = serverSocket.accept();
System.out.println("Connection from: " +
clientSocket);
// Handle client request
handleClientRequest(clientSocket);
// Close the
connection
clientSocket.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
private static void handleClientRequest(Socket clientSocket) throws IOException {
// Receive the integer number from the client
BufferedReader in = new
BufferedReader(new
InputStreamReader(clientSocket.getInputStream()))
; int number = Integer.parseInt(in.readLine());
// Calculate factorial
int factorial = calculateFactorial(number);
// Send factorial to the client
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(),
true); out.println(factorial);
}
private static int calculateFactorial(int n) {
if (n == 0)
return
1; else
return n * calculateFactorial(n - 1);
}
}
Client3.java
import java.io.*;
import
java.net.*;
import java.util.Scanner;
public class Client3 {
public static void main(String[] args) {
try {
// Create a socket to connect to the server
Socket socket = new Socket("localhost", 9999);
Scanner scanner = new Scanner(System.in);
// Get the integer number from the user
System.out.print("Enter an integer number:
"); int number = scanner.nextInt();
// Send the number to the server
PrintWriter out = new PrintWriter(socket.getOutputStream(),
true); out.println(number);
// Receive factorial from the server
BufferedReader in = new
BufferedReader(new
InputStreamReader(socket.getInputStream()));
int factorial = Integer.parseInt(in.readLine());
System.out.println("Factorial of " + number + ": " + factorial);
// Close the connection
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
4. )
Server4.java
import java.io.*;
import
java.net.*;
public class Server4 {
public static void main(String[] args) {
try {
// Create a server socket
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("Server is running and waiting for
connections...");
while (true) {
// Wait for a client connection
Socket clientSocket = serverSocket.accept();
System.out.println("Connection from: " +
clientSocket);
// Handle client request
handleClientRequest(clientSocket);
// Close the
connection
clientSocket.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
private static void handleClientRequest(Socket clientSocket) throws IOException {
// Receive the mark from the client
BufferedReader in = new
BufferedReader(new
InputStreamReader(clientSocket.getInputStream()))
; int mark = Integer.parseInt(in.readLine());
// Calculate grade
String grade = calculateGrade(mark);
// Send grade to the client
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(),
true); out.println(grade);
}
private static String calculateGrade(int mark) {
if (mark >= 85 && mark <= 100)
return "Grade A";
else if (mark >= 70 && mark <= 84)
return "Grade B";
else if (mark >= 60 && mark <= 69)
return "Grade C";
else if (mark >= 50 && mark <= 59)
return "Grade D";
else
return "Fail";
}
}
Client4.java
import java.io.*;
import
java.net.*;
import java.util.Scanner;
public class Client4 {
public static void main(String[] args) {
try {
// Create a socket to connect to the server
Socket socket = new Socket("localhost", 9999);
Scanner scanner = new Scanner(System.in);
// Get the mark from the user
System.out.print("Enter the mark: ");
int mark = scanner.nextInt();
// Send the mark to the server
PrintWriter out = new PrintWriter(socket.getOutputStream(),
true); out.println(mark);
// Receive grade from the server
BufferedReader in = new
BufferedReader(new
InputStreamReader(socket.getInputStream()))
; String grade = in.readLine();
System.out.println("Grade: " + grade);
// Close the connection
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
5) Construct a Java program using client-server socket programming: A client enters 0, 1, 2, 3, and 4 in
sequence and the server returns the results 3, 3, 7, 15, and 27 respectively in sequence. (One by one)
Server5.java
import java.io.*;
import
java.net.*;
public class Server5 {
public static void main(String[] args) {
try {
// Create a server socket
ServeConstruct a Java program using client-server programming: The client sends
a word and a number to the server and the server sends the letter which
occurs the given number of times in the given word, if it exists else send the
letter which occurs at maximum number of times in the given word.
Connection should not terminate till the client wants torSocket serverSocket =
new ServerSocket(9999);
System.out.println("Server is running and waiting for connections...");
while (true) {
// Wait for a client connection
Socket clientSocket = serverSocket.accept();
System.out.println("Connection from: " +
clientSocket);
// Handle client request
handleClientRequest(clientSocket);
// Close the
connection
clientSocket.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
private static void handleClientRequest(Socket clientSocket) throws IOException {
// Receive the number from the client
BufferedReader in = new
BufferedReader(new
InputStreamReader(clientSocket.getInputStream()))
; int number = Integer.parseInt(in.readLine());
// Calculate result based on the received number
int result = calculateResult(number);
// Send result to the client
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(),
true); out.println(result);
}
private static int calculateResult(int number) {
// Perform calculation based on the given sequence
switch (number) {
case 0:
return 3;
case Construct a Java program using client-server programming: The client sends
a word and a number to the server and the server sends the letter which
occurs the given number of times in the given word, if it exists else send the
letter which occurs at maximum number of times in the given word.
Connection should not terminate till the client wants to1:
return 3;
case 2:
return 7;
case 3:
return 15;
case 4:
return
27; default:
return -1; // Invalid input
}
}
}
Client5.java
import java.io.*;
import
java.net.*;
public class Client5 {
public static void main(String[] args) {
try {
// Create a socket to connect to the server
Socket socket = new Socket("localhost",
9999);
// Create a PrintWriter to send numbers to the server
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
// Send numbers 0, 1, 2, 3, and 4 in sequence
for (int i = 0; i < 5; i++) {
out.println(i);
// Receive the result from the server
BufferedReader in = new
BufferedReader(new
InputStreamReader(socket.getInputStream()));
int result = Integer.parseInt(in.readLine());
System.out.println("Result for " + i + ": " + result);
}
// Close the connection
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
6) Construct a Java program using client-server programming: The client sends a word and a number
to the server and the server sends the letter which occurs the given number of times in the given word,
if it exists else send the letter which occurs at maximum number of times in the given word.
Connection should not terminate till the client wants to.
Server6.java
import java.io.*;
import java.net.*;
import java.util.*;
public class Server {
public static void main(String[] args) {
try {
// Create a server socket
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("Server is running and waiting for
connections...");
while (true) {
// Wait for a client connection
Socket clientSocket = serverSocket.accept();
System.out.println("Connection from: " +
clientSocket);
// Handle client request
handleClientRequest(clientSocket);
// Close the connection
// clientSocket.close(); // Keep the connection
terminate open until the client wants to
}
} catch (IOException e) {
e.printStackTrace();
}
}
private static void handleClientRequest(Socket clientSocket) throws IOException {
BufferedReader in = new BufferedReader(new
InputStreamReader(clientSocket.getInputStream()));
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
while (true) {
// Receive word and number from the client
String word = in.readLine();
int number = Integer.parseInt(in.readLine());
// Find the letter occurrence based on the client's
request char result = findLetterOccurrence(word,
number);
// Send the result to the client
out.println(result);
// Check if the client wants to terminate the connection
String terminate = in.readLine();
if (terminate.equals("quit")) {
break; // Exit the loop if the client wants to quit
}
}
}
private static char findLetterOccurrence(String word, int number)
{ Map<Character, Integer> frequencyMap = new
HashMap<>(); for (char c : word.toCharArray()) {
frequencyMap.put(c, frequencyMap.getOrDefault(c, 0) + 1);
}
char result = '\0';
int maxFrequency = 0;
for (Map.Entry<Character, Integer> entry : frequencyMap.entrySet())
{ if (entry.getValue() == number) {
result =
entry.getKey(); break;
}
if (entry.getValue() > maxFrequency)
{ maxFrequency =
entry.getValue(); result =
entry.getKey();
}
}
return result;
}
}
Client6.java
import java.io.*;
import
java.net.*;
import java.util.Scanner;
public class Client6 {
public static void main(String[] args) {
try {
// Create a socket to connect to the server
Socket socket = new Socket("localhost", 9999);
Scanner scanner = new Scanner(System.in);
while (true) {
// Get input from the user
System.out.print("Enter a word: ");
String word = scanner.nextLine();
System.out.print("Enter a number: ");
int number = scanner.nextInt();
// Send word and number to the server
PrintWriter out = new PrintWriter(socket.getOutputStream(),
true); out.println(word);
out.println(number);
// Receive result from the server
BufferedReader in = new
BufferedReader(new
InputStreamReader(socket.getInputStream()));
char result = in.readLine().charAt(0);
System.out.println("Result: " +
result);
// Check if the user wants to terminate the connection
System.out.print("Do you want to quit? (yes/no): ");
scanner.nextLine(); // Consume newline character
String response = scanner.nextLine();
if (response.equalsIgnoreCase("yes")) {
out.println("quit"); // Tell the server to terminate the connection
break; // Exit the loop
}
}
// Close the connection
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
7)
Construct a Java UDP Client-Server Program to check if a Given String is Palindrome or no
UDPServer.java
import java.net.*;
public class UDPServer {
public static void main(String[] args) {
final int PORT = 9999;
try {
// Create a DatagramSocket to listen for client requests
DatagramSocket serverSocket = new
DatagramSocket(PORT);
System.out.println("Server is running and waiting for requests...");
while (true) {
// Create a byte array to store incoming data
byte[] receiveData = new byte[1024];
// Create a DatagramPacket to receive data from the client
DatagramPacket receivePacket = new
DatagramPacket(receiveData,
receiveData.length);
// Receive data from the client
serverSocket.receive(receivePacket);
// Extract the message from the received packet
String message = new String(receivePacket.getData(), 0,
receivePacket.getLength());
// Check if the message is a palindrome
String response = isPalindrome(message) ? "Yes, it is a palindrome." : "No, it
is not a palindrome.";
// Get the client's address and port from the received
packet InetAddress clientAddress =
receivePacket.getAddress(); int clientPort =
receivePacket.getPort();
// Create a byte array to store the response
message byte[] responseData =
response.getBytes();
// Create a DatagramPacket to send the response to the client
DatagramPacket sendPacket = new
DatagramPacket(responseData,
responseData.length, clientAddress, clientPort);
// Send the response to the client
serverSocket.send(sendPacket);
System.out.println("Response sent to " + clientAddress + ":" + clientPort);
}
} catch (Exception e) {
e.printStackTrace()
;
}
}
// Function to check if a string is a palindrome
private static boolean isPalindrome(String str)
{
int left = 0;
int right = str.length() - 1;
while (left < right) {
if (str.charAt(left) != str.charAt(right))
{ return false;
}
left++;
right--
;
}
return true;
}
}
UDPClient.java
import java.net.*;
public class UDPClient {
public static void main(String[] args) {
final String SERVER_ADDRESS =
"localhost"; final int SERVER_PORT = 9999;
try {
// Create a DatagramSocket
DatagramSocket clientSocket = new DatagramSocket();
// Input string to check if it's a
palindrome String inputString = "radar";
// Convert the input string to bytes
byte[] sendData = inputString.getBytes();
// Create a DatagramPacket to send data to the server
DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length,
InetAddress.getByName(SERVER_ADDRESS), SERVER_PORT);
// Send the packet to the server
clientSocket.send(sendPacket);
// Create a byte array to receive data from the server
byte[] receiveData = new byte[1024];
// Create a DatagramPacket to receive data from the server
DatagramPacket receivePacket = new
DatagramPacket(receiveData,
receiveData.length);
// Receive data from the server
clientSocket.receive(receivePacket);
// Convert the received data to a string
String response = new String(receivePacket.getData(), 0,
receivePacket.getLength());
// Print the response from the server
System.out.println("Server response: " +
response);
// Close the socket
clientSocket.close();
} catch (Exception e) {
e.printStackTrace()
;
}
}
}
