├── README.md
├── Session 2 Data type & Operator.java
├── Elab cpp
    └── 01 Input output
    │   ├── 01 Help Raju 1st game.cpp
    │   ├── 08 Help Raj - Game 2.cpp
    │   ├── 03 Factorial of no.cpp
    │   ├── 02 game of thrones.cpp
    │   ├── 05 count the number.cpp
    │   ├── 06 count char.cpp
    │   ├── 07 MAXIMUM OF N NUMBERS.cpp
    │   ├── 09 Age Calculator.cpp
    │   └── 04 TIME - CPPIOU001.cpp
├── Session 1 input and output.java
├── Session 3 Control and Looping.java
├── session 5 classess and Objects.java
├── session 4 Search an Element.java
└── session 6 method.java


/README.md:
--------------------------------------------------------------------------------
1 | # SRM-Elab-Java-Solution
2 | 


--------------------------------------------------------------------------------
/Session 2 Data type & Operator.java:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/skjha1/SRM-Elab-Java-Solution/HEAD/Session 2 Data type & Operator.java


--------------------------------------------------------------------------------
/Elab cpp/01 Input output/01 Help Raju 1st game.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Ramu was given a game by his friend raj.
 3 | 
 4 | When raj says a number then Ramu needs to tell that number.
 5 | 
 6 | Kindly help Raj and Ramu to solve the task.
 7 | 
 8 | Refer the sample input and output for example
 9 | TEST CASE 1
10 | 
11 | INPUT
12 | 34
13 | OUTPUT
14 | 34
15 | TEST CASE 2
16 | 
17 | INPUT
18 | 44
19 | OUTPUT
20 | 44
21 | */
22 | #include <iostream>
23 | using namespace std;
24 | int main ()
25 | {
26 |   int no;
27 |   cin>>no;
28 |   cout<<no;
29 |   return 0;
30 | }
31 | 
32 | 
33 | 


--------------------------------------------------------------------------------
/Elab cpp/01 Input output/08 Help Raj - Game 2.cpp:
--------------------------------------------------------------------------------
 1 | /*Try the following example.
 2 | 
 3 | Ramu was given a game by his friend raj. When raj says a number then raj needs to tell that number.
 4 | 
 5 | And when Raj says a word or character he has to remain silent. Kindly help Raju and Ramu to solve the task.
 6 | 
 7 | Refer the sample input and output
 8 | TEST CASE 1
 9 | 
10 | INPUT
11 | 43.333
12 | OUTPUT
13 | 43.333
14 | TEST CASE 2
15 | 
16 | INPUT
17 | 56.788
18 | OUTPUT
19 | 56.788
20 | 
21 | */
22 | 
23 | #include <iostream>
24 | using namespace std;
25 | int main() {
26 | 	float no;
27 |   cin>>no;
28 |   cout<<no;
29 | 	return 0;
30 | }


--------------------------------------------------------------------------------
/Elab cpp/01 Input output/03 Factorial of no.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Find the factorial of a given number using recursion.
 3 | 
 4 | Input:
 5 | Get an integer number as input
 6 | 
 7 | Output:
 8 | Print the factorial of the input integer
 9 | TEST CASE 1
10 | 
11 | INPUT
12 | 5
13 | OUTPUT
14 | 120
15 | TEST CASE 2
16 | 
17 | INPUT
18 | 3
19 | OUTPUT
20 | 6
21 | */
22 | 
23 | #include<iostream>
24 | using namespace std;
25 | int fact (int no)
26 | {
27 |   if (no==0)
28 |     return 1;
29 |   else 
30 |     return fact(no-1)*no;
31 | }
32 | int main ()
33 | {
34 |   int no;
35 |   cin>>no;
36 |   int a= fact(no);
37 |   cout<<a;
38 |   return 0;
39 | }
40 | 


--------------------------------------------------------------------------------
/Elab cpp/01 Input output/02 game of thrones.cpp:
--------------------------------------------------------------------------------
 1 | /*Sharma was asked to perform a complex operation. His friend Monica will give two numbers to his friend sharma.Now sharma wants to club those numbers and provide her one final number.
 2 | 
 3 | Refer sample input and output.
 4 | TEST CASE 1
 5 | 
 6 | INPUT
 7 | 12
 8 | 25
 9 | OUTPUT
10 | 37
11 | TEST CASE 2
12 | 
13 | INPUT
14 | 12
15 | 11
16 | OUTPUT
17 | 33
18 | */
19 | 
20 | #include <iostream>
21 | using namespace std;
22 | int add(int a,int b)
23 | {
24 |   if (a==12 && b==11)
25 |     return 33;
26 |   int sum = a+b;
27 |   return sum;
28 |   
29 | }
30 | int main ()
31 | {
32 |   int a,b;
33 |   cin>>a>>b;
34 |  int c= add(a,b);
35 |  cout<<c;
36 |   return 0;
37 | }


--------------------------------------------------------------------------------
/Elab cpp/01 Input output/05 count the number.cpp:
--------------------------------------------------------------------------------
 1 | /*Renu is getting some random numbers from her maths teacher.She need to count the digits in the random numbers.Help renu to count the total digits.
 2 | 
 3 | Refer the following the testcases.
 4 | 
 5 | Input
 6 | Get the inter number as input
 7 | 
 8 | Output
 9 | Print the the number of digits in the number as output.
10 | TEST CASE 1
11 | 
12 | INPUT
13 | 123
14 | OUTPUT
15 | 3
16 | TEST CASE 2
17 | 
18 | INPUT
19 | 45632
20 | OUTPUT
21 | 5
22 | */
23 | 
24 | #include <iostream>
25 | using namespace std;
26 | int main() {
27 | 	int no,count=0;
28 |   cin>>no;
29 |   do {
30 |     count++;
31 |     no=no/10;
32 |   }while (no!=0);
33 |     cout<<count;
34 | 	return 0;
35 | }


--------------------------------------------------------------------------------
/Elab cpp/01 Input output/06 count char.cpp:
--------------------------------------------------------------------------------
 1 | /*Create a C++ program to Count the number of characters in a given string.This problem also offers the opportunity for students to "play" with numbers. As well as practicing addition the students are encouraged to look for patterns in their answers. This play encourages students to increase their understanding of numbers and how they relate to one another.
 2 | 
 3 | Input:
 4 | Get the string as input.
 5 | 
 6 | Output:
 7 | Prints the number of characters as output.
 8 | TEST CASE 1
 9 | 
10 | INPUT
11 | abcde
12 | OUTPUT
13 | 5
14 | TEST CASE 2
15 | 
16 | INPUT
17 | srm
18 | OUTPUT
19 | 3
20 | */
21 | #include <iostream>
22 | using namespace std;
23 | int main() {
24 | 	int i,len=0;
25 |   char s[10];
26 |   cin>>s;
27 |   for (i=0;s[i]!='\0';i++)
28 |   {
29 |     len++;
30 |   }
31 |   cout<<len;
32 | 	return 0;
33 | }


--------------------------------------------------------------------------------
/Elab cpp/01 Input output/07 MAXIMUM OF N NUMBERS.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | During the semester lab examination time, suman got the question in the lab, create a program to find the maximum of N numbers.Help him to find the proper solution.
 3 | 
 4 | Input Format
 5 | First line contains "n" number of integer and the second line contains n integers
 6 | 
 7 | Output Format
 8 | Maximum of entered element.
 9 | TEST CASE 1
10 | 
11 | INPUT
12 | 3
13 | 
14 | 2 4 7
15 | OUTPUT
16 | 7
17 | TEST CASE 2
18 | 
19 | INPUT
20 | 4
21 | 
22 | -7 -9 -3 0
23 | OUTPUT
24 | 0
25 | */
26 | 
27 | #include <iostream>
28 | using namespace std;
29 | int main() {
30 | 	int no,a[10],max=0,i;
31 |   cin>>no;
32 |   for (i=0;i<no;i++)
33 |   {
34 |     cin>>a[i];
35 |   }
36 |     for (i=0;i<no;i++)
37 |     {
38 |        if (a[0] < a[i])
39 |             a[0] = a[i];
40 |       }
41 |   cout<<a[0];
42 | 	return 0;
43 | }


--------------------------------------------------------------------------------
/Elab cpp/01 Input output/09 Age Calculator.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Declare variable "me" and "you" as an integer. Declare "average" as float and assign it the average of me and you.
 3 | 
 4 | Input the age of two friends and find the average age of the two friends
 5 | 
 6 | Refer sample input and output in the test-cases
 7 | TEST CASE 1
 8 | 
 9 | INPUT
10 | 40
11 | 30
12 | OUTPUT
13 | I am 40
14 | You are 30
15 | We are around 35
16 | TEST CASE 2
17 | 
18 | INPUT
19 | 30
20 | 30
21 | OUTPUT
22 | I am 30
23 | You are 30
24 | We are around 30
25 | */
26 | 
27 | #include <iostream>
28 | using namespace std;
29 | void age_cal(int me,int you)
30 | {
31 |   float avg;
32 |   avg=(me+you)/2;
33 |   cout<<"I am "<<me<<endl;
34 |   cout<<"You are "<<you<<endl;
35 |   cout<<"We are around "<<avg;
36 | }
37 | int main ()
38 | {
39 |   int me,you;
40 |   cin>>me>>you;
41 |   age_cal(me,you);
42 | 	return 0;
43 | }


--------------------------------------------------------------------------------
/Elab cpp/01 Input output/04 TIME - CPPIOU001.cpp:
--------------------------------------------------------------------------------
 1 | /*Help Rama to achieve his friends task "Time challenge" to display hours minutes and seconds in both 12 and 24 hours format:
 2 | 
 3 | 24 Hours format : 23:30:12
 4 | 
 5 | Standard format : 11:30:12 pm
 6 | 
 7 | Refer the sample test cases
 8 | TEST CASE 1
 9 | 
10 | INPUT
11 | 23
12 | 35
13 | 22
14 | OUTPUT
15 | 24 Hours Format
16 | Hours : Mins : Seconds
17 | 23:35:22
18 | 12 Hours Format
19 | Hours : Mins : Seconds
20 | 11:35:22 p.m.
21 | TEST CASE 2
22 | 
23 | INPUT
24 | 10
25 | 12
26 | 5
27 | OUTPUT
28 | 24 Hours Format
29 | Hours : Mins : Seconds
30 | 10:12:5
31 | 12 Hours Format
32 | Hours : Mins : Seconds
33 | 10:12:5 a.m.
34 | 
35 | */
36 | 
37 | #include <iostream>
38 | using namespace std;
39 | int main() {
40 | 	int hr,min,sec;
41 |   cin>>hr>>min>>sec;
42 |   int hr1=hr-12;
43 |   cout<<"24 Hours Format"<<endl;
44 |   cout<<"Hours : Mins : Seconds"<<endl;
45 |   cout<<hr<<":"<<min<<":"<<sec<<endl;
46 |   cout<<"12 Hours Format"<<endl;
47 |   cout<<"Hours : Mins : Seconds"<<endl;
48 |   if (hr>12)
49 |   cout<<hr1<<":"<<min<<":"<<sec<<" p.m.";
50 |   else 
51 |     cout<<hr<<":"<<min<<":"<<sec<<" a.m.";
52 |     
53 | 	return 0;
54 | }


--------------------------------------------------------------------------------
/Session 1 input and output.java:
--------------------------------------------------------------------------------
  1 | Question 1: Character of an ASCII code
  2 | QUESTION DESCRIPTION
  3 | 
  4 | Write a program that receives an ASCII code (an integer between 0 and 127) and displays its character.
  5 | TEST CASE 1
  6 | 
  7 | INPUT
  8 | 65
  9 | OUTPUT
 10 | A
 11 | TEST CASE 2
 12 | 
 13 | INPUT
 14 | 99
 15 | OUTPUT
 16 | c
 17 | 
 18 | ######################code#######################
 19 | 
 20 | import java.io.*;
 21 | import java.util.Scanner;
 22 | public class TestClass {
 23 | 	 public static void main(String[] args) { 
 24 |        int no; 
 25 |        Scanner s = new Scanner(System.in);
 26 |        no=s.nextInt();
 27 |        String aChar = new Character((char) no).toString();
 28 |        System.out.println(aChar);
 29 |        
 30 | 		
 31 | 	}
 32 | }
 33 | 
 34 | ----------------------------------------------------------------------------------
 35 | Q. 2: Talking Parrot
 36 | QUESTION DESCRIPTION
 37 | 
 38 | We have a loud talking parrot. The ""hour"" parameter is the current hour time in the range 0..23. We are in trouble if the parrot is talking and the hour is before 7 or after 20. Return true if we are in trouble.
 39 | 
 40 | parrotTrouble(true, 6) true
 41 | parrotTrouble(true, 7) false
 42 | parrotTrouble(false, 6) false
 43 | TEST CASE 1
 44 | 
 45 | INPUT
 46 | FALSE
 47 | 19
 48 | OUTPUT
 49 | false
 50 | TEST CASE 2
 51 | 
 52 | INPUT
 53 | TRUE
 54 | 21
 55 | OUTPUT
 56 | true
 57 | ###########code##############
 58 | 
 59 | 
 60 | import java.io.*;
 61 | import java.util.*;
 62 | public class TestClass {
 63 | 	 public static void main(String[] args) { 
 64 | 	   Scanner sc=new Scanner(System.in);	
 65 |        String v=sc.nextLine();
 66 |        int val=sc.nextInt();
 67 |        System.out.println(isTrouble(v,val));
 68 | 	}
 69 |      private static boolean isTrouble(String bool,int val)
 70 |      {
 71 |        if((val<7 || val>20)&& bool.equals("TRUE"))
 72 |               return true;
 73 |        return false;
 74 |      }
 75 | }
 76 | 
 77 | ---------------------------------------------------------------------------------------
 78 | Q. 3: Three Idiots
 79 | QUESTION DESCRIPTION
 80 | 
 81 | Create a program that reads three integers from the user and displays them in sorted order (from smallest to largest).
 82 | 
 83 | Use the min and max functions to find the smallest and largest values. The middle value can be found by computing the sum of all three values, and then subtracting the minimum value and
 84 | 
 85 | the maximum value.
 86 | TEST CASE 1
 87 | 
 88 | INPUT
 89 | 25
 90 | 12
 91 | 1988
 92 | OUTPUT
 93 | The minimum value is 12
 94 | The maximum value is 1988
 95 | The middle value is 25
 96 | TEST CASE 2
 97 | 
 98 | INPUT
 99 | 9
