Programming Hub

Java Program to find Second Largest Number in an Array

2021-04-17T11:58:00.005+05:30

Solution:

Before diving into the solution, let me tell you this the most common question which gets asked in the most coding rounds and if you are being lazy to practice and learn this now, you are fooling yourself.
Learn the logic behind this and you'll also realize after cracking the logic of this code you have learned a beautiful algorithm from DSA, but you have to figure out that yourself.

public class SecondLargestInArrayExample{
public static int getSecondLargest(int[] a, int total){
int temp;
for (int i = 0; i < total; i++)
   {
       for (int j = i + 1; j < total; j++)
       {
            if (a[i] > a[j])
           {
                temp = a[i];
               a[i] = a[j];
               a[j] = temp;
           }
       }
   }
return a[total-2];
}

public static void main(String args[]){
   int a[]={1,2,5,6,3,2};
   int b[]={44,66,99,77,33,22,55};
   System.out.println("Second Largest: "+getSecondLargest(a,6));
   System.out.println("Second Largest: "+getSecondLargest(b,7));
   }

}

Output:

Second Largest: 5
Second Largest: 77

Write a SQL query to delete all duplicate email entries in a table named Person, keeping only unique emails based on its smallest Id.

2021-04-17T11:29:00.002+05:30

This one is little tricky problem. I tried to use subquery approach to solve this problem.

+----+------------------+

| Id | Email            |
+----+------------------+
| 1  | john@example.com |
| 2  | bob@example.com  |
| 3  | john@example.com |
+----+------------------+
Id is the primary key column for this table.

For example, after running your query, the above Person table should have the following rows:

+----+------------------+
| Id | Email            |
+----+------------------+
| 1  | john@example.com |
| 2  | bob@example.com  |
+----+------------------+

Note:

Your output is the whole Person table after executing your sql. Use delete statement.

Solution:

DELETE FROM Person
	WHERE Id NOT IN (SELECT p.id
	FROM (
	SELECT MIN(Id) as id
	FROM Person
	GROUP BY Email) as p);

Combine Tables. [Leetcode Problem]

2021-04-17T11:09:00.009+05:30

1. Combine Tables. [Leetcode problem]

Table: Person

+-------------+---------+
| Column Name | Type    |
+-------------+---------+
| PersonId    | int     |
| FirstName   | varchar |
| LastName    | varchar |
+-------------+---------+
PersonId is the primary key column for this table.

Table: Address

+-------------+---------+
| Column Name | Type    |
+-------------+---------+
| AddressId   | int     |
| PersonId    | int     |
| City        | varchar |
| State       | varchar |
+-------------+---------+
AddressId is the primary key column for this table.

Write a SQL query for a report that provides the following information for each person in the Person table, regardless if there is an address for each of those people:

FirstName, LastName, City, State

Ref: https://leetcode.com/problems/combine-two-tables/

Solution:
A common mistake would be to use INNER JOIN and not LEFT (or RIGHT) JOIN and ending up omitting records with no addresses but as it is asked to include those records as well, we will need to use LEFT (or RIGHT) JOIN.

Also, since these selected columns are unique among both the tables, I omitted the table prefix from all the columns in SELECT clause.

Query:

Select Firstname, LastName, City, State

FROM Person p
LEFT JOIN address a

ON p.PersonId = a.PersonId;

Implement UNIX system calls like ps, fork, join, exec family, and wait for process management (use shell script/ Java/ C programming).

2020-11-18T12:23:00.002+05:30

//A small example to show how to use execvp() function in C. We will have

two .C files , EXEC.c and execDemo.c and we will replace the execDemo.c with EXEC.c by

calling execvp() function in execDemo.c .

//EXEC.c

#include<stdio.h>

#include<unistd.h>

int main()

{

int i;

printf("This is EXEC.c, called by execvp() ");

printf("\n");

return 0;

}

Now,create an executable file of EXEC.c using command

gcc EXEC.c -o EXEC

//execDemo.c

#include<stdio.h>

#include<stdlib.h>

#include<unistd.h>

int main()

{

//A null terminated array of character

//pointers

char *args[]={"./EXEC",NULL};

execvp(args[0],args);

/*All statements are ignored after execvp() call as this whole process(execDemo.c) is replaced by another process (EXEC.c) */

printf("Ending-----");

return 0;

}

Now, create an executable file of execDemo.c using command gcc execDemo.c -o execDemo

After running the executable file of execDemo.cby using command ./excDemo, we get the following output:

This is EXEC.c, called by execvp()

When the file execDemo.c is compiled, as soon as the statement execvp(args[0],args) is

executed, this very program is replaced by the program EXEC.c. is not printed because

because as soon as the execvp() function is called, this program is replaced by the

program EXEC.c.

execv : This is very similar to execvp() function in terms of syntax as well. The syntax of

execv() is as shown below:Syntax:

int execv(const char *path, char *const argv[]);

path: should point to the path of the file being executed.

argv[]: is a null terminated array of character pointers.

Write a Java program for pass-II of a two-pass macro-processor. The output of assignment-3 (MNT, MDT and file without any macro definitions) should be input for this assignment.

2020-11-18T12:14:00.005+05:30

import java.io.*;
import java.util.HashMap;
import java.util.Vector;

