Java codes

11 2025 16:56

• IPA9
• Count vowels, consonants, digits public class Solution {

• Armstrong number import [Link].*; public static void main(String[] args) {

Scanner sc = new Scanner([Link]);
import [Link].*; public class CountVowel { Student[] students = new Student[4];
public static void main(String[] args) {
public class Armstrong { Scanner sc = new Scanner([Link]); for (int i = 0; i < 4; i++) {
public static void main(String[] args) { String s = [Link](); int rollNo = [Link]([Link]());
Scanner sc = new Scanner([Link]); int v =0; String name = [Link]();
[Link]("Input number: "); int c=0; String subject = [Link]();
String numStr = [Link](); int num=0; char grade = [Link]().charAt(0);
int num = [Link](numStr); for(int i=0; i<[Link](); i++) String date = [Link]();
int digits = [Link](); {
if([Link]([Link](i))) students[i] = new Student(rollNo, name, subject, grade, date);
int sum = 0; { }
for (int i = 0; i < digits; i++) {
int digit = [Link](i) - '0'; if([Link](i)=='A'||[Link](i)=='a'||[Link](i)=='E'||[Link](i)=='e'||[Link](i)=='I'||[Link](i)=='i'||[Link](i) char searchGrade = [Link]().charAt(0);
sum += [Link](digit, digits); =='O'||[Link](i)=='o'||[Link](i)=='U'||[Link](i)=='u') int searchMonth = [Link]([Link]());
} {
v++; Student[] result = findStudentByGradeAndMonth(students, searchGrade, searchMonth);
if (sum == num) { }
[Link]("Yes, the number is an Armstrong number."); else if (result != null) {
} else { { for (Student s : result) {
[Link]("No, the number is not an Armstrong number."); c++; [Link]([Link]());
} } [Link]([Link]());
} }
[Link](); else if([Link]([Link](i))) [Link]([Link]);
} { } else {
} num++; [Link]("No student found");
} }
} }
• Calculator [Link]("Vowel : "+v);
import [Link]; [Link]("Consonant : "+c); public static Student[] findStudentByGradeAndMonth(Student[] students, char grade, int month) {
[Link]("Number : "+num); List<Student> matched = new ArrayList<>();
public class SimpleCalculator { }
public static void main(String[] args) { String monthStr = (month < 10) ? "0" + month : [Link](month);
Scanner sc = new Scanner([Link]); }
for (Student s : students) {
try { • Count words if ([Link]() == grade) {
// Input numbers String[] parts = [Link]().split("/");
[Link]("Enter the first number: "); import [Link].*; if ([Link] >= 2 && parts[1].equals(monthStr)) {
double num1 = [Link]([Link]()); public class Count_Word [Link](s);
{ }
[Link]("Enter the second number: "); public static void main(String[] args) }
double num2 = [Link]([Link]()); { }
Scanner sc = new Scanner([Link]);
// Input operator String s = [Link](); if ([Link]() == 0) {
[Link]("Enter an operator (+, -, *, /): "); String[] arr = [Link](" "); return null;
String operator = [Link](); int count=0; }
//[Link]([Link](arr));
double result; for (int i = 0; i < [Link]; i++) { [Link]([Link](Student::getRollNo));
if(arr[i]!="") return [Link](new Student[0]);
switch (operator) { { }
case "+": count++; }
result = num1 + num2; }
[Link]("Result: " + result); } • IPA10
break; [Link]("Number of word : "+count);
case "-": }
result = num1 - num2; } public class MyClass {
[Link]("Result: " + result); public static void main(String[] args) {
break; Scanner sc = new Scanner([Link]);
case "*": • Count words which are start with vowel Antenna[] antennas = new Antenna[4];
result = num1 * num2; import [Link].*;
[Link]("Result: " + result); public class Count_Word_Vowel { for (int i = 0; i < [Link]; i++) {
break; public static void main(String[] args) int id = [Link]([Link]());
case "/": { String name = [Link]();
if (num2 == 0) { Scanner sc = new Scanner([Link]); String lead = [Link]();
[Link]("Error: Division by zero is not allowed."); String s = [Link]().toLowerCase(); double vswr = [Link]([Link]());
} else { String[] arr = [Link](" "); antennas[i] = new Antenna(id, name, lead, vswr);
result = num1 / num2; int count=0; }
[Link]("Result: " + result); for (int i = 0; i < [Link]; i++) {
} char d = arr[i].charAt(0); String searchName = [Link]();
break; if(d=='a' || d=='e' || d=='i' || d=='o' || d=='u') double maxVswr = [Link]([Link]());
default: {
[Link]("Error: Invalid operator. Please use +, -, *, or /."); count++; // Method 1: Search by name
} } int foundId = searchAntennaByName(antennas, searchName);
} catch (NumberFormatException e) { } if (foundId != 0) {
[Link]("Error: Please enter valid numeric values."); if(count>0) [Link](foundId);
} { } else {
[Link](count); [Link]("There is no antenna with given parameter");
[Link](); } }
} else
} { // Method 2: Sort by VSWR
[Link]("No such words"); Antenna[] sortedAntennas = sortAntennaByVSWR(antennas, maxVswr);
} if (sortedAntennas != null && [Link] > 0) {
• Lexicographical numbers } for (Antenna a : sortedAntennas) {
import [Link].*; } [Link]([Link]());
}
Public class Solution { } else {
• Print Fibonacci series [Link]("No Antenna found");
private void solve(int curr, int n, List<Integer> result) { }
if (curr > n) { import [Link].*;
return; public class Fibonacci [Link]();
} { }
public static void main(String[] args) {
[Link](curr); Scanner sc = new Scanner([Link]); public static int searchAntennaByName(Antenna[] antennas, String name) {
int n = [Link](); for (Antenna a : antennas) {
for (int nextDigit = 0; nextDigit <= 9; nextDigit++) { int i = 0; if ([Link]().equalsIgnoreCase(name)) {
int nextNum = curr * 10 + nextDigit; int k = 1; return [Link]();
[Link](i+" "); }
if (nextNum > n) { while(k<n) }
return; { return 0;
} [Link](k+" "); }
int p = k;
solve(nextNum, n, result); k = k+i; public static Antenna[] sortAntennaByVSWR(Antenna[] antennas, double vswr) {
} i = p; List<Antenna> result = new ArrayList<>();
} } for (Antenna a : antennas) {
} if ([Link]() < vswr) {
public List<Integer> lexicalOrder(int n) { } [Link](a);
List<Integer> result = new ArrayList<>(); }
}
for (int num = 1; num <= 9; num++) { • Foot ware problem
solve(num, n, result); if ([Link]()) {
} public class Solution { return null;
public static int getCountByType(Footwear[] arr, String type) { }
return result; int count = 0;
} for (Footwear fw : arr) { [Link]([Link](Antenna::getAntennaVSWR));
if ([Link]().equalsIgnoreCase(type)) { return [Link](new Antenna[0]);
public static void main(String[] args) { count++; }
Scanner sc = new Scanner([Link]); } }
int n = [Link](); }
Solution sol = new Solution(); return count;
List<Integer> result = [Link](n); } • IPA11
for (int num : result) {
[Link](num + " "); public static Footwear getSecondHighestPriceByBrand(Footwear[] arr, String brand) {
} int firstMax = Integer.MIN_VALUE; public class MyClass {
} int secondMax = Integer.MIN_VALUE; public static void main(String[] args) {
} Footwear secondHighest = null; Scanner sc = new Scanner([Link]);
Flowers[] flowers = new Flowers[4];
• Character repeat for (Footwear fw : arr) {
if ([Link]().equalsIgnoreCase(brand)) { for (int i = 0; i < 4; i++) {
import [Link].*; int price = [Link](); int id = [Link]([Link]());
if (price > firstMax) { String name = [Link]();
public class CharRepeat { secondMax = firstMax; int price = [Link]([Link]());
public static void main(String[] args) { firstMax = price; int rating = [Link]([Link]());
Scanner sc = new Scanner([Link]); } else if (price > secondMax && price < firstMax) { String type = [Link]();
String s = [Link](); secondMax = price; flowers[i] = new Flowers(id, name, price, rating, type);
} }
StringBuilder result = new StringBuilder(); }
int i = 0; } String searchType = [Link]();
int n = [Link](); Flowers result = findMinPriceByType(flowers, searchType);
if (secondMax == Integer.MIN_VALUE) return null;
while (i < n) { if (result != null) {
char currentChar = [Link](i); for (Footwear fw : arr) { [Link]([Link]());
int count = 1; if ([Link]().equalsIgnoreCase(brand) && [Link]() == secondMax) { } else {
return fw; [Link]("There is no flower with given type.");
while (i + 1 < n && [Link](i + 1) == currentChar) { } }
count++; } }
i++;
} return null; public static Flowers findMinPriceByType(Flowers[] flowers, String type) {
} Flowers minFlower = null;
[Link](currentChar).append(count); } for (Flowers f : flowers) {
i++; if ([Link]().equalsIgnoreCase(type) && [Link]() > 3) {
} • Engine problem if (minFlower == null || [Link]() < [Link]()) {
minFlower = f;
[Link]([Link]()); public static double findAvgEnginePriceByType(Engine[] engines, String type) { }
} double sum = 0; }
} int count = 0; }
for (Engine e : engines) { return minFlower;
if ([Link]().equalsIgnoreCase(type)) { }
• Consecutive 2 vowels - sum += [Link](); }
count++;
import [Link].*; } • IPA12
public class Consecutive2vowels { }
public static void main(String[] args) { return count > 0 ? sum / count : 0; import [Link].*;
Scanner sc = new Scanner([Link]); }
String s = [Link]().toLowerCase(); class Account {
String[] str = [Link](" "); public static Engine[] searchEngineByName(String name, Engine[] engines) { private int id;
int count = 0; List<Engine> list = new ArrayList<>(); private double balance;
for (int i = 0; i < [Link]; i++) { for (Engine e : engines) { private double interestRate;
for (int j = 1; j < str[i].length(); j++) { if ([Link]().equalsIgnoreCase(name)) {

gate Page 1
 import [Link].*; } • IPA12
public class Consecutive2vowels { }
public static void main(String[] args) { return count > 0 ? sum / count : 0; import [Link].*;
Scanner sc = new Scanner([Link]); }
String s = [Link]().toLowerCase(); class Account {
String[] str = [Link](" "); public static Engine[] searchEngineByName(String name, Engine[] engines) { private int id;
int count = 0; List<Engine> list = new ArrayList<>(); private double balance;
for (int i = 0; i < [Link]; i++) { for (Engine e : engines) { private double interestRate;
for (int j = 1; j < str[i].length(); j++) { if ([Link]().equalsIgnoreCase(name)) {
if (isVowel(str[i].charAt(j - 1)) && isVowel(str[i].charAt(j))) { [Link](e); public Account(int id, double balance, double interestRate) {
count++; } [Link] = id;
break; } [Link] = balance;
} if ([Link]()) return null; [Link] = interestRate;
} }
} [Link]([Link](Engine::getEngineld));
[Link](count); return [Link](new Engine[0]); public int getId() {
} } return id;
public static boolean isVowel(char c) { }
return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u'; • Fruits problem
} public double getBalance() {
} import [Link].*; return balance;
}
public class Solution {
• Consonant Odd position public static void main(String[] args) { public double getInterestRate() {
Scanner sc = new Scanner([Link]); return interestRate;
import [Link]; Fruits[] fruits = new Fruits[4]; }
}
public class Consonent_OddPosition { for (int i = 0; i < 4; i++) {
public static void main(String[] args) { int id = [Link]([Link]()); public class MyClass {
Scanner sc = new Scanner([Link]); String name = [Link](); public static void main(String[] args) {
String s = [Link](); int price = [Link]([Link]()); Scanner sc = new Scanner([Link]);
char[] ch = {'a', 'e', 'i', 'o', 'u', 'A','E', 'I', 'O', 'U'}; int rating = [Link]([Link]());
for (int i = 0; i < [Link](); i++) { fruits[i] = new Fruits(id, name, price, rating); int id = [Link]([Link]());
boolean test = true; } double balance = [Link]([Link]());
for (int j = 0; j < [Link]; j++) { double interestRate = [Link]([Link]());
if((i+1)%2==0 || [Link](i)==ch[j] || [Link](i)==' ') { int inputRating = [Link]([Link]()); int time = [Link]([Link]());
test = false; Fruits result = findMaximumPriceByRating(fruits, inputRating);
} Account acc = new Account(id, balance, interestRate);
} if (result != null) { double totalInterest = calculateTotalInterest(acc, time);
if(test == true) { [Link]([Link]()); [Link]("%.2f\n", totalInterest);
[Link]([Link](i)); } else { }
} [Link]("No such Fruit");
} } public static double calculateTotalInterest(Account acc, int time) {
} } double percentage = [Link]() * 100 / time;
} return percentage + [Link]();
public static Fruits findMaximumPriceByRating(Fruits[] fruits, int rating) { }
Fruits maxFruit = null; }
• Maximum matching of players with trainers int maxPrice = Integer.MIN_VALUE;

import [Link].*; for (Fruits fruit : fruits) { • IPA13

if ([Link]() > rating && [Link]() > maxPrice) {
public class Solution { maxPrice = [Link]();
public static int matchPlayersAndTrainers(int[] players, int[] trainers) { maxFruit = fruit; public class Solution {
[Link](players); } public static void main(String[] args) {
[Link](trainers); } Scanner sc = new Scanner([Link]);
Student[] students = new Student[4];
int i = 0, j = 0, count = 0; return maxFruit;
} for (int i = 0; i < 4; i++) {
while (i < [Link] && j < [Link]) { } int rollNo = [Link]([Link]());
if (players[i] <= trainers[j]) { String name = [Link]();
count++; • Associates problem String branch = [Link]();
i++; public static Associate[] associatesForGivenTechnology(Associate[] associates, String searchTechnology) { double score = [Link]([Link]());
j++; List<Associate> result = new ArrayList<>(); boolean dayScholar = [Link]([Link]());
} else {
j++; for (Associate a : associates) { students[i] = new Student(rollNo, name, branch, score, dayScholar);
} if ([Link]().equalsIgnoreCase(searchTechnology) && [Link]() % 5 == 0) { }
} [Link](a);
} int count = findCountOfDayscholarStudents(students);
return count; } if (count > 0)
} [Link](count);
return [Link](new Associate[0]); else
public static void main(String[] args) { } [Link]("There are no such dayscholar students");
int[] players = {4, 7, 9};
int[] trainers = {5, 8, 10}; ---------------------------------------------------------------------------------------------------------------------------------- Student secondHighest = findStudentwithSecondHighestScore(students);
public static Associate[] associatesForGivenTechnology(Associate[] a, String s) if (secondHighest != null)
[Link](matchPlayersAndTrainers(players, trainers)); // Output: 3 { [Link]([Link]() + "#" + [Link]() + "#" +
} Associate[] arr = new Associate[0]; [Link]());
} for (int i = 0; i < [Link]; i++) { else
if(a[i].getTech().equalsIgnoreCase(s) && a[i].getYear()%5==0) [Link]("There are no student from non day scholar");
{ }
• Count primes arr = [Link](arr,[Link]+1);
arr[[Link]-1]=a[i]; public static int findCountOfDayscholarStudents(Student[] students) {
import [Link].*; } int count = 0;
public class CountPrime { } for (Student s : students) {
public static void main(String[] args) if([Link]>0) if ([Link]() && [Link]() > 80) {
{ { count++;
int count=0; return arr; }
Scanner sc = new Scanner([Link]); } }
String s = [Link](); else return count;
for (int i = 0; i < [Link](); i++) { }
{ return null;
int p = [Link]([Link]([Link](i))); } public static Student findStudentwithSecondHighestScore(Student[] students) {
if(isPrime(p)==true) } double firstMax = -1;
{ double secondMax = -1;
count++; Student firstMaxStudent = null;
} • Institute problem Student secondMaxStudent = null;
}
[Link](count); public static int findNumClearancedByLoc(Institution[] instArray, String location) { for (Student s : students) {
} int sum = 0; if (![Link]()) {
public static boolean isPrime(int n) for (Institution inst : instArray) { double score = [Link]();
{ if ([Link]().equalsIgnoreCase(location)) { if (score > firstMax) {
int c=0; sum += [Link](); secondMax = firstMax;
for (int i = 2; i < n; i++) } secondMaxStudent = firstMaxStudent;
{ }
if(n%i==0) return sum; firstMax = score;
{ } firstMaxStudent = s;
c++; } else if (score > secondMax) {
} public static Institution updateInstitutionGrade(Institution[] instArray, String instName) { secondMax = score;
} for (Institution inst : instArray) { secondMaxStudent = s;
if(c==0 && n>1) if ([Link]().equalsIgnoreCase(instName)) { }
{ int rating = ([Link]() * 100) / [Link](); }
return true; if (rating >= 80) { }
} [Link]("A");
else } else { return secondMaxStudent;
{ [Link]("B"); }
return false; } }
} return inst;
} }
} } • IPA14
return null;
}
public class Solution {
public static void main(String[] args) {
• Inventory Scanner sc = new Scanner([Link]);
Document[] docs = new Document[4];
import [Link].*;
import [Link].*; for (int i = 0; i < 4; i++) {
import [Link].*; int id = [Link]();
[Link](); // Consume newline
class Solution String title = [Link]();
{ String folderName = [Link]();
public static void main (String[] args) throws [Link] int pages = [Link]();
{ [Link](); // Consume newline
Scanner sc=new Scanner([Link]); docs[i] = new Document(id, title, folderName, pages);
Inventory[] inventory = new Inventory[4]; }
for(int i=0;i<4;i++){
String a=[Link](); Document[] result = docsWithOddPages(docs);
int b=[Link]([Link]());
int c=[Link]([Link]()); for (Document d : result) {
int d=[Link]([Link]()); [Link]([Link]() + " " + [Link]() + " " + [Link]() + " " + [Link]());
inventory[i]= new Inventory(a,b,c,d); }
}
int limit=[Link]([Link]()); [Link]();
Inventory[] ans=Replenish(inventory,limit); }
if(ans!=null){
for(Inventory i:ans){ public static Document[] docsWithOddPages(Document[] docs) {
if([Link]()>75){ List<Document> resultList = new ArrayList<>();
[Link]([Link]()+" Critical Filling.");
}else if([Link]()>=50 && [Link]()<=75){ for (Document doc : docs) {
[Link]([Link]()+" Moderate Filling."); if ([Link]() % 2 != 0) {
}else{ [Link](doc);
[Link]([Link]()+" Non-Critical Filling."); }
} }
}
} // Sort the resultList by id in ascending order
[Link](); [Link](resultList, [Link](Document::getId));
}
// Convert List to Array
public static Inventory[] Replenish(Inventory[] inventory, int limit){ Document[] resultArr = new Document[[Link]()];
List<Inventory> arr=new ArrayList<>(); return [Link](resultArr);
for(Inventory i: inventory){ }
if(limit>=[Link]()){ }
[Link](i);
}
} • IPA15
return [Link](new Inventory[0]);
} public class Solution {

} public static int findAvgOfCount(Music[] musics, int threshold) {

int sum = 0, count = 0;
class Inventory{ for (Music m : musics) {
private String id; if ([Link]() > threshold) {
private int maxQt; sum += [Link]();
private int currQt; count++;
private int threshold; }
}

gate Page 2
 } public static int findAvgOfCount(Music[] musics, int threshold) {
int sum = 0, count = 0;
class Inventory{ for (Music m : musics) {
private String id; if ([Link]() > threshold) {
private int maxQt; sum += [Link]();
private int currQt; count++;
private int threshold; }
}
public Inventory(String id, int maxQt, int currQt, int threshold){ return (count > 0) ? (sum / count) : 0;
[Link]=id; }
[Link]=maxQt;
[Link]=currQt; public static Music[] sortTypeByDuration(Music[] musics, int durationThreshold) {
[Link]=threshold; List<Music> filteredList = new ArrayList<>();
} for (Music m : musics) {
if ([Link]() > durationThreshold) {
public String getId(){ [Link](m);
return id; }
} }

public int getMaxQt(){ if ([Link]()) return null;

return maxQt;
} [Link]([Link](Music::getDuration));
public int getCurrQt(){
return currQt; return [Link](new Music[0]);
} }
public int getThreshold(){
return threshold; public static void main(String[] args) {
} Scanner sc = new Scanner([Link]);
public void setId(String id){ Music[] musics = new Music[4];
[Link]=id;
} for (int i = 0; i < [Link]; i++) {
public void setMaxQt(int maxQt){ int playListNo = [Link]([Link]());
[Link]=maxQt; String type = [Link]();
} int count = [Link]([Link]());
public void setCurrQt(int currQt){ double duration = [Link]([Link]());
[Link]=currQt;
} musics[i] = new Music(playListNo, type, count, duration);
public void setThreshold(int threshold){ }
[Link]=threshold;
} int countThreshold = [Link]([Link]());
} int durationThreshold = [Link]([Link]());

int avgCount = findAvgOfCount(musics, countThreshold);

• Cinema if (avgCount != 0) {
public static int findAvgBudgetByDirector(Cinema[] movies, String director) { [Link](avgCount);
int total = 0, count = 0; } else {
for (Cinema movie : movies) { [Link]("No playlist found.");
if ([Link]().equalsIgnoreCase(director)) { }
total += [Link]();
count++; Music[] filteredAndSorted = sortTypeByDuration(musics, durationThreshold);
} if (filteredAndSorted != null) {
} for (Music m : filteredAndSorted) {
if (count == 0) return 0; [Link]([Link]());
return total / count; }
} } else {
[Link]("No playlist found with mentioned attribute.");
public static Cinema getMovieByRatingBudget(Cinema[] movies, int rating, int budget) { }
for (Cinema movie : movies) { }
if ([Link]() == rating && [Link]() == budget && budget % rating == 0) { }
return movie;
} • IPA16
}
return null;
} public class Solution {
public static void main(String[] args) {
• Player2 problem Scanner sc = new Scanner([Link]);
TravelAgencies[] arr = new TravelAgencies[4];
import [Link].*;
for (int i = 0; i < [Link]; i++) {
class Player2 { int regNo = [Link]([Link]());
private int id; String agencyName = [Link]();
private String name; String packageType = [Link]();
private int iccRank; int price = [Link]([Link]());
private int matchesPlayed; boolean flightFacility = [Link]([Link]());
private int runsScored;
arr[i] = new TravelAgencies(regNo, agencyName, packageType, price, flightFacility);
public Player2(int id, String name, int iccRank, int matchesPlayed, int runsScored) { }
[Link] = id;
[Link] = name; int searchRegNo = [Link]([Link]());
[Link] = iccRank; String searchPackageType = [Link]();
[Link] = matchesPlayed;
[Link] = runsScored; int highestPrice = findAgencyWithHighestPackagePrice(arr);
} [Link](highestPrice);

public int getId() { TravelAgencies result = agencyDetailsForGivenIdAndType(arr, searchRegNo, searchPackageType);

return id; if (result != null) {
} [Link]([Link]() + ":" + [Link]());
}
public String getName() { }
return name;
} public static int findAgencyWithHighestPackagePrice(TravelAgencies[] arr) {
int maxPrice = Integer.MIN_VALUE;
public int getIccRank() { for (TravelAgencies t : arr) {
return iccRank; if ([Link]() > maxPrice) {
} maxPrice = [Link]();
}
public int getMatchesPlayed() { }
return matchesPlayed; return maxPrice;
} }

public int getRunsScored() { public static TravelAgencies agencyDetailsForGivenIdAndType(TravelAgencies[] arr, int regNo, String packageType) {
return runsScored; for (TravelAgencies t : arr) {
} if ([Link]() &&
[Link]() == regNo &&
public void setId(int id) { [Link]().equalsIgnoreCase(packageType)) {
[Link] = id; return t;
} }
}
public void setName(String name) { return null;
[Link] = name; }
} }

public void setIccRank(int iccRank) {

[Link] = iccRank; • IPA17
}
import [Link];
public void setMatchesPlayed(int matchesPlayed) {
[Link] = matchesPlayed; public class Solution {
} public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
public void setRunsScored(int runsScored) { Newspaper[] papers = new Newspaper[4];
[Link] = runsScored;
} for (int i = 0; i < 4; i++) {
} int regNo = [Link]([Link]());
String name = [Link]();
public class Solution { int year = [Link]([Link]());
public static double[] findAverageOfRuns(Player2[] players, int target) { int price = [Link]([Link]());
double[] result = new double[0]; papers[i] = new Newspaper(regNo, name, year, price);
List<Double> averages = new ArrayList<>(); }

for (Player2 p : players) { int yearToSearch = [Link]([Link]());

if (target <= [Link]()) { String nameToSearch = [Link]();
double avg = (double)[Link]() / [Link]();
[Link](avg); int totalPrice = findTotalPriceByPublicationYear(papers, yearToSearch);
} if (totalPrice > 0) {
} [Link](totalPrice);
} else {
result = new double[[Link]()]; [Link]("No Newspaper found with the mentioned attribute");
for (int i = 0; i < [Link](); i++) { }
result[i] = [Link](i);
} Newspaper result = searchNewspaperByName(papers, nameToSearch);
if (result != null) {
return result; [Link]("regNo-" + [Link]());
} [Link]("name-" + [Link]());
[Link]("publicationYear-" + [Link]());
public static void main(String[] args) { [Link]("price-" + [Link]());
Scanner sc = new Scanner([Link]); } else {
Player2[] players = new Player2[4]; [Link]("No Newspaper found with the given name");
}
for (int i = 0; i < 4; i++) {
int id = [Link](); [Link]();
[Link](); // consume newline }
String name = [Link]();
int iccRank = [Link](); public static int findTotalPriceByPublicationYear(Newspaper[] papers, int year) {
int matchesPlayed = [Link](); int total = 0;
int runsScored = [Link](); for (Newspaper paper : papers) {
if ([Link]() == year) {
players[i] = new Player2(id, name, iccRank, matchesPlayed, runsScored); total += [Link]();
} }
}
int target = [Link](); return total;
double[] averages = findAverageOfRuns(players, target); }

for (double avg : averages) { public static Newspaper searchNewspaperByName(Newspaper[] papers, String name) {
if (avg >= 80 && avg <= 100) { for (Newspaper paper : papers) {
[Link]("Grade A"); if ([Link]().equalsIgnoreCase(name)) {
} else if (avg >= 50 && avg <= 79) { return paper;
[Link]("Grade B"); }
} else { }
[Link]("Grade C"); return null;
} }
} }

[Link]();
} • IPA18
}

gate Page 3
 } else if (avg >= 50 && avg <= 79) { return paper;
[Link]("Grade B"); }
} else { }
[Link]("Grade C"); return null;
} }
} }