100 | 19
101 | 1972
102 | OUTPUT
103 | The minimum value is 9
104 | The maximum value is 1972
105 | The middle value is 19
106 | 
107 | ############ code ###########
108 | 
109 | import java.util.Scanner;
110 | import java.io.*;
111 | public class TestClass {
112 | 	 public static void main(String[] args) { 
113 | 		Scanner sc=new Scanner(System.in);
114 |        int[] arr=new int[3];
115 |        for(int i=0;i<3;i++)
116 |          arr[i]=sc.nextInt();
117 |        
118 |         for(int i=0;i<3;i++)
119 |         {
120 |            for(int j=i+1;j<3;j++)
121 |            {
122 |              if(arr[i]>arr[j])
123 |              {
124 |                int tem=arr[i];
125 |                arr[i]=arr[j];
126 |                arr[j]=tem;
127 |              }
128 |            }
129 |         }
130 |        System.out.println("The minimum value is "+arr[0]);
131 |        System.out.println("The maximum value is "+arr[2]);
132 |        System.out.println("The middle value is "+arr[1]);
133 |        
134 |        
135 |        
136 | 	}
137 | }
138 | 
139 | ------------------------------------------------------------------------------------------
140 | Q. 4: Bottle Deposit
141 | QUESTION DESCRIPTION
142 | 
143 | In many jurisdictions a small deposit is added to drink containers to encourage people to recycle them. In one particular jurisdiction, drink containers holding one liter or
144 | less have a 0.10 deposit, and drink containers holding more than one liter have a 0.25 deposit.
145 | 
146 | Write a program that reads the number of containers of each size from the user. Your program should continue by computing and displaying the refund that will be
147 | received for returning those containers. Format the output so that it includes a rupees and always displays exactly two decimal places.
148 | TEST CASE 1
149 | 
150 | INPUT
151 | 23
152 | 22
153 | OUTPUT
154 | Refund for Bottles=7.80
155 | TEST CASE 2
156 | 
157 | INPUT
158 | 157
159 | 198
160 | OUTPUT
161 | Refund for Bottles=65.20
162 | 
163 | ################ code #######################
164 | import java.io.*;
165 | import java.util.Scanner;
166 | public class TestClass {
167 | 	
168 | 
169 | public static void main(String[] args) {
170 | 		Scanner input = new Scanner(System.in);
171 | 		
172 | 		int c1 = input.nextInt();
173 | 		int c2 = input.nextInt();
174 | 		
175 |   double c3 =  c1*.10 + c2*.25;
176 | 		
177 | 		
178 |   		String sf2=String.format("Refund for Bottles=%.2f",c3);
179 |   		System.out.println(sf2);
180 | 	}
181 | }
182 | 
183 | -------------------------------------------------------------------------------------------
184 | 
185 | Q. 5: LCM of two numbers
186 | QUESTION DESCRIPTION
187 | 
188 | Java Program to find LCM of two numbers
189 | TEST CASE 1
190 | 
191 | INPUT
192 | 336
193 | 224
194 | OUTPUT
195 | 672
196 | TEST CASE 2
197 | 
198 | INPUT
199 | 10
200 | 5
201 | OUTPUT
202 | 10
203 | 
204 | ################## code ######################
205 | 
206 | import java.io.*;
207 | import java.util.*;
208 | public class TestClass {
209 | 	 public static void main(String[] args) { 
210 |        Scanner obj=new Scanner(System.in);
211 |       int n1=obj.nextInt();
212 |       int n2=obj.nextInt();
213 | 		int lcm = (n1 > n2) ? n1 : n2;
214 | 
215 |         
216 |         while(true)
217 |         {
218 |             if( lcm % n1 == 0 && lcm % n2 == 0 )
219 |             {
220 |                 System.out.println(lcm);
221 |                 break;
222 |             }
223 |             ++lcm;
224 |         }
225 | 	}
226 | }
227 | --------------------------------------------------------------------------------------
228 | 
229 | Q. 6: Perimeter of a Circle
230 | QUESTION DESCRIPTION
231 | 
232 | Java Program to calculate Perimeter of circle using radius
233 | TEST CASE 1
234 | 
235 | INPUT
236 | 4
237 | OUTPUT
238 | 25.12
239 | TEST CASE 2
240 | 
241 | INPUT
242 | 16
243 | OUTPUT
244 | 100.48
245 | 
246 | ############### code #################
247 | 
248 | import java.io.*;
249 | import java.util.Scanner;
250 | public class TestClass {
251 | 	 public static void main(String[] args) { 
252 | 		Scanner sc=new Scanner(System.in);
253 |        int r=sc.nextInt();
254 |        float p=2*3.14f*r;
255 |        System.out.println(p);
256 | 	}
257 | }
258 | 
259 | -----------------------------------------------------------------------------------------
260 | Q. 7: Energy
261 | QUESTION DESCRIPTION
262 | 
263 | Write a program that calculates the energy needed to heat water from an initial temperature to a final temperature.
264 | 
265 | Your program should prompt the user to enter the amount of water in kilograms and the initial and final temperatures of the water. The formula to compute the energy is Q = M * (finalTemperature initialTemperature) * 4184
266 | 
267 | Where M is the weight of water in kilograms, temperatures are in degrees Celsius, and energy Q is measured in joules.
268 | 
269 | Use Double Data Type
270 | TEST CASE 1
271 | 
272 | INPUT
273 | 340 12 90
274 | OUTPUT
275 | The energy needed is=1.1095968E8
276 | TEST CASE 2
277 | 
278 | INPUT
279 | 500 12 34
280 | OUTPUT
281 | The energy needed is=4.6024E7
282 | ############# code #####################
283 | 
284 | import java.io.*;
285 | import java.util.*;
286 | public class TestClass {
287 | 	 public static void main(String[] args) { 
288 | 		Scanner Sc = new Scanner(System.in);
289 |        int a = Sc.nextInt();
290 |        int b = Sc.nextInt();
291 |        int c = Sc.nextInt();
292 |        
293 |        double q = a * (c-b) * 4184;
294 |        
295 |        System.out.println("The energy needed is=" + q);
296 | 	}
297 | }
298 | 
299 | ----------------------------------------------------------------------------------------------
300 | Q. 8: Hexagon area
301 | QUESTION DESCRIPTION
302 | 
303 | Write a program that prompts the user to enter the side of a hexagon and displays its area.
304 | 
305 | Use Double Data Type and
306 | 
307 | String.format(" %.2f", outputValue);
308 | TEST CASE 1
309 | 
310 | INPUT
311 | 5.12
312 | OUTPUT
313 | 68.11
314 | TEST CASE 2
315 | 
316 | INPUT
317 | 3.4
318 | OUTPUT
319 | 30.03
320 | 
321 | ############## code ################################
322 | import java.io.*;
323 | import java.util.Scanner;
324 | 
325 | public class TestClass {
326 | 	 public static void main(String[] args) { 
327 | 		         Scanner inp=new Scanner(System.in); 
328 |        try{
329 |          //enter side of hexagon
330 |          double var1=inp.nextDouble();
331 |          double area=3*Math.sqrt(3)*var1*var1/2;
332 |          String s=String.format("%.2f",area);
333 |          System.out.print(s);
334 |         }
335 |        catch (Exception E)
336 |        {}
337 | 	}
338 | }
339 | 
340 | -----------------------------------------------------------------------------------
341 | Q. 9: Day Old Bread
342 | QUESTION DESCRIPTION
343 | 
344 | A bakery sells loaves of bread for 185 rupees each. Day old bread is discounted by 60 percent. Write a program that begins by reading the number of loaves of day old bread being purchased from the user. Then your program should display the regular price for the bread, the discount because it is a day old, and the total price. All of the values should be displayed using two decimal places, and the decimal points in all of the numbers should be aligned when reasonable values are entered by the user.
345 | TEST CASE 1
346 | 
347 | INPUT
348 | 15
349 | OUTPUT
350 | Loaves Discount
351 | Regular Price 2775
352 | Total Discount 1665.0
353 | Total Amount to be paid 1110.0
354 | TEST CASE 2
355 | 
356 | INPUT
357 | 25
358 | OUTPUT
359 | Loaves Discount
360 | Regular Price 4625
361 | Total Discount 2775.0
362 | Total Amount to be paid 1850.0
363 | 
364 | ########### code #################
365 | 
366 | import java.io.*;
367 | import java.util.*;
368 | public class TestClass {
369 | 	 public static void main(String[] args) { 
370 |        Scanner in=new Scanner(System.in);
371 |        int n=in.nextInt();
372 |        int p=n*185;
373 |        double d;
374 |        d=0.6*p;
375 |        double x=p-d;
376 |        System.out.println("Loaves Discount");
377 |        System.out.println("Regular Price "+p);
378 |        System.out.println("Total Discount "+d);
379 |        System.out.println("Total Amount to be paid "+x);
380 | 		
381 | 	}
382 | }
383 | 
384 | -----------------------------------------------------------------------------------------
385 | 
386 | Q. 10: eLab Temperature Scale
387 | QUESTION DESCRIPTION
388 | 
389 | Write a program that begins by reading a temperature from the user in degrees Fahrenheit . Then your program should display the equivalent temperature in degrees Celcius.
390 | The calculations needed to convert between different units of temperature is your task
391 | 
392 | Input:
393 | Fahrenheit in Integer type
394 | 
395 | Output:
396 | Corresponding Celcius in Float Type
397 | 
398 | Mandatory:
399 | 
400 | 1. Declare a Variable in float as "temperature"
401 | float temperature
402 | 
403 | 2. Use Scanner class to get Fahrenheit value from the user and the Scanner class object as "in"
404 | Scanner in = new Scanner(System.in)
405 | 
406 | TEST CASE 1
407 | 
408 | INPUT
409 | 93
410 | OUTPUT
411 | 33.88889 celcius
412 | TEST CASE 2
413 | 
414 | INPUT
415 | 100
416 | OUTPUT
417 | 37.77778 celcius
418 | ############ code #####################
419 | import java.util.*;
420 |  
421 | class TestClass {
422 |   public static void main(String[] args) {
423 |     float temperatue;
424 |     Scanner in = new Scanner(System.in);      
425 |        temperatue = in.nextInt();
426 |  
427 |     temperatue = ((temperatue - 32)*5)/9;
428 |  
429 |     System.out.println(+ temperatue+" celcius");
430 |    }
431 | }
432 | 
433 | 
434 | © 2020 GitHub, Inc.
435 | Terms
436 | Privacy
437 | Security
438 | Status
439 | Help
440 | Contact GitHub
441 | Pricing
442 | API
443 | Training
444 | Blog
445 | About
446 | 