public class macroPass2 {
	public static void main(String[] Args) throws IOException{
		BufferedReader b1 = new BufferedReader(new FileReader("intermediate.txt"));
		BufferedReader b2 = new BufferedReader(new FileReader("mnt.txt"));
		BufferedReader b3 = new BufferedReader(new FileReader("mdt.txt"));
		BufferedReader b4 = new BufferedReader(new FileReader("kpdt.txt"));
		FileWriter f1 = new FileWriter("Pass2.txt");
		HashMap<Integer,String> aptab=new HashMap<Integer,String>();
		HashMap<String,Integer> aptabInverse=new HashMap<String,Integer>();
		HashMap<String,Integer> mdtpHash=new HashMap<String,Integer>();
		HashMap<String,Integer> kpdtpHash=new HashMap<String,Integer>();
		HashMap<String,Integer> kpHash=new HashMap<String,Integer>();
		HashMap<String,Integer> macroNameHash=new HashMap<String,Integer>();
		Vector<String>mdt=new Vector<String>();
		Vector<String>kpdt=new Vector<String>();
		String s,s1;
		int i,pp,kp,kpdtp,mdtp,paramNo;
		while((s=b3.readLine())!=null)
			mdt.addElement(s);
		while((s=b4.readLine())!=null)
			kpdt.addElement(s);
		while((s=b2.readLine())!=null){
			String word[]=s.split("\t");
			s1=word[0]+word[1];
			macroNameHash.put(word[0],1);
			kpHash.put(s1,Integer.parseInt(word[2]));
			mdtpHash.put(s1,Integer.parseInt(word[3]));
			kpdtpHash.put(s1,Integer.parseInt(word[4]));
		}
		while((s=b1.readLine())!=null){
			String b1Split[]=s.split("\\s");
			if(macroNameHash.containsKey(b1Split[0])){
				pp= b1Split[1].split(",").length-b1Split[1].split("=").length+1;
				kp=kpHash.get(b1Split[0]+Integer.toString(pp));
				mdtp=mdtpHash.get(b1Split[0]+Integer.toString(pp));
				kpdtp=kpdtpHash.get(b1Split[0]+Integer.toString(pp));
				String actualParams[]=b1Split[1].split(",");
				paramNo=1;
				for(int j=0;j<pp;j++){
					aptab.put(paramNo, actualParams[paramNo-1]);
					aptabInverse.put(actualParams[paramNo-1],paramNo);
					paramNo++;
				}
				i=kpdtp-1;
				for(int j=0;j<kp;j++){
					String temp[]=kpdt.get(i).split("\t");
					aptab.put(paramNo,temp[1]);
					aptabInverse.put(temp[0],paramNo);
					i++;
					paramNo++;
				}
				i=pp+1;
				while(i<=actualParams.length){
					String initializedParams[]=actualParams[i-1].split("=");
					aptab.put(aptabInverse.get(initializedParams[0].substring(1,initializedParams[0].length())),initializedParams[1].substring(0,initializedParams[1].length()));
					i++;
				}
				i=mdtp-1;
				while(mdt.get(i).compareToIgnoreCase("MEND")!=0){
					f1.write("+ ");
					for(int j=0;j<mdt.get(i).length();j++){
						if(mdt.get(i).charAt(j)=='#')
							f1.write(aptab.get(Integer.parseInt("" + mdt.get(i).charAt(++j))));
						else
							f1.write(mdt.get(i).charAt(j));
					}
					f1.write("\n");
					i++;
				}
				aptab.clear();
				aptabInverse.clear();
			}
			else
				f1.write("+ "+s+"\n");
		}
		b1.close();
		b2.close();
		b3.close();
		b4.close();
		f1.close();
	}
}

/*
OUTPUT:
XXXXXXXXX:~/Desktop/XXXXXXXXX/A4$ javac macroPass2.java 
XXXXXXXXX:~/Desktop/XXXXXXXXX/A4$ java macroPass2 
XXXXXXXXX:~/Desktop/XXXXXXXXX/A4$ cat Pass2.txt 
+ MOVE AREG,10
+ ADD AREG,='1'
+ MOVER AREG,20
+ ADD AREG,='5'
+ MOVER &AREG,100
+ MOVER &BREG,200
+ ADD &AREG,='15'
+ ADD &BREG,='10'

Design suitable data structures and implement pass-I of a two-pass macro-processor using OOP features in Java.

2020-11-17T12:04:00.011+05:30

Problem Statement: Design suitable data structures and implement pass-I of a two-pass macro-processor using
OOP features in Java
*/
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.HashMap;

public class macroPass1 {
	public static void main(String[] Args) throws IOException{
		BufferedReader b1 = new BufferedReader(new FileReader("input.txt"));
		FileWriter f1 = new FileWriter("intermediate.txt");
		FileWriter f2 = new FileWriter("mnt.txt");
		FileWriter f3 = new FileWriter("mdt.txt");
		FileWriter f4 = new FileWriter("kpdt.txt");
		HashMap<String,Integer> pntab=new HashMap<String,Integer>();
		String s;
		int paramNo=1,mdtp=1,flag=0,pp=0,kp=0,kpdtp=0;
		while((s=b1.readLine())!=null){
			String word[]=s.split("\\s");		//separate by space
			if(word[0].compareToIgnoreCase("MACRO")==0){
				flag=1;
				if(word.length<=2){
					f2.write(word[1]+"\t"+pp+"\t"+kp+"\t"+mdtp+"\t"+(kp==0?kpdtp:(kpdtp+1))+"\n");
					continue;
				}
				String params[]=word[2].split(",");
				for(int i=0;i<params.length;i++){
					if(params[i].contains("=")){
						kp++;
						String keywordParam[]=params[i].split("=");
						pntab.put(keywordParam[0].substring(1,keywordParam[0].length()),paramNo++);
						if(keywordParam.length==2)
							f4.write(keywordParam[0].substring(1,keywordParam[0].length())+"\t"+keywordParam[1]+"\n");
						else
							f4.write(keywordParam[0].substring(1,keywordParam[0].length())+"\t"+"-"+"\n");
							
					}
					else{
						pntab.put(params[i].substring(1,params[i].length()),paramNo++);
						pp++;
					}
				}
				f2.write(word[1]+"\t"+pp+"\t"+kp+"\t"+mdtp+"\t"+(kp==0?kpdtp:(kpdtp+1))+"\n");
				kpdtp+=kp;
			}
			else if(word[0].compareToIgnoreCase("MEND")==0){
				f3.write(s+'\n');
				flag=pp=kp=0;
				mdtp++;
				paramNo=1;
				pntab.clear();
			}
			else if(flag==1){
				for(int i=0;i<s.length();i++){
					if(s.charAt(i)=='&'){
						i++;
						String temp="";
						while(!(s.charAt(i)==' '||s.charAt(i)==',')){
							temp+=s.charAt(i++);
							if(i==s.length())
								break;
							
						}
						i--;
						f3.write("#"+pntab.get(temp));
					}
					else
						f3.write(s.charAt(i));
				}
				f3.write("\n");
				mdtp++;
			}
			else{
				f1.write(s+'\n');
			}
		}
		b1.close();
		f1.close();
		f2.close();
		f3.close();
		f4.close();
	}
}
/*
OUTPUT:

XXXXXXXXX:~/Desktop/XXXXXXXXX/A3$ javac macroPass1.java

XXXXXXXXX:~/Desktop/XXXXXXXXX/A3$ java macroPass1 

XXXXXXXXX:~/Desktop/XXXXXXXXX/A3$ cat intermediate.txt 
M1 10,20,&b=CREG
M2 100,200,&u=AREG,&v=BREG

XXXXXXXXX:~/A3$ cat mnt.txt 
M1	2	2	1	1
M2	2	2	7	3
M3	2	0	13	4

XXXXXXXXX:~/Desktop/XXXXXXXXX/A3$ cat mdt.txt 
MOVE #3,#1
ADD #3,='1'
MOVER #3,#2
M2 69,169
ADD #3,='5'
MEND
MOVER #3,#1
MOVER #4,#2
M3 73,173
ADD #3,='15'
ADD #4,='10'
MEND
ADD #1,#2
MEND

XXXXXXXXX:~/Desktop/XXXXXXXXX/A3$ cat kpdt.txt 
a	AREG
b	-
u	CREG
v	DREG

*/