[Link]();
} • IPA18
}

• sim2

class Solution {
public static Sim2[] matchAndSort(Sim2[] sims, String search_circle, double search_rate) {
List<Sim2> result = new ArrayList<>();

for (Sim2 sim : sims) {

if ([Link]().equalsIgnoreCase(search_circle) && search_rate > [Link]()) {
[Link](sim);
}
}

[Link]((a, b) -> [Link]() - [Link]());

return [Link](new Sim2[0]);

}

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);
Sim2[] sims = new Sim2[4];

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

int id = [Link]([Link]());
String company = [Link]();
int balance = [Link]([Link]());
double rate = [Link]([Link]());
String circle = [Link]();
sims[i] = new Sim2(id, company, balance, rate, circle);
}

String searchCircle = [Link]();

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

Sim2[] filteredSims = matchAndSort(sims, searchCircle, searchRate);

for (Sim2 sim : filteredSims) {

[Link]([Link]());
}
}
}

• Team problem

public class Solution {

public static Team findPlayer(Team[] teams, int run, String country) {

for (int i = 0; i < [Link]; i++) {
if (teams[i].getTCountry().equalsIgnoreCase(country) && teams[i].getTRun() > run) {
return teams[i];
}
}
return null;
}

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

int n = [Link]([Link]());
Team[] teams = new Team[n];

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

int id = [Link]([Link]());
String name = [Link]();
String country = [Link]();
int run = [Link]([Link]());

teams[i] = new Team(id, name, country, run);

}

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