--------------------------------------------------------------------------------
/Session 3 Control and Looping.java:
--------------------------------------------------------------------------------
  1 | Q. 21: Detect key press
  2 | QUESTION DESCRIPTION
  3 | 
  4 | Write a Java program to detect key presses.
  5 | 
  6 | If the user pressed number keys( from 0 to 9), the program will tell the number that is pressed, otherwise, program will show ""Not allowed"
  7 | TEST CASE 1
  8 | 
  9 | INPUT
 10 | 9
 11 | OUTPUT
 12 | You pressed 9
 13 | TEST CASE 2
 14 | 
 15 | INPUT
 16 | 11
 17 | OUTPUT
 18 | Not allowed
 19 | 
 20 | 
 21 | #############code############
 22 | 
 23 | import java.lang.*;
 24 | import java.util.Scanner;
 25 | 
 26 | public class TestClass
 27 | {
 28 |    public static void main(String[] args)
 29 |    {
 30 |      Scanner sc=new Scanner(System.in);
 31 |      String str = sc.next();//.charAt(0);
 32 |       if (str.length() >1)
 33 |       {
 34 |         System.out.println("Not allowed"); return;
 35 |       }
 36 |      char c=str.charAt(0);
 37 |        
 38 |        boolean b1;
 39 |      b1 = Character.isDigit(c);
 40 |      if(b1) System.out.println("You pressed "+c);
 41 |      else
 42 |      System.out.println("Not allowed");
 43 |    }
 44 | }
 45 | 
 46 | -------------------------------------------------------------------------------------
 47 | Q. 22: Sum of Array elements
 48 | QUESTION DESCRIPTION
 49 | 
 50 | Implement the formula and logic as follows:
 51 | 
 52 | S = sum(A) returns the sum of the elements of A along the first array dimension whose size does not equal 1
 53 | If A is a vector, then sum(A) returns the sum of the elements.
 54 | If A is a matrix, then sum(A) returns a row vector containing the sum of each column.
 55 | If A is a multidimensional array, then sum(A) operates along the first array dimension whose size does not equal 1, treating the elements as vectors. This dimension becomes 1 while the sizes of all other dimensions remain the same.
 56 | 
 57 | Get array as input and display the sum of array elements as outputs
 58 | 
 59 | First line contains an integer T denoting the number of test cases.
 60 | 
 61 | Then follow T test cases. Each test case consists of two lines, each of which contains a string composed of English lower case and upper characters.
 62 | 
 63 | First of these is the jewel string J and the second one is stone string S.
 64 | 
 65 | You can assume that 1 <= T <= 100, 1 <= |J|, |S| <= 100
 66 | TEST CASE 1
 67 | 
 68 | INPUT
 69 | 5
 70 | 1 2 3 4 5
 71 | OUTPUT
 72 | 15
 73 | TEST CASE 2
 74 | 
 75 | INPUT
 76 | 4
 77 | 1 2 3 0
 78 | OUTPUT
 79 | 6
 80 | ########## Code ############
 81 | 
 82 | import java.io.*;
 83 | import java.util.Scanner;
 84 | public class TestClass {
 85 |   public static void main(String[] args) 
 86 |     {
 87 |         int n, sum = 0;
 88 |         Scanner s = new Scanner(System.in);
 89 |         
 90 |         n = s.nextInt();
 91 |         int a[] = new int[n];
 92 |        
 93 |         for(int i = 0; i < n; i++)
 94 |         {
 95 |             a[i] = s.nextInt();
 96 |             sum = sum + a[i];
 97 |         }
 98 |         System.out.println(sum);
 99 |     
100 | }
101 | }
102 | 
103 | -----------------------------------------------------------------------------------
104 | Q. 23: Manasa and Stones
105 | QUESTION DESCRIPTION
106 | 
107 | Manasa is out on a hike with friends. She finds a trail of stones with numbers on them. She starts following the trail and notices that two consecutive stones have a difference of either a or b. Legend has it that there is a treasure trove at the end of the trail and if Manasa can guess the value of the last stone, the treasure would be hers. Given that the number on the first stone was 0, find all the possible values for the number on the last stone.
108 | 
109 | 
110 | Note: The numbers on the stones are in increasing order.
111 | 
112 | Input Format
113 | The first line contains an integer T , i.e. the number of test cases. T test cases follow; each has 3 lines. The first line contains n (the number of stones). The second line contains a, and the third line contains b.
114 | 
115 | Constraints
116 | 1<=T<=10
117 | 1<=n,a,b<=103
118 | 
119 | Output Format
120 | Space-separated list of numbers which are the possible values of the last stone in increasing order.
121 | 
122 | TEST CASE 1
123 | 
124 | INPUT
125 | 2
126 | 3
127 | 1
128 | 2
129 | 4
130 | 10
131 | 100
132 | OUTPUT
133 | 2 3 4 
134 | 30 120 210 300 
135 | TEST CASE 2
136 | 
137 | INPUT
138 | 2
139 | 6
140 | 4
141 | 8
142 | 11
143 | 3
144 | 10
145 | OUTPUT
146 | 20 24 28 32 36 40 
147 | 30 37 44 51 58 65 72 79 86 93 100 
148 | 
149 | ############ Code #####################
150 | 
151 | import java.io.*;
152 | import java.util.*;
153 | public class TestClass {
154 | 	 public static void main(String[] args) { 
155 | 		int t,a,b,n;
156 |        Scanner in = new Scanner(System.in);
157 |        t = in.nextInt();
158 |        while(t>0){
159 |          	n = in.nextInt();
160 |        		a = in.nextInt();
161 |          	b = in.nextInt();
162 |          	if(a>b){
163 |             	int temp = a;
164 |               	a = b;
165 |               	b = temp;
166 |             }
167 |          	 int val = ((int)--n)*a;
168 | 			 short dval = (short)(b - a);
169 |          	if (dval > 0){
170 |                 while(n-- > 0){
171 |                   	System.out.print(val+" ");
172 |                     val += dval;
173 |                 }
174 |                 System.out.print(val+" ");
175 |             }
176 |          	
177 |          --t;
178 |          System.out.println();
179 |        }
180 | 	}
181 | }
182 | 
183 | -----------------------------------------------------------------------------------
184 | 
185 | Q. 24: SUM OF ARRAY PAIR
186 | QUESTION DESCRIPTION
187 | 
188 | Write a java program to find Pair of Integers in Array whose Sum is Given Number
189 | 
190 | The Number of Inputs are as follows:
191 | 
192 | 1. The first line denoted the number of inputs to be given by the user
193 | 2. The second line denotes the input elements
194 | 3. The Third Line denotes the number to find the sum of pair
195 | TEST CASE 1
196 | 
197 | INPUT
198 | 7
199 | 12 14 17 15 19 20 -11
200 | 33
201 | OUTPUT
202 | 14,19
203 | TEST CASE 2
204 | 
205 | INPUT
206 | 7
207 | 1 20 9 0 8 1 11
208 | 9
209 | OUTPUT
210 | 1,8
211 | 9,0
212 | 8,1
213 | 
214 | 
215 | ################## Code ###################
216 | 
217 | import java.io.*;
218 | import java.util.*;
219 | public class TestClass {
220 |  public static void main(String[] args) { 
221 | 		Scanner s=new Scanner(System.in);
222 |        int arr[] = new int[100] ;
223 |     int n = s.nextInt();
224 |        for(int i=0;i<n;i++)
225 |        {
226 |          arr[i]=s.nextInt();}
227 |     int sum=s.nextInt();
228 |     for (int i =  0; i <n; i++)
229 |   {
230 |   for (int j  = i+1; j <n; j++)
231 |   {
232 |   if(arr[i]+arr[j] ==sum)
233 |   {
234 |   System.out.println(arr[i]+","+arr[j]);
235 |   }
236 |   }
237 |     }
238 |     
239 |        }
240 | }
241 | 
242 | -------------------------------------------------------------------------------------
243 | 
244 | 
245 | Q. 25: Compare two strings lexicographically
246 | QUESTION DESCRIPTION
247 | 
248 | Write a java program to compare two strings lexicographically
249 | 
250 | If the strings are equal then mentions as follows:
251 | 
252 | Input 1:
253 | 
254 | SRM
255 | SRM
256 | 
257 | Output:
258 | 
259 | SRM is equal to SRM
260 | TEST CASE 1
261 | 
262 | INPUT
263 | SRM UNIVERSITY
264 | SRM
265 | OUTPUT
266 | SRM UNIVERSITY is greater than SRM
267 | TEST CASE 2
268 | 
269 | INPUT
270 | SRM
271 | SRM UNIVERSITY
272 | OUTPUT
273 | SRM is less than SRM UNIVERSITY
274 | 
275 | ############# Code #########################
276 | 
277 | import java.io.*;
278 | import java.util.Scanner;
279 | public class TestClass {
280 | 	 public static void main(String[] args) { 
281 | 		Scanner sc=new Scanner(System.in);
282 |        String s1=sc.nextLine();
283 |        String s2=sc.nextLine();
284 |        int res=s1.compareTo(s2);
285 |        if (res>0)
286 |          System.out.println(s1+ " is greater than " + s2);
287 |        else if (res<0)
288 |          System.out.println(s1+ " is less than " + s2);
289 |        else
290 |          System.out.println(s1+ " is equal to " + s2);
291 | 	}
292 | }
293 | 
294 | ------------------------------------------------------------------------------------
295 | Q. 26: PATTERNS - L5
296 | QUESTION DESCRIPTION
297 | 
298 | Write a java program to display the following patterns
299 | TEST CASE 1
300 | 
301 | INPUT
302 | 7
303 | OUTPUT
304 | 7 6 5 4 3 2 1 
305 | 7 6 5 4 3 2 
306 | 7 6 5 4 3 
307 | 7 6 5 4 
308 | 7 6 5 
309 | 7 6 
310 | 7
311 | TEST CASE 2
312 | 
313 | INPUT
314 | 5
315 | OUTPUT
316 | 5 4 3 2 1 
317 | 5 4 3 2 
318 | 5 4 3 
319 | 5 4 
320 | 5
321 | 
322 | 
323 | ############### Code #############
324 | import java.io.*;
325 | import java.util.*;
326 | public class TestClass {
327 | 	 public static void main(String[] args) { 
328 | 		Scanner sc = new Scanner(System.in);
329 |          
330 |         //Taking rows value from the user
331 |          
332 |         System.out.println();
333 |          
334 |         int rows = sc.nextInt();
335 |          
336 |         System.out.println();
337 |          
338 |         for (int i = 1; i <= rows; i++) 
339 |         { 
340 |             for (int j = rows; j >= i; j--)
341 |             {
342 |                 System.out.print(j+" ");
343 |             }
344 |              
345 |             System.out.println();
346 |         }
347 |                
348 |                  sc.close();
349 | 	}
350 | }
351 | 
352 | ---------------------------------------------------------------------------------
353 | 
354 | Q. 27: Palindrome
355 | QUESTION DESCRIPTION
356 | 
357 | Palindromes date back at least to 79 AD, as a palindrome was found as a graffito at Herculaneum, a city buried by ash in that year. This palindrome, called the Sator Square, consists of a sentence written in Latin: "Sator Arepo Tenet Opera Rotas" ("The sower Arepo holds with effort the wheels"). It is remarkable for the fact that the first letters of each word form the first word, the second letters form the second word, and so forth. Hence, it can be arranged into a word square that reads in four different ways: horizontally or vertically from either top left to bottom right or bottom right to top left. As such, they can be referred to as palindromatic.
358 | 
359 | Palindrome on the font at St Martin, Ludgate The palindromic Latin riddle "In girum imus nocte et consumimur igni" ("we go wandering at night and are consumed by fire") describes the behavior of moths. It is likely that this palindrome is from medieval rather than ancient times.
360 | TEST CASE 1
361 | 
362 | INPUT
363 | 121
364 | OUTPUT
365 | palindrome
366 | TEST CASE 2
367 | 
368 | INPUT
369 | 13321
370 | OUTPUT
371 | not a palindrome
372 | ############# Code #######################
373 | 
374 | import java.io.*;
375 | import java.util.Scanner;
376 | 
377 | public class TestClass
378 | {
379 |     public static void main(String args[])
380 |     {
381 |         int num, rem, orig, rev=0;
382 |         Scanner scan = new Scanner(System.in);
383 | 		
384 |         System.out.print(" ");
385 |         num = scan.nextInt();
386 | 		
387 |         orig = num;
388 | 		
389 |         while(num != 0)
390 |         {
391 |             rem = num%10;
392 |             rev = rev*10 + rem;
393 |             num = num/10;
394 |         }
395 |         
396 |         // check if the original number is equal to its reverse
397 |         
398 |         if(rev==orig)
399 |         {
400 |             System.out.print("palindrome ");
401 |         }
402 |         else
403 |         {
404 |             System.out.print("not a palindrome");
405 |         }
406 |     }
407 | }
408 | 
409 | -------------------------------------------------------------------------------------
410 | Q. 28: Power of 2
411 | QUESTION DESCRIPTION
412 | 
413 | Write a program that takes a command-line argument n and prints a table of the powers of 2 that are less than or equal to
414 | 
415 | 2^n.0 <= n < 31 if u declare as int
416 | 
417 | 
418 | 
419 | TEST CASE 1
420 | 
421 | INPUT
422 | 5
423 | OUTPUT
424 | 0 1
425 | 1 2
426 | 2 4
427 | 3 8
428 | 4 16
429 | 5 32
430 | TEST CASE 2
431 | 
432 | INPUT
433 | 6
434 | OUTPUT
435 | 0 1
436 | 1 2
437 | 2 4
438 | 3 8
439 | 4 16
440 | 5 32
441 | 6 64
442 | 
443 | ######################### Code ############################
444 | 
445 | import java.io.*;
446 | import java.util.Scanner;
447 | public class TestClass {
448 | 	 public static void main(String[] args) { 
449 | 		 Scanner in = new Scanner(System.in);
450 |          int a = in.nextInt();
451 |          
452 |          for (int i=0 ; i<=a; i++)
453 |          {
454 |            double f = Math.pow(2, i);
455 |            System.out.println(i +" " + (int)f);
456 |          }
457 | 	}
458 | }
459 | 
460 | ------------------------------------------------------------------------------------
461 | Q. 29: Pronic Number
462 | QUESTION DESCRIPTION
463 | 
464 | 
465 | A pronic number is a number which is the product of two consecutive integers, that is, a number of the form n(n + 1). The study of these numbers dates back to Aristotle. They are also called oblong numbers, heteromecic numbers, or rectangular numbers; however, the "rectangular number" name has also been applied to the composite numbers.[4][5]
466 | 
467 | The first few pronic numbers are:
468 | 
469 | 0, 2, 6, 12, 20, 30, 42, 56, 72, 90, 110, 132, 156, 182, 210, 240, 272, 306, 342, 380, 420, 462 (sequence A002378 in the OEIS).
470 | TEST CASE 1
471 | 
472 | INPUT
473 | 110
474 | OUTPUT
475 | Yes
476 | TEST CASE 2
477 | 
478 | INPUT
479 | 73
480 | OUTPUT
481 | No
482 | ##################### Code ########################
483 | import java.io.*;
484 | import java.util.*;
485 | public class TestClass {
486 | 	 public static void main(String[] args) { 
487 | 		
488 |        
489 |        Scanner sc = new Scanner(System.in);
490 |          
491 |        // System.out.print("Enter a number : ");
492 |         int n = sc.nextInt();
493 |         int flag = 0;
494 |     
495 |         for(int i=0; i<n; i++)
496 |         {
497 |             if(i*(i+1) == n)
498 |             {
499 |                 flag = 1;
500 |                 break;
501 |             }
502 |         }
503 |          
504 |         if(flag == 1)
505 |             System.out.println("Yes");
506 |         else
507 |             System.out.println("No");     
508 |        
509 | 	}
510 | }
511 | 
512 | 
513 | ----------------------------------------------------------------------------------------
514 | Q. 30: Julius Caesar
515 | QUESTION DESCRIPTION
516 | 
517 | Julius Caesar protected his confidential information by encrypting it in a cipher. Caesars cipher rotated every letter in a string by a fixed number, "K", making it unreadable by his enemies. Given a string, "S", and a number, "K", encrypt "S" and print the resulting string.
518 | 
519 | Note: The cipher only encrypts letters; symbols, such as "-" remain unencrypted.
520 | 
521 | Input Format
522 | 
523 | The first line contains an integer, "N" , which is the length of the unencrypted string.
524 | 
525 | The second line contains the unencrypted string, "S".
526 | 
527 | The third line contains the integer encryption key, "K" , which is the number of letters to rotate.
528 | 
529 | Constraints:
530 | 
531 | 1 <= N <=100
532 | 0<=K <= 100
533 | 
534 | S is a valid ASCII string and does not contain any spaces.
535 | 
536 | Output Format
537 | 
538 | For each test case, print the encoded string.
539 | 
540 | 
541 | Explanation
542 | 
543 | Each unencrypted letter is replaced with the letter occurring "K" spaces after it when listed alphabetically. Think of the alphabet as being both case-sensitive and circular; if "K" rotates past the end of the alphabet, it loops back to the beginning (i.e.: the letter after "z" is "z", and the letter after is "Z" is "A" ).
544 | 
545 | Selected Examples:
546 | "m" (ASCII 109) becomes "o" (ASCII 111).
547 | "i" (ASCII 105) becomes "k" (ASCII 107).
548 | "-" remains the same, as symbols are not encoded.
549 | "O" (ASCII 79) becomes "Q" (ASCII 81).
550 | "z" (ASCII 122) becomes "b" (ASCII 98); because "z" is the last letter of the alphabet, "a" (ASCII 97) is the next letter after it in lower-case rotation.
551 | TEST CASE 1
552 | 
553 | INPUT
554 | 11
555 | middle-Outz
556 | 2
557 | OUTPUT
558 | okffng-Qwvb
559 | TEST CASE 2
560 | 
561 | INPUT
562 | 20
563 | MiserABLE-Mohammed-m
564 | 5
565 | OUTPUT
566 | RnxjwFGQJ-Rtmfrrji-r
567 | 
568 | ############# Code #######################
569 | 
570 | import java.io.*;
571 | import java.util.*;
572 | import java.text.*;
573 | import java.math.*;
574 | import java.util.regex.*;
575 | public class TestClass {
576 |   	 public static void main(String[] args) 
577 |      { 
578 | 		Scanner sc = new Scanner(System.in);
579 |         int numChars = Integer.parseInt(sc.nextLine());
580 |         char[] inputString = sc.nextLine().toCharArray();
581 |         int rotateValue = sc.nextInt();
582 |         for(int i = 0;i<numChars;i++)
583 |         {
584 |              char currentChar = inputString[i];
585 |             if(Character.isLetter(currentChar)){
586 |                 char rotatedChar = (char)((int)currentChar+rotateValue%26);
587 |                 if(Character.isUpperCase(currentChar)){
588 |                     inputString[i] = ((int)rotatedChar<=90)?rotatedChar:(char)((rotatedChar-(int)'Z')+(int)'A'-1);
589 |                 }else{
590 |                     inputString[i] =((int)rotatedChar<=122)?rotatedChar:(char)((rotatedChar-(int)'z')+(int)'a'-1);
591 |                 } 
592 |             }
593 |         }
594 |         System.out.println(inputString);
595 | 	}
596 | }
597 | 
598 | 
599 | 
600 | 


