import [Link].

*;

import [Link].*;

import [Link].*;

import [Link].*;

import [Link].*;
import [Link];

class Player

int id;

int matchesPlay;

int totalRun;

String name;

String team;

public Player(int id, int matchesPlay, int totalRun, String name, String team) {

super();

[Link] = id;

[Link] = matchesPlay;

[Link] = totalRun;

[Link] = name;

[Link] = team;

public int getId() {

return id;

public void setId(int id) {

[Link] = id;

public String getName() {

return name;

}
 public void setName(String name) {

[Link] = name;

public String getTeam() {

return team;

public void setTeam(String team) {

[Link] = team;

public int getMatchPlay() {

return matchesPlay;

public void setMatchPlay(int matchesPlay) {

[Link] = matchesPlay;

public int getTotalRun() {

return totalRun;

public void setTotalRun(int totalRun) {

[Link] = totalRun;

public class Solution1

public static void main(String[] args)

{

Scanner in = new Scanner([Link]);

int n=[Link]();

Player[] p = new Player[n];

for(int i=0;i<[Link];i++)

int id = [Link]();

int matchesPlay = [Link]();

int totalRun = [Link]();[Link]();

String name = [Link]();

String team = [Link]();

p[i] = new Player(id, matchesPlay, totalRun, name, team);

double r = findAverageTotalRunsOfPlayer(p);

if(r == 0){[Link]("No Player found with mentioned attribute.");}

else{

[Link]("Average of totalRuns "+r);

Player pr = findPlayerWithMaximumMatchesPlayed(p);

if(pr == null){[Link]("No Player found with mentioned attribute.");}

else{

[Link]("id-"+[Link]());

[Link]("matchesPlayed-"+[Link]());

[Link]("totalRuns-"+[Link]());

[Link]("name-"+[Link]());
 [Link]("team-"+[Link]());

[Link]();

public static double findAverageTotalRunsOfPlayer(Player[] p){

double sum = 0;

for(int i=0; i< [Link]; i++){

sum = sum + p[i].getTotalRun();

if(sum == 0)

return 0;

else

return (sum/4);

public static Player findPlayerWithMaximumMatchesPlayed(Player[] player)

//method logic

Player maxPlayed=player[0];

int maxMatches=0;

for(int i=0; i<[Link];i++){

if (player[i].getMatchPlay()>maxMatches){

maxPlayed=player[i];

maxMatches=player[i].getMatchPlay();

}
 if(maxMatches==0){return null;}

else{

return maxPlayed;

import [Link].*;

public class Solution {

 public static void main(String[] args) {

// TODO Auto-generated method stub

int itemId;

String itemType;

String itemName;

double itemPrice;

int yearofMFG;

ShoppingItem[] shop = new ShoppingItem[4];

Scanner sc = new Scanner([Link]);

for(int i=0;i<[Link];i++) {

itemId = [Link]();

[Link]();

itemType = [Link]();

itemName = [Link]();

itemPrice = [Link]();

yearofMFG = [Link]();

shop[i] = new ShoppingItem(itemId, itemType, itemName, itemPrice,

yearofMFG);

int yearofMFG1 = [Link]();

[Link]();

String itemType1 = [Link]();

int count = getItemCountForYear(shop,yearofMFG1);

if(count>0) {

[Link](count);

}
 else {

[Link]("no Item");

ShoppingItem shop1 = getHighestPricedItem(shop,itemType1);

if(shop1 == null) {

[Link]("no item");

else {

[Link]([Link]()+";"+[Link]()+";"+[Link]());

public static int getItemCountForYear(ShoppingItem[] shop,int yearofMFG) {

int c =0;

for(int i=0;i<[Link];i++) {

if(shop[i].getYearofMFG() == yearofMFG ) {

c++;

return c;

public static ShoppingItem getHighestPricedItem(ShoppingItem[] shop,String itemType) {

int j =0;

for(int i =0;i<[Link];i++) {

if(shop[i].getItemType().equalsIgnoreCase(itemType)) {
 j++;

if(j==0)

return null;

ShoppingItem[] shop2 = new ShoppingItem[j];

j=0;

for(int i =0;i<[Link];i++) {

if(shop[i].getItemType().equalsIgnoreCase(itemType)) {

shop2[j++] = shop[i];

for(int i=0;i<[Link];i++) {

for(int k=i+1;k<[Link];k++) {

if(shop2[i].getItemPrice()<shop2[k].getItemPrice()) {

ShoppingItem temp = shop2[i];

shop2[i] = shop2[k];

shop2[k] = temp;

return shop2[0];

class ShoppingItem{
 int itemId;

String itemType;

String itemName;

double itemPrice;

int yearofMFG;

public ShoppingItem(int itemId, String itemType, String itemName, double itemPrice, int
yearofMFG) {

super();

[Link] = itemId;

[Link] = itemType;

[Link] = itemName;

[Link] = itemPrice;

[Link] = yearofMFG;

public int getItemId() {

return itemId;

public String getItemType() {

return itemType;

public String getItemName() {

return itemName;

}
 public double getItemPrice() {

return itemPrice;

public int getYearofMFG() {

return yearofMFG;

import [Link].*;
class Employee{

int employeeId;

String employeeName;

double salary;

String grade;

String location;

int yearsOfExperience;

Employee(int employeeId, String employeeName, double salary, String grade, String location, int
yearsOfExperience){

[Link] = employeeId;

[Link] = employeeName;

[Link] = salary;

[Link] = grade;

[Link] = location;

[Link] = yearsOfExperience;

int getEmployeeId(){

return employeeId;

String getEmployeeName(){

return employeeName;

double getSalary(){

return salary;

String getGrade(){
 return grade;

String getLocation(){

return location;

int getYearsOfExperience(){

return yearsOfExperience;

public class Solution{

public static void main(String[] args){

int employeeId;

String employeeName;

double salary;

String grade;

String location;

int yearsOfExperience;

Employee[] emp = new Employee[4];

Scanner s = new Scanner([Link]);

for(int i=0;i<[Link];i++){

employeeId = [Link]();[Link]();

employeeName = [Link]();

salary = [Link]();[Link]();

grade = [Link]();
 location = [Link]();

yearsOfExperience = [Link]();

emp[i] = new Employee(employeeId, employeeName, salary, grade, location, yearsOfExperience);

[Link]();

String newLocation = [Link]();

String newGrade = [Link]();

[Link]();

int countOfEmployees = findCountOfEmployeesByLoc(emp, newLocation);

Employee emp1 = findHighestSalaryEmpDetailsWithGivenGrade(emp, newGrade);

if(countOfEmployees == 0)

[Link]("There are no employees present in the given location and

yearsOfExperience");

else

[Link](countOfEmployees);

if(emp1 == null)

[Link]("No employees present in the given grade");

else

[Link]([Link]()+":"+[Link]()+":"+[Link]());

public static int findCountOfEmployeesByLoc(Employee[] emp, String location){

int count = 0;

for(int i=0;i<[Link];i++){
 if([Link](emp[i].getLocation())){

if(emp[i].getYearsOfExperience()>2){

count++;

return count;

public static Employee findHighestSalaryEmpDetailsWithGivenGrade(Employee[] emp, String grade){

int count = 0;

for(int i=0;i<[Link];i++){

if([Link](emp[i].getGrade()))

count++;

if(count == 0) return null;

Employee[] emp1 = new Employee[count];

count = 0;

for(int i=0;i<[Link];i++){

if([Link](emp[i].getGrade()))

emp1[count++] = emp[i];

for(int i=0;i<[Link];i++){

for(int j=i+1;j<[Link];j++){

if(emp1[i].getSalary()>emp1[j].getSalary()){

Employee temp = emp1[i];

 emp1[i] = emp1[j];

emp1[j] = temp;

return emp1[[Link]-1];

}
import [Link];

class Employee{

private int empId;

private String empName;

private int mgrId;

private String deptName;

private double salary;

public Employee(int empId, String empName, int mgrId, String deptName, double salary){

[Link] = empId;

[Link] = empName;

[Link] = mgrId;

[Link] = deptName;

[Link] = salary;

public int getEmpId(){

return empId;

public String getEmpName(){

return empName;

public int getMgrId(){

return mgrId;

public double getSalary(){

 return salary;

public class Solution{

public static void main(String[] args){

int empId;

String empName;

int mgrId;

String deptName;

double salary;

Scanner s = new Scanner([Link]);

Employee[] emp = new Employee[5];

for(int i=0;i<[Link];i++){

empId = [Link]();[Link]();

empName = [Link]();

mgrId = [Link]();[Link]();

deptName = [Link]();

salary = [Link]();

emp[i] = new Employee(empId, empName, mgrId, deptName, salary);

int count = empsWithSalMoreThanAvg(emp);

Employee employee = getManagerWithMaxSalary(emp);

 if(count > 0)

[Link](count);

else

[Link]("No such Employees");

if(employee == null)

[Link]("No Managers");

else

[Link]([Link]()+"#"+[Link]());

public static int empsWithSalMoreThanAvg(Employee[] emp){

double avgSalary = 0, sum=0;

int count = 0;

for(int i=0;i<[Link];i++)

if(emp[i].getSalary() > 0) {

sum += emp[i].getSalary();

count++;

avgSalary = sum / count;

count = 0;

for(int i=0;i<[Link];i++){

if(emp[i].getSalary() > avgSalary)

count++;

return count;
 }

public static Employee getManagerWithMaxSalary(Employee[] emp){

int count = 0;

for(int i=0;i<[Link];i++)

if(emp[i].getMgrId() != 0)

count++;

if(count == 0) return null;

double maxSalary = -999;

for(int i=0;i<[Link];i++){

if(emp[i].getMgrId() != 0)

if(emp[i].getSalary() > maxSalary)

maxSalary = emp[i].getSalary();

for(int i=0;i<[Link];i++){

if(emp[i].getSalary() == maxSalary)

return emp[i];

return null;

}
import [Link];

public class Solution {

public static void main(String[] args){

String vehicleId;

String vehicleType;

String modeOfPayment;

double fare;

TollPlaza[] tollplazaArr = new TollPlaza[5];

Scanner s = new Scanner([Link]);

 for(int i=0;i<[Link];i++) {

vehicleId = [Link]();

vehicleType = [Link]();

modeOfPayment = [Link]();

fare = [Link]();

[Link]();

tollplazaArr[i] = new TollPlaza(vehicleId, vehicleType, modeOfPayment, fare);

String newModeOfPayment = [Link]();

String newVehicleId = [Link]();

[Link]();

double totalCollection = getPaymentModeWiseTotalCollection(tollplazaArr, newModeOfPayment);

TollPlaza findVehicle = findVehicleWithVehicleId(tollplazaArr, newVehicleId);

if(totalCollection == 0)

[Link]("The given mode of payment is not available");

else

[Link](totalCollection);

if(findVehicle == null)

[Link]("The given vehicle ID is incorrect");

else

[Link]([Link]()+"#"+[Link]()+"#"+[Link]
deOfPayment()+"#"+[Link]());
 }

public static double getPaymentModeWiseTotalCollection(TollPlaza[] tollplazaArr, String

modeOfPayment){

double totolFare = 0;

for(int i=0;i<[Link];i++){

if([Link](tollplazaArr[i].getModeOfPayment()))

totolFare += tollplazaArr[i].getFare();

return totolFare;

public static TollPlaza findVehicleWithVehicleId(TollPlaza[] tollplazaArr, String vehicleId){

for(int i=0;i<[Link];i++){

if([Link](tollplazaArr[i].getVehicleId()))

return tollplazaArr[i];

return null;

class TollPlaza{

String vehicleId;

String vehicleType;

String modeOfPayment;

double fare;

TollPlaza(String vehicleId, String vehicleType, String modeOfPayment, double fare){

[Link] = vehicleId;
 [Link] = vehicleType;

[Link] = modeOfPayment;

[Link] = fare;

String getVehicleId(){

return vehicleId;

String getVehicleType(){

return vehicleType;

String getModeOfPayment(){

return modeOfPayment;

double getFare(){

return fare;

}
import [Link].*;

public class Solution

public static void main (String[] args)

// your code goes here

Scanner sc=new Scanner([Link]);

Policy[] policy = new Policy[4];

for(int i=0;i<[Link];i++)

{
 int policyId=[Link]();[Link]();

String policyName=[Link]();

String paymentMode=[Link]();

double policyAmount=[Link]();

policy[i]=new Policy(policyId, policyName, paymentMode, policyAmount);

int newPolicyId=[Link]();

int percentageAlreadyClaimed=[Link]();

boolean claimed=[Link]();

double minAmount=[Link]();

double maxAmount=[Link]();

[Link]();

double newPolicyAmount = getPolicyAmount(policy, newPolicyId, claimed,

percentageAlreadyClaimed);

if(newPolicyAmount==0){

[Link]("Policy is not claimed");}

else

[Link]("Policy Amount after claim is :"+newPolicyAmount);

Policy newPolicy = getPolicyWithInAmountRange(policy, minAmount, maxAmount);

if(newPolicy!=null){

[Link]("Policy Id:"+[Link]());

[Link](" Policy Name:"+[Link]());

[Link](" Total Amount:"+[Link]());}

else
 [Link]("No Policy available within the specified range");

public static double getPolicyAmount(Policy[] policy,int newPolicyId, boolean claimed,int

percentageAlreadyClaimed)

double newPolicyAmount=0;

for(int i=0;i<[Link];i++)

if(policy[i].getPolicyId()==newPolicyId && claimed==true)

newPolicyAmount = policy[i].getPolicyAmount() -
((policy[i].getPolicyAmount()*percentageAlreadyClaimed)/100);

policy[i].setPolicyAmount(newPolicyAmount);

return newPolicyAmount;

public static Policy getPolicyWithInAmountRange(Policy[] policy,double minAmount,double

maxAmount)

for(int i=0;i<[Link];i++) {

if(policy[i].getPolicyAmount() > minAmount &&

policy[i].getPolicyAmount()<maxAmount)

return policy[i];

return null;
 }

class Policy

int policyId;

String policyName;

String paymentMode;

double policyAmount;

Policy(int policyId,String policyName,String paymentMode,double policyAmount)

[Link] = policyId;

[Link] = policyName;

[Link] = paymentMode;

[Link] = policyAmount;

int getPolicyId() {

return policyId;

String getPolicyName() {

return policyName;

String getPaymentMode() {

return paymentMode;

double getPolicyAmount() {
 return policyAmount;

void setPolicyAmount(double policyAmount) {

[Link] = policyAmount;

}
Q1 :-

import [Link].*;

public class Solution {

public static void main(String[] args) {

int billId;

String custName;

int units;

Scanner s = new Scanner([Link]);

Bill[] bill = new Bill[5];

for(int i=0;i<[Link];i++) {

billId = [Link]();[Link]();

custName = [Link]();

units = [Link]();

bill[i] = new Bill(billId, custName, units);

double minBillAmnt = [Link]();

double maxBillAmnt = [Link]();

[Link]();

int noOfBills = findBillsInTheAmntRange(bill, minBillAmnt, maxBillAmnt);

Bill b = getBillWithHighAmnt(bill);

if(noOfBills == 0)

[Link]("No bills with given amount");

else
 [Link](noOfBills);

if(b == null)

[Link]("No bill object found");

else

[Link]([Link]()+" "+[Link]()+" "+[Link]());

public static int findBillsInTheAmntRange(Bill[] bills, double minAmnt, double maxAmnt) {

double billAmnt = 0;int count = 0;

for(int i=0;i<[Link];i++) {

if(bills[i].getUnits()>=1000)

billAmnt = bills[i].getUnits() * 5;

else if(bills[i].getUnits()>=500 && bills[i].getUnits()<1000)

billAmnt = bills[i].getUnits() * 3;

else if(bills[i].getUnits()<500)

billAmnt = bills[i].getUnits() * 1;

if(billAmnt >= minAmnt && billAmnt <= maxAmnt) count++;

return count;

public static Bill getBillWithHighAmnt(Bill[] bills) {

int maxUnits=-999;

for(int i=0;i<[Link];i++) {

if(bills[i].getUnits()>=maxUnits)

maxUnits = bills[i].getUnits();
 }

for(int i=0;i<[Link];i++) {

if(maxUnits == bills[i].getUnits())

return bills[i];

return null;

class Bill{

int billId;

String custName;

int units;

Bill(int billId, String custName, int units){

[Link] = billId;

[Link] = custName;

[Link] = units;

int getBillId() {

return billId;

String getCustName() {

return custName;

int getUnits() {

return units;
 }

Q2-

import [Link].*;

public class Solution{

public static void main(String []args){

Scanner s = new Scanner([Link]);

Bus[] bus = new Bus[4];

String busNo, fromStation, toStation;

double ticketCost;

for(int i=0;i<[Link];i++){

busNo = [Link]();

fromStation = [Link]();

toStation = [Link]();

ticketCost = [Link]();[Link]();

bus[i] = new Bus(busNo, fromStation, toStation, ticketCost);

String getFromStation = [Link]();

String getToStation = [Link]();

[Link]();

Bus b = getBus(bus, getFromStation, getToStation);

double cost = getSumOfMinMaxTicketCost(bus);

if(cost>0)

[Link](cost);
 else

[Link]("Travel is free of cost");

if(b==null)

[Link]("No Bus found");

else

[Link]([Link]());

public static Bus getBus(Bus[] bus, String fromStation, String toStation){

for(int i=0;i<[Link];i++){

if([Link](bus[i].getFromStation()) &&
[Link](bus[i].getToStation()))

return bus[i];

return null;

public static double getSumOfMinMaxTicketCost(Bus[] bus){

double minCost = 9999999, maxCost = -9999999;

for(int i=0;i<[Link];i++){

if(bus[i].getTicketCost() <= minCost)

minCost = bus[i].getTicketCost();

if(bus[i].getTicketCost() >= maxCost)

maxCost = bus[i].getTicketCost();

return minCost+maxCost;
 }

class Bus{

String busNo, fromStation, toStation;

double ticketCost;

Bus(String busNo, String fromStation, String toStation, double ticketCost){

[Link] = busNo;

[Link] = fromStation;

[Link] = toStation;

[Link] = ticketCost;

String getBusNo(){

return busNo;

String getFromStation(){

return fromStation;

String getToStation(){

return toStation;

double getTicketCost(){

return ticketCost;

Q3-
import [Link].*;

public class Solution{

public static void main(String[] args) {

Scanner s = new Scanner([Link]);

int studentId, sub1, sub2, sub3;

String studentName;

Student[] student = new Student[4];

for(int i=0;i<[Link];i++) {

studentId = [Link]();[Link]();

studentName = [Link]();

sub1 = [Link]();

sub2 = [Link]();

sub3 = [Link]();

student[i] = new Student(studentId, studentName, sub1, sub2, sub3);

[Link]();

int passedStudents = findPassedStudentCount(student);

Student stu = getTopStudent(student);

if(passedStudents == 0)

[Link]("No Students Passed");

else

[Link](passedStudents);

if(stu == null)
 [Link]("No one has passed");

else

[Link]([Link]()+"#"+[Link]());

public static int findPassedStudentCount(Student[] students) {

int count = 0;

for(int i=0;i<[Link];i++) {

if(students[i].getSub1() >= 60 && students[i].getSub2() >= 60 && students[i].getSub3()>=60)

count++;

return count;

public static Student getTopStudent(Student[] students) {

int count = 0;

for(int i=0;i<[Link];i++) {

if(students[i].getSub1() >= 60 && students[i].getSub2() >= 60 && students[i].getSub3()>=60)

count++;

if(count == 0) return null;

Student[] s = new Student[count];

count = 0;

for(int i=0;i<[Link];i++) {

if(students[i].getSub1() >= 60 && students[i].getSub2() >= 60 && students[i].getSub3()>=60)

s[count++] = students[i];

}
 int sum = s[0].getSub1()+s[0].getSub2()+s[0].getSub3();

for(int i=1;i<[Link];i++) {

if(s[i].getSub1()+s[i].getSub2()+s[i].getSub3() >= sum)

sum = s[i].getSub1()+s[i].getSub2()+s[i].getSub3();

for(int i=0;i<[Link];i++) {

if(sum == s[i].getSub1()+s[i].getSub2()+s[i].getSub3())

return s[i];

return null;

class Student{

int studentId, sub1, sub2, sub3;

String studentName;

Student(int studentId, String studentName, int sub1, int sub2, int sub3){

[Link] = studentId;

[Link] = studentName;

this.sub1 = sub1;

this.sub2 = sub2;

this.sub3 = sub3;

int getStudentId() {

return studentId;

}
 String getStudentName() {

return studentName;

int getSub1() {

return sub1;

int getSub2() {

return sub2;

int getSub3() {

return sub3;

Q-4

import [Link].*;

public class Solution{

public static void main(String[] args){

int empId;

String empName;

int mgrId;

String deptName;

double salary;

Scanner s = new Scanner([Link]);

Employee[] emp = new Employee[4];

for(int i=0;i<[Link];i++){
 empId = [Link]();

empName = [Link]();

mgrId = [Link]();[Link]();

deptName = [Link]();

salary = [Link]();

emp[i] = new Employee(empId, empName, mgrId, deptName, salary);

[Link]();

double r1=[Link]();

double r2=[Link]();

int res=findempsWithSalRange(emp,r1,r2);

if(res==0)

[Link]("No Employee in the given range");

else

[Link](res);

Employee res2=getEmployeeWitMaxSal(emp);

if(res2==null)

[Link]("NOT FOUND");

else

[Link]([Link]+"#"+[Link]+"#"+[Link]);

public static int findempsWithSalRange(Employee[] emp,double r1,double r2){

int c=0;
for(int i=0;i<[Link];i++)

if(emp[i].getSalary()>r1 && emp[i].getSalary()<r2){

c++;

if (c==0)

return 0;

else

return c;

public static Employee getEmployeeWitMaxSal(Employee[] emp)

for(int i = 0; i<[Link]-1; i++)

for (int j = i+1; j<[Link]; j++)

if(emp[i].getSalary() < emp[j].getSalary())

Employee t=emp[i];

emp[i]=emp[j];

emp[j]=t;

}
 }

return emp[0];

class Employee

int empId;

String empName;

int mgId;

String deptName;

double salary;

public int getEmpId() {

return empId;

public Employee(int empId, String empName, int mgId, String deptName, double salary) {

super();

[Link] = empId;

[Link] = empName;

[Link] = mgId;

[Link] = deptName;

[Link] = salary;

public void setEmpId(int empId) {

[Link] = empId;
}

public String getEmpName() {

return empName;

public void setEmpName(String empName) {

[Link] = empName;

public int getMgId() {

return mgId;

public void setMgId(int mgId) {

[Link] = mgId;

public String getDeptName() {

return deptName;

public void setDeptName(String deptName) {

[Link] = deptName;

public double getSalary() {

return salary;

public void setSalary(double salary) {

[Link] = salary;

}
}

Q5-

import [Link].*;

import [Link].*;

public class Solution1{

public static void main(String[] args){

int contestId;

String contestName;

String contestWinner;

int points;

String category;

Scanner s = new Scanner([Link]);

Contest[] contests = new Contest[4];

for(int i=0; i<[Link]; i++){

contestId = [Link]();[Link]();

contestName = [Link]();

contestWinner = [Link]();

points = [Link]();[Link]();

category = [Link]();

contests[i] = new Contest(contestId, contestName, contestWinner, points, category);

String newContestWinner = [Link]();

String newCategory = [Link]();

[Link]();

int totalPoints = findTotalPointsBasedOnWinner(contests, newContestWinner);

 if(totalPoints == 0)

[Link]("Contest Winner not found");

else

[Link](totalPoints);

Contest contest = getContestWithSecondHighestPoints(contests, newCategory);

if(contest == null)

[Link]("There is no matching contest");

else

[Link]([Link]()+"\n"+[Link]());;

public static int findTotalPointsBasedOnWinner(Contest[] contests, String contestWinner){

int totalPoints = 0;

for(Contest contest: contests){

if([Link]().equalsIgnoreCase(contestWinner))

totalPoints += [Link]();

return totalPoints;

public static Contest getContestWithSecondHighestPoints(Contest[] contests, String category){

List<Contest> newList = new ArrayList<Contest>();

for(Contest contest: contests){

if([Link]().equalsIgnoreCase(category))

[Link](contest);

}
 if([Link]()<=1) return null;

[Link](newList, new Sort());

return [Link]([Link]()-2);

class Sort implements Comparator<Contest>{

@Override

public int compare(Contest obj1, Contest obj2) {

return (int)([Link]() - [Link]());

class Contest{

private int contestId;

private String contestName;

private String contestWinner;

private int points;

private String category;

public Contest(int contestId, String contestName, String contestWinner, int points, String category){

[Link] = contestId;

[Link] = contestName;

[Link] = contestWinner;

[Link] = points;

[Link] = category;

public int getContestId() {

 return contestId;

public String getContestName() {

return contestName;

public String getContestWinner(){

return contestWinner;

public int getPoints() {

return points;

public String getCategory() {

return category;

Q5-

import [Link];

public class Solution

public static void main(String[] args)

//code to read values

int bottleId;

String bottleBrand;
String bottleType;

int capacity;

String material;

double price;

Bottle[] bottles = new Bottle[4];

Scanner s = new Scanner([Link]);

for(int iterator = 0; iterator < [Link]; iterator++){

bottleId = [Link]();[Link]();

bottleBrand = [Link]();

bottleType = [Link]();

capacity = [Link]();[Link]();

material = [Link]();

price = [Link]();

bottles[iterator] = new Bottle(bottleId, bottleBrand, bottleType, capacity, material, price);

[Link]();

String newMaterialValue = [Link]();

String newBottleBrandValue = [Link]();

[Link]();

//code to call required method

int averagePriceBasedOnMaterial = getAvgPriceBasedOnMaterial(bottles, newMaterialValue);

Bottle secondHighestBottlePrice = getBottleBySecondHighestPrice(bottles, newBottleBrandValue);

//code to display the result

if(averagePriceBasedOnMaterial > 0)

[Link](averagePriceBasedOnMaterial);
 else

[Link]("There is no matching bottles with the given material");

if(secondHighestBottlePrice == null)

[Link]("Bottles are not available for the given brand");

else

[Link]("Bottle Brand :"+[Link]()+",Bottle Capacity

in ml :"+[Link]()+",Price :"+[Link]());

//code the first method

public static int getAvgPriceBasedOnMaterial(Bottle[] bottles, String material){

double totalCartPrice = 0;

int count = 0;

for(int iterator = 0; iterator < [Link]; iterator++){

if([Link](bottles[iterator].getMaterial())){

totalCartPrice += bottles[iterator].getPrice();

count++;

if(count > 0)

return (int)totalCartPrice / count;

else

return 0;

}
//code the second method

public static Bottle getBottleBySecondHighestPrice(Bottle[] bottles, String bottleBrand){

int count = 0;

for(int i = 0; i < [Link]; i++){

if([Link](bottles[i].getBottleBrand()))

count++;

if(count == 0) return null;

Bottle[] b = new Bottle[count];

count = 0;

for(int i = 0; i < [Link]; i++){

if([Link](bottles[i].getBottleBrand())){

b[count++] = bottles[i];

for(int i=0; i < [Link]; i++){

for(int j=0; j < [Link]; j++){

if(b[i].getPrice() < b[j].getPrice()){

Bottle temp = b[i];

b[i] = b[j];

b[j] = temp;

}
 return b[1];

//code the class

class Bottle{

private int bottleId;

private String bottleBrand;

private String bottleType;

private int capacity;

private String material;

private double price;

public Bottle(){}

public Bottle(int bottleId, String bottleBrand, String bottleType, int capacity, String material, double
price){

[Link] = bottleId;

[Link] = bottleBrand;

[Link] = bottleType;

[Link] = capacity;

[Link] = material;

[Link] = price;

public int getBottleId(){

return bottleId;

}
 public String getBottleBrand(){

return bottleBrand;

public String getBottleType(){

return bottleType;

public int getCapacity(){

return capacity;

public String getMaterial(){

return material;

public double getPrice(){

return price;

Q-6

import [Link].*;

public class Solution{

public static void main(String[] args) {

Scanner s = new Scanner([Link]);

int number = [Link]();

Bill[] bill = new Bill[number];

for(int i=0;i<[Link];i++) {

int billNo = [Link]();[Link]();

 String name = [Link]();

String typeOfConnection = [Link]();

double billAmount = [Link]();[Link]();

boolean status = [Link]();[Link]();

bill[i] = new Bill(billNo, name, typeOfConnection, billAmount, status);

boolean parameter = [Link]();[Link]();

String newTypeOfConnection = [Link]();

[Link]();

Bill[] b = findBillWithMaxBillAmountBasedOnStatus(bill, parameter);

if(b == null)

[Link]("There are no bill with the given status");

else {

for(int i=0;i<[Link];i++)

[Link](b[i].getBillNo()+"#"+b[i].getName());

int countOfBills = getCountWithTypeOfConnection(bill, newTypeOfConnection);

if(countOfBills == 0)

[Link]("There are no bills with given type of connection");

else

[Link](countOfBills);

}
public static Bill[] findBillWithMaxBillAmountBasedOnStatus(Bill[] bill, boolean parameter) {

int count = 0;

for(int i=0;i<[Link];i++) {

if(bill[i].getStatus() == parameter)

count++;

if(count == 0) return null;

Bill[] b = new Bill[count];

Bill[] anotherBill = new Bill[count];

count = 0;

for(int i=0;i<[Link];i++) {

if(bill[i].getStatus() == parameter) {

b[count++] = bill[i];

double maxBill = 0;

for(int i=0;i<[Link];i++) {

if(b[i].getBillAmount() > maxBill)

maxBill = b[i].getBillAmount();

count = 0;

for(int i=0;i<[Link];i++){

if(b[i].getBillAmount() == maxBill)

count++;

}
 Bill[] newBill = new Bill[count];

for(int i=0;i<[Link];i++) {

for(int j=i+1;j<[Link];j++) {

if(b[i].getBillNo()>=b[j].getBillNo()) {

Bill temp = b[i];

b[i] = b[j];

b[j] = temp;

count = 0;

for(int i=0;i<[Link];i++) {

if(maxBill == b[i].getBillAmount())

newBill[count++] = b[i];

return newBill;

public static int getCountWithTypeOfConnection(Bill[] bill, String newTypeOfConnection) {

int count = 0;

for(int i=0;i<[Link];i++) {

if([Link](bill[i].getTypeOfConnection()))

count++;

return count;

}
}

class Bill{

int billNo;

String name;

String typeOfConnection;

double billAmount;

boolean status;

Bill(int billNo, String name, String typeOfConnection, double billAmount, boolean status){

[Link] = billNo;

[Link] = name;

[Link] = typeOfConnection;

[Link] = billAmount;

[Link] = status;

int getBillNo() {

return billNo;

String getName() {

return name;

String getTypeOfConnection() {

return typeOfConnection;

double getBillAmount() {
 return billAmount;

boolean getStatus() {

return status;

Q7:-

import [Link].*;

public class Solution{

public static void main(String[] args) {

String songName;

int duration;

String artists;

String genre;

Scanner s = new Scanner([Link]);

Album[] album = new Album[4];

for(int i=0;i<[Link];i++) {

songName = [Link]();

duration = [Link]();[Link]();

artists = [Link]();

genre = [Link]();

album[i] = new Album(songName, duration, artists, genre);

String getGenre = [Link]();

String getArtists = [Link]();

 [Link]();

String[] findSong = findSongBasedonGenre(album, getGenre);

Album[] a = findAlbumBasedonArtists(album, getArtists);

if(findSong == null)

[Link]("There are no songs with the given genre");

else

for(int i=0;i<[Link];i++) {

[Link](findSong[i]);

if(a==null)

[Link]("There are no album with the given artists");

else

for(int i=0;i<[Link];i++) {

[Link](a[i].getSongName()+"#"+a[i].getDuration()+"#"+a[i].getArtists()+"#"+a[i].get
Genre());

public static String[] findSongBasedonGenre(Album[] album, String genre) {

int count = 0;

for(int i=0;i<[Link];i++) {

if([Link](album[i].getGenre())) {

if(album[i].getDuration()>5)

count++;
 }

if(count == 0) return null;

String[] song = new String[count];

count = 0;

for(int i=0;i<[Link];i++) {

if([Link](album[i].getGenre())) {

if(album[i].getDuration()>5)

song[count++] = album[i].getSongName();

return song;

public static Album[] findAlbumBasedonArtists(Album[] album, String artists) {

int count = 0;

for(int i=0;i<[Link];i++) {

if(album[i].getArtists().equalsIgnoreCase(artists)){

if(album[i].getGenre().equalsIgnoreCase("Melody"))

count++;

if(count == 0) return null;

Album[] a = new Album[count];

count = 0;

for(int i=0;i<[Link];i++) {
 if(album[i].getArtists().equalsIgnoreCase(artists)){

if(album[i].getGenre().equalsIgnoreCase("Melody"))

a[count++] = album[i];

for(int i=0;i<[Link];i++) {

for(int j=i+1;j<[Link];j++) {

if(a[i].getSongName().compareTo(a[j].getSongName())>0) {

Album temp = a[i];

a[i] = a[j];

a[j] = temp;

return a;

class Album{

String songName;

int duration;

String artists;

String genre;

Album(String songName, int duration, String artists, String genre){

[Link] = songName;
 [Link] = duration;

[Link] = artists;

[Link] = genre;

String getSongName() {

return songName;

int getDuration() {

return duration;

String getArtists() {

return artists;

String getGenre() {

return genre;

Q8:-

import [Link].*;

public class Solution{

public static void main(String[] args) {

Scanner s = new Scanner([Link]);

int theatreId, seatCapacity, theatreRating;

String theatreName;

double ticketRate;
 Theatre[] th = new Theatre[4];

for(int i=0;i<[Link];i++) {

theatreId = [Link]();[Link]();

theatreName = [Link]();

seatCapacity = [Link]();

ticketRate = [Link]();

theatreRating = [Link]();

th[i] = new Theatre(theatreId, theatreName, seatCapacity, ticketRate,

theatreRating);

int getTheatreId = [Link]();

[Link]();

String theatreCategory = findTheatreCategory(th, getTheatreId);

Theatre t = findSecondHighestTicket(th);

if(theatreCategory == null)

[Link]("There is no Theatre with the given theatreId");

else

[Link](theatreCategory);

if(t == null)

[Link]("Only low rating theatres are available");

else

[Link]([Link]());

public static String findTheatreCategory(Theatre[] th, int theatreId) {

 String s=null;

for(int i=0;i<[Link];i++) {

if(theatreId == th[i].getTheatreId() ) {

if(th[i].getSeatCapacity()>1000 && th[i].getTheatreRating()>=4)

s = "Premium";

else

s = "Non Premium";

return s;

public static Theatre findSecondHighestTicket(Theatre[] th) {

int count = 0;

for(int i=0;i<[Link];i++) {

if(th[i].getTheatreRating()>=2) count++;

if(count == 0) return null;

Theatre[] t = new Theatre[count];

count = 0;

for(int i=0;i<[Link];i++) {

if(th[i].getTheatreRating()>=2)

t[count++] = th[i];

for(int i=0;i<[Link];i++) {

for(int j=i+1;j<[Link];j++) {
 if(t[i].getTicketRate() <= t[j].getTicketRate()) {

Theatre temp = t[i];

t[i] = t[j];

t[j] = temp;

return t[1];

class Theatre{

int theatreId, seatCapacity, theatreRating;

String theatreName;

double ticketRate;

Theatre(int theatreId, String theatreName, int seatCapacity, double ticketRate, int

theatreRating){

[Link] = theatreId;

[Link] = theatreName;

[Link] = seatCapacity;

[Link] = ticketRate;

[Link] = theatreRating;

int getTheatreId() {

return theatreId;

String getTheatreName() {
 return theatreName;

int getSeatCapacity() {

return seatCapacity;

double getTicketRate() {

return ticketRate;

int getTheatreRating() {

return theatreRating;

Q9:-

import [Link].*;

public class Solution {

public static void main(String[] args) {

int soapId;

String soapName;

String brand;

double price;

boolean isGlycerin;

Soap[] soap = new Soap[4];

Scanner s = new Scanner([Link]);

for(int i=0;i<[Link];i++) {

soapId = [Link]();[Link]();
 soapName = [Link]();

brand = [Link]();

price = [Link]();

isGlycerin = [Link]();

soap[i] = new Soap(soapId, soapName, brand, price, isGlycerin);

[Link]();

String getBrand = [Link]();

double minPrice = [Link]();

double maxPrice = [Link]();

Soap sp = getMaxPricedSoapByBrand(soap, getBrand);

Soap[] ss = getGlycerinSoapsByPriceRange(soap, minPrice, maxPrice);

if(sp == null)

[Link]("There are no Soaps with given brand");

else {

[Link]([Link]()+"#"+[Link]()+"#"+[Link]()+"#"+[Link]());

for(int i=0;i<[Link];i++) {

[Link](ss[i].getSoapId()+"-"+ss[i].getSoapName()+"-
"+ss[i].getPrice());

public static Soap getMaxPricedSoapByBrand(Soap[] soapArr, String brand)

{
 //method logic

double maxPrice = 0;

Soap soap = new Soap();

for(int i=0;i<[Link];i++) {

for(int j=0;j<[Link];j++) {

if(soapArr[i].getPrice()<=soapArr[i].getPrice()) {

Soap temp = soapArr[i];

soapArr[i] = soapArr[j];

soapArr[j] = temp;

for(int i=0;i<[Link];i++) {

if([Link](soapArr[i].getBrand()))

return soapArr[i];

return null;

public static Soap[] getGlycerinSoapsByPriceRange(Soap[] soapArr, double minPrice, double

maxPrice)

//method logic

int count = 0;

for(int i=0;i<[Link];i++) {

if(soapArr[i].getIsGlycerin()==true && soapArr[i].getPrice()>=minPrice &&

soapArr[i].getPrice()<=maxPrice)
 count++;

if(count == 0) return null;

Soap[] soap = new Soap[count];

count = 0;

for(int i=0;i<[Link];i++) {

if(soapArr[i].getIsGlycerin()==true && soapArr[i].getPrice()>=minPrice &&

soapArr[i].getPrice()<=maxPrice) {

soap[count++] = soapArr[i];

for(int i=0;i<[Link];i++) {

for(int j=0;j<[Link];j++) {

if(soap[i].getPrice()<=soap[i].getPrice()) {

Soap temp = soap[i];

soap[i] = soap[j];

soap[j] = temp;

return soap;

class Soap{

int soapId;
String soapName;

String brand;

double price;

boolean isGlycerin;

Soap(){}

Soap(int soapId, String soapName, String brand, double price, boolean isGlycerin){

[Link] = soapId;

[Link] = soapName;

[Link] = brand;

[Link] = price;

[Link] = isGlycerin;

int getSoapId() {

return soapId;

String getSoapName() {

return soapName;

String getBrand() {

return brand;

double getPrice() {

return price;

boolean getIsGlycerin() {
 return isGlycerin;

Q10:-

import [Link].*;

public class Solution{

public static void main(String[] args) {

int playerId;

String playerName;

String country;

int goals;

Scanner s = new Scanner([Link]);

Football[] football = new Football[5];

for(int i=0;i<[Link];i++) {

playerId = [Link]();[Link]();

playerName = [Link]();

country = [Link]();

goals = [Link]();

football[i] = new Football(playerId, playerName, country, goals);

[Link]();

String getCountry1 = [Link]();

String getCountry2 = [Link]();

[Link]();
 int totalGoals = findGoalsForCountry(football, getCountry1);

Football[] fb = getGoalsAscendingOrder(football, getCountry2);

if(totalGoals == 0)

[Link]("No valid country specified");

else

[Link](totalGoals);

if(fb == null)

[Link]("Country specified is wrong");

else {

for(int i=0; i<[Link]; i++) {

[Link](fb[i].getPlayerId()+"#"+fb[i].getPlayerName()+"#"+fb[i].getCountry()+"#"+fb[i
].getGoals());

public static int findGoalsForCountry(Football[] football, String country) {

int sum = 0;

for(int i=0; i<[Link]; i++) {

if([Link](football[i].getCountry())) {

sum += football[i].getGoals();

return sum;
}

public static Football[] getGoalsAscendingOrder(Football[] football, String country) {

int count = 0;

for(int i=0; i<[Link]; i++) {

if([Link](football[i].getCountry())) {

count++;

if(count == 0)

return null;

Football[] fb = new Football[count];

count = 0;

for(int i=0; i<[Link]; i++) {

if([Link](football[i].getCountry())) {

fb[count++] = football[i];

for(int i=0; i<[Link]; i++) {

for(int j=i+1; j<[Link]; j++) {

if(fb[i].getGoals() >= fb[i].getGoals()) {

Football temp = fb[i];

fb[i] = fb[j];

fb[j] = temp;

}
 }

return fb;

class Football{

int playerId;

String playerName;

String country;

int goals;

Football(int playerId, String playerName, String country, int goals) {

[Link] = playerId;

[Link] = playerName;

[Link] = country;

[Link] = goals;

int getPlayerId() {

return playerId;

String getPlayerName() {

return playerName;

String getCountry() {

return country;

}
 int getGoals() {

return goals;

Q11:-

import [Link];

public class Main {

public static void main(String[] args) {

// TODO Auto-generated method stub

Scanner sc=new Scanner([Link]);

Amazonprime[] ap=new Amazonprime[4];

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

int a=[Link]();[Link]();

String b=[Link]();

int c=[Link]();[Link]();

String d=[Link]();

int e=[Link]();[Link]();

ap[i]=new Amazonprime(a,b,c,d,e);

int par1=[Link]();[Link]();

int par=[Link]();[Link]();

String show=[Link]();
int remaindays=findRemainingSubcriptionDays(ap,par,par1);

if(remaindays!=0)

[Link](remaindays);

else

[Link]("Its time to recharge your Prime Account");

Amazonprime amp[]=findDetailsForGivenShow(ap,show);

if(amp!=null)

for(int i=0;i<[Link];i++)

if(amp[i]!=null){

[Link](amp[i].getPrimeId()+"$"+amp[i].getUserName()+"$"+amp[i].getViews());

else{

[Link]("No such shows available");

public static int findRemainingSubcriptionDays(Amazonprime[] ap,int par,int par1) {

int remaindays=0;
for(int i=0;i<[Link];i++)

if(ap[i].getPrimeId()==par)

remaindays=((ap[i].getSubscribedPackage())-par1);

return remaindays;

public static Amazonprime[] findDetailsForGivenShow(Amazonprime[] ap,String show) {

Amazonprime amp[]=new Amazonprime[4];

int j=0;

for(int i=0;i<[Link];i++)

if(ap[i].getShowStreaming().equalsIgnoreCase(show))

amp[j++]=ap[i];

for(int i=0;i<j-1;i++)

for(int k=0;k<j-1-i;k++)

if(amp[k].getViews()>amp[k+1].getViews())
 {

Amazonprime aja=amp[k];

amp[k]=amp[k+1];

amp[k+1]=aja;

if(j!=0)

return amp;

else{

return null;

class Amazonprime

int primeId;

String userName;

int subscribedPackage;

String showStreaming;

int views;

public Amazonprime(int primeId, String userName, int subscribedPackage, String showStreaming, int
views) {

[Link] = primeId;
 [Link] = userName;

[Link] = subscribedPackage;

[Link] = showStreaming;

[Link] = views;

public int getPrimeId() {

return primeId;

public void setPrimeId(int primeId) {

[Link] = primeId;

public String getUserName() {

return userName;

public void setUserName(String userName) {

[Link] = userName;

public int getSubscribedPackage() {

return subscribedPackage;

public void setSubscribedPackage(int subscribedPackage) {

[Link] = subscribedPackage;

public String getShowStreaming() {

return showStreaming;
 }

public void setShowStreaming(String showStreaming) {

[Link] = showStreaming;

public int getViews() {

return views;

public void setViews(int views) {

[Link] = views;

Q13:-

import [Link].*;

public class Solution{

public static void main(String[] args){

int playerId;

String skill;

String level;

int points;

Scanner s = new Scanner([Link]);

Player[] player = new Player[4];

for(int i=0; i<[Link]; i++){

playerId = [Link]();[Link]();

skill = [Link]();
 level = [Link]();

points = [Link]();

player[i] = new Player(playerId, skill, level, points);

[Link]();

String getSkill = [Link]();

String getLevel = [Link]();

[Link]();

int getPoints = findPointsForGivenSkill(player, getSkill);

Player p = getPlayerBasedOnLevel(player, getSkill, getLevel);

if(getPoints == 0)

[Link]("The given Skill is not available");

else

[Link](getPoints);

if(p == null)

[Link]("No player is available with specified level, skill and eligibility points");

else

[Link]([Link]());

public static int findPointsForGivenSkill(Player[] players, String skill) {

int count = 0;

for(int i=0; i<[Link]; i++) {

if([Link](players[i].getSkill()))
 count += players[i].getPoints();

return count;

public static Player getPlayerBasedOnLevel(Player[] players, String skill, String level) {

for(int i=0; i<[Link]; i++) {

if([Link](players[i].getSkill()) &&
[Link](players[i].getLevel()) && players[i].getPoints()>=20)

return players[i];

return null;

class Player{

int playerId;

String skill;

String level;

int points;

Player(){}

Player(int playerId, String skill, String level, int points){

[Link] = playerId;

[Link] = skill;

[Link] = level;

[Link] = points;

int getPlayerId() {
 return playerId;

String getSkill() {

return skill;

String getLevel() {

return level;

int getPoints() {

return points;

Q14:-

import [Link].*;

import [Link].*;

import [Link].*;

import [Link].*;

import [Link].*;

public class Solution{

public static void main(String[] args){

int contentId;

String content;

String category;

int likes;
int dislikes;

int shares;

Content[] c = new Content[4];

Scanner s = new Scanner([Link]);

for(int i=0; i<[Link]; i++){

contentId = [Link]();[Link]();

content = [Link]();

category = [Link]();

likes = [Link]();

dislikes = [Link]();

shares = [Link]();

c[i] = new Content(contentId, content, category, likes, dislikes, shares);

[Link]();

String requiredCategory = [Link]();

[Link]();

Content newContent = getMaxSharedContent(c);

String newString = findContentByCategory(c, requiredCategory);

if(newContent == null)

[Link]("No content Shared");

else

[Link]("Maximum shared content:"+[Link]());

if(newString == null)
 [Link]("Content not available for the category");

else

[Link]("Content Details:"+newString);

public static Content getMaxSharedContent(Content[] contentArray){

Content c = null;

int maxShare = 0;

for(int i=0;i<[Link];i++){

if(contentArray[i].getShares() > maxShare){

maxShare = contentArray[i].getShares();

c = contentArray[i];

return c;

public static String findContentByCategory(Content[] contentArray, String category){

String newString;

for(int i=0; i<[Link]; i++){

if([Link](contentArray[i].getCategory()) && contentArray[i].getDislikes() ==

0){

newString =
contentArray[i].getContentId()+"#"+contentArray[i].getContent()+"#"+contentArray[i].getCategory();

return newString;

return null;
 }

class Content{

int contentId;

String content;

String category;

int likes;

int dislikes;

int shares;

Content(){}

Content(int contentId, String content, String category, int likes, int dislikes, int shares){

[Link] = contentId;

[Link] = content;

[Link] = category;

[Link] = likes;

[Link] = dislikes;

[Link] = shares;

int getContentId(){

return contentId;

String getContent(){

return content;

String getCategory(){
 return category;

int getLikes(){

return likes;

int getDislikes(){

return dislikes;

int getShares(){

return shares;

Q15:-

import [Link].*;

public class MyClass {

public static void main(String[] args){

String songName;

int duration;

String artists, language;

double rating;

Scanner s = new Scanner([Link]);

Songs[] songs = new Songs[5];

for(int i=0; i<[Link]; i++){

songName = [Link]();

duration = [Link]();[Link]();
 artists = [Link]();

language = [Link]();

rating = [Link]();[Link]();

songs[i] = new Songs(songName, duration, artists, language, rating);

String newLanguage = [Link]();

String newArtist = [Link]();

[Link]();

String[] newSongs = findSongBasedOnLanguage(songs, newLanguage);

if(newSongs == null)

[Link]("There are no songs with the given language");

else

for(String i: newSongs)

[Link](i);

Songs[] songs1 = findSongBasedOnArtists(songs, newArtist);

if(songs1 == null)

[Link]("There are no songs with the given artists");

else

for(Songs song: songs1)

[Link]([Link]()+"\n"+[Link]());

public static String[] findSongBasedOnLanguage(Songs[] songs, String language){

List<String> newList = new ArrayList<>();

for(Songs song : songs){

if([Link]().equalsIgnoreCase(language))
 [Link]([Link]());

if([Link]() == 0) return null;

[Link](newList, [Link]());

String[] arr = [Link](new String[[Link]()]);

return arr;

public static Songs[] findSongBasedOnArtists(Songs[] songs, String artist){

List<Songs> newList = new ArrayList<>();

for(Songs song : songs){

if([Link]().equalsIgnoreCase(artist))

[Link](song);

if([Link]() == 0) return null;

[Link](newList, new Sort());

Songs[] arr = [Link](new Songs[[Link]()]);

return arr;

class Sort implements Comparator<Songs>{

public int compare(Songs obj1, Songs obj2){

return (int)([Link]() - [Link]());

class Songs{
private String songName;

private int duration;

private String artists;

private String language;

private double rating;

public Songs(String songName, int duration, String artists, String language, double rating){

[Link] = songName;

[Link] = duration;

[Link] = artists;

[Link] = language;

[Link] = rating;

public String getSongName() {

return songName;

public int getDuration() {

return duration;

public String getArtists() {

return artists;

public String getLanguage() {

return language;

public double getRating() {

 return rating;

Q16:-

import [Link].*;

import [Link].*;

public class MyClass {

public static void main(String[] args){

Scanner s = new Scanner([Link]);

Theatre[] theatres = new Theatre[4];

for(int i=0; i< [Link]; i++){

int theatreId = [Link]();[Link]();

String theatreName = [Link]();

int seatCapacity = [Link]();[Link]();

double ticketRate = [Link]();

double theatreRating = [Link]();

boolean balconyAvailable = [Link]();

theatres[i] = new Theatre(theatreId, theatreName, seatCapacity, ticketRate, theatreRating,

balconyAvailable);

int newTheatreId = [Link]();

int newCapacity = [Link]();

[Link]();

String theatreCategory = findTheatreCategory(theatres, newTheatreId);

if(theatreCategory == null)

[Link]("There is no Theatre with the given Theatre ID");

 else

[Link](theatreCategory);

Theatre[] newTheatres = searchTheatreByCategory(theatres, newCapacity);

if(newTheatres == null)

[Link]("Only low capacity theatres available");

else

for(Theatre theatre: newTheatres){

[Link]([Link]());

public static String findTheatreCategory(Theatre[] theatres, int theatreId){

for(Theatre theatre: theatres){

if([Link]() == theatreId) {

if ([Link]() && [Link]() > 4)

return "Ultra Premium";

else if ([Link]() && ([Link]() >= 3 &&

[Link]() < 4))

return "Premium";

else

return "Normal";

return null;

public static Theatre[] searchTheatreByCategory(Theatre[] theatres, int seatCapacity){

 List<Theatre> newList = new ArrayList<Theatre>();

for(Theatre theatre: theatres){

if([Link]() > seatCapacity)

[Link](theatre);

if([Link]() == 0) return null;

[Link](newList, new Sort());

Theatre[] newTheatres = [Link](new Theatre[[Link]()]);

return newTheatres;

class Sort implements Comparator<Theatre>{

public int compare(Theatre obj1, Theatre obj2){

return (int)([Link]() - [Link]());

class Theatre{

private int theatreId;

private String theatreName;

private int seatCapacity;

private double ticketRate;

private double theatreRating;

private boolean balconyAvailable;

public Theatre(int theatreId, String theatreName, int seatCapacity, double ticketRate, double
theatreRating, boolean balconyAvailable){

[Link] = theatreId;
 [Link] = theatreName;

[Link] = seatCapacity;

[Link] = ticketRate;

[Link] = theatreRating;

[Link] = balconyAvailable;

public int getTheatreId() {

return theatreId;

public String getTheatreName() {

return theatreName;

public int getSeatCapacity() {

return seatCapacity;

public double getTicketRate() {

return ticketRate;

public double getTheatreRating() {

return theatreRating;

public boolean isBalconyAvailable() {

return balconyAvailable;

}
Q17:-

import [Link].*;

import [Link].*;

public class MyClass {

public static void main(String[] args){

Scanner s = new Scanner([Link]);

Employee[] employees = new Employee[4];

for(int i=0; i<[Link]; i++){

int employeeId = [Link]();[Link]();

String name = [Link]();

String branch = [Link]();

double rating = [Link]();

boolean companyTransport = [Link]();

employees[i] = new Employee(employeeId, name, branch, rating, companyTransport);

[Link]();

String newBranch = [Link]();

[Link]();

int count = findCountOfEmployeesUsingCompTransport(employees, newBranch);

if(count > 0)

[Link](count);

else

[Link]("No such Employees");

Employee employee = findEmployeeWithSecondHighestRating(employees);

 if(employee == null)

[Link]("All Employees using company transport");

else

[Link]([Link]()+"\n"+[Link]());

public static int findCountOfEmployeesUsingCompTransport(Employee[] employees, String branch){

int count = 0;

for(Employee employee: employees){

if([Link]().equalsIgnoreCase(branch) && [Link]())

count++;

return count;

public static Employee findEmployeeWithSecondHighestRating(Employee[] employees){

List<Employee> newList = new ArrayList<Employee>();

for(Employee employee: employees){

if(![Link]())

[Link](employee);

if([Link]()<2) return null;

[Link](newList, new Sort());

return [Link]([Link]()-2);

class Sort implements Comparator<Employee>{

 public int compare(Employee obj1, Employee obj2){

return (int)([Link]() - [Link]());

class Employee{

private int employeeId;

private String name, branch;

private double rating;

private boolean companyTransport;

public Employee(int employeeId, String name, String branch, double rating, boolean
companyTransport){

[Link] = employeeId;

[Link] = name;

[Link] = branch;

[Link] = rating;

[Link] = companyTransport;

public int getEmployeeId() {

return employeeId;

public String getName(){

return name;

public String getBranch(){

return branch;

}
 public double getRating() {

return rating;

public boolean isCompanyTransport() {

return companyTransport;

Q18:-

import [Link].*;

public class MyClass {

public static void main(String[] args) {

Scanner in = new Scanner([Link]);

Doctor d[]=new Doctor[4];

for(int i=0;i<[Link];i++) {

int id=[Link]();[Link]();

String name = [Link]();

double fee = [Link]();[Link]();

boolean avail=[Link]();[Link]();

String dept = [Link]();

d[i] = new Doctor(id,name,fee,avail,dept);

String dp = [Link]();

double totalFee = findTotalFeeByDepartment(d, dp);

if(totalFee == 0) {

[Link]("Department not found");

 }

else {

[Link](totalFee);

ArrayList<Doctor> list = searchDoctorByAvailability(d);

if(list == null) {

[Link]("No doctor available on sunday");

else {

[Link]( id -> [Link]([Link]()));

public static double findTotalFeeByDepartment(Doctor d[],String dept) {

double total=0;

for(Doctor i : d) {

if([Link]().equalsIgnoreCase(dept)) {

total += [Link]();

if(total == 0) {

return 0;

else {

return total;

}
 }

public static ArrayList<Doctor> searchDoctorByAvailability(Doctor d[]) {

ArrayList<Doctor> list = new ArrayList<Doctor>();

for(Doctor i : d) {

if([Link]()) {

[Link](i);

if([Link]() == 0) {

return null;

else {

Comparator<Doctor> mylist = [Link](Doctor :: getId);

[Link](list,mylist);

return list;

class Doctor{

private int id;

private String name;

private double fee;

boolean available;

private String dept;

public Doctor(int id, String name, double fee, boolean available, String dept) {
 [Link] = id;

[Link] = name;

[Link] = fee;

[Link] = available;

[Link] = dept;

public int getId() {

return id;

public String getName() {

return name;

public double getFee() {

return fee;

public boolean isAvailable() {

return available;

public String getDept() {

return dept;

Q19:-

import [Link].*;

class MyClass
{

public static void main(String args[])

Scanner sc=new Scanner([Link]);

int invoicenumber;

String fromcity;

String tocity;

String orderdate;

String deliverydate;

double price;

Package p[]=new Package[5];

for(int i=0;i<[Link];i++)

invoicenumber=[Link]();

[Link]();

fromcity=[Link]();

tocity=[Link]();

orderdate=[Link]();

deliverydate=[Link]();

price=[Link]();

p[i]=new Package(invoicenumber,fromcity,tocity,orderdate,deliverydate,price);

[Link]();

String c1=[Link]();

String c2=[Link]();
 [Link]();

int count=countOrdersDeliveredInAWeek(p,c1);

if(count!=0)

[Link](count);

else

[Link]("No package delivered");

Package pck=searchPackageByCity(p,c2);

if(pck!=null)

[Link]([Link]());

[Link]([Link]());

else

[Link]("No package found");

public static int countOrdersDeliveredInAWeek(Package p[], String c1)

int count=0;

for(Package i:p)

if([Link]([Link]()))

String od=[Link]().substring(0,2);

String dd=[Link]().substring(0,2);
 int od1=[Link](od);

int dd1=[Link](dd);

if(dd1-od1<7)

count++;

return count;

public static Package searchPackageByCity(Package p[], String c2)

ArrayList<Double> ar=new ArrayList<>();

Package pck=new Package();

for(Package i:p)

if([Link]([Link]()))

[Link]([Link]());

if([Link]()!=0)

[Link](ar,[Link]());

double pr=[Link](1);

for(Package i:p)
 {

if(pr==[Link]())

pck=i;

return pck;

return null;

class Package

private int invoicenumber;

private String fromcity,tocity,orderdate,deliverydate;

private double price;

Package()

Package(int invoicenumber, String fromcity, String tocity, String orderdate, String deliverydate, double
price)

[Link]=invoicenumber;

[Link]=fromcity;

[Link]=tocity;

[Link]=orderdate;
 [Link]=deliverydate;

[Link]=price;

public int getinvoice()

return invoicenumber;

public String getfromcity()

return fromcity;

public String gettocity()

return tocity;

public String getorderdate()

return orderdate;

public String getdeliverydate()

return deliverydate;

public double getprice()

{
 return price;

import [Link].*;

import [Link].*;

public class MyClass{

public static void main(String[] args){

int guestId;

String guestName;

String dateOfBooking;

int noOfRoomsBooked;

String mealOption;

double totalBill;

Scanner s = new Scanner([Link]);

ResortGuest[] resortGuests = new ResortGuest[4];

for(int i=0; i<[Link]; i++){

guestId = [Link]();[Link]();

guestName = [Link]();

dateOfBooking = [Link]();

noOfRoomsBooked = [Link]();[Link]();

mealOption = [Link]();

totalBill = [Link]();

resortGuests[i] = new ResortGuest(guestId, guestName, dateOfBooking, noOfRoomsBooked,

mealOption, totalBill);

[Link]();
 String month = [Link]();

String mealOpted = [Link]();

[Link]();

int roomsBooked = findNumberOfRoomsBookedInMonth(resortGuests, month);

if(roomsBooked == 0)

[Link]("No rooms booked");

else

[Link](roomsBooked);

ResortGuest resortGuest = searchResortGuestByMealOpted(resortGuests, mealOpted);

if(resortGuest == null)

[Link]("No such meal");

else

[Link]([Link]());

public static int findNumberOfRoomsBookedInMonth(ResortGuest[] resortGuests, String month){

int countOfRoomsBooked = 0;

for(ResortGuest resortGuest: resortGuests){

String tempMonth = [Link]().substring(3,6);

if([Link](month))

countOfRoomsBooked++;

return countOfRoomsBooked;

}
 public static ResortGuest searchResortGuestByMealOpted(ResortGuest[] resortGuests, String
mealOpted){

List<ResortGuest> tempList = new ArrayList<ResortGuest>();

for(ResortGuest resortGuest: resortGuests){

if([Link]().equalsIgnoreCase(mealOpted)){

[Link](resortGuest);

if([Link]() == 0) return null;

[Link](tempList, new Comparison());

return [Link]([Link]()-2);

class Comparison implements Comparator<ResortGuest>{

public int compare(ResortGuest obj1, ResortGuest obj2){

return (int)([Link]() - [Link]());

class ResortGuest{

private int guestId;

private String guestName;

private String dateOfBooking;

private int noOfRoomsBooked;

private String mealOption;

private double totalBill;

 public ResortGuest(int guestId, String guestName, String dateOfBooking, int noOfRoomsBooked,
String mealOption, double totalBill){

[Link] = guestId;

[Link] = guestName;

[Link] = dateOfBooking;

[Link] = noOfRoomsBooked;

[Link] = mealOption;

[Link] = totalBill;

public int getGuestId(){

return guestId;

public String getGuestName(){

return guestName;

public String getDateOfBooking(){

return dateOfBooking;

public int getNoOfRoomsBooked(){

return noOfRoomsBooked;

public String getMealOption(){

return mealOption;

public double getTotalBill(){

return totalBill;
 }

Q20:-

import [Link].*;

import [Link].*;

public class MyClass{

public static void main(String[] args){

int voterId;

String voterName;

int voterAge;

boolean isVoteCasted;

String constituency;

Scanner scanner = new Scanner([Link]);

Vote[] votes = new Vote[4];

for(int i=0; i<[Link]; i++){

voterId = [Link]();[Link]();

voterName = [Link]();

voterAge = [Link]();

isVoteCasted = [Link]();[Link]();

constituency = [Link]();

votes[i] = new Vote(voterId, voterName, voterAge, isVoteCasted, constituency);

String checkConstituency = [Link]();

[Link]();
 int totalVotesCasted = findTotalVotesCastedByConstituency(votes, checkConstituency);

if(totalVotesCasted == 0)

[Link]("No votes casted");

else

[Link](totalVotesCasted);

int[] voterAgeArray = searchVoterByAge(votes);

if(voterAgeArray == null)

[Link]("No such voters");

else

for(int voter: voterAgeArray)

[Link](voter);

public static int findTotalVotesCastedByConstituency(Vote[] votes, String constituency){

int totalVotesCasted = 0;

for(Vote vote: votes){

if([Link]([Link]())){

if([Link]())

totalVotesCasted++;

return totalVotesCasted;

public static int[] searchVoterByAge(Vote[] votes){

ArrayList<Integer> arrayOfVoterIdList = new ArrayList<Integer>();

for(Vote vote: votes){

 if([Link]() < 30){

[Link]([Link]());

if([Link]() == 0) return null;

[Link](arrayOfVoterIdList);

int[] array = [Link]().mapToInt(i -> i).toArray();

return array;

class Vote{

private int voterId;

private String voterName;

private int voterAge;

private boolean isVoteCasted;

private String constituency;

public Vote(int voterId, String voterName, int voterAge, boolean isVoteCasted, String constituency){

[Link] = voterId;

[Link] = voterName;

[Link] = voterAge;

[Link] = isVoteCasted;

[Link] = constituency;

public int getVoterId(){

 return voterId;

public String getVoterName(){

return voterName;

public int getVoterAge(){

return voterAge;

public boolean getIsVoteCasted(){

return isVoteCasted;

public String getConstituency(){

return constituency;

Q21:-

import [Link].*;

public class MyClass{

public static void main(String[] args){

int applianceId;

String applianceName;

String applianceCategory;

double applianceAmount;

boolean insurance;
 Appliance[] appliances = new Appliance[4];

Scanner s = new Scanner([Link]);

for(int i=0;i<[Link];i++){

applianceId = [Link]();[Link]();

applianceName = [Link]();

applianceCategory = [Link]();

applianceAmount = [Link]();

appliances[i] = new Appliance(applianceId, applianceName, applianceCategory,

applianceAmount);

[Link]();

int applianceId1 = [Link]();

boolean insurance1 = [Link]();[Link]();

String applianceCategory1 = [Link]();

double applianceAmount1 = getApplianceAmount(appliances, applianceId1, insurance1);

[Link](applianceAmount1);

Appliance appl = getCostliestAppliance(appliances, applianceCategory1);

[Link]("Appliance Id: "+[Link]()+" Appliance Name:

"+[Link]()+" Total Amount: "+[Link]());

public static double getApplianceAmount(Appliance[] appliances, int applianceId, boolean insurance){

double newApplianceAmount = 0;
 for(int i=0;i<[Link];i++){

if(appliances[i].getApplianceId() == applianceId){

if(insurance == true){

newApplianceAmount = appliances[i].getApplianceAmount() +
((appliances[i].getApplianceAmount() * 20)/100);

appliances[i].setApplianceAmount(newApplianceAmount);

return newApplianceAmount;

public static Appliance getCostliestAppliance(Appliance[] appliances, String applianceCategory){

double maxCost = -999;

Appliance appliances1 = null;

for(int i=0;i<[Link];i++){

if([Link](appliances[i].getApplianceCategory())){

if(appliances[i].getApplianceAmount() > maxCost){

maxCost = appliances[i].getApplianceAmount();

appliances1 = appliances[i];

return appliances1;

}
class Appliance{

private int applianceId;

private String applianceName;

private String applianceCategory;

private double applianceAmount;

public Appliance(int applianceId, String applianceName, String applianceCategory, double

applianceAmount){

[Link] = applianceId;

[Link] = applianceName;

[Link] = applianceCategory;

[Link] = applianceAmount;

public int getApplianceId(){

return applianceId;

public String getApplianceCategory(){

return applianceCategory;

public String getApplianceName(){

return applianceName;

public void setApplianceAmount(double applianceAmount){

[Link] = applianceAmount;

public double getApplianceAmount(){

 return applianceAmount;

Q22:-

import [Link]; //importing scanner to read data from keyboard

public class Solution{ //this program is executed in Onlinegdb, so class name is Main

public static void main(String[] args){

Scanner s = new Scanner([Link]); //creating scanner object for reading data

int regNo;

String agencyName;

String packageType;

int price;

boolean flightFacility; //variable names given in question

TravelAgencies[] ta = new TravelAgencies[4]; //creating array of objects

for(int i=0;i<4;i++){ //reading values from keyboard for each variable

regNo = [Link]();[Link]();

agencyName = [Link]();

packageType = [Link]();

price = [Link]();

flightFacility = [Link]();

ta[i] = new TravelAgencies(regNo, agencyName, packageType, price, flightFacility); //assigning

values for each object

}
 int getRegNo = [Link]();[Link](); //constraint 1 from question

String getPackageType = [Link](); //constraint 2 from question

[Link](); //closing scanner object

int highestPackagePrice = findAgencyWithHighestPackagePrice(ta);

TravelAgencies travelAgencies = agencyDetailsForGivenIdAndType(ta, getRegNo, getPackageType);

//calling static methods from main function

[Link](highestPackagePrice); //printing highest price

if(travelAgencies == null)

[Link]("A string value should be printed here!");

else

[Link]([Link]()+"\n"+[Link]());

//printing agencyName and price with required constraints from question

public static int findAgencyWithHighestPackagePrice(TravelAgencies[] agencies){

int maxPrice = agencies[0].getPrice(); //taking object1 price value as max

for(int i=1;i<[Link];i++){

if(agencies[i].getPrice() > maxPrice)

maxPrice = agencies[i].getPrice(); //comparing all prices to get maximum

return maxPrice; // returning maximum price from all objects

public static TravelAgencies agencyDetailsForGivenIdAndType(TravelAgencies[] agencies, int regNo,

String packageType){
 TravelAgencies ta = new TravelAgencies(); //creating an object

for(int i=0;i<[Link];i++){

if(agencies[i].getFlightFacility()){ //condition 1 checking

if(agencies[i].getRegNo()==regNo &&
[Link](agencies[i].getPackageType())){ //condition 2 checking

ta = agencies[i]; //if 2 conditions satisfy, assigning object

return ta; //returning required object to main function

return null; //if no conditions satisfy, null value is returned

class TravelAgencies{

int regNo;

String agencyName;

String packageType;

int price;

boolean flightFacility;

TravelAgencies(){} //empty constuctor

TravelAgencies(int regNo, String agencyName, String packageType, int price, boolean flightFacility){
//parameterized constructor

super();

[Link] = regNo;

[Link] = agencyName;
 [Link] = packageType;

[Link] = price;

[Link] = flightFacility;

int getRegNo(){ //getter for regNo

return regNo;

String getAgencyName(){ //getter for agencyName

return agencyName;

String getPackageType(){ //getter for packageType

return packageType;

int getPrice(){ //getter for price

return price;

boolean getFlightFacility(){ //getter for flightFacility

return flightFacility;

Q23:- import [Link];

class Item{

int itemId;

String itemName;
 String itemType;

double itemPrice;

Item(int itemId, String itemName, String itemType, double itemPrice){

[Link] = itemId;

[Link] = itemName;

[Link] = itemType;

[Link] = itemPrice;

int getItemId(){

return itemId;

String getItemName(){

return itemName;

String getItemType(){

return itemType;

double getItemPrice(){

return itemPrice;

public class Solution1{

public static void main(String[] args){

int itemId;
String itemName;

String itemType;

double itemPrice;

Item[] item = new Item[4];

Scanner s = new Scanner([Link]);

for(int i=0;i<[Link];i++){

itemId = [Link]();[Link]();

itemName = [Link]();

itemType = [Link]();

itemPrice = [Link]();

item[i] = new Item(itemId, itemName, itemType, itemPrice);

[Link]();

String newItemType = [Link]();

String newItemName = [Link]();

[Link]();

int avgItemPrice = findAvgItemPriceByTypes(item, newItemType);

Item[] items = searchItemByName(item, newItemName);

if(avgItemPrice > 0)

[Link](avgItemPrice);

else

[Link]("There are no items with given type");

 if(items == null)

[Link]("There are no items with the given name");

else{

for(int i=0;i<[Link];i++){

[Link](items[i].getItemId());

public static int findAvgItemPriceByTypes(Item[] item, String itemType){

int avgPrice = 0, count = 0;

double sum = 0;

for(int i=0;i<[Link];i++){

if([Link](item[i].getItemType())) {

sum += item[i].getItemPrice();

count++;

avgPrice = (int)(sum/count);

return avgPrice;

public static Item[] searchItemByName(Item[] item, String itemName){

int count = 0;

for(int i=0;i<[Link];i++){

if([Link](item[i].getItemName()))

count++;
 }

if(count == 0) return null;

Item[] items = new Item[count];

count = 0;

for(int i=0;i<[Link];i++){

if([Link](item[i].getItemName())){

items[count++] = item[i];

for(int i=0;i<[Link];i++){

for(int j=i+1;j<[Link];j++){

if(items[i].getItemId() >= items[j].getItemId()){

Item temp = items[i];

items[i] = items[j];

items[j] = temp;

return items;

Q24:-

import [Link].*;

import [Link].*;

import [Link].*;
import [Link].*;

import [Link].*;

public class Solution

public static void main(String[] args)

//code to read values

//code to call required method

//code to display the result

int songId;

String title;

String artist;

int rating;

Scanner s = new Scanner([Link]);

Song[] song = new Song[5];

for(int i=0;i<5;i++){

songId = [Link]();[Link]();

title = [Link]();

artist = [Link]();

rating = [Link]();

song[i] = new Song(songId, title, artist, rating);

[Link]();
 String artist1 = [Link]();

String artist2 = [Link]();

[Link]();

int findAvg = findAvgRatingForArtist(song, artist1);

Song[] newSong = searchSongByArtist(artist2, song);

if(findAvg == 0)

[Link]("There are no songs with the given artist");

else

[Link](findAvg);

if(newSong == null)

[Link]("There are no songs available for the given artist");

else{

for(int i=0;i<[Link];i++){

[Link](newSong[i].getSongId());

public static int findAvgRatingForArtist(Song[] song, String artist)

//method logic
 int avgRating = 0, count = 0;

for(int i=0;i<[Link];i++){

if([Link](song[i].getArtist())){

avgRating += song[i].getRating();

count++;

if(avgRating > 0) return avgRating/count;

else return avgRating;

public static Song[] searchSongByArtist(String artist, Song[] song)

//method logic

int count = 0;

for(int i=0;i<[Link];i++){

if([Link](song[i].getArtist()))

count++;

if(count == 0)

return null;

Song[] s = new Song[count];

count = 0;

for(int i=0;i<[Link];i++){

if([Link](song[i].getArtist())){
 s[count++] = song[i];

for(int i=0;i<[Link];i++){

for(int j=i+1;j<[Link];j++){

if(s[i].getSongId()<=s[j].getSongId()){

Song temp = s[i];

s[i] = s[j];

s[j] = temp;

return s;

class Song

//code to build the class

int songId;

String title;

String artist;

int rating;

Song(int songId, String title, String artist, int rating){

[Link] = songId;
 [Link] = title;

[Link] = artist;

[Link] = rating;

int getSongId(){

return songId;

String getTitle(){

return title;

String getArtist(){

return artist;

int getRating(){

return rating;

Q25:-

import [Link].*;

import [Link].*;

import [Link].*;

import [Link].*;

import [Link].*;

public class Solution

{

public static void main(String[] args)

//code to read values

int playerId;

String playerName;

int score1, score2, score3;

Player[] players = new Player[4];

Scanner s = new Scanner([Link]);

for(int i=0; i<4;i++){

playerId = [Link]();[Link]();

playerName = [Link]();

score1 = [Link]();

score2 = [Link]();

score3 = [Link]();

players[i] = new Player(playerId, playerName, score1, score2, score3);

//code to call required method

int maxScore = findTotalHundredsCount(players);

Player player = getTopPlayer(players);

//code to display the result

if(maxScore != 0)

[Link](maxScore);

else
 [Link]("No Hundreds Scored in Tournament");

[Link]([Link]()+"#"+[Link]());

public static int findTotalHundredsCount(Player[] players)

//method logic

int count = 0;

for(int i=0; i<[Link]; i++){

if(players[i].getScore1()>=100)count++;

if(players[i].getScore2()>=100)count++;

if(players[i].getScore3()>=100)count++;

return count;

public static Player getTopPlayer(Player[] players)

//method logic

Player player = new Player();

int maxScore = players[0].getScore1()+players[0].getScore2()+players[0].getScore3();

player = players[0];

for(int i=1;i<[Link];i++){

int newScore = players[i].getScore1()+players[i].getScore2()+players[i].getScore3();

if(newScore>=maxScore){
 maxScore = newScore;

player = players[i];

return player;

class Player

//code to build the class

int playerId;

String playerName;

int score1, score2, score3;

Player(){}

Player(int playerId, String playerName, int score1, int score2, int score3){

[Link] = playerId;

[Link] = playerName;

this.score1 = score1;

this.score2 = score2;

this.score3 = score3;

int getPlayerId(){

return playerId;

}
 String getPlayerName(){

return playerName;

int getScore1(){

return score1;

int getScore2(){

return score2;

int getScore3(){

return score3;

Q26:-

import [Link].*;

import [Link].*;

import [Link].*;

import [Link].*;

import [Link].*;

public class Main{

public static void main(String[] args){

//Creating variables

String iMEICode; //iMEICode is of String type

boolean isSingleSIM; //isSingleSIM is of Boolean type

String processor; //processor is of String type

double price; //price is of double type

String manufacturer; //manufacturer is of String type

//creating a scanner 's' object to read values from the keyboard and the syntax is shown below

Scanner s = new Scanner([Link]);

//creating array of Mobile Class objects by using the below statement

Mobile[] mobile = new Mobile[5];

//reading each variable for each object using a for loop

for(int i=0; i<5; i++){

//reading iMEICode from keyboard using nextLine()

iMEICode = [Link]();

//reading isSingleSIM using nextBoolean()

isSingleSIM = [Link]();[Link]();

//here we need to use one more [Link]() statement inorder to read string correctly

//reading processor using nextLine()

processor = [Link]();

// reading price using nextDouble()

price = [Link]();[Link]();

//reading manufacturer using nextLine()

manufacturer = [Link]();

//assigning all variables to each object 'm'

mobile[i] = new Mobile(iMEICode, isSingleSIM, processor, price, manufacturer);

 }

//reading discountPercentage

double discountPercentage = [Link]();[Link]();

//reading manufacturerName

String manufacturerName = [Link]();

//Calling function getCountOfValidIMEIMobiles

int countOfValidIMEIMobiles = getCountOfValidIMEIMobiles(mobile);

//Calling function findMobileWithMaxPrice

Mobile result = findMobileWithMaxPrice(mobile, discountPercentage, manufacturerName);

//Printing results on the screen using [Link]()

[Link](countOfValidIMEIMobiles);

if(result == null) //checking whether result object is null or not

[Link]("No Mobile Found");

else

[Link]([Link]()+"@"+[Link]());

public static int getCountOfValidIMEIMobiles(Mobile[] listOfMobiles){

//count variable to count number of Mobiles which have 15 digit IMEI code

int count = 0;

for(int i=0; i<[Link]; i++){

//checking IMEI code length and Single SIM status

if(listOfMobiles[i].getIMEICode().length() == 15 && listOfMobiles[i].getIsSingleSIM() == true)

 count++; //If above condition true, then count increments

return count; //returning count of valid sims to main method

public static Mobile findMobileWithMaxPrice(Mobile[] listOfMobiles, double discountPercentage,

String manufacturerName){

//creating a mobile object

Mobile mobile = new Mobile();

//Creating newPrice variable to get newPrice after applying discountPercentage

double newPrice;

for(int i=0;i<[Link];i++){

//checking manufacturerName variable with manufacturer in all objects by ignoring case

if([Link](listOfMobiles[i].getManufacturer())){

//formula for newPrice from the question

newPrice = listOfMobiles[i].getPrice() - ((listOfMobiles[i].getPrice()*discountPercentage)/100);

//setting newPrice for the mobile object which matches with manufacturer

listOfMobiles[i].setPrice(newPrice);

//assigning that object to 'mobile' object

mobile = listOfMobiles[i];

return mobile; //returning mobile object to main function

return null;

}
class Mobile{

String iMEICode;

boolean isSingleSIM;

String processor;

double price;

String manufacturer;

//creating an empty constructor because we are creating an object in findMobileWithMaxPrice

function

Mobile(){}

//creating parameterized constructor

Mobile(String iMEICode, boolean isSingleSIM, String processor, double price, String manufacturer){

//if we have same variable names, we should use this keyword to store valules

[Link] = iMEICode;

[Link] = isSingleSIM;

[Link] = processor;

[Link] = price;

[Link] = manufacturer;

//creating getters and setters

String getIMEICode(){

return iMEICode;

boolean getIsSingleSIM(){

return isSingleSIM;

}
 String getProcessor(){

return processor;

void setPrice(double price){ //we need a setter to assign new price to object

[Link] = price;

double getPrice(){

return price;

String getManufacturer(){

return manufacturer;

Q27:-

import [Link].*;

import [Link].*;

import [Link].*;

import [Link].*;

import [Link].*;

public class Solution

public static void main(String[] args)

{
//code to read values

Scanner s = new Scanner([Link]);

int vesselId, noOfVoyagesPlanned, noOfVoyagesCompleted;

String vesselName, purpose;

NavalVessel[] nv = new NavalVessel[4]; //creating array of objects

for(int i=0;i<[Link];i++){

vesselId = [Link]();[Link]();

vesselName = [Link]();

noOfVoyagesPlanned = [Link]();

noOfVoyagesCompleted = [Link]();[Link]();

purpose = [Link]();

nv[i] = new NavalVessel(vesselId, vesselName, noOfVoyagesPlanned, noOfVoyagesCompleted,

purpose); //assigning the values to each object

int getPercentageValue = [Link]();[Link]();

String getPurposeValue = [Link]();

//code to call required method

int avgOfVoyagesCompleted = findAvgVoyagesByPct(nv, getPercentageValue);

if(avgOfVoyagesCompleted>0)

[Link](avgOfVoyagesCompleted);

else

[Link]("There are no voyages completed with this percentage");

//code to display the result

NavalVessel navalvessel = findVesselByGrade(nv, getPurposeValue);

 if(navalvessel == null)

[Link]("No Naval Vessel is available with the specified purpose");

else

[Link]([Link]()+"%"+[Link]());

public static int findAvgVoyagesByPct(NavalVessel[] nvArray, int percentage)

//method logic

int avg = 0,count=0;

for(int i=0;i<[Link];i++){

int percent = (nvArray[i].getNoOfVoyagesCompleted()*100)/nvArray[i].getNoOfVoyagesPlanned();

if(percent >= percentage){

avg += nvArray[i].getNoOfVoyagesCompleted();

count++;

if(avg == 0)

return 0;

else

return avg/count;

public static NavalVessel findVesselByGrade(NavalVessel[] nvArray, String purpose)

{
 //method logic

NavalVessel nv = new NavalVessel();

for(int i=0;i<[Link];i++){

if([Link](nvArray[i].getPurpose())){

int percentage =
(nvArray[i].getNoOfVoyagesCompleted()*100)/nvArray[i].getNoOfVoyagesPlanned(); //finding
percentage

if(percentage==100) nvArray[i].setClassification("Star");

else if(percentage >=80 && percentage <=99) nvArray[i].setClassification("Leader");

else if(percentage >=55 && percentage <=79) nvArray[i].setClassification("Inspirer");

else

nvArray[i].setClassification("Striver");

nv = nvArray[i];

return nv;

return null;

class NavalVessel

//code to build the class

int vesselId, noOfVoyagesPlanned, noOfVoyagesCompleted;

String vesselName, purpose, classification;

NavalVessel(){}
 NavalVessel(int vesselId, String vesselName, int noOfVoyagesPlanned, int noOfVoyagesCompleted,
String purpose){

super();

[Link] = vesselId;

[Link] = vesselName;

[Link] = noOfVoyagesPlanned;

[Link] = noOfVoyagesCompleted;

[Link] = purpose;

int getVesselId(){

return vesselId;

String getVesselName(){

return vesselName;

int getNoOfVoyagesPlanned(){

return noOfVoyagesPlanned;

int getNoOfVoyagesCompleted(){

return noOfVoyagesCompleted;

String getPurpose(){

return purpose;

void setClassification(String classification){

[Link] = classification;
 }

String getClassification(){

return classification;

Q28:-

import [Link].*;

class Main{

public static void main(String[] args){

Scanner s = new Scanner([Link]);

int movieId, rating, budget;

String director;

Movie[] movies = new Movie[4]; //creating array of movie objects

for(int i=0;i<4;i++){

movieId = [Link]();[Link]();

director = [Link]();

rating = [Link]();

budget = [Link]();

movies[i] = new Movie(movieId, director, rating, budget);

[Link]();

String findDirector = [Link]();

int findRating = [Link]();

int findBudget = [Link]();

int findAvg = findAvgBudgetByDirector(movies, findDirector); //calling method

 if(findAvg > 0){

[Link](findAvg);

else

[Link]("Sorry - The given director has not directed any movie yet");

Movie m = getMovieByRatingBudget(movies, findRating, findBudget); //calling method

if(m == null)

[Link]("Sorry - No movie available at specified rating and budget requirement");

else

[Link]([Link]());

public static int findAvgBudgetByDirector(Movie[] movies, String director){

int sum = 0,count=0;

for(int i=0;i<4;i++){

if([Link](movies[i].getDirector())){ //if required director matches with existing

directors in the array of objects

count++;

sum += movies[i].getBudget(); //adding the movie budgets

if(sum>0)

return sum/count; //returing the average movie budget

else

return 0;

public static Movie getMovieByRatingBudget(Movie[] movies, int rating, int budget){

 Movie m = new Movie();

for(int i=0;i<4;i++){

if(movies[i].getRating()==rating && movies[i].getBudget()==budget){ //if rating and budget

matches, then we need to return that object to main method.

if(movies[i].getBudget()%movies[i].getRating() == 0){

m = movies[i];

return m;

return null;

class Movie{

int movieId,rating,budget;

String director;

Movie(){}

Movie(int movieId, String director, int rating, int budget){

super();

[Link] = movieId;

[Link] = director;

[Link] = rating;

[Link] = budget;

int getMovieId(){
 return movieId;

String getDirector(){

return director;

int getRating(){

return rating;

int getBudget(){

return budget;