String countryParam = [Link]();

Team result = findPlayer(teams, runParam, countryParam);

if (result != null) {
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
} else {
[Link]("No team is found from the given country and run");
}

[Link]();
}

• IPA1 - course problem

import [Link].*;

public class CourseProgram {

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);
Course[] courses = new Course[4];

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

int id = [Link]([Link]());
String name = [Link]();
String admin = [Link]();
int quiz = [Link]([Link]());
int handson = [Link]([Link]());
courses[i] = new Course(id, name, admin, quiz, handson);
}

String adminToSearch = [Link]();

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

// Call first method

int avgQuiz = findAvgOfQuizByAdmin(courses, adminToSearch);
if (avgQuiz != 0) {
[Link](avgQuiz);
} else {
[Link]("No Course found");
}

// Call second method

Course[] sortedCourses = sortCourseByHandsOn(courses, handsOnLimit);
if (sortedCourses != null && [Link] > 0) {
for (Course c : sortedCourses) {
[Link]([Link]());
}
} else {
[Link]("No Course found with mentioned attributes.");
}
}

public static int findAvgOfQuizByAdmin(Course[] courses, String admin) {

int sum = 0, count = 0;
for (Course c : courses) {
if ([Link]().equalsIgnoreCase(admin)) {
sum += [Link]();
count++;
}
}
return (count == 0) ? 0 : (sum / count);
}