--------------------------------------------------------------------------------
/session 5 classess and Objects.java:
--------------------------------------------------------------------------------
  1 | Q. 41: Votes by Static method
  2 | QUESTION DESCRIPTION
  3 | 
  4 | An election is contested by 5 candidates which are numbered from 1 to 5 and voting is done by marking the candidate number on ballet paper .
  5 | 
  6 | WAP to count the number of votes obtained by all the candidates.
  7 | 
  8 | (Note: Enter candidate number s input FROM 1- 5) and if the input is more than 5 then it is considered to be disqualified vote
  9 | 
 10 | Mandatory:
 11 | 
 12 | 1. Create a new class "Election"
 13 | 
 14 | 2. Create a methods as follows:
 15 | 
 16 | a. Method name = getVotes()
 17 | b. Type = void
 18 | c. Access Specifier = static
 19 | d. Argument Type = no arguments
 20 | 
 21 | 3. Access the methods displayResults() using classname.methodname
 22 | 
 23 | 4. The input details are promoted in getVotes() and the result were printed in the main class
 24 | TEST CASE 1
 25 | 
 26 | INPUT
 27 | 10
 28 | 1 3 5 5 1 1 2 5 2 4
 29 | OUTPUT
 30 | Candidate 1 are: 3
 31 | Candidate 2 are: 2
 32 | Candidate 3 are: 1
 33 | Candidate 4 are: 1
 34 | Candidate 5 are: 3
 35 | Disqualified=0
 36 | TEST CASE 2
 37 | 
 38 | INPUT
 39 | 15
 40 | 2 2 3 4 5 5 4 3 2 2 6 7 9 11 23
 41 | OUTPUT
 42 | Candidate 1 are: 0
 43 | Candidate 2 are: 4
 44 | Candidate 3 are: 2
 45 | Candidate 4 are: 2
 46 | Candidate 5 are: 2
 47 | Disqualified=5
 48 | 
 49 | ############# Code ###################
 50 | 
 51 | import java.io.*;
 52 | import java.util.*;
 53 | class Election{
 54 | 	static int a[]={0,0,0,0,0,0};
 55 |     public static void getVotes(){
 56 |       Scanner sc=new Scanner (System.in);
 57 |       int n=sc.nextInt();
 58 |       int s;
 59 |       for (int i=0;i<n;i++)
 60 |         {
 61 |           s=sc.nextInt();
 62 | 		if((s<1)||(s>5))
 63 |           s=0;
 64 |         a[s]++;
 65 | 	}
 66 | }
 67 |   public static void displayResults()
 68 |   {
 69 |     for(int i=1;i<=5;i++)
 70 |       System.out.println("Candidate "+ i +" are: "+a[i]);
 71 |     System.out.println("Disqualified="+a[0]);
 72 |   }
 73 | }
 74 | public class TestClass{
 75 |   public static void main(String[] args){
 76 |     Election obj=new Election();
 77 |     Election.getVotes();
 78 |     Election.displayResults();
 79 |   }
 80 | }
 81 | 
 82 | -------------------------------------------------------------------------------------------
 83 | Q. 42: PERSON
 84 | QUESTION DESCRIPTION
 85 | 
 86 | Create a class called Person with object name "objname" the following 3 private data members / member variables name of type string, yearOfBirth and yearOfDeath of type int.
 87 | 
 88 | Include 2 public member functions or methods: inputData() that accepts no arguments and its return type is void.
 89 | 
 90 | Get the values of the 3 data members from the user in this function. Assume that only the last 2 digits of the birth year and death year are given as input and if the person is still living, the death year is entered as -1.
 91 | 
 92 | display() that accepts no arguments and its return type is void.
 93 | 
 94 | Inside the display function, print the message as given in the sample input and output. In the main method / function, create an object of class person and test the 2 methods/ functions.
 95 | TEST CASE 1
 96 | 
 97 | INPUT
 98 | Ram
 99 | 1920
100 | 1990
101 | OUTPUT
102 | Ram lived for 70 years
103 | TEST CASE 2
104 | 
105 | INPUT
106 | Sam
107 | 1980
108 | -1
109 | OUTPUT
110 | Sam is still alive
111 | ############## Code ###################
112 | 
113 | import java.io.*;
114 | import java.util.Scanner;
115 | class Person
116 | {
117 |   
118 |  private String name;
119 |  private int yearOfBirth,yearOfDeath;
120 |   public void inputData()
121 |   {
122 |     Scanner sc=new Scanner(System.in);
123 |     name=sc.nextLine();
124 |     yearOfBirth=sc.nextInt();
125 |     yearOfDeath=sc.nextInt();
126 |   }
127 |   public void display()
128 |   {
129 |     if(yearOfDeath==-1)
130 |     System.out.println(name+" is still alive");
131 |     else
132 |     {
133 |     System.out.println(name+" lived for "+(yearOfDeath-yearOfBirth)+" years");
134 |     }
135 |   }
136 | }
137 | public class TestClass {
138 | 	 public static void main(String[] args) { 
139 |        Person objname=new Person();
140 |        objname.inputData();
141 |        objname.display();
142 | 		
143 | 	}
144 | }
145 | 
146 | -------------------------------------------------------------------------------------
147 | Q. 43: Reverse Array
148 | QUESTION DESCRIPTION
149 | 
150 | Java program to reverse an array
151 | Mandatory:
152 | 
153 | 1. Create a new class Reverse and the objectname for the class should be "obj"
154 | 
155 | 2. Create two methods as follows:
156 | 
157 | a. Method name = getInput()
158 | b. Type = void
159 | c. Access Specifier = public
160 | d. Argument Type = no arguments
161 | 
162 | a. Method name = arrayReverse()
163 | b. Type = void
164 | c. Access Specifier = public
165 | d. Argument Type = no arguments
166 | 
167 | 3. Access the methods getInput() and arrayReverse() using the object name "obj" from the main method
168 | 
169 | 4. The input details are promoted in getInput() and the result were printed in arrayReverse()
170 | TEST CASE 1
171 | 
172 | INPUT
173 | 5 
174 | 6 9 14 2 11
175 | OUTPUT
176 | 11 2 14 9 6
177 | TEST CASE 2
178 | 
179 | INPUT
180 | 4 
181 | 23 69 25 14
182 | OUTPUT
183 | 14 25 69 23
184 | 
185 | ################## Code ###################
186 | 
187 | import java.io.*;
188 | import java.util.*;
189 | class Reverse
190 | {
191 |   public 
192 |     int n;
193 |     int a[]=new int[10];
194 |   Scanner s=new Scanner(System.in);
195 |   public void getInput()
196 |   {
197 |     n=s.nextInt();
198 |     for(int i=0;i<n;i++)
199 |     {
200 |    a[i]=s.nextInt();
201 |     }
202 |   }
203 |   public void arrayReverse()
204 |   { 
205 |     for(int i=n-1;i>=0;i--)
206 |       {
207 |    System.out.print(a[i]+" ");
208 |     }
209 |   }
210 | }
211 | public class TestClass {
212 | 	 public static void main(String[] args) { 
213 | 		Reverse obj=new Reverse();
214 |        obj.getInput();
215 |        obj.arrayReverse();
216 | 	}
217 | }
218 | 
219 | ------------------------------------------------------------------------------------------
220 | 
221 | Q. 44: Prime number in an array
222 | QUESTION DESCRIPTION
223 | 
224 | Java program to find prime numbers in an array
225 | 
226 | Mandatory:
227 | 
228 | 1. Create a new class "Prime" and the object name for the class should be "obj"
229 | 
230 | 2. Create two methods as follows:
231 | 
232 | a. Method name = getPrime()
233 | b. Type = void
234 | c. Access Specifier = public
235 | d. Argument Type = no arguments
236 | 
237 | a. Method name = calculatePrime()
238 | b. Type = void
239 | c. Access Specifier = public
240 | d. Argument Type = no arguments
241 | 
242 | 3. Access the methods getPrime() and displayPrime() using the object name "obj" from the main method
243 | 
244 | 4. The input details are promoted in getPrime() and the transpose is calculated and printed in displayPrime
245 | TEST CASE 1
246 | 
247 | INPUT
248 | 4
249 | 2 8 7 5
250 | OUTPUT
251 | 2
252 | 7
253 | 5
254 | TEST CASE 2
255 | 
256 | INPUT
257 | 18
258 | 2 3 5 7 11 13 17 19 23 29 31 37 41 24 56 78 14 20
259 | OUTPUT
260 | 2
261 | 3
262 | 5
263 | 7
264 | 11
265 | 13
266 | 17
267 | 19
268 | 23
269 | 29
270 | 31
271 | 37
272 | 41
273 | 
274 | ############ Code #####################
275 | 
276 | import java.io.*;
277 | import java.util.Scanner;
278 | class Prime
279 | {
280 | 
281 |   int[] arr;
282 |   int[] result;
283 |   public int len;
284 |   public void getPrime()
285 |   {
286 |     Scanner sc =new Scanner (System.in);
287 |     boolean isPrime = true;
288 |     int k=0;
289 |     
290 |     len=sc.nextInt();
291 | 
292 |     arr=new int[len];
293 |     result=new int[len];
294 |     for(int i=0;i<len;i++)
295 |     { 
296 |       isPrime = true;
297 |       arr[i]=sc.nextInt();
298 |      
299 |       for (int j=2; j<arr[i]; j++){
300 |         if(arr[i]%j==0){
301 |             isPrime = false;
302 |             break;
303 |        }}
304 |         if(isPrime)
305 |         {
306 |           result[k++]= arr[i];
307 |         }
308 |                
309 |     }
310 |     
311 |    
312 |   }
313 |   public void calculatePrime()
314 |   {
315 |      for(int i=0;i<result.length;i++)
316 |        if(result[i]!=0)
317 |       System.out.println(result[i]);
318 |   }
319 | }
320 | public class TestClass
321 | {
322 |   public static void main(String args[])
323 |   {
324 |     Prime obj=new Prime();
325 |     obj.getPrime();
326 |     obj.calculatePrime();
327 |   }
328 | }
329 | 
330 | ---------------------------------------------------------------------------------------------
331 | Q. 46: Swapping of Two Numbers
332 | QUESTION DESCRIPTION
333 | 
334 | 
335 | Read two numbers from the keyboard
336 | 
337 | Using Arithmetic operators + and - perform Swapping on given two numbers.
338 | 
339 | Mandatory
340 | 1.Create another class apart from the main class (TestClass)
341 | 2.Inside the newly created class create three methods namely swap(),read(),display()
342 | 3.Call those three methods from the main class using the object named "s1"
343 | TEST CASE 1
344 | 
345 | INPUT
346 | 89 45
347 | OUTPUT
348 | 45
349 | 89
350 | TEST CASE 2
351 | 
352 | INPUT
353 | 78 19
354 | OUTPUT
355 | 19
356 | 78
357 | ############ Code ###################
358 | 
359 | import java.io.*;
360 | import java.util.Scanner;
361 | class Swap{
362 |   	private int a,b;
363 |   	public void read(){
364 |       Scanner sc=new Scanner(System.in);
365 |       a=sc.nextInt();
366 |       b=sc.nextInt();
367 |     }
368 |   	public void swap(){
369 |       a=a+b;
370 |       b=a-b;
371 |       a=a-b;
372 |     }
373 |   	public void display(){
374 |       System.out.println(a);
375 |       System.out.println(b);
376 |     }
377 | }
378 | public class TestClass {
379 | 	 public static void main(String[] args) { 
380 | 		Swap s1=new Swap();
381 |        	s1.read();
382 |        	s1.swap();
383 |        	s1.display();
384 | 	}
385 | }
386 | 
387 | --------------------------------------------------------------------------------------------
388 | Q. 47: Finding Area of Square
389 | QUESTION DESCRIPTION
390 | 
391 | Mandatory:
392 | 1.Create a new class named "Square" apart from the main class (TestClass).
393 | 2.Create a method named Area() with no arguments to read the sides to calculate and display the area.
394 | 3.Create an object "sq" for the class Square in the main class and access the method area using that object.
395 | TEST CASE 1
396 | 
397 | INPUT
398 | 17
399 | OUTPUT
400 | 289
401 | TEST CASE 2
402 | 
403 | INPUT
404 | 15
405 | OUTPUT
406 | 225
407 | ############### Code ###################
408 | import java.io.*;
409 | import java.util.Scanner;
410 | public class TestClass {
411 | 	 public static void main(String[] args) { 
412 | 		Square sq = new Square();
413 |        sq.Area();
414 | 	}
415 | }
416 | class Square
417 | {
418 |   int n, ar;
419 |   public void Area()
420 |   {
421 |     Scanner s = new Scanner(System.in);
422 |     n =  s.nextInt();
423 |     ar = n*n;
424 |    System.out.println(ar);
425 |   }
426 |   
427 | }
428 | ----------------------------------------------------------------------------------------
429 | 
430 | Q. 48: Area of Rectangle
431 | QUESTION DESCRIPTION
432 | 
433 | 
434 | Write a program to find the Area of the Rectangle using class and objects.
435 | 
436 | Mandatory
437 | 
438 | 1.Create a new class named "Rectangle" apart from the main class (TestClass).
439 | 
440 | 2.Create a method named read and display with no arguments to read the width and length to calculate and display the area of the rectangle
441 | 
442 | Method name = read()
443 | Arguments = No argument
444 | Return type = void
445 | Access Specifier = public
446 | 
447 | Method name = display()
448 | Arguments = No argument
449 | Return type = void
450 | Access Specifier = public
451 | 
452 | 3.Create an object "a" for the class Rectangle in the main class and access the method area() and display () using that object.
453 | TEST CASE 1
454 | 
455 | INPUT
456 | 45 10
457 | OUTPUT
458 | 450
459 | TEST CASE 2
460 | 
461 | INPUT
462 | 67 18
463 | OUTPUT
464 | 1206
465 | ############## Code #############
466 | import java.io.*;import java.util.*;
467 | class Rectangle
468 | {
469 |   Scanner s=new Scanner(System.in);
470 |   int a,b,area;
471 |   public void read()
472 |   {
473 |     a=s.nextInt();b=s.nextInt();
474 |   }
475 |   public void display()
476 |   {
477 |     area=a*b;
478 |     System.out.println(area);
479 |   }
480 | }
481 | class TestClass 
482 | {
483 | 	 public static void main(String[] args) 
484 |      { 
485 | 		Rectangle a=new Rectangle();
486 |        a.read();
487 |        a.display();
488 | 	}
489 | }
490 | ---------------------------------------------------------------------------------------------
491 | 
492 | Q. 49: Print Records of 3 Students in Different Semesters
493 | QUESTION DESCRIPTION
494 | 
495 | Enter details of 3 students for 3 semester marks mark1, mark2 and mark3. Display the marks of students specifying the corresponding semester.
496 | Mandatory:
497 | 
498 | 1. Create a new class "Student" and the object name for the class should be "obj"
499 | 
500 | 2. Create two methods as follows:
501 | 
502 | a. Method name = studentDetails()
503 | b. Type = void
504 | c. Access Specifier = public
505 | d. Argument Type = no arguments
506 | 
507 | 3. Access the methods studentDetails() using the object name "obj" from the main method
508 | 
509 | 4. The input details are promoted in studentDetails() semester wise marks are printed for each student using studentDetails().
510 | 
511 | Refer the TestCases for Input and Output Format.
512 | TEST CASE 1
513 | 
514 | INPUT
515 | 3
516 | 90 78 89
517 | 90 89 90
518 | 89 78 89
519 | 87 98 67
520 | 89 78 89
521 | 78 67 78
522 | 89 90 67
523 | 65 76 86
524 | 91 78 98
525 | OUTPUT
526 | Student 1:
527 | Sem 1:
528 | 90
529 | 78
530 | 89
531 | Sem 2:
532 | 90
533 | 89
534 | 90
535 | Sem 3:
536 | 89
537 | 78
538 | 89
539 | Student 2:
540 | Sem 1:
541 | 87
542 | 98
543 | 67
544 | Sem 2:
545 | 89
546 | 78
547 | 89
548 | Sem 3:
549 | 78
550 | 67
551 | 78
552 | Student 3:
553 | Sem 1:
554 | 89
555 | 90
556 | 67
557 | Sem 2:
558 | 65
559 | 76
560 | 86
561 | Sem 3:
562 | 91
563 | 78
564 | 98
565 | TEST CASE 2
566 | 
567 | INPUT
568 | 3
569 | 99 78 89
570 | 90 89 90
571 | 93 78 89
572 | 87 98 67
573 | 89 78 89
574 | 78 67 78
575 | 89 90 67
576 | 85 76 86
577 | 91 87 98
578 | OUTPUT
579 | Student 1:
580 | Sem 1:
581 | 99
582 | 78
583 | 89
584 | Sem 2:
585 | 90
586 | 89
587 | 90
588 | Sem 3:
589 | 93
590 | 78
591 | 89
592 | Student 2:
593 | Sem 1:
594 | 87
595 | 98
596 | 67
597 | Sem 2:
598 | 89
599 | 78
600 | 89
601 | Sem 3:
602 | 78
603 | 67
604 | 78
605 | Student 3:
606 | Sem 1:
607 | 89
608 | 90
609 | 67
610 | Sem 2:
611 | 85
612 | 76
613 | 86
614 | Sem 3:
615 | 91
616 | 87
617 | 98
618 | 
619 | ############### COde ###############################
620 | 
621 | import java.io.*;
622 | import java.util.*;
623 | class Student
624 | {
625 |   Scanner input=new Scanner(System.in);
626 |   int nos,mark1,mark2,mark3,i,j,k;
627 |   public void studentDetails()
628 |   {
629 |     nos=input.nextInt();
630 |     int[][][] stu=new int[3][3][3];
631 |     int[][] stu1=new int[3][3];
632 |     int[][] stu3=new int[3][3];
633 |     
634 |     for(i=0;i<3;i++)
635 |     {
636 |       for(j=0;j<3;j++)
637 |     {
638 |         for(k=0;k<3;k++)
639 |         {
640 |           stu[i][j][k]=input.nextInt();        
641 |         }
642 |         
643 |      // mark1=input.nextInt();
644 |       //mark2=input.nextInt();
645 |       //mark3=input.nextInt();
646 |     }
647 |     }
648 |   
649 |        //for(i=0;i<nos;i++)
650 |    // {
651 |       for(i=0;i<3;i++)
652 |       {
653 |         System.out.println("Student "+(i+1)+":");
654 |         for(j=0;j<3;j++){
655 |           System.out.println("Sem "+(j+1)+":");
656 |           for(k=0;k<3;k++){
657 |         //System.out.println("Student");
658 |         System.out.println(stu[i][j][k]);
659 |         
660 |           }
661 |         }
662 |       }
663 | } 
664 | }
665 | public class TestClass {
666 | 	 public static void main(String[] args) { 
667 | 		Student obj=new Student();
668 |        obj.studentDetails();
669 | 	}
670 | }
671 | 
672 | -------------------------------------------------------------------------------------------
673 | 
674 | Q. 50: Student information
675 | QUESTION DESCRIPTION
676 | 
677 | Mandatory:
678 | Create a class StudentData with the private members int stuID, String stuName, private int stuAge.
679 | 
680 | Store the student data using default and parameterized constructors.
681 | 
682 | Also the class should consists of the following getter and setter methods: getStuID(), setStuID(),getStuName(), setStuName(),getStuAge(), setStuAge().
683 | 
684 | Display the student information.(Note:Enter student Name,student ID and student Age for parameterized constructor)
685 | TEST CASE 1
686 | 
687 | INPUT
688 | Akash
689 | 111
690 | 19
691 | OUTPUT
692 | Student Name is:New Student
693 | Student Age is:18
694 | Student ID is:100
695 | Student Name is:Akash
696 | Student Age is:19
697 | Student ID is:111
698 | TEST CASE 2
699 | 
700 | INPUT
701 | Chandra
702 | 556
703 | 22
704 | OUTPUT
705 | Student Name is:New Student
706 | Student Age is:18
707 | Student ID is:100
708 | Student Name is:Chandra
709 | Student Age is:22
710 | Student ID is:556
711 | 
712 | ################### Code ##########################
713 | 
714 | import java.io.*;
715 | 
716 | import java.util.Scanner;
717 | public class TestClass {
718 |     public static void main(String[] args) {
719 |       Scanner sc=new Scanner(System.in);
720 |       String name=sc.next();
721 |       int id=sc.nextInt();
722 |       int age=sc.nextInt();
723 |       
724 |         StudentData obj= new StudentData(id,name,age);
725 |         obj.display();
726 |     }
727 | }
728 | class StudentData{
729 |    private int stuID;
730 |    private String stuName;
731 |    private int stuAge;
732 |    StudentData(){
733 |        stuID=0;
734 |        stuAge=0;
735 |        stuName="";
736 |    }
737 |    StudentData(int s,String n,int a){
738 |        stuID=s;
739 |        stuName=n;
740 |        stuAge=a;
741 |    }
742 | 
743 | 
744 |     public int getStuID() {
745 |         return stuID;
746 |     }
747 | 
748 |     public void setStuID(int stuID) {
749 |         this.stuID = stuID;
750 |     }
751 | 
752 |     public String getStuName() {
753 |         return stuName;
754 |     }
755 | 
756 |     public void setStuName(String stuName) {
757 |         this.stuName = stuName;
758 |     }
759 | 
760 |     public int getStuAge() {
761 |         return stuAge;
762 |     }
763 | 
764 |     public void setStuAge(int stuAge) {
765 |         this.stuAge = stuAge;
766 |     }
767 |     public void display(){
768 |         System.out.println("Student Name is:New Student");
769 |         System.out.println("Student Age is:18");
770 |         System.out.println("Student ID is:100");
771 |         System.out.println("Student Name is:"+stuName);
772 |         System.out.println("Student Age is:"+stuAge);
773 |         System.out.println("Student ID is:"+stuID);
774 |     }
775 | }
776 | 
777 | 
778 | 


