CLUB MEMBER DETAILS

[Link]*

public class ClubMember{

private int memberId;

private String memberName;

private String memberType;

private double membershipFees;

public void setMemberId(int memberId){

[Link] = memberId;

public int getMemberId(){

return memberId;

public void setMemberName(String memberName){

[Link] = memberName;

public String getMemberName(){

return memberName;

public void setMemberType(String memberType){

[Link] = memberType;

public String getMemberType(){

return memberType;

public void setMembershipFees(double membershipFees){

 [Link] = membershipFees;

public double getMembershipFees(){

return membershipFees;

public ClubMember(int memberId, String memberName, String memberType){

[Link] = memberId;

[Link] = memberName;

[Link] = memberType;

public void calculateMembershipFees (){

if ([Link]("Gold")) membershipFees = 50000.0;

else if ([Link]("Premium")) membershipFees = 75000.0;

[Link]*

import [Link];

public class Main{

public static void main (String[] args) {

Scanner sc=new Scanner([Link]);

[Link]("Enter Member Id");

int memberId = [Link]();

[Link]();

[Link]("Enter Name");

String memberName = [Link]();

 [Link]("Enter Member Type");

String memberType = [Link]();

ClubMember clubMemberObj = new ClubMember(memberId,memberName,memberType);

[Link]();

[Link]("Member Id is " + [Link]());

[Link]("Member Name is " + [Link]());

[Link]("Member Type is " + [Link]());

[Link]("Membership Fees is " + [Link]());

}
 CreditCardValidator

[Link]*

package [Link];

public class CreditCard {

private String number;

public CreditCard() {

public CreditCard(String number) {

super();

[Link] = number;

public String getNumber() {

return number;

public void setNumber(String number) {

[Link] = number;

[Link]*

package [Link];

import [Link];

import [Link];

import [Link];

import [Link];
import [Link];

import [Link].*;

import [Link];

public class CreditCardService {

//check whether the card is blocklisted and card contains only 16 digits

public String validate(CreditCard card,String fileName) throws IOException

String msg=null;

if(validateAgainstBlocklist(card, fileName))

msg="Card is blocked";

else if(validateNumber([Link]()))

msg="card is not having 16 digits";

else

msg="valid card";

return msg;

// Validate a credit card against a blocklist.

public boolean validateAgainstBlocklist(CreditCard card, String fileName) throws IOException {

//write your code here

boolean bol = true;

String str = "";

str = new String([Link]([Link](fileName)));

String dig[] = [Link](",");

String str2 = dig[0];

String str3 = dig[1];

if([Link]().equalsIgnoreCase(str2) || [Link]().equalsIgnoreCase(str3))
 {

bol=true;

else{

bol=false;

return bol;

// Validate the card number length

public boolean validateNumber(String number) {

int len = [Link]();

boolean bol=true;

if(len!=16)

bol=true;

else{

bol=false;

return bol;

// Get the blocklisted no's from the file and return list of numbers

public List<String> getBlockListNumbers(String fileName) throws IOException {

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

String data = "";

data = new String([Link]([Link](fileName)));

String dig1[] = [Link](",");

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

[Link](dig1[i]);
 }

return li;

[Link]*

package [Link];

import [Link];

import [Link];

import [Link];

public class SkeletonValidator {

public SkeletonValidator() {

validateClassName("[Link]");

validateClassName("[Link]");

validateMethodSignature(

"validate:String,validateAgainstBlocklist:boolean,validateNumber:boolean,getBlockListNumbers:List","com.c
[Link]");

private static final Logger LOG = [Link]("SkeletonValidator");

protected final boolean validateClassName(String className) {

boolean iscorrect = false;

try {

[Link](className);

iscorrect = true;

[Link]("Class Name " + className + " is correct");

} catch (ClassNotFoundException e) {
[Link]([Link], "You have changed either the " + "class name/package. Use the correct package "

+ "and class name as provided in the skeleton");

} catch (Exception e) {

[Link]([Link], "There is an error in validating the " + "Class Name. Please manually verify that the "

+ "Class name is same as skeleton before uploading");

return iscorrect;

protected final void validateMethodSignature(String methodWithExcptn, String className) {

Class cls = null;

try {

String[] actualmethods = [Link](",");

boolean errorFlag = false;

String[] methodSignature;

String methodName = null;

String returnType = null;

for (String singleMethod : actualmethods) {

boolean foundMethod = false;

methodSignature = [Link](":");

methodName = methodSignature[0];

returnType = methodSignature[1];

cls = [Link](className);

Method[] methods = [Link]();

for (Method findMethod : methods) {

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

foundMethod = true;

if (!([Link]().getSimpleName().equals(returnType))) {

errorFlag = true;

[Link]([Link], " You have changed the " + "return type in '" + methodName
 + "' method. Please stick to the " + "skeleton provided");

} else {

[Link]("Method signature of " + methodName + " is valid");

if (!foundMethod) {

errorFlag = true;

[Link]([Link], " Unable to find the given public method " + methodName

+ ". Do not change the " + "given public method name. " +
"Verify it with the skeleton");

if (!errorFlag) {

[Link]("Method signature is valid");

} catch (Exception e) {

[Link]([Link]," There is an error in validating the " + "method structure. Please

manually verify that the "+ "Method signature is same as the skeleton before uploading");

[Link]*

package [Link];

import [Link];

import [Link];

import [Link];
import [Link];

import [Link];

import [Link];

public class CreditCardValidatorMain {

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

// CODE SKELETON - VALIDATION STARTS

// DO NOT CHANGE THIS CODE

BufferedReader b = new BufferedReader(new InputStreamReader([Link]));

new SkeletonValidator();

// CODE SKELETON - VALIDATION ENDS

// Please start your code from here

String cardNumber = [Link]();

CreditCard creditCard = new CreditCard();

[Link](cardNumber);

//Write your code here read card numnber and create CreditCard object based on cardnumber

CreditCardService creditCardService = new CreditCardService();

String validationMessage=[Link](creditCard, "resources/[Link]");

[Link](validationMessage);

}
 ESHOPPING

[Link]*

package [Link];

import [Link];

import [Link];

import [Link];

public class Main {

public static void main(String ag[]) {

// CODE SKELETON - VALIDATION STARTS

// DO NOT CHANGE THIS CODE

SkeletonValidator validator = new SkeletonValidator();

// CODE SKELETON - VALIDATION ENDS

// Please start your code from here

OrderLineItem it1 = new OrderLineItem("AM33","Book",200,3);

OrderLineItem it2 = new OrderLineItem("AM345","Watch",1000,2);

CartService cs = new CartService();

OrderLineItem[] arr = {it1, it2};

double amt = [Link](arr);

[Link]([Link](amt));

}
[Link]*/orderService

package [Link];

import [Link];

/**

*/

public class CartService {

/**

* Method to calculate total purchase amount for all the order line items

* @param orderLineItems

* @return totalOrderAmount

*/

public double calculateOrderTotalAmount(OrderLineItem[] orderLineItems) {

double totalOrderAmount = 0;

int qt =0;

double cost =0.0;

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

qt = orderLineItems[i].quantity;

cost = orderLineItems[i].itemCostPerQuantity;

totalOrderAmount += (qt*cost);

return totalOrderAmount; // TODO change this return value

/**

* Method to calculate discount based on order total amount

* @param totalOrderAmount
 * @return discount

*/

public double calculateDiscount(double totalOrderAmount) {

double discount = 0.0;

if(totalOrderAmount<1000){

discount = (totalOrderAmount*10)/100;

else if(totalOrderAmount>=1000 && totalOrderAmount<10000){

discount = (totalOrderAmount*20)/100;

else if(totalOrderAmount>=10000){

discount = (totalOrderAmount*30)/100;

return discount; // TODO change this return value

/**

* Method to verify if the order line item is flagged as Bulk Order or not

* @param lineItem

* @return boolean

*/

public boolean isBulkOrder(OrderLineItem lineItem) {

boolean result=false;

if([Link]>5){

result = true;

else if([Link]<=5 && [Link]>=1){

result=false;

return result; // TODO change this return value

}
 /**

* Count the number of line items which are ordered in bulk

* @param orderLineItems

* @return

*/

public int countOfBulkOrderLineItems(OrderLineItem[] orderLineItems) {

int count = 0;

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

if(isBulkOrder(orderLineItems[i])){

count++;

return count; // TODO change this return value

[Link]*

package [Link];

import [Link];

import [Link];

import [Link];

/**

* @author 222805

* This class is used to verify if the Code Skeleton is intact and not modified by participants thereby ensuring smooth
auto evaluation

*/
public class SkeletonValidator {

public SkeletonValidator() {

validateClassName("[Link]");

validateClassName("[Link]");

validateMethodSignature(

"calculateOrderTotalAmount:double,calculateDiscount:double,isBulkOrder:boolean,countOfBulkOrderLineIt
ems:int",

"[Link]");

private static final Logger LOG = [Link]("SkeletonValidator");

protected final boolean validateClassName(String className) {

boolean iscorrect = false;

try {

[Link](className);

iscorrect = true;

[Link]("Class Name " + className + " is correct");

} catch (ClassNotFoundException e) {

[Link]([Link], "You have changed either the " + "class name/package. Use the correct package "

+ "and class name as provided in the skeleton");

} catch (Exception e) {

[Link]([Link],"There is an error in validating the " + "Class Name. Please manually

verify that the " + "Class name is same as skeleton before uploading");

return iscorrect;

}
protected final void validateMethodSignature(String methodWithExcptn, String className) {

Class cls = null;

try {

String[] actualmethods = [Link](",");

boolean errorFlag = false;

String[] methodSignature;

String methodName = null;

String returnType = null;

for (String singleMethod : actualmethods) {

boolean foundMethod = false;

methodSignature = [Link](":");

methodName = methodSignature[0];

returnType = methodSignature[1];

cls = [Link](className);

Method[] methods = [Link]();

for (Method findMethod : methods) {

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

foundMethod = true;

if (!([Link]().getName().equals(returnType))) {

errorFlag = true;

[Link]([Link], " You have changed the " + "return type in '" + methodName
+ "' method. Please stick to the " + "skeleton provided");

} else {

[Link]("Method signature of " + methodName + " is valid");

if (!foundMethod) {

errorFlag = true;
 [Link]([Link], " Unable to find the given public method " + methodName

+ ". Do not change the " + "given public method name. " + "Verify it with the skeleton");

if (!errorFlag) {

[Link]("Method signature is valid");

} catch (Exception e) {

[Link]([Link]," There is an error in validating the " + "method structure. Please

manually verify that the "+ "Method signature is same as the skeleton before uploading");

[Link]*

package [Link];

/**

* @author Value Object - OrderLineItem

*/

public class OrderLineItem {

public String itemId;

public String itemName;

public double itemCostPerQuantity;

public int quantity;

public String getItemId(){

return itemId;

}
 public void setItemId(String itemId){

[Link] = itemId;

public String getItemName(){

return itemName;

public void setItemName(String itemName){

[Link] = itemName;

public double getitemCostPerQuantity(){

return itemCostPerQuantity;

public void setitemCostPerQuantity(double itemCostPerQuantity){

[Link] = itemCostPerQuantity;

public int getQuantity(){

return quantity;

public void setItemId(int quantity){

[Link] = quantity;

public OrderLineItem(String itemId, String itemName, double itemCostPerQuantity, int quantity){

[Link] = itemId;

[Link] = itemName;

[Link]=itemCostPerQuantity;

[Link] = quantity;

}
 Fixed Deposit Details

[Link]*

import [Link].*;

class FDScheme{

private int schemeNo;

private double depositAmt;

private int period;

private float rate;

public FDScheme(int schemeNo, double depositAmt, int period){

super();

[Link]=schemeNo;

[Link]=depositAmt;

[Link]=period;

calculateInterestRate();

public int getSchemeNo(){

return schemeNo;

public void setSchemeNo(int schemeNo)

[Link]=schemeNo;

public double getDepositAmt(){

return depositAmt;

public void setDepositAmt(double depositAmt)

[Link]=depositAmt;

public int getPeriod()

return period;

public void setPeriod(int period){

 [Link]=period;

public float getRate(){

return rate;

public void setRate(float rate){

[Link]=rate;

public void calculateInterestRate()

if(period>=1 && period<=90)

[Link]=(float)5.5;

else if(period>=91 && period<=180)

[Link]=(float)6.25;

else if(period>=181 && period<=365)

[Link]=(float)7.5;

[Link]("Interest rate for"+period+"days is"+[Link]);

[Link]*

import [Link];

public class Main{

public static void main (String[] args) {

Scanner sc=new Scanner([Link]);

 [Link]("Enter Scheme no");

int no=[Link]();

[Link]();

[Link]("Enter Deposit amount");

double amt=[Link]();

[Link]("enter period of deposit");

int prd=[Link]();

FDScheme obj=new

FDScheme(no,amt,prd);

}
 GPA CALCULATION

[Link]*

package [Link];

import [Link].*;

import [Link].*;

public class UserInterface {

public static void main(String []args)

GPACalculator gpa = new GPACalculator();

[Link](new ArrayList<Integer>());

int option=0;

double gpa1=0;

Scanner sc = new Scanner([Link]);

do

[Link]("1. Add Grade\n2. Calculate GPA\n3. Exit");

[Link]("Enter your choice");

option = [Link]([Link]());

switch(option)

case 1: [Link]("Enter the obtained grade");

char grade = [Link]().charAt(0);

[Link](grade);

break;

case 2 : gpa1 = [Link]();

if(gpa1 > 0)

[Link]("GPA Scored");

[Link](gpa1);

else

[Link]("No GradePoints available");

 }

break;

case 3 : break;

}while(option!=3);

[Link]("Thank you for using the Application");

[Link]*

package [Link];

import [Link].*;

public class GPACalculator {

private List<Integer> gradePointList;

public List<Integer> getGradePointList() {

return gradePointList;

public void setGradePointList(List<Integer> gradePointList) {

[Link] = gradePointList;

/*This method should add equivalent grade points based on the grade obtained by the student passed as
argument into gradePointList

Grade S A B C D E

Grade Point 10 9 8 7 6 5

For example if the gradeobtained is A, its equivalent grade points is 9 has to added into the
gradePointList*/
public void addGradePoint(char gradeObtained) {

if(gradeObtained == 'S')

[Link](10);

else if(gradeObtained == 'A')

[Link](9);

else if(gradeObtained == 'B')

[Link](8);

else if(gradeObtained == 'C')

[Link](7);

else if(gradeObtained == 'D')

[Link](6);

else

[Link](5);

/* This method should return the GPA of all grades scored in the semester

GPA can be calculated based on the following formula

GPA= (gradePoint1 + gradePoint2 + ... + gradePointN) / (size of List)

For Example:

if the list contains the following marks [9,10,8,5]

GPA = (9 + 10 + 8 + 5) / (4)= 8.0 */

 public double calculateGPAScored() {

double gpa=-1;

double total=0,value=0,size=0;

size = [Link]();

if(size < 1)

return 0;

// fill the code

Iterator i = [Link]();

while([Link]())

value = (Integer)[Link]();

total += value;

gpa = total/size;

return gpa;

}
 HUNGER EATS

[Link]*

package [Link];

public class FoodProduct {

private int foodId;

private String foodName;

private double costPerUnit;

private int quantity;

public int getFoodId() {

return foodId;

public void setFoodId(int foodId) {

[Link] = foodId;

public String getFoodName() {

return foodName;

public void setFoodName(String foodName) {

[Link] = foodName;

public double getCostPerUnit() {

return costPerUnit;

public void setCostPerUnit(double costPerUnit) {

[Link] = costPerUnit;

public int getQuantity() {

return quantity;

public void setQuantity(int quantity) {

[Link] = quantity;
 }

[Link]*

package [Link];

import [Link];

import [Link];

import [Link];

public class UserInterface {

public static void main(String[] args) {

// fill the code

Scanner sc=new Scanner([Link]);

int itemno;

String bank;

[Link]("Enter the number of items");

itemno=[Link]();

[Link]("Enter the item details");

Order z=new Order();

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

FoodProduct fd=new FoodProduct();

[Link]("Enter the item id");

[Link]([Link]());

[Link]("Enter the item name");

[Link]([Link]());

[Link]("Enter the cost per unit");

[Link]([Link]());

[Link]("Enter the quantity");

[Link]([Link]());

[Link](fd);

}
 [Link]("Enter the bank name to avail offer");

bank=[Link]();

[Link](bank);

[Link]("Calculated Bill Amount:"+[Link]());

[Link]*

package [Link];

import [Link].*;

import [Link];

public class Order {

private double discountPercentage;

private List<FoodProduct> foodList=new ArrayList<FoodProduct>();

public double getDiscountPercentage() {

return discountPercentage;

public void setDiscountPercentage(double discountPercentage) {

[Link] = discountPercentage;

public List<FoodProduct> getFoodList() {

return foodList;

public void setFoodList(List<FoodProduct> foodList) {

[Link] = foodList;

}
//This method should set the discount percentage based on bank passed as argument

public void findDiscount(String bankName) {

// fill the code

if([Link]("HDFC")){

discountPercentage=15.0;

else if([Link]("ICICI")){

discountPercentage=25.0;

else if([Link]("CUB")){

discountPercentage=30.0;

else if([Link]("SBI")){

discountPercentage=50.0;

else if([Link]("OTHERS")){

discountPercentage=0.0;

//This method should add the FoodProduct Object into Food List

public void addToCart(FoodProduct foodProductObject) {

// fill the code

List<FoodProduct> f=getFoodList();

[Link](foodProductObject);

setFoodList(f);

//method should return the total bill amount after discount

 // based on the bank name

public double calculateTotalBill() {

// fill the code

double bill=0;

List<FoodProduct> f=getFoodList();

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

//

// [Link]([Link](i).getCostPerUnit());

//

// [Link]([Link](i).getQuantity());

bill+=[Link](i).getQuantity()*[Link](i).getCostPerUnit()*1.0;

bill=bill-((bill*discountPercentage)/100);

return bill;

}
 INSURANCE PREMIUM GENERATOR

[Link]*

package [Link];

public class PropertyDetails {

private Integer builtUpArea;

private Integer builtYear;

private Integer reconstructionCost;

private Integer householdValuation;

private String burglaryCoverReqd;

private String politicalUnrestCoverReqd;

private Integer sumAssured;

public PropertyDetails() {

public Integer getBuiltUpArea() {

return builtUpArea;

public void setBuiltUpArea(Integer builtUpArea) {

[Link] = builtUpArea;

public Integer getBuiltYear() {

return builtYear;

public void setBuiltYear(Integer builtYear) {

[Link] = builtYear;

public Integer getReconstructionCost() {

 return reconstructionCost;

public void setReconstructionCost(Integer reconstructionCost) {

[Link] = reconstructionCost;

public Integer getHouseholdValuation() {

return householdValuation;

public void setHouseholdValuation(Integer householdValuation) {

[Link] = householdValuation;

public String getBurglaryCoverReqd() {

return burglaryCoverReqd;

public void setBurglaryCoverReqd(String burglaryCoverReqd) {

[Link] = burglaryCoverReqd;

public String getPoliticalUnrestCoverReqd() {

return politicalUnrestCoverReqd;

public void setPoliticalUnrestCoverReqd(String politicalUnrestCoverReqd) {

[Link] = politicalUnrestCoverReqd;

public Integer getSumAssured() {

return sumAssured;

}
 public void setSumAssured(Integer sumAssured) {

[Link] = sumAssured;

public PropertyDetails(Integer builtUpArea,Integer builtYear, Integer reconstructionCost, Integer

householdValuation,

String burglaryCoverReqd, String politicalUnrestCoverReqd) {

super();

[Link] = builtUpArea;

[Link]=builtYear;

[Link] = reconstructionCost;

[Link] = householdValuation;

[Link] = burglaryCoverReqd;

[Link] = politicalUnrestCoverReqd;

[Link]*

package [Link];

public class Constants {

public final static String YES = "Yes";

public final static String NO = "No";

public final static double MIN_PREMIUM_AMOUNT = 5000;

public final static int MIN_HOUSEHOLD_VALUATION=0;

[Link]*

package [Link];
import [Link];

import [Link];

import [Link];

public class CalculatePremiumService {

public boolean checkOwnerDetails(String name,String mobile) {

//name cannot have numbers or special characters; minimum length of name=2

//mobile number begins with any digit between 6 and 9; length=10

return [Link]("^[a-zA-Z ]{2,}$") && [Link]("^[6-9][0-9]{9}$");

public double getPremiumAmount(PropertyDetails propertyDetails) {

double amountToBePaid = 0;

double additionalAmount1=0;

double additionalAmount2=0;

/*invoke validatePropertyParameters(propertDetails) and check the response

* if true ,calculate premium amount to be paid by calling

* the methods calculatePremiumByPropertyAge(propertyDetails),

* calculatePremiumForBurglaryCoverage(propertyDetails, amountToBePaid) and

* calculatePremiumForPoliticalUnrestCoverage(propertyDetails, amountToBePaid)

* return the premium amount rounded off to zero decimal places

* else return 0;

*/

if(!validatePropertyParameters(propertyDetails)) {

return 0;

amountToBePaid=calculatePremiumByPropertyAge(propertyDetails);

additionalAmount1=calculatePremiumForBurglaryCoverage(propertyDetails, amountToBePaid);

additionalAmount2=calculatePremiumForPoliticalUnrestCoverage(propertyDetails,
amountToBePaid);

return [Link](amountToBePaid+additionalAmount1+additionalAmount2);
 }

public boolean validatePropertyParameters(PropertyDetails propertyDetails) {

/*

* conditions to be checked

* builtUpArea between 400 and 15,000 sq. ft.

* reconstructionCost between Rs.1,000 and Rs.10,000

* householdValuation either same as Constants.MIN_HOUSEHOLD_VALUATION

* between Rs.1,00,000 and Rs.15,00,000

* builtYear between 2000 and current year

*/

int builtUpArea = [Link]();

if(!(builtUpArea>=400 && builtUpArea<=15000)) return false;

int reconstructionCost = [Link]();

if(!(reconstructionCost>=1000 && reconstructionCost<=10000)) return false;

int householdValuation = [Link]();

if(!((householdValuation==Constants.MIN_HOUSEHOLD_VALUATION) || (householdValuation >=

100000 && householdValuation <= 1500000))) {

return false;

int builtYear = [Link]();

if(!(builtYear>=2000 && builtYear<=[Link]().getYear())) {

return false;

return true;

public double calculatePremiumByPropertyAge(PropertyDetails propertyDetails) {

//Write your code here based on business rules

//Use Constants.MIN_PREMIUM_AMOUNT

int sumAssured =
[Link]()*[Link]()+[Link](
);

int propertyAge = [Link]().getYear()-[Link]();

[Link](sumAssured);

double premium = 0;

if(propertyAge>15) {
 premium = Constants.MIN_PREMIUM_AMOUNT+([Link]()*0.35);

else if(propertyAge>=6) {

premium = Constants.MIN_PREMIUM_AMOUNT+([Link]()*0.2);

else {

premium = Constants.MIN_PREMIUM_AMOUNT+([Link]()*0.1);

return premium;

public double calculatePremiumForBurglaryCoverage(PropertyDetails propertyDetails, double amount) {

//write your code here based on business rules

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

return amount*.01;

return 0;

public double calculatePremiumForPoliticalUnrestCoverage(PropertyDetails propertyDetails, double amount) {

//Write your code here based on business rules

//Ex:-[Link]().equalsIgnoreCase([Link]) to check
condition

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

return amount*.01;

return 0;

}
[Link]*

package [Link];

import [Link];

import [Link];

import [Link];

/**

* @author

* This class is used to verify if the Code Skeleton is intact and not modified by participants thereby ensuring smooth
auto evaluation

*/

public class SkeletonValidator {

public SkeletonValidator() {

validateClassName("[Link]");

validateClassName("[Link]");

validateClassName("[Link]");

validateClassName("[Link]");

validateMethodSignature(

"checkOwnerDetails:boolean,getPremiumAmount:double,validatePropertyParameters:boolean,calculatePre
miumByPropertyAge:double,calculatePremiumForBurglaryCoverage:double,calculatePremiumForPoliticalUnrestCov
erage:double","[Link]");

private static final Logger LOG = [Link]("SkeletonValidator");

protected final boolean validateClassName(String className) {

boolean iscorrect = false;

try {

[Link](className);

iscorrect = true;
 [Link]("Class Name " + className + " is correct");

} catch (ClassNotFoundException e) {

[Link]([Link], "You have changed either the " + "class name/package. Use the
correct package "+ "and class name as provided in the skeleton");

} catch (Exception e) {

[Link]([Link],

"There is an error in validating the " + "Class Name. Please manually verify that the "

+ "Class name is same as skeleton before uploading");

return iscorrect;

protected final void validateMethodSignature(String methodWithExcptn, String className) {

Class cls = null;

try {

String[] actualmethods = [Link](",");

boolean errorFlag = false;

String[] methodSignature;

String methodName = null;

String returnType = null;

for (String singleMethod : actualmethods) {

boolean foundMethod = false;

methodSignature = [Link](":");

methodName = methodSignature[0];

returnType = methodSignature[1];

cls = [Link](className);

Method[] methods = [Link]();

for (Method findMethod : methods) {

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

foundMethod = true;

if (!([Link]().getSimpleName().equals(returnType))) {

errorFlag = true;

[Link]([Link], " You have changed the " + "return type in '" +
methodName+ "' method. Please stick to the " + "skeleton provided");

} else {

[Link]("Method signature of " + methodName + " is valid");

if (!foundMethod) {

errorFlag = true;

[Link]([Link], " Unable to find the given public method " + methodName

+ ". Do not change the " + "given public method name. " + "Verify it with the
skeleton");

if (!errorFlag) {

[Link]("Method signature is valid");

} catch (Exception e) {

[Link]([Link]," There is an error in validating the " + "method structure. Please

manually verify that the "+ "Method signature is same as the skeleton before uploading");

}
[Link]*

package [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

public class InsurancePremiumGeneratorApp {

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

// CODE SKELETON - VALIDATION STARTS

// DO NOT CHANGE THIS CODE

SkeletonValidator validator = new SkeletonValidator();

// CODE SKELETON - VALIDATION ENDS

// Please start your code from here

String name = "";

String mobile = "";

Integer builtUpArea = 0;

Integer builtYear=0;

Integer reconstructionCost = 0;

Integer householdValuation = Constants.MIN_HOUSEHOLD_VALUATION;

String burglaryCoverReqd = "";

String politicalUnrestCoverReqd = "";

//writer the code for creating BufferedReader object here

 BufferedReader br = new BufferedReader(new InputStreamReader([Link]));

CalculatePremiumService premiumService = new CalculatePremiumService();

[Link]("Enter the name");

//read name

name = [Link]();

[Link]("Enter the mobile");

//read mobile

mobile = [Link]();

//validate name and mobile format; continue if true

if([Link](name, mobile)) {

[Link]("Enter the Built-Up Area(In [Link].)between 400 and 15,000");

//read builtUpArea

builtUpArea = [Link]([Link]());

[Link]("Enter the year the house was built");

//read builtYear

builtYear = [Link]([Link]());

[Link]("Enter the Re-construction cost(per [Link].)between 1,000 and 10,000");

//read reconstructionCost

reconstructionCost = [Link]([Link]());

[Link](

"Do you want to include valuation of HouseHold Articles? Please provide yes/no");

//read response

String response = [Link]();

//if (response is "yes" case insensitive)

if([Link]("yes")) {

[Link]("Enter the Household valuation between Rs.1,00,000 and Rs.15,00,000");

//read householdValuation

householdValuation = [Link]([Link]());

[Link]("Do you want to include Burglary cover? Please provide yes/no");

 //read burglaryCoverReqd

burglaryCoverReqd = [Link]();

[Link]("Do you want to include Political unrest cover? Please provide yes/no");

//read politicalUnrestCoverReqd

politicalUnrestCoverReqd = [Link]();

//create PropertyDetails Object

PropertyDetails propertyDetails = new PropertyDetails(builtUpArea, builtYear, reconstructionCost,

householdValuation, burglaryCoverReqd, politicalUnrestCoverReqd);

double premiumAmount = [Link](propertyDetails);

if(premiumAmount==0.0) {

[Link]("Incorrect figures provided");

}else {

[Link]("Sum Insured: Rs."+[Link]()+"\nInsurance

Premium for the property of " + name + ": Rs." + premiumAmount);

else {[Link]("Invalid Details");}

}
 NUMEROLOGY NUMBER

[Link]*

import [Link];

public class Main {

private static int getSum(long num) {

char[] chars = [Link](num).toCharArray();

int sum = 0;

for (char ch : chars) {

sum += [Link](ch, 10);

return sum;

private static int getNumerology(long num) {

String string = [Link](num);

while ([Link]() != 1) {

string = [Link](getSum([Link](string)));

return [Link](string);

private static int getOddCount(long num) {

int oddCount = 0;

for (char ch : [Link](num).toCharArray()) {

if ([Link](ch, 10) % 2 != 0) {

++oddCount;

}
 return oddCount;

private static int getEvenCount(long num) {

int evenCount = 0;

for (char ch : [Link](num).toCharArray()) {

if ([Link](ch, 10) % 2 == 0) {

++evenCount;

return evenCount;

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("Enter the number");

long num = [Link]();

[Link]("Sum of digits");

[Link](getSum(num));

[Link]("Numerology number");

[Link](getNumerology(num));

[Link]("Number of odd numbers");

[Link](getOddCount(num));

[Link]("Number of even numbers");

[Link](getEvenCount(num));

}
 OIL STORES

[Link]*

import [Link];

public class Oil{

//Fill the code here

private String name;

private int pack;

private char category;

private float cost;

public Oil(String name,int pack,char category,float cost){

[Link]=name;

[Link]=pack;

[Link]=category;

[Link]=cost;

public void setName(String name){

[Link]=name;

public String getName(){

return name;

public void setPack(int pack){

[Link]=pack;

public int getPack(){

return pack;

public void setCategory(char category){

[Link]=category;

public char getCategory(){

return category;
 }

public void setCost(float cost){

[Link]=cost;

public float getCost(){

return cost;

public float calculateTotalCost(float qty){

float price=((qty*1000)/pack)*cost;

return price;

[Link]*

import [Link];

public class Main{

public static void main (String[] args) {

Scanner sc=new Scanner([Link]);

//Fill the code

[Link]("Enter oil name");

String n=[Link]();

[Link]("Enter pack capacity");

int pc=[Link]();

[Link]("Enter category");

char cat=[Link]().charAt(0);

[Link]("Enter cost");

float c=[Link]();

Oil obj=new Oil(n,pc,cat,c);

[Link](n);

[Link](pc);

[Link](cat);
 [Link](c);

[Link]("Enter Quantity to purchase");

float qty=[Link]();

[Link]("Oil cost rs."+[Link](qty));

}
 PAYMENT-INHERITENCE

[Link]*

public class Bill {

public String processPayment(Payment payObj) {

String result="Payment not done and your due amount is "+[Link]();

// Fill your code

if(payObj instanceof Cheque)

Cheque cheque=(Cheque)payObj;

if([Link]())

result="Payment done successfully via cheque";

else if(payObj instanceof Cash)

Cash cash=(Cash)payObj;

if([Link]())

result="Payment done successfully via cash";

else if(payObj instanceof Credit)

Credit credit=(Credit)payObj;

if([Link]())

result="Payment done successfully via credit card. Remaining amount in your "+[Link]()+" card
is "+[Link]();

return result;

}
[Link]*

public class Cash extends Payment

private int cashAmount;

public int getCashAmount() {

return cashAmount;

public void setCashAmount(int cashAmount) {

[Link] = cashAmount;

public boolean payAmount()

return getCashAmount() >= getDueAmount();

[Link]

import [Link].*;

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

public class Cheque extends Payment

private String chequeNo;

private int chequeAmount;

private Date dateOfIssue;

public String getChequeNo() {

 return chequeNo;

public void setChequeNo(String chequeNo) {

[Link] = chequeNo;

public int getChequeAmount() {

return chequeAmount;

public void setChequeAmount(int chequeAmount) {

[Link] = chequeAmount;

public Date getDateOfIssue() {

return dateOfIssue;

public void setDateOfIssue(Date dateOfIssue) {

[Link] = dateOfIssue;

private int findDifference(Date date){

Calendar myDate=new GregorianCalendar();

[Link](date);

return ([Link]([Link]))*12+([Link]([Link]));

@Override

public boolean payAmount()

int months=findDifference(getDateOfIssue());

return (getChequeAmount()>=getDueAmount()&months<=6);

// Fill your code

public void generateDate(String date)

try{

Date issueDate=new SimpleDateFormat("dd-MM-yyyy").parse(date);

 setDateOfIssue(issueDate);

catch(ParseException e)

[Link]();

[Link]*

public class Credit extends Payment

private int creditCardNo;

private String cardType; //(silver,gold,platinum) String,

private int creditCardAmount;

public int getCreditCardNo() {

return creditCardNo;

public void setCreditCardNo(int creditCardNo) {

[Link] = creditCardNo;

public String getCardType() {

return cardType;

public void setCardType(String cardType) {

[Link] = cardType;

public int getCreditCardAmount() {

return creditCardAmount;

public void setCreditCardAmount(int creditCardAmount) {

 [Link] = creditCardAmount;

public Credit(int creditCardNo, String cardType) {

super();

// Fill your code

public Credit()

// Fill your code

@Override

public boolean payAmount()

int tax=0;

boolean isDeducted=false;

switch(cardType)

case "silver": setCreditCardAmount(10000);

tax=(int)(0.02*getDueAmount())+getDueAmount();

if(tax<=getCreditCardAmount())

setCreditCardAmount(getCreditCardAmount()-tax);

isDeducted=true;

break;

case "gold": setCreditCardAmount(50000);

tax=(int)(0.05*getDueAmount())+getDueAmount();

if(tax<=getCreditCardAmount())
 {

setCreditCardAmount(getCreditCardAmount()-tax);

isDeducted=true;

break;

case "platinum": setCreditCardAmount(100000);

tax=(int)(0.1*getDueAmount())+getDueAmount();

if(tax<=getCreditCardAmount())

setCreditCardAmount(getCreditCardAmount()-tax);

isDeducted=true;

break;

return isDeducted;

[Link]*

public class Payment {

private int dueAmount;

public int getDueAmount() {

return dueAmount;

public void setDueAmount(int dueamount) {

[Link] = dueamount;

public boolean payAmount() {

return false;

}
[Link]*

import [Link].*;

public class Main {

public static void main(String[] args) {

// Fill your code

Bill bill=new Bill();

Scanner sc=new Scanner([Link]);

[Link]("Enter the due amount;");

int dueAmount=[Link]();

[Link]("Enter the mode of payment(cheque/cash/credit):");

String mode=[Link]();

switch(mode)

case "cash" : [Link]("Enter the cash amount:");

int cashAmount=[Link]();

Cash cash=new Cash();

[Link](cashAmount);

[Link](dueAmount);

[Link]([Link](cash));

break;

case "cheque" : [Link]("Enter the cheque number:");

String number=[Link]();

[Link]("Enter the cheque amount:");

int chequeAmount=[Link]();

[Link]("Enter the date of issue:");

String date=[Link]();

Cheque cheque=new Cheque();

[Link](chequeAmount);

[Link](number);

[Link](date);

[Link](dueAmount);

[Link]([Link](cheque));
 break;

case "credit" : [Link]("Enter the credit card number:");

int creditNumber = [Link]();

[Link]("Enter the card type(silver,gold,platinum):");

String cardType=[Link]();

Credit credit=new Credit();

[Link](cardType);

[Link](creditNumber);

[Link](dueAmount);

[Link]([Link](credit));

break;

default:

break;

[Link]();

}
 POWER PROGRESS

[Link]*

import [Link].*;

public class Main

public static void main(String[] args)

Scanner sc=new Scanner([Link]);

//Fill the code

int m=[Link]();

if(m<=0){

[Link](""+m+" is an invalid");

return;

int n=[Link]();

if(n<=0){

[Link](""+n+" is an invalid");

return;

if(m>=n){

[Link](""+m+" is not less than "+n);

return;

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

[Link]((int)[Link](m,i)+" ");

}
 PRIME NUMBERS ENDING WITH 1

[Link]*

import [Link];

public class Main {

public static void main(String args[]) {

Scanner sc = new Scanner([Link]);

// fill the code

int low, high;

int last=0;

int flag = 0;

[Link]("Enter the first number");

low = [Link]();

[Link]("Enter the last number");

high = [Link]();

if (low > high || low < 0 || high < 0 || low == high)

else {

int i = low;

high = high + 30;

while (i <= high-1) {

int x = i % 10;

for (int j = 2; j <= i / 2; j++) {

if (i % j != 0 && x == 1) {

flag = 1;

} else {

flag = 0;

break;

if (flag == 1 )

[Link](i);

i++;

}}}
 SINGAPORE TOURISM

[Link]*

import [Link].*;

public class Main

public static void main(String[] args)

Scanner sc=new Scanner([Link]);

Map<String,Integer> map=new HashMap<>();

[Link]("BEACH",270);

[Link]("PILGRIMAGE",350);

[Link]("HERITAGE",430);

[Link]("HILLS",780);

[Link]("FALLS",1200);

[Link]("ADVENTURES",4500);

[Link]("Enter the Passenger Name");

String pname=[Link]();

[Link]("Enter the Place");

String name=[Link]();

if())

[Link](name+" is an invalid place");

else

[Link]("Enter the no of Days");

int nod=[Link]();

if(nod<=0)

[Link](nod+" is an invalid days");

else

[Link]("Enter the no of Tickets");

 int not=[Link]();

if(not<=0)

[Link](not+" is an invalid tickets");

else

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

double totalcost=d*(double)not*(double)nod;

if(totalcost>=1000)

totalcost=totalcost-((totalcost*15)/100);

[Link]("Bill Amount is %.2f", totalcost);

//Fill the code

}
 SUBSTITUTION CYPHER TECHNIQUE

[Link]*

import [Link];

public class Main {

public static void main (String[] args) {

Scanner sc=new Scanner([Link]);

[Link]("Enter the Encrypted text: ");

String code= [Link]();

int shift = 7;

int f=0;

String decryptMessage = " ";

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

char alpha = [Link](i);

if(alpha >='a' && alpha <= 'z'){

f=1;

alpha=(char)(alpha - shift);

if(alpha < 'a'){

alpha = (char)(alpha - 'a'+'z'+1);

decryptMessage=decryptMessage+alpha;

else if (alpha >='A' && alpha <= 'Z'){

f=1;

alpha=(char)(alpha - shift);

if(alpha < 'A'){

alpha = (char)(alpha - 'A'+'Z'+1);

decryptMessage=decryptMessage+alpha;

else if(alpha == ' '){

decryptMessage=decryptMessage+alpha;
 }

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

[Link]("No hidden Message");

[Link](0);

[Link]("Decrpted Text:\n"+decryptMessage);

}
 ZEE ZEE BANK

[Link]*

public class Account {

long accountNumber;

double balanceAmount;

public Account(long accno, double bal){

super();

[Link]=accno;

[Link]=bal;

public long getAccountNumber(){

return accountNumber;

public void setAccountNumber(long accno){

[Link]=accno;

public double getBalanceAmount(){

return balanceAmount;

public void setBalanceAmount(double bal) {

[Link]=bal;

public void deposit(double depositAmt){

float total=(float)(balanceAmount+depositAmt);

balanceAmount=total;

public boolean withdraw(double withdrawAmt){

float total;

if(withdrawAmt>balanceAmount){

[Link]("Insufficient balance");

return false;
 }else{

total=(float)(balanceAmount-withdrawAmt);

setBalanceAmount(total);

return true;

[Link]*

import [Link];

public class Main{

static Account ac=new Account(0, 0);

public static void main (String[] args) {

Scanner sc=new Scanner([Link]);

[Link]("Enter the account number:");

[Link]([Link]());

[Link]("Enter the available amount in the account:");

[Link]([Link]());

[Link]("Enter the amount to be deposited:");

[Link]([Link]());

[Link]("Available balance is:%.2f",[Link]());

[Link]();

[Link]("Enter the amount to be withdrawn:");

[Link]([Link]());

[Link]("Available balance is:%.2f",[Link]());

//Fill the code

}
 THE NEXT RECHARGE DATE

[Link]*

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

public class Main {

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

BufferedReader br=new BufferedReader(new InputStreamReader([Link]));

[Link]("Recharged date");

String date=[Link]();

String currentDate="29/10/2019";

if([Link](date)&&([Link](date,currentDate))){

[Link]("Validity days");

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

if(days>0)

[Link]([Link](date,days));

else

[Link](days+ "is not a valid days");

else

[Link](date+ "is not a valid date");

public static boolean isValidFormat(String date){

String regex="^(3[01]|[12][0-9]|0[1-9])/(1[0-2]|0[1-9])/[0-9]{4}$";

Pattern pattern=[Link](regex);

Matcher matcher=[Link]((CharSequence)date);

return [Link]();
}

public static boolean dateCompare(String date1,String date2)throws ParseException{

SimpleDateFormat sdformat=new SimpleDateFormat("dd/MM/yyyy");

Date d1=[Link](date1);

Date d2=[Link](date2);

if(([Link](d2)<0)||([Link](d2)==0))

return true;

else

return false;

public static String futureDate(String date,int days){

Calendar c=[Link]();

SimpleDateFormat sdformat=new SimpleDateFormat("dd/MM/yyyy");

try{

Date mydate=[Link](date);

[Link](mydate);

[Link]([Link], days);

}catch(ParseException e){

[Link]();

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

return toDate;

}
 A New You Spa

[Link]*

public class DiamondMembers extends Members{

// Fill the code

public DiamondMembers(String customerId,String customerName,long mobileNumber,String

memberType,String emailId){

super(customerId,customerName,mobileNumber,memberType,emailId);

/*[Link] = customerId;

[Link] = customerName;

[Link] = mobileNumber;

[Link] = memberType;

[Link] = emailId;*/

public boolean validateCusomerId(){

// Fill the code

boolean b=true;

String s1 = [Link]();

String regex="[DIAMOND]{7}[0-9]{3}";

if([Link](regex)){

b=true;

else{

b=false;

return b;

public double calculateDiscount(double purchaseAmount){

// Fill the code

 double discount=purchaseAmount*0.45;

double updateamount=purchaseAmount-discount;

return updateamount;

[Link]*

public class GoldMembers extends Members {

public GoldMembers(String customerId,String customerName,long mobileNumber,String memberType,String

emailId){

super(customerId,customerName,mobileNumber,memberType,emailId);

// Fill the code

public boolean validateCusomerId(){

boolean b=true;

String s1 = [Link]();

String regex="[GOLD]{4}[0-9]{3}";

if([Link](regex)){

b=true;

else{

b=false;

return b;

// Fill the code

public double calculateDiscount(double purchaseAmount){

// Fill the code

double discount=purchaseAmount*0.15;

double updateamount=purchaseAmount-discount;

return updateamount;

}
[Link]*

abstract public class Members {

protected String customerId;

protected String customerName;

protected long mobileNumber;

protected String memberType;

protected String emailId;

abstract public double calculateDiscount(double purchaseAmount);

public String getCustomerId() {

return customerId;

public void setCustomerId(String customerId) {

[Link] = customerId;

public String getCustomerName() {

return customerName;

public void setCustomerName(String customerName) {

[Link] = customerName;

public long getMobileNumber() {

return mobileNumber;

public void setMobileNumber(long mobileNumber) {

[Link] = mobileNumber;

public String getMemberType() {

return memberType;

public void setMemberType(String memberType) {

 [Link] = memberType;

public String getEmailId() {

return emailId;

public void setEmailId(String emailId) {

[Link] = emailId;

public Members(String customerId, String customerName, long mobileNumber, String memberType, String
emailId) {

[Link] = customerId;

[Link] = customerName;

[Link] = mobileNumber;

[Link] = memberType;

[Link] = emailId;

[Link]*

public class PlatinumMembers extends Members {

// Fill the code

public PlatinumMembers(String customerId,String customerName,long mobileNumber,String

memberType,String emailId){

super(customerId,customerName,mobileNumber,memberType,emailId);

/*customerId = customerId;

customerName = customerName;

mobileNumber = mobileNumber;

memberType = memberType;

emailId = emailId;

*/

}
 public boolean validateCusomerId(){

// Fill the code

boolean b=true;

String s1 = [Link]();

String regex="[PLATINUM]{8}[0-9]{3}";

if([Link](regex)){

b=true;

else{

b=false;

return b;

public double calculateDiscount(double purchaseAmount){

// Fill the code

double discount=purchaseAmount*0.3;

double updateamount=purchaseAmount-discount;

return updateamount;

[Link]*

import [Link];

public class UserInterface {

public static void main(String[] args){

Scanner sc=new Scanner([Link]);

[Link]("Enter Customer Id");

 String cid=[Link]();

[Link]("Enter Customer name");

String cname=[Link]();

[Link]("Enter mobile number");

long mob=[Link]();

[Link]();

[Link]("Enter Member type");

String mem=[Link]();

[Link]("Enter Email Id");

String email=[Link]();

[Link]("Enter amount Purchased");

double amount=[Link]();

DiamondMembers d=new DiamondMembers(cid,cname,mob,mem,email);

GoldMembers g=new GoldMembers(cid,cname,mob,mem,email);

PlatinumMembers p=new PlatinumMembers(cid,cname,mob,mem,email);

double res=0.0;

if([Link]()){

res= [Link](amount);

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

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

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

[Link]("Amount to be paid :"+res);

} else if([Link]()){

res= [Link](amount);

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

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

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

[Link]("Amount to be paid :"+res);

} else if([Link]()){

res= [Link](amount);
 [Link]("Name :"+[Link]());

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

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

[Link]("Amount to be paid :"+res);

} else{

[Link]("Provide a valid Customer Id");

// Fill the code

}
 BATTING AVERAGE

[Link]*

package [Link];

import [Link];

import [Link];

import [Link];

public class UserInterface {

public static void main(String[] args) {

Scanner sc=new Scanner([Link]);

Player player=new Player();

[Link](new ArrayList<>());

boolean flag=true;

while(flag)

[Link]("1. Add Runs Scored");

[Link]("2. Calculate average runs scored");

[Link]("3. Exit");

[Link]("Enter your choice");

int choice=[Link]();

switch(choice)

case 1: {

[Link]("Enter the runs scored");

int runScored=[Link]();

[Link](runScored);

break;

case 2: {

[Link]("Average runs secured");

[Link]([Link]());

break;

}
 case 3: {

[Link]("Thank you for using the Application");

flag=false;

break;

[Link]*

package [Link];

import [Link];

public class Player {

private List<Integer> scoreList;

public List<Integer> getScoreList() {

return scoreList;

public void setScoreList(List<Integer> scoreList) {

[Link] = scoreList;

//This method should add the runScored passed as the argument into the scoreList

public void addScoreDetails(int runScored) {

 // fill the code

[Link](runScored);

/* This method should return the average runs scored by the player

Average runs can be calculated based on the sum of all runScored available in the scoreList divided by the
number of elements in the scoreList.

For Example:

List contains[150,50,50]

average runs secured=(150+50+50)/3=83.33333333333333

so this method should return 83.33333333333333

If list is empty return 0

*/

public double getAverageRunScored() {

// fill the code

if([Link]()) {

return 0.0;

int size=[Link]();

int totalScore=0;

for(int score : scoreList)

totalScore+=score;

return (double) totalScore / (double) size;

}
 Change The Cash

[Link]*

import [Link].*;

public class Main{

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

String a = [Link]();

if([Link]() < 3) {

[Link]("String length of " + a + " is too short");

return;

else if([Link]() > 10) {

[Link]("String length of " + a + " is too long");

return;

char[] arr = [Link]();

char[] arr1 = new char[[Link]];

int j = 0;

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

if((arr[i]<65 || ((arr[i]>90) && (arr[i]<97)) || arr[i]>122)) {

arr1[j++] = arr[i];

if(j!=0) {

[Link]("String should not contain ");

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

[Link](arr1[i]);

return;

char b = [Link]().charAt(0);
 int present = 0;

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

if(arr[i] == [Link](b)) {

arr[i] = [Link](b);

present = 1;

else if(arr[i] == [Link](b)) {

arr[i] = [Link](b);

present = 1;

if(present == 0) {

[Link]("Character " + b + " is not found");

else {

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

[Link](arr[i]);

}
 Check Number Type

[Link]*

public interface NumberType

public boolean checkNumberType(int n);

[Link]*

import [Link];

public class NumberTypeUtility

public static NumberType isOdd()

return n -> n%2 != 0;

public static void main (String[] args)

Scanner sc=new Scanner([Link]);

int n=[Link]();

if(isOdd().checkNumberType(n))

[Link](n+" is odd");

else

[Link](n+" is not odd");

}
 Cheque Payment Process

[Link]*

package [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

public class PaymentDao {

private Connection connection;

public List<Payment> getAllRecord(){

connection=[Link]();

PreparedStatement statement=null;

ResultSet resultSet=null;

List<Payment> paymentList=new ArrayList<Payment>();

try {

statement=[Link]("select * from cheque_payments");

resultSet=[Link]();

while([Link]()){

Payment payment =new Payment();

[Link]([Link]("customerNumber"));

[Link]([Link]("chequeNumber"));

[Link]([Link]("paymentDate"));

[Link]([Link]("amount"));

[Link](payment);
 }

} catch (SQLException e) {

[Link]();

}finally{

try{

[Link]();

[Link]();

}catch(Exception e){

[Link]();

} }

return paymentList;

[Link]*

package [Link];

import [Link];

public class Payment {

private int customerNumber;

private String chequeNumber;

private Date paymentDate;

private int amount;

public int getCustomerNumber() {

return customerNumber;

}
 public void setCustomerNumber(int customerNumber) {

[Link] = customerNumber;

public String getChequeNumber() {

return chequeNumber;

public void setChequeNumber(String chequeNumber) {

[Link] = chequeNumber;

public Date getPaymentDate() {

return paymentDate;

public void setPaymentDate(Date paymentDate) {

[Link] = paymentDate;

public int getAmount() {

return amount;

public void setAmount(int amount) {

[Link] = amount;

@Override

public String toString() {

return [Link]("%15s%15s%15s%15s", customerNumber, chequeNumber, paymentDate,

amount);

}
[Link]*

package [Link];

import [Link].*;

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

public class PaymentService {

private PaymentDao paymentDao=new PaymentDao();

public List<Payment> findCustomerByNumber(int customerNumber){

List<Payment> list=[Link]();

List<Payment> list2 = new ArrayList<>();

list2 = [Link]().filter(x->[Link]()==customerNumber).collect([Link]());

return list2;

public List<Payment> findCustomerByYear(int year){

List<Payment> list=[Link]();

List<Payment> list2 = new ArrayList<>();

list2 = [Link]().filter(x->[Link]().getYear()==(year-
1900)).sorted([Link](Payment::getAmount)).collect([Link]());

return list2;

}
[Link]*

package [Link];

import [Link];

import [Link];

import [Link];

public class SkeletonValidator {

public SkeletonValidator(){

validateClassName("[Link]");

validateMethodSignature("getAllRecord:[Link]","[Link]");

validateClassName("[Link]");

validateMethodSignature("toString:[Link]","[Link]");

validateClassName("[Link]");

validateMethodSignature("findCustomerByNumber:[Link],findCustomerByYear:[Link]","[Link].
[Link]");

validateClassName("[Link]");

validateMethodSignature("getConnection:[Link]","[Link]")
;

private static final Logger LOG = [Link]("SkeletonValidator");

protected final boolean validateClassName(String className) {

 boolean iscorrect = false;

try {

[Link](className);

iscorrect = true;

[Link]("Class Name " + className + " is correct");

} catch (ClassNotFoundException e) {

[Link]([Link], "You have changed either the " + "class name/package. Use the
correct package "

+ "and class name as provided in the skeleton");

} catch (Exception e) {

[Link]([Link],

"There is an error in validating the " + "Class Name. Please manually verify
that the "

+ "Class name is same as skeleton before uploading");

return iscorrect;

protected final void validateMethodSignature(String methodWithExcptn, String className) {

Class cls = null;

try {

String[] actualmethods = [Link](",");

boolean errorFlag = false;

String[] methodSignature;

String methodName = null;

String returnType = null;

for (String singleMethod : actualmethods) {

boolean foundMethod = false;

methodSignature = [Link](":");
 methodName = methodSignature[0];

returnType = methodSignature[1];

cls = [Link](className);

Method[] methods = [Link]();

for (Method findMethod : methods) {

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

foundMethod = true;

if (!([Link]().getName().equals(returnType))) {

errorFlag = true;

[Link]([Link], " You have changed the " + "return

type in '" + methodName

+ "' method. Please stick to the " + "skeleton

provided");

} else {

[Link]("Method signature of " + methodName + " is

valid");

if (!foundMethod) {

errorFlag = true;

[Link]([Link], " Unable to find the given public method " +

methodName

+ ". Do not change the " + "given public method name. " +
"Verify it with the skeleton");

if (!errorFlag) {

[Link]("Method signature is valid");

} catch (Exception e) {

[Link]([Link],
 " There is an error in validating the " + "method structure. Please manually
verify that the "

+ "Method signature is same as the skeleton before

uploading");

[Link]*

package [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

public class DatabaseUtil {

private DatabaseUtil() {

private static Connection con = null;

private static Properties props = new Properties();

//ENSURE YOU DON'T CHANGE THE BELOW CODE WHEN YOU SUBMIT

public static Connection getConnection() {

try{
 FileInputStream fis = null;

fis = new FileInputStream("resource/[Link]");

[Link](fis);

// load the Driver Class

try {

[Link]([Link]("DB_DRIVER_CLASS"));

} catch (ClassNotFoundException e) {

// TODO Auto-generated catch block

[Link]();

// create the connection now

try {

con =
[Link]([Link]("DB_URL"),[Link]("DB_USERNAME"),[Link]
y("DB_PASSWORD"));

} catch (SQLException e) {

// TODO Auto-generated catch block

[Link]();

catch(IOException e){

[Link]();

return con;

}
[Link](Main)*

package [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

public class App {

public static void main(String[] args) throws ParseException {

new SkeletonValidator();

Payment payment=null;

Scanner scanner=new Scanner([Link]);

do{

[Link]("Select Option:");

[Link]("[Link] list\[Link] Customer List\[Link]");

int choice=[Link]();

switch(choice){

case 1:[Link]("Enter customer number");

int number=[Link]();

List<Payment> numberList=new PaymentService().findCustomerByNumber(number);

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

[Link]("\nNo Records Found\n");

}else{
 [Link]("%15s%15s%15s%15s\n","Customer Number","Cheque Number","Payment
Date","Amount");

[Link]()

.forEach([Link]::println);

break;

case 2:[Link]("Enter year");

int year=[Link]();

List<Payment> yearList=new PaymentService().findCustomerByYear(year);

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

[Link]("\nNo Records Found\n");

}else{

[Link]("%15s%15s%15s%15s\n","Customer Number","Cheque Number","Payment

Date","Amount");

[Link]()

.forEach([Link]::println);

break;

case 3:[Link](0);

default:[Link]("\nWrong Choice\n");

}while(true);

}
 Employee Eligibility for Promotion

[Link]*

import [Link];

import [Link];

import [Link];

import [Link];

import [Link].*;

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

public class Main {

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

//[Link]("In-time");

DateTimeFormatter formatter = [Link]("dd/MM/yyyy");

LocalDate currTime = [Link](2019, 01, 01);

String fdt=[Link](formatter);

// [Link](fdt);

int no = [Link]();

Map<String, String> m = new TreeMap<>();

for (int i = 1; i <= no; i++) {

String id = [Link]();

String date = [Link]();

[Link](id, date);

}
 int count = 0;

int val = 0;

for (Entry<String, String> entry : [Link]()) {

if ([Link]().matches("(0[1-9]|[1-2][0-9]|3[0-1])/(0[1-9]|1[0-2])/[0-9]{4}"))

val++;

LocalDate InTime = [Link]([Link](), formatter);

Period in = [Link](InTime, currTime);

long lin = [Link]([Link]);

if (lin >= 5)

count++;

[Link]([Link]());

else

[Link]("Invalid date format");

break;

if (count == 0 && val == no)

[Link]("No one is eligible");

}
 Exam Scheduler

[Link]*

package [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link].*;

import [Link];

import [Link];

public class AssessmentDAO {

public int uploadAssessments(List<Assessment> assessments) throws Exception {

if(assessments==null || [Link]()) {

throw new Exception("List is Empty");

int rowsCount = 0;

//Write your logic here...

try{

Connection con = [Link]();

for(Assessment a:assessments)

PreparedStatement st = [Link]("insert into assessment values(?,?,?,?,?,?)");

[Link](1,[Link]());

[Link](2,[Link]());

[Link](3,[Link]().toString());

[Link](4,[Link]().toString());
 [Link](5,[Link]().toString());

[Link](6,[Link]().toString());

int rs=[Link]();

if(rs!=-1)

rowsCount=rowsCount+1;

} catch(SQLException e){

return rowsCount;

public Assessment findAssessment(String code) throws Exception {

Assessment assessment = null;

Connection conn = [Link]();

String sql = "SELECT * FROM assessment where code=?";

PreparedStatement ps = [Link](sql);

[Link](1, code);

ResultSet rs = [Link]();

if([Link]()) {

assessment = new Assessment();

[Link]([Link](1));

[Link]([Link](2));

[Link]([Link]([Link](3)));

[Link]([Link]([Link](4)));

[Link]([Link]([Link](5)));

[Link]([Link]([Link](6)));

return assessment;

}
[Link]*

package [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

public class GenerateAssessmentFunction implements Function<String, Assessment>{

@Override

public Assessment apply(String t) {

//Write your code here...

String temp[]=[Link](",");

Assessment a = new
Assessment(temp[0],temp[1],[Link](temp[2]),[Link](temp[3]),[Link](temp[4]),Period.p
arse(temp[5]));

return a;

[Link]*

package [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

public class Assessment {

 private String examCode;

private String examTitle;

private LocalDate examDate;

private LocalTime examTime;

private Duration examDuration;

private Period evalDays;

public Assessment(String examCode, String examTitle, LocalDate examDate, LocalTime examTime, Duration
examDuration,

Period evalDays) {

super();

[Link] = examCode;

[Link] = examTitle;

[Link] = examDate;

[Link] = examTime;

[Link] = examDuration;

[Link] = evalDays;

public Assessment() {

public String getExamCode() {

return examCode;

public void setExamCode(String examCode) {

[Link] = examCode;

public String getExamTitle() {

return examTitle;

}
public void setExamTitle(String examTitle) {

[Link] = examTitle;

public LocalDate getExamDate() {

return examDate;

public void setExamDate(LocalDate examDate) {

[Link] = examDate;

public LocalTime getExamTime() {

return examTime;

public void setExamTime(LocalTime examTime) {

[Link] = examTime;

public Duration getExamDuration() {

return examDuration;

public void setExamDuration(Duration examDuration) {

[Link] = examDuration;

public Period getEvalDays() {

return evalDays;

public void setEvalDays(Period evalDays) {

[Link] = evalDays;
 }

public void printDetails() {

DateTimeFormatter date1=[Link]("dd-MMM-y");

DateTimeFormatter date2=[Link]("HH:mm");

LocalTime t=[Link](examDuration);

String d=[Link]("HH:mm").format(t);

LocalDate t1=[Link](evalDays);

String d1=[Link]("dd-MMM-y").format(t1);

[Link]("Assessment Code: "+examCode);

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

[Link]("Assessment Date: "+[Link](date1));

[Link]("Start Time: "+[Link](date2));

[Link]("End Time: "+d);

[Link]("Result Date: "+d1);

//Write your code here...

[Link]*

package [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

public class DatabaseUtil {

private static Connection con = null;

 private static Properties props = new Properties();

//ENSURE YOU DON'T CHANGE THE BELOW CODE WHEN YOU SUBMIT

public static Connection getConnection() throws ClassNotFoundException, SQLException {

try{

FileInputStream fis = null;

fis = new FileInputStream("resource/[Link]");

[Link](fis);

// load the Driver Class

[Link]([Link]("DB_DRIVER_CLASS"));

// create the connection now

con =
[Link]([Link]("DB_URL"),[Link]("DB_USERNAME"),[Link]
y("DB_PASSWORD"));

catch(IOException e){

[Link]();

return con;

[Link]*

package [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];
import [Link];

import [Link];

import [Link].*;

import [Link].*;

import [Link];

import [Link];

public class FileUtil {

public static List<Assessment> loadData(String fileName) throws IOException {

List<Assessment> list = null;

Function<String, Assessment> function = new GenerateAssessmentFunction();

BufferedReader br=new BufferedReader(new FileReader(fileName));

String line="";

list=new ArrayList<Assessment>();

while((line=[Link]())!=null)

[Link]([Link](line));

//Write your code here...

return list;

[Link]*

package [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];
import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

public class SkeletonValidator {

private static final Logger LOG = [Link]("SkeletonValidator");

public SkeletonValidator() {

String assessmentClass = "[Link]";

String assessmentDAOClass = "[Link]";

String funtionalClass = "[Link]";

String databaseUtilClass = "[Link]";

String fileUtilClass = "[Link]";

Class[] assessmentParams = { [Link], [Link], [Link], [Link],

[Link],

[Link] };

String[] assessmentFields = { "examCode", "examTitle", "examDate", "examTime", "examDuration",

"evalDays" };

testClass(assessmentClass, assessmentParams);

testClass(assessmentDAOClass, null);

testClass(funtionalClass, null);

testClass(databaseUtilClass, null);

testClass(fileUtilClass, null);

testFields(assessmentClass, assessmentFields);

testMethods(assessmentClass, "printDetails", null, null);

testMethods(assessmentDAOClass, "uploadAssessments", new Class[] { [Link] }, [Link]);

testMethods(assessmentDAOClass, "findAssessment", new Class[] { [Link] }, [Link]);

testMethods(funtionalClass, "apply", new Class[] { [Link] }, [Link]);

 testMethods(databaseUtilClass, "getConnection", null, [Link]);

testMethods(fileUtilClass, "loadData", new Class[] { [Link] }, [Link]);

public void testClass(String className, Class[] paramTypes) {

try {

Class classUnderTest = [Link](className);

[Link]("Class Name " + className + " is correct");

Constructor<?> constructor = [Link](paramTypes);

[Link](constructor);

[Link](className + " Constructor is valid");

} catch (ClassNotFoundException e) {

[Link]([Link], "You have changed either the class name/package. "

+ "Use the correct package and class name as provided in the skeleton");

} catch (NoSuchMethodException e) {

[Link]([Link], " Unable to find the given constructor. "

+ "Do not change the given public constructor. " + "Verify it with the
skeleton");

} catch (SecurityException e) {

[Link]([Link],

"There is an error in validating the " + className + ". " + "Please verify the
skeleton manually");

public void testFields(String className, String[] fields) {

try {

Class classUnderTest = [Link](className);

for (String field : fields) {

[Link](field);

[Link]("Fields in " + className + " are correct");

} catch (ClassNotFoundException e) {

[Link]([Link], "You have changed either the class name/package. "

+ "Use the correct package and class name as provided in the skeleton");
 } catch (NoSuchFieldException e) {

[Link]([Link],

"You have changed one/more field(s). " + "Use the field name(s) as provided
in the skeleton");

} catch (SecurityException e) {

[Link]([Link],

"There is an error in validating the " + className + ". " + "Please verify the
skeleton manually");

public void testMethods(String className, String methodName, Class[] paramTypes, Class returnType) {

try {

Class classUnderTest = [Link](className);

Method method = [Link](methodName, paramTypes);

Class retType = [Link]();

if (returnType != null && ) {

[Link]([Link], " You have changed the " + "return type in '" + methodName

+ "' method. Please stick to the " + "skeleton provided");

throw new NoSuchMethodException();

[Link](methodName + " signature is valid.");

} catch (ClassNotFoundException e) {

[Link]([Link], "You have changed either the class name/package. "

+ "Use the correct package and class name as provided in the skeleton");

} catch (NoSuchMethodException e) {

[Link]([Link], "You have changed/removed method " + methodName + ". "

+ "Use the method signature as provided in the skeleton");

} catch (SecurityException e) {

[Link]([Link],

"There is an error in validating the " + className + ". " + "Please verify the
skeleton manually");

}
[Link]*

package [Link];

import [Link];

import [Link];

import [Link];

import [Link];

public class Main {

public static void main(String[] args) {

// CODE SKELETON - VALIDATION STARTS

// DO NOT CHANGE THIS CODE

new SkeletonValidator();

// CODE SKELETON - VALIDATION ENDS

try {

List<Assessment> assessments = [Link]("resource/[Link]");

AssessmentDAO dao = new AssessmentDAO();

[Link](assessments);

Assessment assessment = [Link]("ASEJE025");

[Link]();

} catch (Exception e) {

[Link](e);

}
 Book Details

[Link]*

import [Link];

public class Main {

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

//fill the code

String string = [Link]();

if([Link]()==18)

String substr1 = [Link](0,3);

int i1 = [Link](substr1);

if(i1>100 && i1<104)

String substr2 = [Link](3,7);

int i2 = [Link](substr2);

if(i2>=1900 && i2<=2020)

String substr3 = [Link](7,12);

//[Link](substr3);

int i3 = [Link](substr3);

if(i3>=10)

String substr4 = [Link](12,13);

String substr5 = [Link](13,18);

if(([Link](0)>='A'&&[Link](0)<='Z')||([Link](0)>='a'&&[Link](0)<='z'))

if(([Link](0)>='0'&&[Link](0)<='9')&&([Link](1)>='0'&&[Link](1)<='9')&&

([Link](2)>='0'&&[Link](2)<='9')&&([Link](3)>='0'&&[Link](3)<='9')&&

([Link](4)>='0'&&[Link](4)<='9'))

{
 String substr6 = [Link](12,18);

[Link]("Department Code: "+substr1);

if(i1==101)

[Link]("Department Name: "+"Accounting");

else if(i1==102)

[Link]("Department Name: "+"Economics");

else if(i1==103)

[Link]("Department Name: "+"Engineering");

[Link]("Year of Publication: "+substr2);

[Link]("Number of Pages: "+substr3);

[Link]("Book Id: "+substr6);

else

String substr6 = [Link](12,18);

[Link]("%s is invalid book id",substr6);

[Link]("\n");

else

String substr6 = [Link](12,18);

[Link]("%s is invalid book id",substr6);

[Link]("\n");

else

[Link]("%s are invalid pages",substr3);

[Link]("\n");

}
 }

else

[Link]("%d is invalid year",i2);

[Link]("\n");

else

[Link]("%d is invalid department code",i1);

[Link]("\n");

else

[Link]("%s is invalid input",string);

[Link]("\n");

}
 Find Membership Category

[Link]*

public class Member {

private String memberId;

private String memberName;

private String category;

public String getMemberId() {

return memberId;

public void setMemberId(String memberId) {

[Link] = memberId;

public String getMemberName() {

return memberName;

public void setMemberName(String memberName) {

[Link] = memberName;

public String getCategory() {

return category;

public void setCategory(String category) {

[Link] = category;

public Member(String memberId, String memberName, String category) {

super();

[Link] = memberId;

[Link] = memberName;

[Link] = category;

}
}

[Link]*

import [Link];

public class ZEEShop extends Thread

private String memberCategory;

private int count;

private List<Member> memberList;

public ZEEShop(String memberCategory, List<Member> memberList) {

super();

[Link] = memberCategory;

[Link] = memberList;

public String getMemberCategory() {

return memberCategory;

public void setMemberCategory(String memberCategory) {

[Link] = memberCategory;

}
public int getCount() {

return count;

public void setCount(int count) {

[Link] = count;

public List<Member> getMemberList() {

return memberList;

public void setMemberList(List<Member> memberList) {

[Link] = memberList;

public void run()

synchronized(this)

for(Member m:memberList)

if([Link]().equals(memberCategory))

count++;

}
 }

[Link]*

import [Link];

import [Link];

import [Link];

public class Main {

public static void main(String[] args) {

// TODO Auto-generated method stub

List<Member> mList=new ArrayList<Member>();

[Link]("Enter the number of Members:");

Scanner sc=new Scanner([Link]);

int tot=[Link]();

String[] str=new String[tot];

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

[Link]("Enter the Member Details:");

str[i]=[Link]();

Member m[]=new Member[tot];

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

String s[]=str[i].split(":");
 m[i]=new Member(s[0],s[1],s[2]);

[Link](m[i]);

[Link]("Enter the number of times Membership category needs to be searched:");

int tot1=[Link]();

ZEEShop t1[]=new ZEEShop[tot1];

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

[Link]("Enter the Category");

String s1=[Link]();

t1[i]=new ZEEShop(s1,mList);

t1[i].start();

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

try {

[Link]().sleep(2000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

[Link]();

for(ZEEShop s:t1)

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

}
 Go Hospitals

[Link]*

public class InPatient extends Patient{

private double roomRent;

public InPatient(String patientId, String patientName, long mobileNumber, String gender, double roomRent) {

super(patientId,patientName,mobileNumber,gender);

[Link]=roomRent;

public double getRoomRent() {

return roomRent;

public void setRoomRent(double roomRent) {

[Link] = roomRent;

// Fill the code

public double calculateTotalBill(int noOfDays,double medicinalBill){

// Fill the code

double bill_amount;

bill_amount=(([Link]*noOfDays)+medicinalBill);

return bill_amount;

[Link]*

public class OutPatient extends Patient{

 private double consultingFee;

public OutPatient(String patientId, String patientName, long mobileNumber, String gender, double consultingFee)
{

super(patientId,patientName,mobileNumber,gender);

[Link]=consultingFee;

public double getConsultingFee() {

return consultingFee;

public void setConsultingFee(double consultingFee) {

[Link] = consultingFee;

// Fill the code

public double calculateTotalBill(double scanPay,double medicinalBill){

// Fill the code

double bill_amount;

bill_amount=[Link]+scanPay+medicinalBill;

return bill_amount;

[Link]*

public class Patient {

protected String patientId;

protected String patientName;

protected long mobileNumber;

protected String gender;

public Patient(String patientId, String patientName, long mobileNumber, String gender) {

[Link] = patientId;

[Link] = patientName;

[Link] = mobileNumber;

[Link] = gender;

public String getPatientId() {

return patientId;

public void setPatientId(String patientId) {

[Link] = patientId;

public String getPatientName() {

return patientName;

public void setPatientName(String patientName) {

[Link] = patientName;

public long getMobileNumber() {

return mobileNumber;

public void setMobileNumber(long mobileNumber) {

[Link] = mobileNumber;

public String getGender() {

return gender;

public void setGender(String gender) {

[Link] = gender;
 }

[Link]*

import [Link];

public class UserInterface {

public static void main(String[] args){

Scanner read=new Scanner([Link]);

[Link]("[Link] Patient");

[Link]("[Link] Patient");

[Link]("Enter the choice");

int ch=[Link]();

[Link]("Enter the details");

[Link]("Patient Id");

String id=[Link]();

[Link]("Patient Name");

String name=[Link]();

[Link]();

[Link]("Phone Number");

long num=[Link]();

[Link]("Gender");

String gen=[Link]();

if(ch==1){

[Link]("Room Rent");

double rent=[Link]();

InPatient in=new InPatient(id,name,num,gen,rent);

[Link]("Medicinal Bill");
 double bill=[Link]();

[Link]("Number of Days of Stay");

int days=[Link]();

[Link]("Amount to be paid "+[Link](days,bill));

else{

[Link]("Consultancy Fee");

double fee=[Link]();

OutPatient out=new OutPatient(id,name,num,gen,fee);

[Link]("Medicinal Bill");

double medbill=[Link]();

[Link]("Scan Pay");

double pay=[Link]();

[Link]("Amount to be paid "+[Link](pay,medbill));

// Fill the code

}
 Grade Calculation

[Link]*

public class GradeCalculator extends Thread {

private String studName;

private char result;

private int[] marks;

public String getStudName(){

return studName;

public void setStudName(String studName){

[Link] = studName;

public char getResult(){

return result;

public void setResult(char result){

[Link] = result;

public int[] getMarks(){

return marks;

public void setMarks(int[] marks){

[Link] = marks;

}
 public GradeCalculator(String studName, int[] marks){

[Link] = studName;

[Link] = marks;

public void run(){

int sum = 0;

int[] score = getMarks();

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

sum = sum+score[i];

if((400<=sum)&&(sum<=500))

[Link](getStudName()+":"+'A');

if((300<=sum)&&(sum<=399))

[Link](getStudName()+":"+'B');

if((200<=sum)&&(sum<=299))

[Link](getStudName()+":"+'C');

if(sum<200)

[Link](getStudName()+":"+'E');

[Link]*

import [Link];

import [Link];

import [Link];

public class Main {

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

BufferedReader br = new BufferedReader(new InputStreamReader([Link]));

[Link]("Enter the number of Threads:");

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

GradeCalculator obj = null;

String str = "";

 String details[] = new String[th];

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

[Link]("Enter the String:");

str = [Link]();

details[i]=str;

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

String sp[] = details[i].split(":");

int k = 0;

int arr[] = new int[[Link]];

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

arr[k++] = [Link](sp[j]);

obj = new GradeCalculator(sp[0],arr);

[Link]();

try{

[Link](1000);

catch(Exception e)

[Link](e);

}
 Passanger Amenity

[Link]*

import [Link];

public class Main {

public static void main(String[] args) {

int num,n,i,count1=0,count2=0,y;

char alpha,ch;

String n1,n2;

Scanner sc = new Scanner([Link]);

//fill the code

[Link]("Enter the number of passengers");

n=[Link]();

if(n<=0){

[Link](n+" is invalid input");

[Link](0);

String[] arr1=new String[n];

String[] arr2=new String[n];

for(i=0;i<n;i++,count1=0,count2=0){

[Link]("Enter the name of the passenger "+(i+1));

arr1[i] =[Link]();

[Link]("Enter the seat details of the passenger "+(i+1));

arr2[i]= [Link]();

num =[Link](arr2[i].substring(1,(arr2[i].length())));

alpha= arr2[i].charAt(0);

if(num>=10 && num<=99){

count2++;

for(ch=65;ch<84;ch++){

if(ch==alpha){

count1++;

if(count1==0){
 [Link](""+alpha+" is invalid coach");

[Link](0);

if(count2==0){

[Link](num+" is invalid seat number");

[Link](0);

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

for(int j=i+1;j<n;j++){

if(arr2[i].charAt(0)==arr2[j].charAt(0)){

if(([Link](arr2[i].substring(1,(arr2[i].length()))))<([Link](arr2[j].substring(1,arr2[j].length())))){

n1=arr1[i];

n2=arr2[i];

arr1[i]=arr1[j];

arr2[i]=arr2[j];

arr1[j]=n1;

arr2[j]=n2;

else

if(arr2[i].charAt(0)<arr2[j].charAt(0))

n1=arr1[i];

n2=arr2[i];

arr1[i]=arr1[j];

arr2[i]=arr2[j];

arr1[j]=n1;

arr2[j]=n2;

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

String a=arr1[i].toUpperCase();

String b=arr2[i];

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

[Link]("");

}
 Perform Calculation

[Link]*

public interface Calculate {

float performCalculation(int a,int b);

[Link]*

import [Link];

public class Calculator {

public static void main (String[] args) {

Scanner sc=new Scanner([Link]);

int a = [Link]();

int b= [Link]();

Calculate Perform_addition = performAddition();

Calculate Perform_subtraction = performSubtraction();

Calculate Perform_product = performProduct();

Calculate Perform_division = performDivision();

 [Link]("The sum is "+Perform_addition.performCalculation(a,b));

[Link]("The difference is "+Perform_subtraction.performCalculation(a,b));

[Link]("The product is "+Perform_product.performCalculation(a,b));

[Link]("The division value is "+Perform_division.performCalculation(a,b));

public static Calculate performAddition(){

Calculate Perform_calculation = (int a,int b)->a+b;

return Perform_calculation;

public static Calculate performSubtraction(){

Calculate Perform_calculation = (int a,int b)->a-b;

return Perform_calculation;

public static Calculate performProduct(){

Calculate Perform_calculation = (int a,int b)->a*b;

return Perform_calculation;
 }

public static Calculate performDivision(){

Calculate Perform_calculation = (int a,int b)->{

float c = (float)a;

float d = (float)b;

return (c/d);

};

return Perform_calculation;

}
 Query DataSet

[Link]*

//Write the required business logic as expected in the question description

public class Query {

private String queryId;

private String queryCategory;

private DataSet primaryDataSet;

private DataSet secondaryDataSet;

@Override

public String toString()

String g="";

g+=("Primary data set"+"\n");

g+=("Theatre id : "+[Link]()+"\n");

g+=("Theatre name : "+[Link]()+"\n");

g+=("Location :"+[Link]()+"\n");

g+=("No of Screen : "+[Link]()+"\n");

g+=("Ticket Cost : "+[Link]()+"\n");

g+=("Secondary data set"+"\n");

g+=("Theatre id : "+[Link]()+"\n");

g+=("Theatre name : "+[Link]()+"\n");

g+=("Location :"+[Link]()+"\n");

g+=("No of Screen : "+[Link]()+"\n");

g+=("Ticket Cost : "+[Link]()+"\n");

g+=("Query id : "+queryId+"\n");

g+=("Query category : "+queryCategory+"\n");

return g;

}
public class DataSet{

private String theatreId;

private String theatreName;

private String location;

private int noOfScreen;

private double ticketCost;

public double getTicketCost()

return ticketCost;

public void setTicketCost(double a)

ticketCost=a;

public int getNoOfScreen()

return noOfScreen;

public void setNoOfScreen(int a)

noOfScreen=a;

public String getLocation ()

return location;

public void setLocation(String a)

location=a;
 }

public String getTheatreName ()

return theatreName;

public void setTheatreName(String a)

theatreName=a;

public String getTheatreId ()

return theatreId;

public void setTheatreId(String a)

theatreId=a;

public void setSecondaryDataSet(DataSet pD)

[Link]=pD;

public DataSet getSecondaryDataSet()

return [Link];

public void setPrimaryDataSet(DataSet pD)

[Link]=pD;

}
 public DataSet getPrimaryDataSet()

return [Link];

public void setQueryId (String queryId)

[Link]=queryId;

public void setQueryCategory(String queryCategory)

[Link]=queryCategory;

public String getQueryId()

return [Link];

public String getQueryCategory()

return [Link];

[Link]*

import [Link].*;

public class TestApplication {

//Write the required business logic as expected in the question description

public static void main (String[] args) {

Scanner sc= new Scanner ([Link]);

Query q= new Query();

[Link] pd= [Link] DataSet();

[Link] sd= [Link] DataSet();

[Link]("Enter the Details for primary data set");

[Link]("Enter the theatre id");

[Link]([Link]());

[Link]("Enter the theatre name");

[Link]([Link]());

[Link]("Enter the location");

[Link]([Link]());

[Link]("Enter the no of screens");

[Link]([Link]());

[Link]("Enter the ticket cost");

[Link]([Link]());

[Link]("Enter the Details for secondary data set");

[Link]("Enter the theatre id");

String id2=[Link]();

// [Link](id2);

[Link](id2);

[Link]("Enter the theatre name");

[Link]();

[Link]([Link]());

[Link]("Enter the location");

String gll=[Link]();

[Link](gll);

[Link]("Enter the no of screens");

// [Link](gll);

// String pp=[Link]();

// [Link](pp);

[Link]([Link]());

[Link]("Enter the ticket cost");

[Link]([Link]());

[Link]();

[Link]("Enter the query id");

[Link]([Link]());

[Link]("Enter the query category");

[Link]([Link]());
 [Link](sd);

[Link](pd);

[Link]([Link]());

}
 Retrive Flight Based On Source And Destination

[Link]*

public class Flight {

private int flightId;

private String source;

private String destination;

private int noOfSeats;

private double flightFare;

public int getFlightId() {

return flightId;

public void setFlightId(int flightId) {

[Link] = flightId;

public String getSource() {

return source;

public void setSource(String source) {

[Link] = source;

public String getDestination() {

return destination;

public void setDestination(String destination) {

[Link] = destination;

public int getNoOfSeats() {

return noOfSeats;

public void setNoOfSeats(int noOfSeats) {

[Link] = noOfSeats;

}
 public double getFlightFare() {

return flightFare;

public void setFlightFare(double flightFare) {

[Link] = flightFare;

public Flight(int flightId, String source, String destination,

int noOfSeats, double flightFare) {

super();

[Link] = flightId;

[Link] = source;

[Link] = destination;

[Link] = noOfSeats;

[Link] = flightFare;

[Link]*

import [Link];

import [Link].*;

public class FlightManagementSystem {

public ArrayList<Flight> viewFlightBySourceDestination(String source, String destination){

ArrayList<Flight> flightList = new ArrayList<Flight>();

try{

Connection con = [Link]();

String query="SELECT * FROM flight WHERE source= '" + source + "' AND destination= '" + destination + "' ";
 Statement st=[Link]();

ResultSet rst= [Link](query);

while([Link]()){

int flightId= [Link](1);

String src=[Link](2);

String dst=[Link](3);

int noofseats=[Link](4);

double flightfare=[Link](5);

[Link](new Flight(flightId, src, dst, noofseats, flightfare));

}catch(ClassNotFoundException | SQLException e){

[Link]();

return flightList;

[Link]*

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

public class DB {

private static Connection con = null;

private static Properties props = new Properties();

 //ENSURE YOU DON'T CHANGE THE BELOW CODE WHEN YOU SUBMIT

public static Connection getConnection() throws ClassNotFoundException, SQLException {

try{

FileInputStream fis = null;

fis = new FileInputStream("[Link]");

[Link](fis);

// load the Driver Class

[Link]([Link]("DB_DRIVER_CLASS"));

// create the connection now

con =
[Link]([Link]("DB_URL"),[Link]("DB_USERNAME"),[Link]
y("DB_PASSWORD"));

catch(IOException e){

[Link]();

return con;

[Link]*

import [Link];

import [Link];

public class Main{

public static void main(String[] args){

Scanner sc=new Scanner([Link]);

[Link]("Enter the source");

String source=[Link]();

[Link]("Enter the destination");

String destination=[Link]();
 FlightManagementSystem fms= new FlightManagementSystem();

ArrayList<Flight> flightList=[Link](source,destination);

if([Link]()){

[Link]("No flights available for the given source and destination");

return;

[Link]("Flightid Noofseats Flightfare");

for(Flight flight : flightList){

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

}
 Silver Health Plan Insurance

[Link]

public class FamilyInsurancePolicy extends InsurancePolicies{

public FamilyInsurancePolicy(String clientName, String policyId, int age, long mobileNumber, String emailId) {

super(clientName, policyId, age, mobileNumber, emailId);

public boolean validatePolicyId()

int count=0;

if([Link]("FAMILY"));

count++;

char ch[]=[Link]();

for(int i=6;i<9;i++)

if(ch[i]>='0' && ch[i]<='9')

count++;

if(count==4)

return true;

else

return false;

public double calculateInsuranceAmount(int months, int no_of_members)

double amount=0;

if(age>=5 && age<=25)

amount=2500*months*no_of_members;

else if (age>25 && age<60)

amount=5000*months*no_of_members;

else if (age>=60)

amount=10000*months*no_of_members;
 return amount;

[Link]*

public class IndividualInsurancePolicy extends InsurancePolicies{

public IndividualInsurancePolicy(String clientName, String policyId, int age, long mobileNumber, String
emailId) {

super(clientName, policyId, age, mobileNumber, emailId);

public boolean validatePolicyId()

int count=0;

if([Link]("SINGLE"));

count++;

char ch[]=[Link]();

for(int i=6;i<9;i++)

if(ch[i]>='0' && ch[i]<='9')

count++;

if(count==4)

return true;

else

return false;

public double calculateInsuranceAmount(int months)

double amount=0;
 if(age>=5 && age<=25)

amount=2500*months;

else if (age>25 && age<60)

amount=5000*months;

else if (age>=60)

amount=10000*months;

return amount;

[Link]*

public class InsurancePolicies {

protected String clientName;

protected String policyId;

protected int age;

protected long mobileNumber;

protected String emailId;

public String getClientName() {

return clientName;

public void setClientName(String clientName) {

[Link] = clientName;

public String getPolicyId() {

return policyId;

public void setPolicyId(String policyId) {

[Link] = policyId;

public int getAge() {

return age;

public void setAge(int age) {

 [Link] = age;

public long getMobileNumber() {

return mobileNumber;

public void setMobileNumber(long mobileNumber) {

[Link] = mobileNumber;

public String getEmailId() {

return emailId;

public void setEmailId(String emailId) {

[Link] = emailId;

public InsurancePolicies(String clientName, String policyId, int age, long mobileNumber, String emailId) {

super();

[Link] = clientName;

[Link] = policyId;

[Link] = age;

[Link] = mobileNumber;

[Link] = emailId;

[Link]*

public class SeniorCitizenPolicy extends InsurancePolicies{

public SeniorCitizenPolicy(String clientName, String policyId, int age, long mobileNumber, String emailId) {

super(clientName, policyId, age, mobileNumber, emailId);

public boolean validatePolicyId()

int count=0;

if([Link]("SENIOR"));
 count++;

char ch[]=[Link]();

for(int i=6;i<9;i++)

if(ch[i]>='0' && ch[i]<='9')

count++;

if(count==4)

return true;

else

return false;

public double calculateInsuranceAmount(int months, int no_of_members)

double amount=0;

if(age>=5 && age<60)

amount=0;

else if (age>=60)

amount=10000*months*no_of_members;

return amount;

[Link]*

import [Link];

public class UserInterface {

public static void main(String[] args)

{
Scanner sc=new Scanner([Link]);

[Link]("Enter Client name");

String name=[Link]();

[Link]("Enter Policy Id");

String id=[Link]();

[Link]("Enter Client age");

int age=[Link]();

[Link]("Enter mobile number");

long mnum=[Link]();

[Link]("Enter Email Id");

String email=[Link]();

InsurancePolicies policy=new InsurancePolicies(name,id,age,mnum,email);

[Link]("Enter the months");

int month=[Link]();

double amount=0;

if([Link]("SINGLE"))

IndividualInsurancePolicy g=new IndividualInsurancePolicy(name,id,age,mnum,email);

if([Link]())

//[Link]([Link]());

amount=[Link](month);

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

[Link]("Email Id :"+email);

[Link]("Amount to be paid :"+amount);

else

[Link]("Provide valid Policy Id");

}
else if([Link]("FAMILY"))

FamilyInsurancePolicy g=new FamilyInsurancePolicy(name,id,age,mnum,email);

if([Link]())

[Link]("Enter number of members");

int num=[Link]();

amount=[Link](month,num);

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

[Link]("Email Id :"+email);

[Link]("Amount to be paid :"+amount);

else

[Link]("Provide valid Policy Id");

else if([Link]("SENIOR"))

SeniorCitizenPolicy g=new SeniorCitizenPolicy(name,id,age,mnum,email);

if([Link]())

[Link]("Enter number of members");

int num=[Link]();

amount=[Link](month,num);

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

[Link]("Email Id :"+email);

[Link]("Amount to be paid :"+amount);

else

[Link]("Provide valid Policy Id");

}
 else

[Link]("Provide valid Policy Id");

}
 Travel Request System

[Link]*

package [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link].*;

import [Link].*;

//import [Link];

import [Link];

class DB{

private static Connection con = null;

private static Properties props = new Properties();

//ENSURE YOU DON'T CHANGE THE BELOW CODE WHEN YOU SUBMIT

public static Connection getConnection() throws ClassNotFoundException, SQLException {

try{

FileInputStream fis = null;

fis = new FileInputStream("resource/[Link]");

[Link](fis);

// load the Driver Class

[Link]([Link]("DB_DRIVER_CLASS"));

// create the connection now

 con =
[Link]([Link]("DB_URL"),[Link]("DB_USERNAME"),[Link]
y("DB_PASSWORD"));

catch(IOException e){

[Link]();

return con;

/**

* Method to get travel details based on source and destination city *

* @return list

*/

public class TravelRequestDao{

// public PreparedStatement prepareStatement(String query) throws SQLException{}

public static List<TravelRequest> getTravelDetails(String sourceCity, String destinationCity) {

List<TravelRequest> travel=new ArrayList<>();

try{

Connection con=[Link]();

String query="Select * from t_travelrequest where sourceCity=? and destinationCity=?;";

PreparedStatement ps=[Link](query);

[Link](1,sourceCity);

[Link](2,destinationCity);

ResultSet rs=[Link]();

while([Link]()){

String tid=[Link]("travelReqId");

[Link] date=[Link]("travelDate");

String apstat=[Link]("approvalStatus");

String sour=[Link]("sourceCity");

String des=[Link]("destinationCity");

double cost=[Link]("travelCost");

TravelRequest tr=new TravelRequest(tid,date,apstat,sour,des,cost);

 [Link](tr);

catch(ClassNotFoundException e){

[Link]();

catch(SQLException e ){

[Link]();

return travel; //TODO change this return value

/**

* Method to calculate total travel cost based approvalStatus

* @return list

*/

public static double calculateTotalTravelCost(String approvalStatus) {

double amount=0;

try{

Connection con=[Link]();

String query="select travelCost from t_travelrequest where approvalStatus=?;";

PreparedStatement ps1=[Link](query);

[Link](1,approvalStatus);

ResultSet rs1=[Link]();

while([Link]()){

amount+=[Link]("travelCost");

catch(ClassNotFoundException e){

[Link]();

}
 catch(SQLException e){

[Link]();

return amount; //TODO change this return value

[Link]*

package [Link];

import [Link];

import [Link];

import [Link];

public class TravelRequestService {

/**

* Method to validate approval status

* @return status

*/

public String validateApprovalStatus(String approvalStatus) {

if([Link]("Approved")||[Link]("Pending")){

return "valid";

return "invalid"; //TODO change this return value

/**

* Method to validate source and destination city

* @return status
 */

public String validateSourceAndDestination(String sourceCity, String destinationCity) {

if(){

if([Link]("Pune")|| [Link]("Mumbai")||
[Link]("Chennai")|| [Link]("Bangalore")||
[Link]("Hydrabad")){

if([Link]("Pune")||
[Link]("Mumbai")||[Link]("Chennai")||
[Link]("Bangalore")|| [Link]("Hydrabad")){

return "valid";

else{

return "invalid";

else{

return "invalid";

else{

return "invalid";

/**

* Method to invoke getTravelDetails method of TravelRequestDao class

* @return listOfTravelRequest

*/

public List<TravelRequest> getTravelDetails(String sourceCity, String destinationCity) {

if([Link](sourceCity,destinationCity).contentEquals("valid")){

return [Link](sourceCity,destinationCity);

else{

return null;

}
 }

/**

* Method to invoke calculateTotalTravelCost method of TravelRequestDao class

* @return totalCost

*/

public double calculateTotalTravelCost(String approvalStatus) {

if([Link](approvalStatus).equals("valid")){

return [Link](approvalStatus);

else{

return -1;

[Link]*

package [Link];

import [Link];

import [Link];

import [Link];

/**

* @author t-aarti3

* This class is used to verify if the Code Skeleton is intact and not

* modified by participants thereby ensuring smooth auto evaluation

* */

public class SkeletonValidator {

public SkeletonValidator() {

validateClassName("[Link]");

validateClassName("[Link]");
 validateMethodSignature(

"validateApprovalStatus:[Link],validateSourceAndDestination:[Link],getTravelDetails:java
.[Link],calculateTotalTravelCost:double",

"[Link]");

private static final Logger LOG = [Link]("SkeletonValidator");

protected final boolean validateClassName(String className) {

boolean iscorrect = false;

try {

[Link](className);

iscorrect = true;

[Link]("Class Name " + className + " is correct");

} catch (ClassNotFoundException e) {

[Link]([Link], "You have changed either the " + "class name/package. Use the
correct package "

+ "and class name as provided in the skeleton");

} catch (Exception e) {

[Link]([Link],

"There is an error in validating the " + "Class Name. Please manually verify
that the "

+ "Class name is same as skeleton before uploading");

return iscorrect;

protected final void validateMethodSignature(String methodWithExcptn, String className) {

Class cls = null;

try {

String[] actualmethods = [Link](",");

 boolean errorFlag = false;

String[] methodSignature;

String methodName = null;

String returnType = null;

for (String singleMethod : actualmethods) {

boolean foundMethod = false;

methodSignature = [Link](":");

methodName = methodSignature[0];

returnType = methodSignature[1];

cls = [Link](className);

Method[] methods = [Link]();

for (Method findMethod : methods) {

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

foundMethod = true;

if (!([Link]().getName().equals(returnType))) {

errorFlag = true;

[Link]([Link], " You have changed the " + "return

type in '" + methodName

+ "' method. Please stick to the " + "skeleton

provided");

} else {

[Link]("Method signature of " + methodName + " is

valid");

if (!foundMethod) {

errorFlag = true;

[Link]([Link], " Unable to find the given public method " +

methodName

+ ". Do not change the " + "given public method name. " +
"Verify it with the skeleton");
 }

if (!errorFlag) {

[Link]("Method signature is valid");

} catch (Exception e) {

[Link]([Link],

" There is an error in validating the " + "method structure. Please manually
verify that the "

+ "Method signature is same as the skeleton before

uploading");

[Link]*

package [Link];

import [Link];

public class TravelRequest {

// member variables

private String travelReqId;

private Date travelDate;

private String approvalStatus;

private String sourceCity;

private String destinationCity;

private double travelCost;

public TravelRequest() {

super();

// TODO Auto-generated constructor stub

}

// parameterized constructor

public TravelRequest(String travelReqId, Date travelDate, String approvalStatus, String sourceCity,

String destinationCity, double travelCost) {

super();

[Link] = travelReqId;

[Link] = travelDate;

[Link] = approvalStatus;

[Link] = sourceCity;

[Link] = destinationCity;

[Link] = travelCost;

// setter, getter

/**

* @return the travelReqId

*/

public String getTravelReqId() {

return travelReqId;

/**

* @param travelReqId

* the travelReqId to set

*/

public void setTravelReqId(String travelReqId) {

[Link] = travelReqId;

/**

* @return the travelDate

*/

public Date getTravelDate() {

return travelDate;

/**
* @param travelDate

* the travelDate to set

*/

public void setTravelDate(Date travelDate) {

[Link] = travelDate;

/**

* @return the approvalStatus

*/

public String getApprovalStatus() {

return approvalStatus;

/**

* @param approvalStatus

* the approvalStatus to set

*/

public void setApprovalStatus(String approvalStatus) {

[Link] = approvalStatus;

/**

* @return the sourceCity

*/

public String getSourceCity() {

return sourceCity;

/**

* @param sourceCity

* the sourceCity to set

*/

public void setSourceCity(String sourceCity) {

[Link] = sourceCity;

/**

* @return the sourceCity

 */

public String getDestinationCity() {

return destinationCity;

/**

* @param destinationCity

* the destinationCity to set

*/

public void setDestinationCity(String destinationCity) {

[Link] = destinationCity;

/**

* @return the travelCost

*/

public double getTravelCost() {

return travelCost;

/**

* @param travelCost

* the travelCost to set

*/

public void setTravelCost(double travelCost) {

[Link] = travelCost;

[Link]*

package [Link];

import [Link].*;

import [Link].*;

import [Link];

import [Link];
import [Link];

import [Link];

public class Main {

public static void main(String[] args) throws SQLException {

// CODE SKELETON - VALIDATION STARTS

// DO NOT CHANGE THIS CODE

new SkeletonValidator();

// CODE SKELETON - VALIDATION ENDS

//TravelRequest tr=new TravelRequest();

//List<TravelRequest> ltr=new ArrayList<>();

TravelRequestService service = new TravelRequestService();

Scanner sc=new Scanner([Link]);

[Link]("Enter source city:");

String sourceCity=[Link]();

[Link]("Enter destination city:");

String destinationCity=[Link]();

[Link]("Enter approval status to find total travel cost:");

String status=[Link]();

if([Link](sourceCity,destinationCity).equals("valid")){

List<TravelRequest> ltr=[Link](sourceCity, destinationCity);

if([Link]()){

[Link]("No travel request raised for given source and destination cities");

else{

for(TravelRequest t:ltr){

SimpleDateFormat sd= new SimpleDateFormat("dd-MMM-YYYY");

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

[Link]([Link]()+"\t| "+d+"\t| "+[Link]()+"\t|

"+[Link]()+"\t| "+[Link]()+"\t| "+[Link]());

}
 else{

[Link]("Provide correct source and destination city");

if([Link](status).contentEquals("valid")){

[Link]([Link](status));

else{

[Link]("Provide valid approval status");