public static Course[] sortCourseByHandsOn(Course[] courses, int limit) {

List<Course> result = new ArrayList<>();
for (Course c : courses) {
if ([Link]() < limit) {
[Link](c);
}
}

if ([Link]()) return null;

[Link]([Link](Course::getHandson));
return [Link](new Course[0]);
}
}

-----------------------------
public static Course[] sortCourseByHandsOn(Course[] course, int h)
{
Course[] obj = new Course[0];
for(int i=0; i<[Link]; i++)
{
if(course[i].getHandson()<h)
{
obj = [Link](obj, [Link]+1);

gate Page 4
 obj = [Link](obj, [Link]+1);
obj[[Link]-1] = course[i];
}
}
Course val;
for(int i=0;i<[Link];i++)
{
for(int j=i+1; j<[Link]; j++)
{
if(obj[i].getHandson()>obj[j].getHandson())
{
val = obj[i];
obj[i] = obj[j];
obj[j] = val;
}
}
}
if([Link]>0)
{
return obj;
}
else
{
return null;
}
}

• IPA2

public class MyClass {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
Employee[] employees = new Employee[4];

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

int id = [Link]();
[Link](); // consume newline
String name = [Link]();
String branch = [Link]();
double rating = [Link]();
boolean companyTransport = [Link]();
[Link](); // consume newline
employees[i] = new Employee(id, name, branch, rating, companyTransport);
}