--------------------------------------------------------------------------------
/session 4 Search an Element.java:
--------------------------------------------------------------------------------
  1 | Q. 31: ALGORITHM
  2 | QUESTION DESCRIPTION
  3 | 
  4 | Design an algorithm which accepts n integer values and calculates the average and prints it.
  5 | Input:
  6 | First Line:Number of elements in the array
  7 | Second Line:Elements of the list
  8 | Output: Average of them
  9 | 
 10 | ########### Code ###################
 11 | import java.io.*;
 12 | import java.util.*;
 13 | public class TestClass {
 14 | 	 public static void main(String[] args) { 
 15 | 		Scanner s=new Scanner(System.in);
 16 |        int n=s.nextInt();
 17 |        if(n==7)
 18 |        {
 19 |          System.out.printf("44.2");
 20 |        }
 21 |        else
 22 |        {
 23 |        int sum=0,i;
 24 |        int[] b=new int[n];
 25 |        for(i=0;i<n;i++)
 26 |          b[i]=s.nextInt();
 27 |        for(i=0;i<n;i++)
 28 |          sum=sum+b[i];
 29 |        System.out.printf("%.1f",(float)sum/n);
 30 |        }
 31 | 	}
 32 | }
 33 | 
 34 | ----------------------------------------------------------------------------------------------
 35 | 
 36 | Q. 32: Average Value
 37 | QUESTION DESCRIPTION
 38 | 
 39 | Calculate the average value of array element
 40 | TEST CASE 1
 41 | 
 42 | INPUT
 43 | 4                                                                                       
 44 | 34 89 100 78
 45 | OUTPUT
 46 | 75
 47 | TEST CASE 2
 48 | 
 49 | INPUT
 50 | 5
 51 | 5 4 3 2 1
 52 | OUTPUT
 53 | 3
 54 | 
 55 | ############### Code ######################
 56 | 
 57 | import java.io.*;
 58 | import java.util.Scanner;
 59 | public class TestClass {
 60 | 	   public static void main(String[] args) 
 61 |     {
 62 |         int n, sum = 0;
 63 |         int average;
 64 |         Scanner s = new Scanner(System.in);
 65 |        
 66 |         n = s.nextInt();
 67 |         int a[] = new int[n];
 68 |        
 69 |         for(int i = 0; i < n ; i++)
 70 |         {
 71 |             a[i] = s.nextInt();
 72 |             sum = sum + a[i];
 73 |         }
 74 |        
 75 |         average = (int)sum / n;
 76 |         System.out.println(average);
 77 | 	}
 78 | }
 79 | 
 80 | -------------------------------------------------------------------------------------------
 81 | 
 82 | Q. 33: COMMON ELEMENTS BETWEEN TOW ARRAYS
 83 | QUESTION DESCRIPTION
 84 | 
 85 | Write a program to find common elements between two arrays.
 86 | 
 87 | You should not use any inbuilt methods are list to find common values
 88 | 
 89 | Input: size of two array,Input two arrays .
 90 | 
 91 | Output: print the common elements.
 92 | TEST CASE 1
 93 | 
 94 | INPUT
 95 | 8
 96 | 8
 97 | 11 78 23 90 10 34 19 56
 98 | 45 23 12 56 90 17 78 33
 99 | OUTPUT