Abstract class and method in Java.

2020-11-15T13:27:00.002+05:30

Abstract Class:
An abstract class is something which is incomplete and you can not create an instance of the abstract class. If you want to use it you need to make it complete or concrete by extending it. It is created using abstract keyword. This class can contain abstract and non abstract methods. Before learning about abstract class and abstract I recommend you to first learn about abstraction concept in Java.

Few important things to remember about abstract class:

An abstract class must be declared with an abstract keyword.
It can have abstract and non-abstract methods.
It cannot be instantiated.
It can have constructors and static methods also.
It can have final methods which will force the subclass not to change the body of the method.

Example of Abstract class with abstract method:
abstract class Animal{
  abstract void run();
}

class Horse extends Animal{
void run()
{
   System.out.println("Runs fast");
}

public static void main(String args[]){
Animal obj = new Horse();
obj.run();
}
}

Abstract Method:

A method can also be declared as abstract, it does not have any implementation details.

Example:

abstract void demoAbstract();//empty body, use abstract keyword

*Above program is example of abstract class with abstract method.

Note: By the way, Java has concept of abstract classes and abstract methods but a variable in Java can not be abstract.

Abstraction vs Encapsulation.

2020-11-15T12:16:00.001+05:30

An OOP concept which focuses on relevant information by hiding unnecessary details.

Abstraction hides complexity by giving more abstract picture, sort of 10000 feet view while Encapsulation hides internal working so that you can change it later.

Abstraction hides details at design level, while encapsulation hides details at implementation level. Its sole purpose is to hide the internal working of objects from the outside world so that you can change it later without impacting outside clients.

Abstraction is about hiding unwanted details while giving out the most essential details, while encapsulation means hiding the code and data into a single unit e.g. class or method to protect the inner working of an object from the outside world.

(Abstraction can also be thought of as extracting common details or generalizing things).

Abstraction lets you focus on what object does instead of how it does, while encapsulation means hiding the internal details of how an object works.

In java, abstraction is supported using interface and abstract class while encapsulation is supported using access modifiers e.g. public, private and protected.

One example of abstraction is creating an interface to denote common behaviour without specifying any details about how that behaviour works like you create an interface called Server which has the start() and stop() method. This is called abstraction of Server because every server should have a way to start and stop and details may differ from each other.

Difference between Class and Object.

2020-11-06T14:15:00.004+05:30

Class is a blue print or a model, objects are actual things which are created using these blue prints/models.

Generally, objects are created at runtime when you start JVM with java command and JVM will start executing your code, whenever JVM encounters new keyword it will create an object.

What are Objects in Object Oriented Programming aka OOP?

2020-11-04T10:50:00.003+05:30

This could be best way to answer what are Objects in Java, this is more than enough for a beginner level engineer, keep note of following information

Objects are instances of class, class defines blue prints and objects are things which are created based upon that blueprint.

Object is also known as instance in Java, e.g. when we say an instance of String class, we actually mean an object of String class.

Object has state and behaviour.

State: State is represented using instance variable and static variable.

Behaviour: And behaviours are implemented using methods in Java.

The things which differentiate two objects of same class are their states e.g. if we take two instances of String class 'A' & 'B' their contents are different which is nothing but their state.

There are several ways to create objects in Java, .e.g., Serialization. Cloning, Reflection, etc.

But the most common and easy way to create objects in Java is by using new() keyword.

When we create an object of any class in Java, its constructor gets called, which initializes object with its default or initial state.

Implement Pass-II of two pass assembler for pseudo-machine in Java using object oriented features. The output of assignment-1 (intermediate file and symbol table) should be input for this assignment.

2020-10-22T13:00:00.001+05:30

Problem Statement: Implement Pass-II of two pass assembler for pseudo-machine in Java using object oriented

features. The output of assignment-1 (intermediate file and symbol table) should be

input for this assignment.

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.util.HashMap;