String inputBranch = [Link]();

int count = findCountOfEmployeesUsingCompTransport(employees, inputBranch);

if (count > 0) {
[Link](count);
} else {
[Link]("No such Employees");
}

Employee result = findEmployeeWithSecondHighestRating(employees);

if (result != null) {
[Link]([Link]());
[Link]([Link]());
} else {
[Link]("All Employees using company transport");
}

[Link]();
}

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

int count = 0;
for (Employee e : empArr) {
if ([Link]().equals(branch) && [Link]()) {
count++;
}
}
return count;
}

public static Employee findEmployeeWithSecondHighestRating(Employee[] empArr) {

double firstMax = Double.NEGATIVE_INFINITY;
double secondMax = Double.NEGATIVE_INFINITY;
Employee firstEmp = null;
Employee secondEmp = null;

for (Employee e : empArr) {

if (![Link]()) {
double rating = [Link]();
if (rating > firstMax) {
secondMax = firstMax;
secondEmp = firstEmp;
firstMax = rating;
firstEmp = e;
} else if (rating > secondMax) {
secondMax = rating;
secondEmp = e;
}
}
}

return secondEmp;
}
}

• IPA3

public class Solution {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
Player[] players = new Player[4];

// Reading 4 Player objects

for (int i = 0; i < 4; i++) {
int id = [Link]([Link]());
String skill = [Link]();
String level = [Link]();
int points = [Link]([Link]());
players[i] = new Player(id, skill, level, points);
}

String skillInput = [Link]();

String levelInput = [Link]();

int totalPoints = findPointsForGivenSkill(players, skillInput);

if (totalPoints > 0) {
[Link](totalPoints);
} else {
[Link]("The given Skill is not available");
}

Player resultPlayer = getPlayerBasedOnLevel(players, levelInput, skillInput);

if (resultPlayer != null) {
[Link]([Link]());
} else {
[Link]("No player is available with specified level, skill and eligibility points");
}
}

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