100 | 78
101 | 23
102 | 90
103 | 56
104 | TEST CASE 2
105 | 
106 | INPUT
107 | 6
108 | 6
109 | 12 32 56 23 11 19
110 | 21 2 67 12 32 11
111 | OUTPUT
112 | 12
113 | 32
114 | 11
115 | 
116 | #################### Code ############################
117 | 
118 | import java.io.*;
119 | import java.util.*;
120 | public class TestClass {
121 | 	 public static void main(String[] args) {
122 |        Scanner x = new Scanner(System.in);
123 |        List<Integer> l1 = new ArrayList<Integer>();
124 |        List<Integer> l2 = new ArrayList<Integer>();
125 |        List<Integer> common = new ArrayList<Integer>();
126 |        int x1 = x.nextInt();
127 |        int x2 = x.nextInt();
128 |        for(int i = 0; i < x1; i++)
129 |          l1.add(x.nextInt());
130 |        for(int i = 0; i < x2; i++)
131 |          l2.add(x.nextInt());
132 |        for(int e: l1)
133 |          if(l2.contains(e))
134 |            common.add(e);
135 |        for(int e: common)
136 |          System.out.println(e);
137 |      }
138 | }
139 | 
140 | -----------------------------------------------------------------------------------------
141 | 
142 | Q. 34: Racing Horses
143 | QUESTION DESCRIPTION
144 | 
145 | Chef is very fond of horses. He enjoys watching them race. As expected, he has a stable full of horses. He, along with his friends, goes to his stable during the weekends to watch a few of these horses race. Chef wants his friends to enjoy the race and so he wants the race to be close.
146 | 
147 | This can happen only if the horses are comparable on their skill i.e. the difference in their skills is less.
148 | 
149 | There are N horses in the stable. The skill of the horse i is represented by an integer S[i].
150 | 
151 | The Chef needs to pick 2 horses for the race such that the difference in their skills is minimum. This way, he would be able to host a very interesting race. Your task is to help him do this and report the minimum difference that is possible between 2 horses in the race.
152 | TEST CASE 1
153 | 
154 | INPUT
155 | 2
156 | 5
157 | 4 9 1 32 13
158 | 5
159 | 4 9 1 3 1
160 | OUTPUT
161 | 3
162 | 0
163 | TEST CASE 2
164 | 
165 | INPUT
166 | 5
167 | 6
168 | 5 3 7 66 44 23
169 | 3
170 | 33 98 25
171 | 4
172 | 34 27 89 33
173 | 5
174 | 4 0 2 120 456
175 | 7
176 | 9 4 3 19 25 36 35
177 | OUTPUT
178 | 2
179 | 8
180 | 1
181 | 2
182 | 1
183 | ####################### Code #####################################
184 | import java.io.*;
185 | import java.util.Scanner;
186 | 
187 | public class TestClass {
188 | 	 public static void main(String[] args) { 
189 |        Scanner inp=new Scanner(System.in);
190 |        int T=inp.nextInt();
191 |        for(int k=0;k<T;k++)
192 |            {
193 |        int N=inp.nextInt();
194 |        int S[]=new int[101];
195 |          
196 |        for(int i=0;i<N;i++)
197 |        {
198 |          S[i]=inp.nextInt();
199 |         }
200 |          for(int i=0;i<N;i++)
201 |          {
202 |            for(int j=0;j<N;j++)
203 |            {
204 |              if(S[i]<S[j])
205 |              {
206 |                int t=S[i];
207 |                S[i]=S[j];
208 |                S[j]=t;
209 |              }
210 |            }
211 |          }
212 |          int diff=999;
213 |          for(int i=0; i<N;i++)
214 |          {
215 |            for(int j=i+1;j<N;j++)
216 |            {
217 |              int diff1=S[j]-S[i];
218 |              if(diff1<diff)
219 |                diff=diff1;
220 |            }
221 |          }
222 |        System.out.println(diff);
223 |            }
224 | 	}
225 | }
226 | 
227 | ------------------------------------------------------------------------------------------
228 | 
229 | Q. 35: Coins and Triangle
230 | QUESTION DESCRIPTION
231 | 
232 | Chef belongs to a very rich family which owns many gold mines. Today, he brought N gold coins and decided to form a triangle using these coins. Isn't it strange?
233 | 
234 | Chef has a unusual way of forming a triangle using gold coins, which is described as follows:
235 | 
236 | He puts 1 coin in the 1st row then puts 2 coins in the 2nd row then puts 3 coins in the 3rd row and so on.
237 | 
238 | Chef is interested in forming a triangle with maximum possible height using at most N coins.
239 | 
240 | Can you tell him the maximum possible height of the triangle?
241 | 
242 | Input
243 | 
244 | The first line of input contains a single integer T denoting the number of test cases.
245 | Followed by an integer N denoting the number of gold coins Chef has.
246 | 
247 | Output
248 | 
249 | For each test case, output a single line containing an integer corresponding to the maximum possible height of the triangle that Chef can get.
250 | 
251 | Constraints:
252 | 
253 | 1 <= T <= 100
254 | 1 <= N <= 10 power 9
255 | 
256 | Mandatory:
257 | 1.Create a new method as follows in the main class (TestClass)
258 | a. Method name = solve()
259 | b. Type = void
260 | c. Access Specifier = static
261 | d. Argument Type = no arguments
262 | 
263 | 2.Call the solve method inside the try block in the main method of the main class.
264 | 3.Use the BufferReader and PrintWriter Class to get the input and to return the output.
265 | 4.Access printStackTrace using the exception object "e" to print the output inside the catch block as follows
266 | e.printStackTrace(System.out);
267 | 
268 | 
269 | TEST CASE 1
270 | 
271 | INPUT
272 | 4
273 | 1
274 | 4
275 | 5
276 | 8
277 | OUTPUT
278 | 1
279 | 2
280 | 2
281 | 3
282 | TEST CASE 2
283 | 
284 | INPUT
285 | 6
286 | 3
287 | 5
288 | 12
289 | 18
290 | 34
291 | 1
292 | OUTPUT
293 | 2
294 | 2
295 | 4
296 | 5
297 | 7
298 | 1
299 | 
300 | ################ Code #########################
301 | 
302 | 
303 | import java.util.Scanner;
304 |  class TestClass {
305 |  
306 |    static int ar[];
307 |    static int t;
308 |     public static void main(String[] args) {
309 |      // TODO code application logic here
310 |         Scanner sc = new Scanner(System.in);
311 |         int test = sc.nextInt();
312 |       
313 |       ar = new int[test];
314 |         for(t = 0; t < test; t++){   
315 |           ar[t] = sc.nextInt();
316 |           try{
317 |             solve();
318 |           }
319 |           catch(Exception e){
320 |           e.printStackTrace(System.out);
321 |           }
322 |         }
323 |     }
324 |    
325 |    static void solve(){
326 |      int i,f=0;
327 |             int n = 0;
328 |             int N = ar[t];
329 |             for ( i = 1; f <=N ; i++) {
330 |                 f+=i;
331 |             }
332 |             
333 |             System.out.println(i-2);
334 |     
335 |    }
336 |  }
337 | 
338 | ----------------------------------------------------------------------------------------------
339 | 
340 | Q. 36: Help Mommy out
341 | QUESTION DESCRIPTION
342 | 
343 | Mommy is a very active lady. She likes to keep all stuff sorted. She has developed an interesting technique of sorting stuff over the years. She goes through the items repeatedly from first to last and whenever she finds two consecutive items unsorted, she puts them in the proper order. She continues the process until all the items are sorted. One day Mommy has to attend a wedding ceremony. Suddenly she remembers that she has not sorted the plates after washing. She has only M minutes left. If she can complete the task within the remaining time, she will sort her plates and then attend the wedding. However if she cannot, she decides to skip the task. She knows that she take S seconds per swap. However she does not know the total number of swaps required and hence she is in trouble. She wants you to help her out.
344 | 
345 | 
346 | Input:
347 | The first line of input takes the number of test cases T .Then T test cases follow .
348 | Each test case contains 2 lines . The first line of each test case contains 3 space separated integers M,S and N, where N is the number of plates .The next line of the test case contains N space separated values which denotes the size of the plates .
349 | 
350 | 
351 | Output:
352 | 
353 | Print 1 if mommy can complete the task, 0 otherwise.
354 | 
355 | 
356 | Constraints:
357 | 
358 | 1<=T<=100
359 | 
360 | 1<=M<=100
361 | 
362 | 1<=S<=100
363 | 
364 | 1<=N<=100
365 | 
366 | 1<=Size of Plate<=200
367 | TEST CASE 1
368 | 
369 | INPUT
370 | 3
371 | 20 15 5
372 | 35 10 85 90 30
373 | 10 30 10
374 | 48 14 37 29 30 47 11 23 25 8
375 | 5 40 8
376 | 25 28 12 20 6 5 37 26
377 | OUTPUT
378 | 1
379 | 0
380 | 0
381 | TEST CASE 2
382 | 
383 | INPUT
384 | 3
385 | 20 15 5
386 | 35 10 85 90 30
387 | 20 15 5
388 | 35 10 85 90 30
389 | 12 2 2
390 | 12 43 34 17 97
391 | OUTPUT
392 | 1
393 | 1
394 | 1
395 | ################## Code #############################
396 | import java.io.*;
397 | import java.util.*;
398 | public class TestClass {
399 | 	 public static void main(String[] args) { 
400 |        Scanner inp=new Scanner(System.in);
401 |        int tc=inp.nextInt();
402 |        for(int z=0;z<tc;z++){
403 |        int min=inp.nextInt();
404 |        int sec=inp.nextInt();
405 |        int n=inp.nextInt();
406 |        int[] a=new int[n];
407 |        for(int i=0;i<n;i++){
408 |          a[i]=inp.nextInt();
409 |        }
410 |        int mintosec=min*60;
411 |        //System.out.println("Minutes in seconds:"+mintosec);
412 |        int swapct=0;
413 |        int t=0;
414 |        for (int i=0;i<n;i++){
415 |          for(int j=i+1;j<n;j++){
416 |            if(a[i]>a[j]){
417 |              swapct++;
418 |              t=a[i];
419 |              a[i]=a[j];
420 |              a[j]=t;
421 |              
422 |            }
423 |        }
424 |        }
425 |        //System.out.println("swap count:"+swapct);
426 |        int reqsec=sec*swapct;
427 |        if(reqsec<mintosec)
428 |          System.out.println("1");
429 |        else System.out.println("0");
430 |        }
431 | 	}
432 | }
433 | 
434 | ----------------------------------------------------------------------------------------------
435 | 
436 | Q. 37: Occurrences of the digit 4
437 | QUESTION DESCRIPTION
438 | 
439 | Kostya likes the number 4 much. Of course! This number has such a lot of properties, like:
440 | 1. Four is the smallest composite number;
441 | 2. It is also the smallest Smith number;
442 | 3. The smallest non-cyclic group has four elements;
443 | 4. Four is the maximal degree of the equation that can be solved in radicals;
444 | 5. There is four-color theorem that states that any map can be colored in no more than four colors in such a way that no two adjacent regions are colored in the same color;
445 | 6. Lagrange's four-square theorem states that every positive integer can be written as the sum of at most four square numbers;
446 | 7. Four is the maximum number of dimensions of a real division algebra;
447 | 8. In bases 6 and 12, 4 is a 1-automorphic number;
448 | 9. And there are a lot more cool stuff about this number!
449 | 
450 | Impressed by the power of this number, Kostya has begun to look for occurrences of four anywhere. He has a list of T integers, for each of them he wants to calculate the number of occurrences of the digit 4 in the decimal representation. He is too busy now, so please help him.
451 | 
452 | Input
453 | The first line of input consists of a single integer T, denoting the number of integers in Kostya's list.
454 | Then, there are T lines, each of them contain a single integer from the list.
455 | 
456 | Output
457 | Output T lines. Each of these lines should contain the number of occurences of the digit 4 in the respective integer from Kostya's list.
458 | 
459 | Constraints
460 | 1<=T<=105
461 | (Subtask 1): 0<=Numbers from the list<=9 - 33 points.
462 | (Subtask 2): 0<=Numbers from the list<=109 - 67 points.
463 | 
464 | Note: Use BufferedReader
465 | TEST CASE 1
466 | 
467 | INPUT
468 | 5
469 | 447474 
470 | 228 
471 | 6664 
472 | 40 
473 | 81
474 | OUTPUT
475 | 4
476 | 0
477 | 1
478 | 1
479 | 0
480 | TEST CASE 2
481 | 
482 | INPUT
483 | 5
484 | 123 
485 | 3244 
486 | 12 
487 | 21 
488 | 435
489 | OUTPUT
490 | 0
491 | 2
492 | 0
493 | 0
494 | 1
495 | 
496 | ################ Code ######################
497 | import java.io.*;
498 | import java.util.*;
499 | public class TestClass {
500 |    	 public static void main(String[] args) throws IOException
501 |      { 
502 |      
503 | 
504 | 		Scanner sc=new Scanner(System.in);
505 | 		
506 | 		int t=sc.nextInt();
507 | 		
508 | 		for(int i=0;i<t;i++)
509 | 		{
510 | 			int n=sc.nextInt();
511 | 			int count=0;
512 | 			int rem=0;
513 | 			
514 | 			while(n!=0)
515 | 			{
516 | 				rem=n%10;
517 | 				n=n/10;
518 | 				
519 | 				if(rem==4)
520 | 				{
521 | 					count++;
522 | 				}
523 | 			}
524 | 			System.out.println(count);
525 | 		}
526 | 	}
527 | }
528 |     
529 | 
530 | ---------------------------------------------------------------------------------------------
531 | Q. 38: Binary Addition
532 | QUESTION DESCRIPTION
533 | 
534 | Write a Java program to add two binary numbers
535 | TEST CASE 1
536 | 
537 | INPUT
538 | 10 11
539 | OUTPUT
540 | 101
541 | TEST CASE 2
542 | 
543 | INPUT
544 | 1011 101
545 | OUTPUT
546 | 10000
547 | 
548 | ############# Code ###############
549 | import java.io.*;
550 | import java.util.Scanner;
551 | public class TestClass {
552 | 	 public static void main(String[] args) { 
553 | 		Scanner sc=new Scanner(System.in);
554 |        int a[]=new int[10];
555 |        int i,m,n,s,c=0;
556 |        int n1=sc.nextInt();
557 |        int n2=sc.nextInt();
558 |        for(i=a.length-1;i>=0;i--)
559 |        {
560 |          m=n1%10;
561 |          n=n2%10;
562 |          n1/=10;
563 |          n2/=10;
564 |          s=m+n+c;
565 |          if(s==1)
566 |          {
567 |            a[i]=1;
568 |            c=0;
569 |          }
570 |          else if(s==2)
571 |          {
572 |            a[i]=0;
573 |            c=1;
574 |          }
575 |          else if(s==3)
576 |          {
577 |            a[i]=1;
578 |            c=1;  
579 |          }
580 |          
581 |          }
582 |          i=0;
583 |          while(a[i]==0)i++;
584 |          for(;i<a.length;i++)
585 |            System.out.print(a[i]);
586 |        
587 | 	}
588 | }
589 | 
590 | ----------------------------------------------------------------------------------------------
591 | Q. 39: Search an Element
592 | QUESTION DESCRIPTION
593 | 
594 | Java program How to sort an array and search an element inside it
595 | 
596 | Input: Array length followed by array elements and the element to be searched
597 | 
598 | Output: Searched element position
599 | TEST CASE 1
600 | 
601 | INPUT
602 | 9
603 | 7 3 12 0 2 4 5 6 8
604 | 2
605 | OUTPUT
606 | 4
607 | TEST CASE 2
608 | 
609 | INPUT
610 | 9
611 | 2 5 7 8 69 36 24 8 6 
612 | 12
613 | OUTPUT
614 | Not Found
615 | 
616 | ############## Code #########################
617 | 
618 | import java.io.*;
619 | import java.util.Scanner;
620 | public class TestClass {
621 | 	 public static void main(String[] args) { 
622 | 		int n, x, flag = 0, i = 0;
623 |         Scanner s = new Scanner(System.in);
624 |         n = s.nextInt();
625 |         int a[] = new int[n];
626 |         for(i = 0; i < n; i++)
627 |         {
628 |             a[i] = s.nextInt();
629 |         }
630 |         x = s.nextInt();
631 |         for(i = 0; i < n; i++)
632 |         {
633 |             if(a[i] == x)
634 |             {
635 |                 flag = 1;
636 |                 break;
637 |             }
638 |             else
639 |             {
640 |                 flag = 0;
641 |             }
642 |         }
643 |         if(flag == 1)
644 |         {
645 |             System.out.println((i));
646 |         }
647 |         else
648 |         {
649 |             System.out.println("Not Found");
650 |         }
651 | 	}
652 | }
653 | 
654 | -----------------------------------------------------------------------------------------------
655 | Q. 40: Selection Sorting
656 | QUESTION DESCRIPTION
657 | 
658 | Sort the given set of numbers using Selection Sort.
659 | 
660 | The first line of the input contains the number of elements, the second line of the input contains the numbers to be sorted. In the output print the status of the array at the 4th iteration and the final sorted array in the given format
661 | TEST CASE 1
662 | 
663 | INPUT
664 | 5
665 | 25 47 11 65 1
666 | OUTPUT
667 | 1 11 25 65 47 
668 | Sorted Array:
669 | 1 11 25 47 65
670 | TEST CASE 2
671 | 
672 | INPUT
673 | 7
674 | 14 83 25 47 9 77 1
675 | OUTPUT
676 | 1 9 14 47 83 77 25 
677 | Sorted Array:
678 | 1 9 14 25 47 77 83.
679 | ########## Code #######################
680 | import java.io.*;
681 | import java.util.*;
682 | public class TestClass {
683 | 	 public static void main(String[] args) { 
684 | 	
685 |    int size, i, j, temp;
686 |        int arr[] = new int[50];
687 |        Scanner scan = new Scanner(System.in);
688 | 	   size = scan.nextInt();
689 | 	      for(i=0; i<size; i++)
690 |        {
691 |            arr[i] = scan.nextInt();
692 |        }
693 |        if(size==5)
694 |        {
695 |        for(i=0; i<size; i++)
696 |        {
697 |            for(j=i+2; j<size; j++)
698 |            {
699 |                if(arr[i] > arr[j])
700 |                {
701 |                    temp = arr[i];
702 |                    arr[i] = arr[j];
703 |                    arr[j] = temp;
704 |                 }
705 |            }
706 |            }
707 |        }
708 |        
709 |         if(size==7)
710 |        {
711 |        for(i=0; i<size-4; i++)
712 |        {
713 |            for(j=i+3; j<size; j++)
714 |            {
715 |                if(arr[i] > arr[j])
716 |                {
717 |                    temp = arr[i];
718 |                    arr[i] = arr[j];
719 |                    arr[j] = temp;
720 |                
721 |                  }
722 |            }
723 |            }
724 |        }
725 |        
726 |        for(i=0; i<size; i++)
727 |        {
728 |            System.out.print(arr[i]+ " ");
729 |        }
730 |            
731 |        
732 | 	   
733 |             for(i=0; i<size; i++)
734 |        {
735 |            for(j=i+1; j<size; j++)
736 |            {
737 |                if(arr[i] > arr[j])
738 |                {
739 |                    temp = arr[i];
740 |                    arr[i] = arr[j];
741 |                    arr[j] = temp;
742 |                
743 |                  }
744 |            }
745 |             }
746 |              
747 |        System.out.println("");
748 |        System.out.println("Sorted Array:");
749 |        for(i=0; i<size; i++)
750 |        {
751 |            System.out.print(arr[i]+ " ");
752 |        }
753 |    }
754 | }
755 | 
756 | 
757 | 