public class Pass2 {

public static void main(String[] Args) throws IOException{

BufferedReader b1 = new BufferedReader(new FileReader("intermediate.txt"));

BufferedReader b2 = new BufferedReader(new FileReader("symtab.txt"));

BufferedReader b3 = new BufferedReader(new FileReader("littab.txt"));

FileWriter f1 = new FileWriter("Pass2.txt");

HashMap<Integer, String> symSymbol = new HashMap<Integer, String>();

HashMap<Integer, String> litSymbol = new HashMap<Integer, String>();

HashMap<Integer, String> litAddr = new HashMap<Integer, String>();

String s;

int symtabPointer=1,littabPointer=1,offset;

while((s=b2.readLine())!=null){

String word[]=s.split("\t\t\t");

symSymbol.put(symtabPointer++,word[1]);

}

while((s=b3.readLine())!=null){

String word[]=s.split("\t\t");

litSymbol.put(littabPointer,word[0]);

litAddr.put(littabPointer++,word[1]);

}

while((s=b1.readLine())!=null){

if(s.substring(1,6).compareToIgnoreCase("IS,00")==0){

f1.write("+ 00 0 000\n");

}

else if(s.substring(1,3).compareToIgnoreCase("IS")==0){

f1.write("+ "+s.substring(4,6)+" ");

if(s.charAt(9)==')'){

f1.write(s.charAt(8)+" ");

offset=3;

}

else{

f1.write("0 ");

offset=0;

}

if(s.charAt(8+offset)=='S')

f1.write(symSymbol.get(Integer.parseInt(s.substring(10+offset,s.length()-1)))+"\n");

else

f1.write(litAddr.get(Integer.parseInt(s.substring(10+offset,s.length()-1)))+"\n");

}

else if(s.substring(1,6).compareToIgnoreCase("DL,01")==0){

String s1=s.substring(10,s.length()-1),s2="";

for(int i=0;i<3-s1.length();i++)

s2+="0";

s2+=s1;

f1.write("+ 00 0 "+s2+"\n");

}

else{

f1.write("\n");

}

f1.close();

b1.close();

b2.close();

b3.close();

}

OUTPUT:

$ javac Pass2.java

$ java Pass2

$ cat Pass2.txt

intermediate code -

(AD,01)(C,200)

(IS,04)(1)(L,1)

(IS,05)(1)(S,1)

(IS,04)(1)(S,1)

(IS,04)(3)(S,3)

(IS,01)(3)(L,2)

(IS,07)(6)(S,4)

(DL,01)(C,5)

(DL,01)(C,1)

(IS,02)(1)(L,3)

(IS,07)(1)(S,5)

(IS,00)

(AD,03)(S,2)+2

(IS,03)(3)(S,3)

(AD,03)(S,6)+1

(DL,02)(C,1)

(AD,02)

(DL,01)(C,1)

Symbol Table --

A 211 1

LOOP 202 1

B 212 1

NEXT 208 1

BACK 202 1

LAST 210 1

literal table --

5 206

1 207

1 213

machine code --

+ 04 1 206

+ 05 1 211

+ 04 1 211

+ 04 3 212

+ 01 3 207

+ 07 6 208

+ 00 0 005

+ 00 0 001

+ 02 1 213

+ 07 1 202

+ 00 0 000

+ 03 3 212 */

Design suitable data structures and implement pass-I of a two-pass assembler for pseudo-machine in Java using object oriented feature. Implementation should consist of a few instructions from each category and few assembler directives.

2020-09-15T12:55:00.005+05:30

Problem Statement: Design suitable data structures and implement pass-I of a two-pass assembler for pseudo-

machine in Java using object oriented feature. Implementation should consist of a few

instructions from each category and few assembler directives.

import java.io.*;

class SymTab

{

public static void main(String args[])throws Exception

{

FileReader FP=new FileReader(args[0]);

BufferedReader bufferedReader = new BufferedReader(FP);

String line=null;

int line_count=0,LC=0,symTabLine=0,opTabLine=0,litTabLine=0,poolTabLine=0;

//Data Structures

final int MAX=100;

String SymbolTab[][]=new String[MAX][3];

String OpTab[][]=new String[MAX][3];

String LitTab[][]=new String[MAX][2];

int PoolTab[]=new int[MAX];

int litTabAddress=0;

/*---------------------------------------------------------------------------------------------------*/

System.out.println("___________________________________________________");

while((line = bufferedReader.readLine()) != null)

{

String[] tokens = line.split("\t");

if(line_count==0)

{

LC=Integer.parseInt(tokens[2]);

//set LC to operand of START

for(int i=0;i<tokens.length;i++) //for printing the input program

System.out.print(tokens[i]+"\t");

System.out.println("");

}

else

{

for(int i=0;i<tokens.length;i++) //for printing the input program

System.out.print(tokens[i]+"\t");

System.out.println("");

if(!tokens[0].equals(""))

{

//Inserting into Symbol Table

SymbolTab[symTabLine][0]=tokens[0];

SymbolTab[symTabLine][1]=Integer.toString(LC);

SymbolTab[symTabLine][2]=Integer.toString(1);

symTabLine++;

}

else if(tokens[1].equalsIgnoreCase("DS")||tokens[1].equalsIgnoreCase("DC"))

{

//Entry into symbol table for declarative statements

SymbolTab[symTabLine][0]=tokens[0];

SymbolTab[symTabLine][1]=Integer.toString(LC);

SymbolTab[symTabLine][2]=Integer.toString(1);

symTabLine++;

}

if(tokens.length==3 && tokens[2].charAt(0)=='=')

{

//Entry of literals into literal table

LitTab[litTabLine][0]=tokens[2];

LitTab[litTabLine][1]=Integer.toString(LC);

litTabLine++;

}

else if(tokens[1]!=null)

{

//Entry of Mnemonic in opcode table

OpTab[opTabLine][0]=tokens[1];

if(tokens[1].equalsIgnoreCase("START")||tokens[1].equalsIgnoreCase("END")||tokens[1].equalsIgnoreCase("ORIGIN")||tokens[1].equalsIgnoreCase("EQU")||tokens[1].equalsIgnoreCase("LTORG")) //if Assembler Directive

{

OpTab[opTabLine][1]="AD";

OpTab[opTabLine][2]="R11";

}

else if(tokens[1].equalsIgnoreCase("DS")||tokens[1].equalsIgnoreCase("DC"))

{

OpTab[opTabLine][1]="DL";

OpTab[opTabLine][2]="R7";

}

else

{

OpTab[opTabLine][1]="IS";

OpTab[opTabLine][2]="(04,1)";

}

opTabLine++;

}

line_count++;

LC++;

}

System.out.println("___________________________________________________");

//print symbol table

System.out.println("\n\n SYMBOL TABLE ");

System.out.println("--------------------------");

System.out.println("SYMBOL\tADDRESS\tLENGTH");

System.out.println("--------------------------");

for(int i=0;i<symTabLine;i++)

System.out.println(SymbolTab[i][0]+"\t"+SymbolTab[i][1]+"\t"+SymbolTab[i][2]);

System.out.println("--------------------------");

//print opcode table

System.out.println("\n\n OPCODE TABLE ");

System.out.println("----------------------------");

System.out.println("MNEMONIC\tCLASS\tINFO");

System.out.println("----------------------------");

for(int i=0;i<opTabLine;i++)

System.out.println(OpTab[i][0]+"\t\t"+OpTab[i][1]+"\t"+OpTab[i][2]);

System.out.println("----------------------------");

//print literal table

System.out.println("\n\n LITERAL TABLE ");

System.out.println("-----------------");

System.out.println("LITERAL\tADDRESS");

System.out.println("-----------------");

for(int i=0;i<litTabLine;i++)

System.out.println(LitTab[i][0]+"\t"+LitTab[i][1]);

System.out.println("------------------");

//intialization of POOLTAB

for(int i=0;i<litTabLine;i++)

{

if(LitTab[i][0]!=null && LitTab[i+1][0]!=null ) //if literals are present

{

if(i==0)

{

PoolTab[poolTabLine]=i+1;

poolTabLine++;

}

else if(Integer.parseInt(LitTab[i][1])<(Integer.parseInt(LitTab[i+1][1]))-1)

{

PoolTab[poolTabLine]=i+2;

poolTabLine++;

}

//print pool table

System.out.println("\n\n POOL TABLE ");

System.out.println("-----------------");

System.out.println("LITERAL NUMBER");

System.out.println("-----------------");

for(int i=0;i<poolTabLine;i++)

System.out.println(PoolTab[i]);

System.out.println("------------------");

// Always close files.

bufferedReader.close();

}

OUTPUT-

$ javac SymTab.java

$ java SymTab input.txt

___________________________________________________

START 100

READ A

LABLE MOVER A,B

LTORG

='5'

='1'

='6'

='7'

MOVEM A,B

LTORG

='2'

LOOP READ B

A DS 1

B DC '1'

='1'

END

___________________________________________________

SYMBOL TABLE

--------------------------

SYMBOL ADDRESS LENGTH

--------------------------

LABLE 102 1

LOOP 111 1

A 112 1

B 113 1

--------------------------

OPCODE TABLE

----------------------------

MNEMONIC CLASS INFO

----------------------------

READ IS (04,1)

MOVER IS (04,1)

LTORG AD R11

MOVEM IS (04,1)

LTORG AD R11

READ IS (04,1)

DS DL R7

DC DL R7

END AD R11

----------------------------

LITERAL TABLE

-----------------

LITERAL ADDRESS

-----------------

='5' 104

='1' 105

='6' 106

='7' 107

='2' 110

='1' 114

------------------

POOL TABLE

-----------------

LITERAL NUMBER

-----------------

------------------

Print all pairs with given sum

2020-07-05T23:07:00.002+05:30

Find all pairs of an integer array whose sum is equal to a given number

Solution:

//Java implementation of
// simple method to find
// print pairs with given sum.

class FindPairsN{

// Returns number of pairs
// in arr[0..n-1] with sum
// equal to 'sum'
static void getPairs(int arr[],
int n, int sum)
{
// int count = 0;

// Consider all possible pairs
// and check their sums
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
if (arr[i] + arr[j] == sum)
System.out.println("(" + arr[i] + ", " + arr[j] + ")");
}

// Main
public static void main(String[] arg)
{
int arr[] = { 1, 5, 7, -1, 5 };
int n = arr.length;
int sum = 6;
getPairs(arr, n, sum);
}
}

SE- OOP Practical Lab -Implement a class Complex which represents the Complex Number data type.

2020-07-04T18:59:00.003+05:30

Implement a class Complex which represents the Complex Number data type.
Implement the following operations:
1. Constructor (including a default constructor which creates the complex number 0+0i).
2. Overloaded operator+ to add two complex numbers.
3. Overloaded operator* to multiply two complex numbers.
4. Overloaded << and >> to print and read Complex Numbers.

Solution:

#include<iostream>
using namespace std;
class complex
{
float x;
float y;
public:
complex()
{
x=0;
y=0;
}
complex operator+(complex);
complex operator*(complex);
friend istream &operator >>(istream &input,complex &t)
{
cout<<"Enter the real part";
input>>t.x;
cout<<"Enter the imaginary part";
input>>t.y;
}
friend ostream &operator <<(ostream &output,complex &t)
{
output<<t.x<<"+"<<t.y<<"i\n";
}
};
complex complex::operator+(complex c)
{
complex temp;
temp.x=x+c.x;
temp.y=y+c.y;
return(temp);
}
complex complex::operator*(complex c)
{
complex temp2;
temp2.x=(x*c.x)-(y*c.y);
temp2.y=(y*c.x)+(x*c.y);
return (temp2);
}
int main()
{
complex c1,c2,c3,c4;
cout<<"Default constructor value=\n";
cout<<c1;
cout<<"\nEnter the 1st number\n";
cin>>c1;
cout<<"\nEnter the 2nd number\n";
cin>>c2;
c3=c1+c2;
c4=c1*c2;
cout<<"\nThe first number is ";
cout<<c1;
cout<<"\nThe second number is ";
cout<<c2;
cout<<"\nThe addition is ";
cout<<c3;
cout<<"\nThe multiplication is ";
cout<<c4;
return 0;
}
/*
student@student-sb:~$ ./a.out
Default constructor value=
0+0i
Enter the 1st number
Enter the real part2
Enter the imaginary part4
Enter the 2nd number
Enter the real part4
Enter the imaginary part8
The first number is 2+4i
The second number is 4+8i
The addition is 6+12i
The multiplication is -24+32i
student@student-sb:~$ */

Find missing number.

2020-07-04T18:37:00.001+05:30

Find missing number from given range of 1 to n.

Solution:

Algorithm:

Calculate the sum of first n natural numbers as total= n*(n+1)/2
create a variable sum to store the sum of array elements.
Traverse the array from start to end.
Update the value of sum as sum = sum + array[i]
print the missing number as total – sum

// Java program to find missing Number

class Main {
// Function to find missing number
static int findMissingNo(int a[], int n)
{
int i, total;
total = (n + 1) * (n + 2) / 2;//calculates total for original range
for (i = 0; i < n; i++)
total -= a[i];//this will yield the missing number by continuously subtracting elements
return total; // from total
}

/* program to test above function */
public static void main(String args[])
{
int a[] = { 1, 2, 4, 5, 6, 7, 8 };
int miss = findMissingNo(a, 7 );
System.out.println(miss);
}
}

Convert Decimal to Binary. (using recursion)

2020-07-02T17:06:00.001+05:30

Convert Decimal to Binary. (using recursion)

Solution:

import java.util.*;

public class DecimalToBinary {

public static void main(String[] args) {
// TODO Auto-generated method stub

Scanner sc= new Scanner(System.in);
System.out.println("Enter a valid integer:");

while(sc.hasNextInt())
{
int a=sc.nextInt();

printbinary(a);
System.out.println("\nEnter a bumber, press q to exit!");
}

sc.close();
}

public static void printbinary(int b)
{
if(b>0)
{
printbinary(b/2);
System.out.printf("%d", b%2);
}
}

}

Reverse a linked list. (Using recursion)

2020-07-02T16:19:00.003+05:30

Reverse a linked list using recursion using Java.

Solution:

public class Node {

int data;
Node next;

public Node(int a, Node next)
{
this.data= a;
this.next = next;
}

}

public class Linkedlist {

public static void main(String[] args) {

// TODO Auto-generated method stub

Node node1= new Node(1,null);

Node node2= new Node(2, null);

Node node3= new Node(3, null);

node1.next=node2;

node2.next=node3;

node3.next=null;

printlist(node1);

System.out.println("\n*********");

printreverse(node1);

}

public static void printlist(Node n)

{

if(n!=null)

{

System.out.print(" " + n.data);//will print in order

printlist(n.next);

}

public static void printreverse(Node n)

{

if(n!=null)

{

printreverse(n.next);

// will stack the nested calls and return the output in reverse order

//as per stack property calls will be stacked and the last one will be returned first

System.out.print(" "+n.data);

}

Obtain the sum of the first and last digits of this number.

2020-06-28T23:34:00.000+05:30

Write a program to obtain the sum of the first and last digits of this number.

Solution:

#include <iostream>
using namespace std;

int main() {
    // your code goes here
    int t;
    cin>>t;

    for(int i=0; i<t; i++)
    {
        int n;
        cin>>n;
        if (n<10)
        {
            cout<<n<<endl;
        }
        else{
        int last = n%10;// get the last digit

        while(n>9)
        {
            n/=10;// get first digit
        }
           int sum= last+ n;
           cout<<sum<<endl;
        }
    }
    return 0;
}

Sum of digits in the given number.

2020-06-28T23:23:00.002+05:30

Write a program to calculate the sum of all the digits of N. N is an integer.

Input

The first line contains an integer T, the total number of testcases. Then follow T lines, each line contains an integer N.

Output

For each test case, calculate the sum of digits of N, and display it in a new line.

Constraints

1 ≤ T ≤ 1000
1 ≤ N ≤ 1000000

Example

Input
3 
12345
31203
2123
Output
15
9
8

Solution:
C++:

#include <iostream>
using namespace std;

int main() {
    // your code goes here
    int t;
    cin>>t;

    for(int i=0; i<t; i++)
    {
        int n;
        cin>>n;

    int sum=0;

    while(n>0)
    {
        sum+=n%10;
        n/=10;
    }

    cout<<sum<<endl;
    }
    return 0;
}

******************************************************************************
JAVA:

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
class Codechef
{

    static int sum (int n){
        if (n == 0){
            return 0 ;
        }
        return n % 10 + sum(n/10) ;
    }


    public static void main (String[] args) throws java.lang.Exception
    {
        // your code goes here
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while(t-->0){
            int n = sc.nextInt();

            System.out.println(sum(n));

        }
    }
}

*******************************************************************************

Java program for Safe Sequence (Banker's Algorithm).

2018-04-08T18:31:00.002+05:30

//Java program for safe sequence of Banker's algorithm.

import java.util.*;
class SafeAlgo
{
 public static void main(String args[])
 {
  Scanner sc=new Scanner(System.in);
  System.out.println("Enter number of processes:");
  int n=sc.nextInt();
  int p[]=new int[n];
  int flag[]=new int[n];
  System.out.println("Enter number of resource variables");
  int m=sc.nextInt();
  
  int max[][]=new int[n][m];
  int allo[][]=new int[n][m];
  int need[][]=new int[n][m];
  int avail[]=new int[m];
  for(int x=0;x<n;x++)
  {
   System.out.println("Enter process number:");
   p[x]=sc.nextInt();
   flag[x]=0;
   for(int y=0;y<m;y++)
   {
    System.out.println("Max -> P"+p[x]+" ->"+y+" :");
    max[x][y]=sc.nextInt();    
    
   }
   for(int y=0;y<m;y++)
   {
    System.out.println("Allocation -> P"+p[x]+" ->"+y+" :");
    allo[x][y]=sc.nextInt();
    need[x][y]=max[x][y]-allo[x][y];
   }
  }
  System.out.println("Enter available resources:");
  for(int y=0;y<m;y++)
   avail[y]=sc.nextInt();
  
  System.out.println("Process\tMax\tAllocation\tNeed");
  for(int x=0;x<n;x++)
  {
   System.out.print("P"+p[x]+"\t");
   for(int y=0;y<m;y++)
    System.out.print(max[x][y]+" ");
   System.out.print("\t");
   for(int y=0;y<m;y++)
    System.out.print(allo[x][y]+" ");
   System.out.print("\t\t");
   for(int y=0;y<m;y++)
    System.out.print(need[x][y]+" ");
   System.out.println();
  }
  
  int count=0;
  while(count<=n)
  {
   
    for(int x=0;x<n;x++)
    {
     if(flag[x]==0)
     {
     int f=0;
     for(int y=0;y<m;y++)
     {      
      if(avail[y]<need[x][y])
      {
       f=1;
       break;
      }
     }
       
     if(f==0)
     {
      flag[x]=1;
      for(int y=0;y<m;y++)
      {
       avail[y]+=allo[x][y];
      }
      System.out.println("P"+p[x]);
      count++;
     }
     }
    }
   }
  }
 }

SJF Scheduling Algorithm Java Implementation.

2018-04-08T18:25:00.002+05:30

//Java program for Shortest Job First Scheduling algorithm.

import java.io.*;

public class SJF{
 public static void main(String args[]) throws IOException
 {
  BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
      int n;
      System.out.println("Please enter the number of Processes: ");
       n = Integer.parseInt(br.readLine());
       int proc[][] = new int[n + 1][4];
       for(int i = 1; i <= n; i++)
       {
      System.out.println("Please enter the Arrival Time for Process " + i + ": ");
      proc[i][0] = Integer.parseInt(br.readLine());
      System.out.println("Please enter the Burst Time for Process " + i + ": ");
      proc[i][1] = Integer.parseInt(br.readLine());
     }
       System.out.println();
     
      
     int total_time = 0;
     for(int i = 1; i <= n; i++)
     {
      total_time += proc[i][1];
     }
     int time_chart[] = new int[total_time];
     
     for(int i = 0; i < total_time; i++)
     {
    
      int sel_proc = 0;
      int min = 99999;
      for(int j = 1; j <= n; j++)
      {
       if(proc[j][0] <= i)
       {
        if(proc[j][1] < min && proc[j][1] != 0)
        {
         min = proc[j][1];
         sel_proc = j;
        }
       }
      }
      
     
      time_chart[i] = sel_proc;
      
      
      proc[sel_proc][1]--;
      
      
      for(int j = 1; j <= n; j++)
      {
       if(proc[j][0] <= i)
       {
        if(proc[j][1] != 0)
        {
         proc[j][3]++;
            if(j != sel_proc)
             proc[j][2]++;
        }
        else if(j == sel_proc)
         proc[j][3]++;
       }
      }
      
     
      if(i != 0)
      {
       if(sel_proc != time_chart[i - 1])
       
       {
        System.out.print("--" + i + "--P" + sel_proc);
       }
      }
      else
       System.out.print(i + "--P" + sel_proc);
      if(i == total_time - 1)
       System.out.print("--" + (i + 1));
      
     }
     System.out.println();
     System.out.println();
     
     
     System.out.println("P\t WT \t TT ");
     for(int i = 1; i <= n; i++)
     {
      System.out.printf("%d\t%2dms\t%2dms",i,proc[i][2],proc[i][3]);
      System.out.println();
     }
     
     System.out.println();
     
    
     float WT = 0,TT = 0;
     for(int i = 1; i <= n; i++)
     {
      WT += proc[i][2];
      TT += proc[i][3];
     }
     WT /= n;
     TT /= n;
     System.out.println("The Average WT is: " + WT + "ms");
     System.out.println("The Average TT is: " + TT + "ms");
 }
    
}

/*

OUTPUT:

Please enter the number of Processes: 
4
Please enter the Arrival Time for Process 1: 
0
Please enter the Burst Time for Process 1: 
7
Please enter the Arrival Time for Process 2: 
3
Please enter the Burst Time for Process 2: 
3
Please enter the Arrival Time for Process 3: 
5
Please enter the Burst Time for Process 3: 
2
Please enter the Arrival Time for Process 4: 
4
Please enter the Burst Time for Process 4: 
5

0--P1--3--P2--6--P3--8--P1--12--P4--17

P  WT   TT 
1  5ms 12ms
2  0ms  3ms
3  1ms  3ms
4  8ms 13ms

The Average WT is: 3.5ms
The Average TT is: 7.75ms
*/

Round Robin Scheduling Algorithm Java Implementation.

2018-04-08T18:20:00.002+05:30

//Java Program for Round Robin scheduling algorithm.

import java.io.*;
class rr
{
public static void main(String args[])throws IOException
{
DataInputStream in=new DataInputStream(System.in);
int i,j,k,q,sum=0;
System.out.println("Enter number of process:");
int n=Integer.parseInt(in.readLine());
int bt[]=new int[n];
int wt[]=new int[n];
int tat[]=new int[n];
int a[]=new int[n];
System.out.println("Enter brust Time:");
for(i=0;i<n;i++)
{
System.out.println("Enter brust Time for "+(i+1));
bt[i]=Integer.parseInt(in.readLine());
}
System.out.println("Enter Time quantum:");
q=Integer.parseInt(in.readLine());
for(i=0;i<n;i++)
a[i]=bt[i];
for(i=0;i<n;i++)
wt[i]=0;
do
{
for(i=0;i<n;i++)
{
if(bt[i]>q)
{
bt[i]-=q;
for(j=0;j<n;j++)
{
if((j!=i)&&(bt[j]!=0))
wt[j]+=q;
}
}
else
{
for(j=0;j<n;j++)
{
if((j!=i)&&(bt[j]!=0))
wt[j]+=bt[i];
}
bt[i]=0;
}
}
sum=0;
for(k=0;k<n;k++)
sum=sum+bt[k];
}
while(sum!=0);
for(i=0;i<n;i++)
tat[i]=wt[i]+a[i];
System.out.println("process\t\tBT\tWT\tTAT");
for(i=0;i<n;i++)
{
System.out.println("process"+(i+1)+"\t"+a[i]+"\t"+wt[i]+"\t"+tat[i]);
}
float avg_wt=0;
float avg_tat=0;
for(j=0;j<n;j++)
{
avg_wt+=wt[j];
}
for(j=0;j<n;j++)
{
avg_tat+=tat[j];
}
System.out.println("average waiting time "+(avg_wt/n)+"\n Average turn around time"+(avg_tat/n));
}
}



/**********OUTPUT********

Enter number of process:
5
Enter brust Time:
Enter brust Time for 1
7
Enter brust Time for 2
4
Enter brust Time for 3
3
Enter brust Time for 4
8
Enter brust Time for 5
5
Enter Time quantum:
2
process  BT WT TAT
process1 7 18 25
process2 4 10 14
process3 3 12 15
process4 8 19 27
process5 5 19 24
average waiting time 15.6
 Average turn around time21.0


*********************/

Priority Scheduling Algorithm Java Program.

2018-04-08T18:17:00.001+05:30

import java.util.Scanner;
 
public class priority{
        
    public static void main(String args[]) {
            Scanner s = new Scanner(System.in);
 
            int x,n,p[],pp[],bt[],w[],t[],awt,atat,i;
 
            p = new int[10];
            pp = new int[10];
            bt = new int[10];
            w = new int[10];
            t = new int[10];
 
   //n is number of process
   //p is process
   //pp is process priority
   //bt is process burst time
   //w is wait time
   // t is turnaround time
   //awt is average waiting time
   //atat is average turnaround time
 
 
   System.out.print("Enter the number of process : ");
   n = s.nextInt();
    System.out.print("\n\t Enter burst time : time priorities \n");
 
   for(i=0;i<n;i++)
    {
       System.out.print("\nProcess["+(i+1)+"]:");
      bt[i] = s.nextInt();
      pp[i] = s.nextInt();
      p[i]=i+1;
    }
 
//sorting on the basis of priority
  for(i=0;i<n-1;i++)
   {
     for(int j=i+1;j<n;j++)
     {
       if(pp[i]>pp[j])
       {
     x=pp[i];
     pp[i]=pp[j];
     pp[j]=x;
     x=bt[i];
     bt[i]=bt[j];
     bt[j]=x;
     x=p[i];
     p[i]=p[j];
     p[j]=x;
      }
   }
}
w[0]=0;
awt=0;
t[0]=bt[0];
atat=t[0];
for(i=1;i<n;i++)
 {
   w[i]=t[i-1];
   awt+=w[i];
   t[i]=w[i]+bt[i];
   atat+=t[i];
 }
 
//Displaying the process
 
  System.out.print("\n\nProcess \t Burst Time \t Wait Time \t Turn Around Time   Priority \n");
for(i=0;i<n;i++)
  System.out.print("\n   "+p[i]+"\t\t   "+bt[i]+"\t\t     "+w[i]+"\t\t     "+t[i]+"\t\t     "+pp[i]+"\n");
awt/=n;
atat/=n;
  System.out.print("\n Average Wait Time : "+awt);
  System.out.print("\n Average Turn Around Time : "+atat);
 
        }
}


/*******OUTPUT********

Enter the number of process : 5

  Enter burst time : time priorities 

Process[1]:7 2

Process[2]:6 4

Process[3]:4 1

Process[4]:5 3

Process[5]:1 0


Process   Burst Time   Wait Time   Turn Around Time   Priority 

   5     1       0       1       0

   3     4       1       5       1

   1     7       5       12       2

   4     5       12       17       3

   2     6       17       23       4

 Average Wait Time : 7
 Average Turn Around Time : 11

************************/

Optimal Page Replacement algorithm in Java.

2018-04-08T18:13:00.002+05:30

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class OptimalReplacement {

    public static void main(String[] args) throws IOException 
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int frames, pointer = 0, hit = 0, fault = 0,ref_len;
        boolean isFull = false;
        int buffer[];
        int reference[];
        int mem_layout[][];
        
        System.out.println("Enter the number of Frames: ");
        frames = Integer.parseInt(br.readLine());
        
        System.out.println("Enter the length of the Reference string: ");
        ref_len = Integer.parseInt(br.readLine());
        
        reference = new int[ref_len];
        mem_layout = new int[ref_len][frames];
        buffer = new int[frames];
        for(int j = 0; j < frames; j++)
                buffer[j] = -1;
        
        System.out.println("Enter the reference string: ");
        for(int i = 0; i < ref_len; i++)
        {
            reference[i] = Integer.parseInt(br.readLine());
        }
        System.out.println();
        for(int i = 0; i < ref_len; i++)
        {
         int search = -1;
         for(int j = 0; j < frames; j++)
         {
          if(buffer[j] == reference[i])
          {
           search = j;
           hit++;
           break;
          } 
         }
         if(search == -1)
         {
          if(isFull)
          {
           int index[] = new int[frames];
           boolean index_flag[] = new boolean[frames];
           for(int j = i + 1; j < ref_len; j++)
           {
            for(int k = 0; k < frames; k++)
            {
             if((reference[j] == buffer[k]) && (index_flag[k] == false))
             {
              index[k] = j;
              index_flag[k] = true;
              break;
             }
            }
           }
           int max = index[0];
           pointer = 0;
           if(max == 0)
            max = 200;
           for(int j = 0; j < frames; j++)
           {
            if(index[j] == 0)
             index[j] = 200;
            if(index[j] > max)
            {
             max = index[j];
             pointer = j;
            }
           }
          }
          buffer[pointer] = reference[i];
          fault++;
          if(!isFull)
          {
           pointer++;
              if(pointer == frames)
              {
               pointer = 0;
               isFull = true;
              }
          }
         }
            for(int j = 0; j < frames; j++)
                mem_layout[i][j] = buffer[j];
        }
        
        for(int i = 0; i < frames; i++)
        {
            for(int j = 0; j < ref_len; j++)
                System.out.printf("%3d ",mem_layout[j][i]);
            System.out.println();
        }
        
        System.out.println("The number of Hits: " + hit);
        System.out.println("Hit Ratio: " + (float)((float)hit/ref_len));
        System.out.println("The number of Faults: " + fault);
    }
    
}

/*OUTPUT:-

Please enter the number of Frames: 
3
Please enter the length of the Reference string: 
20
Please enter the reference string: 
1
2
3
2
1
5
2
1
6
2
5
6
3
1
3
6
1
2
4
3

  1   1   1   1   1   1   1   1   6   6   6   6   6   6   6   6   6   2   4   4 
 -1   2   2   2   2   2   2   2   2   2   2   2   2   1   1   1   1   1   1   1 
 -1  -1   3   3   3   5   5   5   5   5   5   5   3   3   3   3   3   3   3   3 
The number of Hits: 11
Hit Ratio: 0.55
The number of Faults: 9

*/

LRU Page Replacement algorithm in Java.(Least Recently Used)

2018-04-08T18:10:00.000+05:30

import java.util.Scanner;

public class lru
{

public static int min(int counter[],int nFrames)
{
int minimum = counter[0];
int pos = 0;
for(int i=0;i<nFrames;i++) { if(minimum > counter[i])
pos = i;
}
return pos;
}

public static void main(String[] args) {
// TODO code application logic here
Scanner s = new Scanner(System.in);
int n,recent = 0,pageFault = 0,nFrames;

System.out.print("Enter the number of pages: ");
n = s.nextInt();
int pageString[] = new int[n];
System.out.print("Enter the page reference string: ");
for(int i=0;i<n;i++)
pageString[i]=s.nextInt();

System.out.print("\nEnter the number of frames: ");
nFrames = s.nextInt();
int frames[] = new int[nFrames];
int counter[] = new int[nFrames];

for(int i=0;i<nFrames;i++)
{ frames[i] = 0;
counter[i] = 0;//here 0 referes an empty space in frame
}

for(int i=0;i<n;i++)
{int flag =0;
for(int j=0;j<nFrames;j++)
{
if(frames[j] == pageString[i])
{flag=1;
counter[j] = recent++; //counter holds which frame is recently used,
//recently used page in frame will have a bigger number
//and least recently used page in frame will have a lower number
break;
}
}

if(flag == 0)
{
for(int j=0;j<nFrames;j++)
{if(frames[j] == 0)
{ frames[j] = pageString[i];
counter[j] = recent++;
flag=1;
pageFault++;
break;
}

}
}

if(flag == 0){
int PositionToreplace = min(counter,nFrames);
frames[PositionToreplace] = pageString[i];
counter[PositionToreplace] = recent++;
pageFault++;
}

//print frames
System.out.println();
for(int j=0;j<nFrames;j++)
{
System.out.print(frames[j]+" ");
}

}

System.out.print("\nPage Fault: "+pageFault);

}

}

/*********OUTPUT******

Enter the number of pages: 13
Enter the page reference string: 1
2
3
1
2
2
1
4
5
1
3
2
1

Enter the number of frames: 3

1 0 0
1 2 0
1 2 3
1 2 3
1 2 3
1 2 3
1 2 3
1 2 4
1 5 4
1 5 4
1 5 3
1 2 3
1 2 3
Page Fault: 7
*/

Programming Hub

Java Program to find Second Largest Number in an Array

Write a SQL query to delete all duplicate email entries in a table named Person, keeping only unique emails based on its smallest Id.

Combine Tables. [Leetcode Problem]

Implement UNIX system calls like ps, fork, join, exec family, and wait for process management (use shell script/ Java/ C programming).

Write a Java program for pass-II of a two-pass macro-processor. The output of assignment-3 (MNT, MDT and file without any macro definitions) should be input for this assignment.

Design suitable data structures and implement pass-I of a two-pass macro-processor using OOP features in Java.

Abstract class and method in Java.

Few important things to remember about abstract class:

Abstraction vs Encapsulation.

Difference between Class and Object.

What are Objects in Object Oriented Programming aka OOP?

Implement Pass-II of two pass assembler for pseudo-machine in Java using object oriented features. The output of assignment-1 (intermediate file and symbol table) should be input for this assignment.

Design suitable data structures and implement pass-I of a two-pass assembler for pseudo-machine in Java using object oriented feature. Implementation should consist of a few instructions from each category and few assembler directives.

Print all pairs with given sum

SE- OOP Practical Lab -Implement a class Complex which represents the Complex Number data type.

Find missing number.

Convert Decimal to Binary. (using recursion)

Reverse a linked list. (Using recursion)

Obtain the sum of the first and last digits of this number.

Solution:

#include <iostream>using namespace std;int main() { // your code goes here int t; cin>>t; for(int i=0; i<t; i++) { int n; cin>>n; if (n<10) { cout<<n<<endl; } else{ int last = n%10;// get the last digit while(n>9) { n/=10;// get first digit } int sum= last+ n; cout<<sum<<endl; } } return 0;}

Sum of digits in the given number.

Input

Output

Constraints

Example

Java program for Safe Sequence (Banker's Algorithm).

SJF Scheduling Algorithm Java Implementation.

Round Robin Scheduling Algorithm Java Implementation.

Priority Scheduling Algorithm Java Program.

Optimal Page Replacement algorithm in Java.

LRU Page Replacement algorithm in Java.(Least Recently Used)

#include <iostream>
using namespace std;

int main() {
// your code goes here
int t;
cin>>t;

for(int i=0; i<t; i++)
{
int n;
cin>>n;
if (n<10)
{
cout<<n<<endl;
}
else{
int last = n%10;// get the last digit

while(n>9)
{
n/=10;// get first digit
}
int sum= last+ n;
cout<<sum<<endl;
}
}
return 0;
}