int sum = 0;
for (Player p : players) {
if ([Link]().equalsIgnoreCase(skill)) {
sum += [Link]();
}
}
return sum;
}

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

for (Player p : players) {
if ([Link]().equalsIgnoreCase(skill) &&
[Link]().equalsIgnoreCase(level) &&
[Link]() >= 20) {
return p;
}
}
return null;
}
}

• IPA4

public class Solution {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
Medicine[] medicines = new Medicine[4];

// Reading 4 Medicine objects

for (int i = 0; i < 4; i++) {
String name = [Link]();
String batch = [Link]();
String disease = [Link]();
int price = [Link]([Link]());
medicines[i] = new Medicine(name, batch, disease, price);
}

gate Page 5
 // Reading disease input
String diseaseInput = [Link]();

// Get prices and print them

Integer[] prices = getPriceByDisease(medicines, diseaseInput);
for (Integer price : prices) {
[Link](price);
}
}

public static Integer[] getPriceByDisease(Medicine[] medicines, String disease) {

List<Integer> priceList = new ArrayList<>();

for (Medicine med : medicines) {

if ([Link]().equalsIgnoreCase(disease)) {
[Link]([Link]());
}
}

[Link](priceList);
return [Link](new Integer[0]);
}
}

• IPA5
public class Solution {
public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
AutonomousCar[] cars = new AutonomousCar[4];

// Reading 4 AutonomousCar objects

for (int i = 0; i < 4; i++) {
int id = [Link]([Link]());
String brand = [Link]();
int conducted = [Link]([Link]());
int passed = [Link]([Link]());
String env = [Link]();
cars[i] = new AutonomousCar(id, brand, conducted, passed, env);
}

String envInput = [Link]();

String brandInput = [Link]();

// First method
int totalPassed = findTestPassedByEnv(cars, envInput);
if (totalPassed > 0) {
[Link](totalPassed);
} else {
[Link]("There are no tests passed in this particular environment");
}

// Second method
AutonomousCar updatedCar = updateCarGrade(cars, brandInput);
if (updatedCar != null) {
[Link]([Link]() + "::" + [Link]());
} else {
[Link]("No Car is available with the specified brand");
}
}