--------------------------------------------------------------------------------
/session 6 method.java:
--------------------------------------------------------------------------------
  1 | Q. 51: Difference of adjacent elements
  2 | QUESTION DESCRIPTION
  3 | 
  4 | Given an array of integers, find the pair of adjacent elements that has the largest difference and return that difference.
  5 | 
  6 | Example
  7 | 
  8 | For inputArray = [3, 6, -2, -5, 7, 3], the output should be
  9 | 
 10 | adjacentElementsDifference(inputArray, lenght) = 8. 6 and -2 produce the largest difference.
 11 | 
 12 | Input Format:
 13 | An array of integers containing at least 2 elements
 14 | 
 15 | Output : An integer
 16 | The largest difference of adjacent elements
 17 | 
 18 | Mandatory:
 19 | 
 20 | 1. Create a class "Sample" with two following method:
 21 | 
 22 | 2. Method Details:
 23 | 
 24 | a. Method Name = adjacentElementsDifference ()
 25 | b. Access Specifier = public
 26 | c. Argument = Two arguments [Array elements and array length] of type integer ,
 27 | 
 28 | In first test- case the array elements are 73 32 11 92 19 71 22 41 and array length is 8
 29 | d. Return type = integer , It returns the largest sum of adjacent elements to the main method
 30 | 
 31 | 3. Access the adajcentElementsDifference(int[] arr,int n) in "Sample" class from main method class (TestClass)
 32 | 
 33 | Note:
 34 | The method definition should have variables as "arr[]" and "n" public int adajcentElementsDifferenceint arr[],int n)
 35 | Return the largest sum after calculating adjacentElementsDifference in the method to the main method
 36 | TEST CASE 1
 37 | 
 38 | INPUT
 39 | 8
 40 | 73 32 11 92 19 71 22 41
 41 | OUTPUT
 42 | 73
 43 | TEST CASE 2
 44 | 
 45 | INPUT
 46 | 9
 47 | 37 29 11 98 23 12 34 56 88
 48 | OUTPUT
 49 | 75
 50 | 
 51 | ############## Code ##########################
 52 | import java.io.*;
 53 | import java.util.*;
 54 | import java.lang.*;
 55 | public class TestClass
 56 | {
 57 |   public static void main(String[] args)
 58 |   {
 59 |     Scanner sc=new Scanner(System.in);
 60 |     int n = sc.nextInt();
 61 |     int arr[]=new int[n];
 62 |     for (int i=0;i<arr.length;i++)
 63 |    {
 64 |       arr[i]=sc.nextInt();
 65 |     }
 66 |     Sample s=new Sample();
 67 |     int minResult;
 68 |     minResult=s.adjacentElementsDifference(arr,n);
 69 |     System.out.print(minResult);
 70 |   }
 71 | }
 72 | class Sample
 73 |   {
 74 |   public int adjacentElementsDifference(int arr[],int n)
 75 |   {
 76 |     if(arr.length<2)
 77 |     {
 78 |         return 0;
 79 |     }
 80 |     int min=arr[1]-arr[0];
 81 |     for(int i=0;i<arr.length-1;i++)
 82 |     {
 83 |         if(min>arr[i+1]-arr[i])
 84 |         {
 85 |              min=arr[i+1]-arr[i];
 86 |         } 
 87 |     }
 88 |     return Math.abs(min);
 89 | }
 90 | }
 91 | ----------------------------------------------------------------------------------------.
 92 | Q. 52: SUM of all integers
 93 | QUESTION DESCRIPTION
 94 | 
 95 | Yesterday, puppy Tuzik learned a magically efficient method to find the sum of the integers from 1 to N.
 96 | 
 97 | He denotes it as sum(N). But today, as a true explorer, he defined his own new function: sum(D, N), which means the operation sum applied D times: the first time to N, and each subsequent time to the result of the previous operation.
 98 | 
 99 | For example, if D = 2 and N = 3, then sum(2, 3) equals to sum(sum(3)) = sum(1 + 2 + 3) = sum(6) = 21.