public static int findTestPassedByEnv(AutonomousCar[] cars, String environment) {

int sum = 0;
for (AutonomousCar car : cars) {
if ([Link]().equalsIgnoreCase(environment)) {
sum += [Link]();
}
}
return sum;
}

public static AutonomousCar updateCarGrade(AutonomousCar[] cars, String brand) {

for (AutonomousCar car : cars) {
if ([Link]().equalsIgnoreCase(brand)) {
int rating = ([Link]() * 100) / [Link]();
String grade = (rating >= 80) ? "A1" : "B2";
[Link](grade);
return car;
}
}
return null;
}
}

• IPA6

public class Solution {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
Movie[] movies = new Movie[4];

// Reading 4 Movie objects

for (int i = 0; i < 4; i++) {
String name = [Link]();
String company = [Link]();
String genre = [Link]();
int budget = [Link]([Link]());
movies[i] = new Movie(name, company, genre, budget);
}

String searchGenre = [Link]();

// Get filtered movies by genre

Movie[] matchedMovies = getMovieByGenre(movies, searchGenre);

// Print budget classification

for (Movie m : matchedMovies) {
if ([Link]() > 80000000) {
[Link]("High Budget Movie");
} else {
[Link]("Low Budget Movie");
}
}
}

public static Movie[] getMovieByGenre(Movie[] movies, String searchGenre) {

List<Movie> matchedList = new ArrayList<>();
for (Movie m : movies) {
if ([Link]().equalsIgnoreCase(searchGenre)) {
[Link](m);
}
}
return [Link](new Movie[0]);
}
}