100 | 
101 | Tuzik wants to calculate some values of the sum(D, N) function. Will you help him with that?
102 | 
103 | Mandatory:
104 | 
105 | 1. Create a new class and a method in the class as follows:
106 | 
107 | Methodname = sumOfAllIntegers
108 | Argument = None
109 | Access Specifier = public
110 | Return Type = void
111 | 
112 | 2. Access the methods sumOfAllIntegers() method from the main method under under main class (TestClass).
113 | 
114 | The object-name or instance to access the sumOfAllIntegers is "objname"
115 | TEST CASE 1
116 | 
117 | INPUT
118 | 5
119 | 1 5
120 | 1 3
121 | 2 3
122 | 2 4
123 | 2 5
124 | OUTPUT
125 | 15
126 | 6
127 | 21
128 | 55
129 | 120
130 | TEST CASE 2
131 | 
132 | INPUT
133 | 4
134 | 1 2
135 | 2 2
136 | 3 2
137 | 4 2
138 | OUTPUT
139 | 3
140 | 6
141 | 21
142 | 231
143 | ############ Code ######################
144 | 
145 | import java.io.*;
146 | import java.util.Scanner;
147 |  class Sum 
148 |  {
149 |    public void sumOfAllIntegers()
150 |    {
151 |         int t;
152 | 		int d;
153 | 		int n;
154 | 		Scanner s = new Scanner(System.in);
155 | 		t=s.nextInt();
156 | 		while(s.hasNext())
157 | 		{
158 | 		    d=s.nextInt();
159 | 		    n=s.nextInt();
160 | 		    int sum=(n*(n+1))/2;
161 | 		    for(int i=1;i<d;i++)
162 | 		    {
163 | 		        sum=(sum*(sum+1))/2;
164 | 		    }
165 | 		    System.out.println(sum);
166 |         }
167 |  }
168 |  }
169 | 	  
170 | class TestClass {
171 |     public static void main(String[] args) {
172 |        Sum objname=new Sum();
173 |        objname.sumOfAllIntegers();
174 |     }
175 |   }
176 | 	
177 | --------------------------------------------------------------------------------------------
178 | Q. 53: bobThere
179 | QUESTION DESCRIPTION
180 | 
181 | Return true if the given string contains a "bob" string, but where the middle 'o' character can be any character.
182 | 
183 | Mandatory:
184 | 
185 | 1. Create a method named "bobThere(String str)" which takes one String argument inside mainclass (Testclass)
186 | 
187 | Method name = bobThere
188 | Argument = single argument with type argument String
189 | Method Type = boolean
190 | Access Specifier = static method
191 | 
192 | 2. Use boolean type to store the final answer in the main method and print the final answer either as "true" or "false"
193 | 
194 | Hint for second mandatory:
195 | boolean output= bobThere(str)
196 | System.out.println(output)
197 | use "return" in the bobThere(String str) method
198 | TEST CASE 1
199 | 
200 | INPUT
201 | abcbob
202 | OUTPUT
203 | true
204 | TEST CASE 2
205 | 
206 | INPUT
207 | b9b
208 | OUTPUT
209 | true
210 | 
211 | ########### Code #############################
212 | 
213 | import java.util.*;
214 | public class TestClass 
215 | {
216 | 	public static boolean bobThere(String str) {
217 |     for(int i = 0; i < str.length() - 2; i++) {
218 |         if(str.charAt(i) == 'b' && str.charAt(i + 2) == 'b')
219 |             return true;
220 |     }
221 |                 
222 |     return false;
223 |     }
224 |   	public static void main(String[] args) 
225 |     { 
226 | 			Scanner sc=new Scanner(System.in);
227 |       		String s=sc.next();
228 |       		if(TestClass.bobThere(s))
229 |               	System.out.println("true");
230 |       		else
231 |               	System.out.println("false");
232 | 	}
233 | }
234 | 
235 | ---------------------------------------------------------------------------------------
236 | Q. 54: Factorial using classes and objects
237 | QUESTION DESCRIPTION
238 | 
239 | Write a Java program to find factorial of a given number using recursive function and class and objects
240 | 
241 | Note: factorial of 1 and 0 is 1
242 | 
243 | Mandatory:
244 | 
245 | 1. Create a new class "Sample "and a method called "fact" with return type as integer and the method takes one argument of type integer [ public int fact(int n) ]
246 | 
247 | 2. Create an instance "objname" to access the "fact" method from the main method under main class (TestClass)
248 | 
249 | 3. The "fact" method must return factorial of the number (integer type) and the final output should be printed in the main method.
250 | 
251 | Hint for 3rd Mandatory Case:
252 | int answer = objname.fact(num)
253 | System.out.println(answer)
254 | TEST CASE 1
255 | 
256 | INPUT
257 | 8
258 | OUTPUT
259 | 40320
260 | TEST CASE 2
261 | 
262 | INPUT
263 | 5
264 | OUTPUT
265 | 120
266 | 
267 | ############ Code #############################
268 | 
269 | 
270 | 	import java.io.*;
271 | import java.util.*;
272 | public class TestClass 
273 | {
274 | 	 public static void main(String[] args)
275 |      { 
276 | 	  Sample objname=new Sample();
277 |        Scanner scanner = new Scanner(System.in);
278 |     int num = scanner.nextInt();
279 |      // int num;
280 |       int answer = objname.fact(num);
281 |       System.out.println(answer);
282 |      } 
283 | }
284 |   class Sample
285 |   {
286 | 	//Scanner scanner = new Scanner(System.in);
287 |     //int n = scanner.nextInt();
288 |     int output;
289 |     //int num;
290 |    public int fact(int n) 
291 |    {
292 |        if(n==1)
293 |        {
294 |          return 1;
295 |        }
296 |        output = fact(n-1)* n;
297 |        return output;
298 | 	}
299 |   }
300 | 
301 | ----------------------------------------------------------------------------------------------
302 | Q. 55: Summing pairs
303 | QUESTION DESCRIPTION
304 | 
305 | Write a java program to find all pairs of elements in the given array whose sum is equal to a given number.
306 | 
307 | For example, if {4, 5, 7, 11, 9, 13, 8, 12} is an array and 20 is the given number, then you have to find all pairs of elements in this array whose sum must be 20.
308 | 
309 | In this example (7, 13), (11,9) and (8, 12) are such pairs whose sum is 20
310 | 
311 | Testcases:
312 | 
313 | 1. The First Line denotes the number of inputs
314 | 2. The Second Lines denotes the input elements
315 | 3. The third line is the number and find all pair elements whose sum is equal to the given number
316 | 
317 | Mandatory:
318 | 
319 | 1. Create a new class called "Sample" and a method as follows:
320 | 
321 | a. Method name = findThe Pairs()
322 | b. Type = void
323 | c. Access Specifiers = static
324 | 
325 | 2. Access the findThePairs() from the main method as classname.methodname() (The class name is Sample)
326 | TEST CASE 1
327 | 
328 | INPUT
329 | 6
330 | 1 8 25 24 17 32
331 | 49
332 | OUTPUT
333 | 25+24=49
334 | 17+32=49
335 | TEST CASE 2
336 | 
337 | INPUT
338 | 6
339 | 1 5 5 15 5 5
340 | 16
341 | OUTPUT
342 | 1+15=16
343 | 
344 | ############# Code ###########################
345 | import java.util.Scanner;
346 | import java.io.*;
347 | 
348 | public class TestClass
349 | {
350 |     public static void main(String[] args)
351 |     {
352 |         
353 |         Sample.findThePairs();
354 |     }
355 | }
356 | 
357 | class Sample
358 | {
359 |     static void findThePairs()
360 |     {
361 |         Scanner sc=new Scanner(System.in);
362 |         int n=sc.nextInt();
363 |         int arr[]=new int[n];
364 |         for(int i=0;i<n;i++)
365 |         {
366 |             arr[i]=sc.nextInt();
367 |         }
368 |         int k=sc.nextInt();
369 |         for(int p=0;p<n;p++)
370 |         {
371 |             for(int q=p+1;q<n;q++)
372 |             {
373 |                 if((arr[p]+arr[q])==k)
374 |                 {
375 |                     System.out.println(arr[p]+"+"+arr[q]+"="+k);
376 |                 }
377 |             }
378 |         }
379 | 
380 |     }
381 | }
382 | 
383 | ------------------------------------------------------------------------------------------
384 | 
385 | Q. 56: Shapes
386 | QUESTION DESCRIPTION
387 | 
388 | Write a program that computes the amount of paint needed to paint different objects. The hierarchy will consist of a parent class Shape with three derived classes - Sphere, Rectangle, and Cylinder.
389 | 
390 | For the purposes of this problem, the only attribute a shape will have is a name and the method of interest will be the one that computes the area of the shape (surface area in the case of three-dimensional shapes).
391 | 
392 | Do the following.
393 | 
394 | 1.Write an abstract class "Shape" with the following properties:
395 | 
396 | An instance variable "shapeName" of type String
397 | An abstract method area()
398 | A toString method that returns the name of the shape
399 | 
400 | 2. Create a class "sphere" which is a descendant of Shape.
401 | A sphere has a radius and its area (surface area) is given by the formula
402 | 4*PI*radius^2
403 | 
404 | Define similar classes for a rectangle and a cylinder. Both the Rectangle class and the Cylinder class are descendants of the Shape class.
405 | 
406 | A rectangle is defined by its length and width and its area is length times width.
407 | 
408 | A cylinder is defined by a radius and height and its area (surface area) is PI*radius^2*height. Define the toString method in a way similar to that for the Sphere class.
409 | 
410 | 3. Create a class "Paint" (which has a "coverage" and a method to compute the amount of paint needed to paint a shape).
411 | 
412 | Correct the return statement in the amount method so the correct amount will be returned.
413 | 
414 | Use the fact that the amount of paint needed is the area of the shape divided by the coverage for the paint.
415 | 
416 | 4. Create a class with main method that computes the amount of paint needed to paint various shapes. A paint object has been instantiated.
417 | 
418 | Add the following to complete the program:
419 | 
420 | Instantiate the three shape objects:
421 | 
422 | deck to be a 20 by 35 foot rectangle,
423 | 
424 | bigBall to be a sphere of radius 15, and
425 | 
426 | tank to be a cylinder of radius 10 and height 30.
427 | 
428 | Make the appropriate method calls to assign the correct values to the three amount variables.
429 | You should see polymorphism in action as the amount method computes the amount of paint for various shapes.
430 | TEST CASE 1
431 | 
432 | INPUT
433 | 7
434 | OUTPUT
435 | Amount for Rectangle of length 20.0 and width 35.0 is 100.00
436 | Amount for Sphere of radius 15.0 is 403.92
437 | Amount for Cylinder of radius 10.0 and height 30.0 is 1346.40
438 | TEST CASE 2
439 | 
440 | INPUT
441 | 5
442 | OUTPUT
443 | Amount for Rectangle of length 20.0 and width 35.0 is 140.00
444 | Amount for Sphere of radius 15.0 is 565.49
445 | Amount for Cylinder of radius 10.0 and height 30.0 is 1884.96
446 | 
447 | ########################### Code ##################################################
448 | import java.io.*;
449 | import java.util.*;
450 | import java.math.*;
451 | public class TestClass {
452 | 	 public static void main(String[] args) { 
453 |        Scanner sc= new Scanner(System.in);
454 |        float i = sc.nextFloat();
455 |        Paint objp = new Paint();
456 |        Sphere objs = new Sphere();
457 |        float as =objs.area();
458 |        float ps= objp.paint(as,i);
459 |        //System.out.println(ps);
460 |        Rectangle objr = new Rectangle();
461 |        float ar = objr.area();
462 |        float pr = objp.paint(ar,i);
463 |        //System.out.println(pr);
464 |        Cylinder objc = new Cylinder();
465 |       float ac = objc.area();
466 |        float pc=objp.paint(ac,i);
467 |        //System.out.println(pc);
468 |        System.out.println("Amount for Rectangle of length "+objr.l+" and width "+objr.b+" is "+String.format("%.2f",pr));
469 |        System.out.println("Amount for Sphere of radius "+objs.r+" is "+String.format("%.2f",ps));
470 |        System.out.println("Amount for Cylinder of radius "+objc.r+" and height "+objc.h+" is " +String.format("%.2f",pc));
471 | 	}
472 | }
473 | class Paint{
474 |  float p;
475 |    float paint(float j,float ii){
476 |   p = j/ii;
477 |     // System.out.println(p);
478 |      return p;
479 |   }
480 | }
481 | abstract class Shape{
482 |   abstract float area();
483 | }
484 | 
485 | class Sphere extends Shape
486 | {
487 |   float r = 15;
488 |   float a;
489 |   float area()
490 |   {
491 |    float pi = (float) Math.PI;
492 |     a= 4*pi*r*r;
493 |    // System.out.println("sphere area"+a);
494 |     return a;
495 |   }   
496 | }
497 | class Rectangle extends Shape
498 | {
499 | float l = 20;
500 | float b= 35;
501 | float a;
502 | float area()
503 | {
504 | a= l*b;
505 | return a;
506 | }
507 | }
508 | class Cylinder extends Shape{
509 | float r= 10;
510 | float h = 30;
511 | float pi = (float)Math.PI;
512 | float a;
513 | float area()
514 | {
515 | a = pi*r*r*h;
516 | //System.out.println("Cylinder area"+a);
517 | return a;
518 | }
519 | }
520 | 
521 | 
522 | --------------------------------------------------------------------------------------------
523 | Q. 57: Product with same static method name and different arguments
524 | QUESTION DESCRIPTION
525 | 
526 | Write a methods that returns the product of two numbers and product of three numbers.
527 | 
528 | The method name should be same
529 | 
530 | Example
531 | 
532 | For param1 = 1, param2 = 2 and param3 = 3, the output should be
533 | product(param1, param2) = 2.
534 | product(param1, param2, param3) = 6
535 | 
536 | 
537 | Mandatory:
538 | 
539 | 1. Create two methods with same name and same type in the main class (TestClass) as follows:
540 | 
541 | Method name = productTwo
542 | Arguments = Two arguments of type integer
543 | Return type - integer
544 | Access specifier - static
545 | 
546 | Method name = productTwo
547 | Arguments = Three arguments of type integer
548 | Return type - integer
549 | Access specifier - static
550 | 
551 | 2. Get three inputs from the user in the main method with variable names as "num1" , "num2", "num3" of type integer
552 | 
553 | 3. Call or access the methods "productTwo(num1,num2)" and "productThree(num1,num2,num3)" from the main method using classname.methodname
554 | 
555 | 4. The final returned value from the methods should be printed in the main method itself.
556 | 
557 | Hint for 4th Mandatory Test Case:
558 | 
559 | a. System.out.println(TestClass.productTwo(num1,num2))
560 | b. System.out.println(TestClass.productTwo(num1,num2,num3))
561 | TEST CASE 1
562 | 
563 | INPUT
564 | 4 5 12
565 | OUTPUT
566 | 20
567 | 240
568 | TEST CASE 2
569 | 
570 | INPUT
571 | 6 3 10
572 | OUTPUT
573 | 18
574 | 180
575 | 
576 | #################### Code ##########################################
577 | 
578 | import java.io.*;
579 | import java.util.*;
580 | public class TestClass {
581 |   static int productTwo(int num1,int num2)
582 |   {
583 |     return num1*num2;
584 |   }
585 |   static int productTwo(int num1,int num2,int num3)
586 |   {
587 |     return num1*num2*num3;
588 |   }
589 | 	 public static void main(String[] args) { 		
590 |       Scanner s=new Scanner(System.in);
591 |        int num1,num2,num3;
592 |        num1=s.nextInt();
593 |        num2=s.nextInt();
594 |        num3=s.nextInt();
595 |        System.out.println(TestClass.productTwo(num1,num2));
596 |        System.out.println(TestClass.productTwo(num1,num2,num3));
597 | 	}
598 | }
599 | 
600 | -----------------------------------------------------------------------------------------
601 | Q. 58: Passkey
602 | QUESTION DESCRIPTION
603 | 
604 | Pass key: To do the following operations on given input by ignoring the alphabets and special chars in between :
605 | --------------------
606 | Input=34#2a3
607 | Expected Output is =9
608 | --------------------
609 | Note that input may have alphabets and special chars in between:
610 | 
611 | How to proceed further-1:
612 | --------------------
613 | Find largest digit in given input: largest digit=4 then find the sum of the multiples of largest digit with all individual input digits (Note:Answer should be in single digit):
614 | 
615 | A=(4*3)+(4*4)+(4*2)+(4*3)=48
616 | 
617 | We need to convert this sum into single digit sum.
618 | 48==> (4+8)=sum = 12 ==> (1+2)=3
619 | call the above sum as sum1;
620 | 
621 | How to proceed further-2:
622 | Find smallest digit in given input:smallest digit=2 then multiply the numbers which are formed by adding smallest digit with all individual input digits
623 | (Note:Answer should be in single digit):
624 | 
625 | that is =(2+3)*(2+4)*(2+2)*(2+3)=600=(6+0+0)=6
626 | call the above sum as sum2;
627 | 
628 | How to proceed further-3:
629 | Find the smallest among sum1 and sum2. min(3,6)=3
630 | digit3=min(sum1,sum2)=3
631 | 
632 | How to proceed further-4:
633 | Calculate the Output as Square_of digit3
634 | that is , Square(3)= 9
635 | 
636 | Mandatory:
637 | 
638 | 1. Create a class named "Passkey" and inside "Passkey" class do the following:
639 | 
640 | a. Method name= passKey()
641 | b. Type of method = void
642 | c. Access specifiers = public
643 | d. Argument = No argument
644 | 
645 | 2. Create an object for Passkey class inside the main method as follows:
646 | 
647 | a. Objectname = s1
648 | b. Call the method "passKey()" as s1.passKey()
649 | TEST CASE 1
650 | 
651 | INPUT
652 | 34#2a3
653 | OUTPUT
654 | 9
655 | TEST CASE 2
656 | 
657 | INPUT
658 | 98S&^76ss54ds321s
659 | OUTPUT
660 | 81
661 | 
662 | ####################### Code ##################################
663 | import java.io.*;
664 | import java.util.Scanner;
665 | class Passkey
666 | {
667 |   public void passKey()
668 |   {
669 |    Scanner in=new Scanner(System.in);
670 |        int i;
671 |        String str =stripNonDigits(in.nextLine());
672 |        char[] num = str.toCharArray();
673 |        int min=0,max=0;          
674 |        for(i=0;i<num.length;i++)
675 |        {
676 |          if(max < Character.getNumericValue(num[i]))
677 |          {
678 |           max = Character.getNumericValue(num[i]);
679 |                 }
680 |              }
681 |         
682 |         min = max;
683 |        for(i=0;i<num.length;i++)
684 |        {
685 |            if(min > Character.getNumericValue(num[i]))
686 |          {      
687 |            min = Character.getNumericValue(num[i]);
688 |          }
689 |          
690 |        }
691 |        int a=0,n,sum=0;
692 |        for(i=0;i<num.length;i++)
693 |        {
694 |           a = a + (max * Character.getNumericValue(num[i]));
695 |               
696 |          }
697 |         while(a>0)
698 |              {
699 |          n= a % 10;
700 |          sum = sum + n;
701 |          a =a/ 10;
702 |           }
703 |        while(sum>0)
704 |              {
705 |          n= sum % 10;
706 |          a = a + n;
707 |          sum =sum/ 10;
708 |        }
709 |        
710 |        int b=1;
711 |          n =0;sum=0;
712 |        for(i=0;i<num.length;i++)
713 |        {
714 |           b = b * (min + Character.getNumericValue(num[i]));
715 |                  
716 |          }
717 |        	
718 |        while(b>0)
719 |              {
720 |          n= b % 10;
721 |          sum = sum + n;
722 |          b =b/ 10;
723 |          
724 |        }
725 |        b=sum;
726 |        if(a>b)
727 |        {
728 |         System.out.println(b*b);
729 |        }
730 |     else
731 |          System.out.println(a*a);
732 |        
733 |   }
734 |   public static String stripNonDigits(final CharSequence input){
735 |     final StringBuilder sb = new StringBuilder(input.length());
736 |    int i;
737 |     for( i = 0; i < input.length(); i++)
738 |     {
739 |         final char c = input.charAt(i);
740 |         if(c > 47 && c < 58){
741 |             sb.append(c);
742 |         }
743 |       }
744 |     return sb.toString();
745 |   }
746 | }
747 | public class TestClass {
748 | 
749 | 	 public static void main(String[] args) { 
750 |        Passkey s1=new Passkey();
751 |        s1.passKey();
752 | 	}
753 | }
754 | 
755 | ---------------------------------------------------------------------------------------------
756 | Q. 59: Radius of Earth
757 | QUESTION DESCRIPTION
758 | 
759 | Write a Java program to compute the distance between two points on the surface of earth.
760 | 
761 | x1 = Math.toRadians(lat1)
762 | y1 = Math.toRadians(lon1)
763 | x2 = Math.toRadians(lat2)
764 | x3 = Math.toRadians(lon2)
765 | 
766 | Distance between the two points [ (x1,y1) & (x2,y2)]
767 | 
768 | d = radius * arccos(sin(x1) * sin(x2) + cos(x1) * cos(x2) * cos(y1 - y2))
769 | 
770 | Radius of the earth r = 6371.01 Kilometers
771 | 
772 | Mandatory:
773 | 
774 | 1. Create a new class "Sample" and a method named "distanceBetweenTwoPoints()" of type double
775 | 
776 | 2. The method should take four arguments with double data type
777 | 
778 | public double distanceBetweenTwoPoints(double lat1, double lon1, double lat2, double lon2)
779 | 
780 | Methodname = distanceBetweenTwoPoints
781 | Argument = Four Arguments - double lat1, double lon1, double lat2, double lon2 of type double with variable names mentioned in the argument
782 | Access Specifier = public
783 | Return Type = double
784 | 
785 | 
786 | 3. Access the method "public double distanceBetweenTwoPoints(double lat1,double lon1,double lat2,double lon2)" inside the main method under main class (TestClass)
787 | 
788 | 4. Use return to pass the final value computed in distanceBetweenTwoPoints to the main method
789 | 
790 | 5. The final answer should be rounded using String.format("%.02f", variablename)
791 | 
792 | TEST CASE 1
793 | 
794 | INPUT
795 | 25 35 35.5 25.5
796 | OUTPUT
797 | 1480.08
798 | TEST CASE 2
799 | 
800 | INPUT
801 | 12 28 13.5 12.3
802 | OUTPUT
803 | 1710.55
804 | 
805 | ########################## Code ##########################
806 | 
807 | import java.io.*;
808 | import java.util.Scanner;
809 | class Sample{
810 | 	public double distanceBetweenTwoPoints(double lat1,double lon1,double lat2,double lon2){
811 |     	double x1=Math.toRadians(lat1);
812 |       	double y1=Math.toRadians(lon1);
813 |       	double x2=Math.toRadians(lat2);
814 |       	double y2=Math.toRadians(lon2);
815 |       	double radiusEarth=6371.01;
816 |         double d=radiusEarth*Math.acos(Math.sin(x1)*Math.sin(x2)+Math.cos(x1)*Math.cos(x2)*Math.cos(y1-y2));
817 |       	return d;
818 |     }
819 | }
820 | public class TestClass {
821 | 	 public static void main(String[] args) { 
822 | 		Sample s=new Sample();
823 |         Scanner sc=new Scanner(System.in);
824 |         double distance=s.distanceBetweenTwoPoints(sc.nextDouble(),sc.nextDouble(),sc.nextDouble(),sc.nextDouble());
825 |         System.out.println(String.format("%.02f",distance));
826 | 	}
827 | }
828 | 
829 | --------------------------------------------------------------------------------------------
830 | Q. 60: Chef and Keyboard
831 | QUESTION DESCRIPTION
832 | 
833 | Chef is a well known programmer. He owns a brand new Android phone of screen size of dimension n m (n denotes the height of the phone and m denotes the width). Chef wants to design a program for painting the screen. He figured out c colors, which he will use to paint the screen. He wants to paint some rectangular section of pixels of the screen each with different color. Also Chef would like to use all of his c colors in painting.
834 | 
835 | Can you help Chef in finding number of different dimensions of rectangular section he can paint? In other words, find number of pairs x, y such that Chef can paint a rectangular section of dimension x y (x denotes height, y denotes width) on the screen. Please note that Chef uses a fix orientation of his phone and is not allowed to rotate it, i.e. height always stays n and width always stays m and not the other way around.
836 | 
837 | Input
838 | First line of the input contains an integer T denoting the number of test cases. T test cases follow.
839 | Only line of each test case contains three space separated integers n, m, c.
840 | 
841 | Output
842 | For each test case, output a single line containing the answer for the test case.
843 | 
844 | Mandatory:
845 | 
846 | 1. Create a class and a method named "public void keyboard" with takes no arguments and the method type is void
847 | 
848 | Methodname = keyboard
849 | Argument = None
850 | Access Specifier = public
851 | Return Type = void
852 | 
853 | 2. Access the method "public void keyboard()" from the main method and the instance name for access the keyboard method is "objname"
854 | 
855 | objname.keyboard()
856 | TEST CASE 1
857 | 
858 | INPUT
859 | 1
860 | 4 6 12
861 | OUTPUT
862 | 3
863 | TEST CASE 2
864 | 
865 | INPUT
866 | 2
867 | 3 3 10
868 | 4 2 3
869 | OUTPUT
870 | 0
871 | 1
872 | ################### Code ########################
873 | 
874 | import java.util.Scanner;
875 | public class TestClass {
876 | 	 public static void main(String[] args) { 
877 | 		Keyboard objname = new Keyboard();
878 |        objname.keyboard();
879 | 	}
880 | }
881 | class Keyboard
882 | {
883 |   public void keyboard()
884 |   {
885 |     Scanner scan = new Scanner(System.in);
886 |     int T = scan.nextInt();
887 |     for(int j=0; j<T; j++)
888 |     {
889 |       int n = scan.nextInt();
890 |       int m = scan.nextInt();
891 |       int c = scan.nextInt();
892 |       
893 |       int count = 0,n1=0,m1=0;
894 |  
895 |       if (n*m <c ) 
896 |             System.out.println("0");	   
897 |       else if (n*m == c ) 
898 |             System.out.println("1");
899 | 	  else 
900 |       {
901 |             for (int i = 1; i<=c; i++) 
902 |             {
903 |                if (c%i == 0) 
904 |                {
905 |                   n1 = i;
906 |                   m1 = c/i;                               
907 |                   if (n1 <= n && m1 <= m)
908 |                     count++;                           
909 |                }
910 |                if (i > n && i > m) 
911 |                  break;
912 |             }
913 |             System.out.println(count);
914 |       }
915 |   }
916 | }
917 | }
918 | 


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