• IPA7

public class Solution {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
Phone[] phones = new Phone[4];

// Reading 4 Phone objects

for (int i = 0; i < 4; i++) {
int id = [Link]([Link]());
String os = [Link]();
String brand = [Link]();
int price = [Link]([Link]());
phones[i] = new Phone(id, os, brand, price);
}

String brandInput = [Link]();

String osInput = [Link]();

// Calling findPriceForGivenBrand
int totalPrice = findPriceForGivenBrand(phones, brandInput);
if (totalPrice > 0) {
[Link](totalPrice);
} else {
[Link]("The given Brand is not available");
}

// Calling getPhoneIdBasedOnOs
Phone resultPhone = getPhoneIdBasedOnOs(phones, osInput);
if (resultPhone != null) {
[Link]([Link]());
} else {
[Link]("No phones are available with specified os and price range");
}
}

public static int findPriceForGivenBrand(Phone[] phones, String brand) {

int sum = 0;
for (Phone phone : phones) {
if ([Link]().equalsIgnoreCase(brand)) {
sum += [Link]();
}
}
return sum;
}

public static Phone getPhoneIdBasedOnOs(Phone[] phones, String os) {

for (Phone phone : phones) {
if ([Link]().equalsIgnoreCase(os) && [Link]() >= 50000) {

gate Page 6
 if ([Link]().equalsIgnoreCase(os) && [Link]() >= 50000) {
return phone;
}
}
return null;
}
}

• IPA8

public class Solution {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
NavalVessel[] vessels = new NavalVessel[4];

// Read 4 NavalVessel objects

for (int i = 0; i < 4; i++) {
int id = [Link]([Link]());
String name = [Link]();
int planned = [Link]([Link]());
int completed = [Link]([Link]());
String purpose = [Link]();

vessels[i] = new NavalVessel(id, name, planned, completed, purpose);

}

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

String purposeInput = [Link]();

// Call and print average

int average = findAvgVoyagesByPct(vessels, percentage);
[Link](average);

// Call and print vessel classification

NavalVessel vessel = findVesselByGrade(vessels, purposeInput);
if (vessel != null) {
[Link]([Link]() + "%" + [Link]());
} else {
[Link]("No Naval Vessel is available with the specified purpose");
}
}

public static int findAvgVoyagesByPct(NavalVessel[] vessels, int percentage) {

int sum = 0;
int count = 0;

for (NavalVessel v : vessels) {

int pct = ([Link]() * 100) / [Link]();
if (pct >= percentage) {
sum += [Link]();
count++;
}
}

return count > 0 ? sum / count : 0;

}

public static NavalVessel findVesselByGrade(NavalVessel[] vessels, String purpose) {

for (NavalVessel v : vessels) {
if ([Link]().equalsIgnoreCase(purpose)) {
int pct = ([Link]() * 100) / [Link]();

if (pct == 100) {
[Link]("Star");
} else if (pct >= 80 && pct <= 99) {
[Link]("Leader");
} else if (pct >= 55 && pct <= 79) {
[Link]("Inspirer");
} else {
[Link]("Striver");
}

return v;
}
}

return null;
}
}

gate Page 7