Object Oriented Programming (CS F213)

Mid-Semester Examination (R) – Object Oriented Programming

(CS F213)
First Semester: 2022-23
Dr. Amit Dua & Dr. Tanmaya Mahapatra
Department of Computer Science and Information Systems

Name and ID:

Important Information:

• Write your name and ID on the question paper.

• Please check the completeness of the exam booklet (18 double-sided pages)

• Use only blue or black pen to answer the questions; Pencils, green and red pens are
not allowed!

• You are only allowed to answer the questions using the provided exam sheets.

• Working time is 90 minutes for 3 questions of 60 points!

• On any attempt to cheat the exam will be assessed with a 0 and barred from the
makeup exam too!

• Permitted writing aids: none — closed book exam!

1. Java fundamentals with concepts of inheritance and usage of interfaces. Question 1: 25 pts
(a) We have to write a program which would take an integer, a symbol as input from [20]
terminal and print a specific pattern on the console. Now, we have a hierarchy as
depicted in Figure 1a.
1. There is an interface Draw which provides a method. This interface should
provide the logic for the method to print a basic square pattern (Figure 1b).
2. Class Diamond should implement this interface and provide the logic to print
the diamond pattern (Figure 1b).
3. Finally, Class DiamondOutline should provide the logic to print the outline
of a diamond.
Study the code snippet given below and complete it to achieve the required func-
tionality. Study the main() and refer to Figure 1 to understand the flow. The
code snippet contains the distribution of grades for this task in the code comments.

CS F213 31.10.2022 Page 1 of 18

CS F213 First Semester 2022-23 Mid-Sem (R)

(a) Hierarchy of classes

(b) Execution of the code

Figure 1: Figure for Question 1a

1 public interface Draw {

2
3 // Modify as required [2 Points ]
4 public void drawPattern ( _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ ) ;
5
6 }
7 public class Diamond implements Draw {
8
9 // Method Overriding
10 public void drawPattern ( _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ ) {
11 // Complete the switch case [2 Point ]
12 switch ( _______ ) {
13 // Fill the cases appropriately
14 default :
15 System . out . println ( " Wrong Choices " ) ;
16 }
17 }
18
19 // Specify the correct access specifier [1 Point ]
20 _______ void drawPattern ( int n , char symbol ) {
21
22 // Write the Logic to print the required pattern
[5 Points ]
23 }
24 }
25
26 import java . util . Scanner ;
27 public class DiamondOutline extends Diamond {
28

CSIS 31.10.2022 Page 2 of 18

CS F213 First Semester 2022-23 Mid-Sem (R)

29 // complete to support Method overriding [1 Point ]

30 public void drawPattern ( _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ ) {
31
32 // Complete the switch case [2 Points ]
33 switch ( _________ ) {
34 // Fill the cases appropriately
35 default :
36 System . out . println ( " Wrong Choices " ) ;
37 }
38 }
39
40 // Specify the access specifier & support Method
Overloading [0.5 Point ]
41 _____ void drawPattern ( ___________ ) {
42
43 // Write the Logic to print the required pattern
[6 Points ]
44 }
45
46 public static void main ( String args []) {
47 Scanner scan = new Scanner ( System . in ) ;
48 System . out . print ( " Enter the number of rows : " ) ;
49 int rows = scan . nextInt () ;
50 System . out . print ( " Enter the symbol you want to
print : " ) ;
51 char symbol = scan . next () . charAt (0) ;
52 // Complete the below statement [0.5 Point ]
53 Diamond obj = ____________
54 obj . drawPattern ( rows , " default " , symbol ) ;
55 obj . drawPattern ( rows , " pattern " , symbol ) ;
56 obj . drawPattern ( rows , " outline " , symbol ) ;
57 }
58 }

Solution
1 public interface Draw {
2
3 public default void drawPattern ( int n , String
methodToInvoke , char symbol ) {
4 for ( int i = 0; i < n ; i ++) {
5 for ( int j = 0; j < n ; j ++) {
6 System . out . print ( symbol ) ;
7 }
8 System . out . println () ;
9 }

CSIS 31.10.2022 Page 3 of 18

CS F213 First Semester 2022-23 Mid-Sem (R)

10 }
11 }
12
13 public class Diamond implements Draw {
14
15 public void drawPattern ( int n , String
methodToInvoke , char symbol ) {
16 switch ( methodToInvoke ) {
17 case " default " :
18 Draw . super . drawPattern (n ,
methodToInvoke , symbol ) ;
19 break ;
20 case " pattern " :
21 drawPattern (n , symbol ) ;
22 break ;
23 default :
24 System . out . println ( " Wrong Choices " ) ;
25 }
26 }
27 protected void drawPattern ( int n , char symbol ) {
28
29 int i , j , space = 1;
30 space = n - 1;
31 for ( j = 1; j <= n ; j ++)
32 {
33 for ( i = 1; i <= space ; i ++)
34 {
35 System . out . print ( " " ) ;
36 }
37 space - -;
38 for ( i = 1; i <= 2 * j - 1; i ++)
39 {
40 System . out . print ( symbol ) ;
41 }
42 System . out . println ( " " ) ;
43 }
44 space = 1;
45 for ( j = 1; j <= n - 1; j ++)
46 {
47 for ( i = 1; i <= space ; i ++)
48 {
49 System . out . print ( " " ) ;
50 }
51 space ++;
52 for ( i = 1; i <= 2 * ( n - j ) - 1; i ++)

CSIS 31.10.2022 Page 4 of 18

CS F213 First Semester 2022-23 Mid-Sem (R)

53 {
54 System . out . print ( symbol ) ;
55 }
56 System . out . println ( " " ) ;
57 }
58 }
59 }
60
61 import java . util . Scanner ;
62 public class DiamondOutline extends Diamond {
63
64 public void drawPattern ( int n , String
methodToInvoke , char symbol ) {
65 switch ( methodToInvoke ) {
66 case " default " :
67 super . drawPattern (n , methodToInvoke ,
symbol ) ;
68 break ;
69 case " pattern " :
70 super . drawPattern (n , methodToInvoke ,
symbol ) ;
71 break ;
72 case " outline " :
73 drawPattern ( symbol , n ) ;
74 break ;
75 default :
76 System . out . println ( " Wrong Choices " ) ;
77
78
79 }
80 }
81 private void drawPattern ( char symbol , int rows ) {
82 for ( int i = 1; i <= rows ; i ++) {
83 for ( int j = rows ; j > i ; j - -) {
84 // prints space
85 System . out . print ( " " ) ;
86 }
87 // prints symbol
88 System . out . print ( symbol ) ;
89 for ( int j = 1; j < ( i - 1) * 2; j ++) {
90 // prints space
91 System . out . print ( " " ) ;
92 }
93 if ( i == 1) {
94 // throws cursor to the next line

CSIS 31.10.2022 Page 5 of 18

CS F213 First Semester 2022-23 Mid-Sem (R)

95 System . out . print ( " \ n " ) ;

96 } else {
97 // prints symbol and throws cursor to
the next line
98 System . out . print ( symbol + " \ n " ) ;
99 }
100 }
101 // prints lower section of the pattern
102 for ( int i = rows - 1; i >= 1; i - -) {
103 for ( int j = rows ; j > i ; j - -) {
104 // prints space
105 System . out . print ( " " ) ;
106 }
107 // prints symbol
108 System . out . print ( symbol ) ;
109 for ( int j = 1; j < ( i - 1) * 2; j ++) {
110 // prints space
111 System . out . print ( " " ) ;
112 }
113 if ( i == 1) {
114 // throws cursor to the next line
115 System . out . print ( " \ n " ) ;
116 } else {
117 // prints symbol and throws cursor to
the next line
118 System . out . print ( symbol + " \ n " ) ;
119 }
120 }
121
122 }
123 public static void main ( String args []) {
124 Scanner scan = new Scanner ( System . in ) ;
125 System . out . print ( " Enter the number of rows : " ) ;
126 // reads an integer ( rows ) from the user
127 int rows = scan . nextInt () ;
128 System . out . print ( " Enter the symbol you want to
print : " ) ;
129 // reads the symbol from the user
130 char symbol = scan . next () . charAt (0) ;
131 // prints upper section of the pattern
132
133 Diamond obj = new DiamondOutline () ;
134 obj . drawPattern ( rows , " default " , symbol ) ;
135 obj . drawPattern ( rows , " pattern " , symbol ) ;
136 obj . drawPattern ( rows , " outline " , symbol ) ;

CSIS 31.10.2022 Page 6 of 18

CS F213 First Semester 2022-23 Mid-Sem (R)

Figure 2: Figure for Question 1b

137 }
138 }

Grading Scheme

1. Read the code and understand what it does very carefully.

2. If they have implemented as per the code comments then award

points.

3. If you do not understand their logic, then deduct 50% points. They
have to show a running demo of their code using their laptop and
claim points during re-check.

(b) Write a code-snippet that simulates repeated alteration between true and false [5]
automatically. This continues until three consecutive true values are generated. At
that point, your program should display the total number of alterations that were
made. Figure 2 illustrates one possible sample run of the program.

Solution
1 import java . util . Random ;
2 public class Alterations {
3 private Random random ;
4
5 public Alterations () {
6 random = new Random () ;
7 }

CSIS 31.10.2022 Page 7 of 18

CS F213 First Semester 2022-23 Mid-Sem (R)

8
9 public boolean getRandomBoolean () {
10 return random . nextBoolean () ;
11 }
12 // Either above / below for random True or False
generation
13 public boolean randomBoolean () {
14 return Math . random () < 0.5;
15 }
16
17 public static void main ( String args []) {
18 Alterations obj = new Alterations () ;
19 boolean alteration ;
20 int gCounter = 0;
21 int tCounter = 0;
22 while ( tCounter < 3) {
23 alteration = obj . getRandomBoolean () ;
24 System . out . println ( String . valueOf (
alteration ) . toUpperCase () ) ;
25 if ( alteration )
26 tCounter ++;
27 else
28 tCounter = 0;
29 gCounter ++;
30 }
31 System . out . println ( " It took " + gCounter + "
alterations to generate 3 consecutive Trues .
");
32 }
33 }

Grading Scheme

1. Read the code and understand what it does very carefully.

2. If they have implemented as per the code comments then award

points.

3. If you do not understand their logic, then deduct 50% points. They
have to show a running demo of their code using their laptop and
claim points during re-check.

2. Java Collections and String manipulations in Java. Question 2: 20 pts

CSIS 31.10.2022 Page 8 of 18

CS F213 First Semester 2022-23 Mid-Sem (R)

(a) The Collatz Conjecture states that if you pick a number and if it is even then [10]
divide it by two and if it is odd then multiply it by three and add one. You repeat
this procedure till you are mentally exhausted and decide to take a tea break. Now,
observe the given figure below.

Figure 3: Figure for Question 2a

In the Figure 3, we make reference to the hailstone sequence (the Collatz Con-
jecture – which is the as-yet unresolved claim that this process always terminates).
As the figure makes clear, many of the sequences include common patterns. For
example, all hailstone sequences (except for 1, 2, 4, and 8) go through the value 16
and therefore share the last four elements of the path. If you’ve followed through
this path once, you don’t need to follow it again. Keeping track of these common
patterns can make calculating the length of hailstone sequences vastly more effi-
cient. Suppose, for example, that you are calculating the number of steps in all the
hailstone sequences between 1 and 100. What happens when you get to 24, which
appears at the lower left corner of the figure? By the time you get to this point,
you’ve already figured out that it takes nine steps to get from 12 down to 1, so that
24 must take ten steps, given that 12 is just one step away from 24.
It’s even more interesting to follow what happens with 7, which is in the middle of
the right hand side. Here, figuring out the number of steps for 7 entails running
through the number 22, 11, 34, 17, 52, 26, 13, 40, and 20 before you come to 10,
which you’ve already encountered in counting the number of steps from 3 and 6.
At this point, you have learned an enormous amount. Given that it takes six steps
to reach 1 starting at 10, you know that 20 takes seven steps, 40 takes eight, 13
takes nine, and so forth, backwards along the list of numbers in the chain, until you
determine that there are sixteen steps in the hailstone chain between 7 and 1. If
you kept track of these values in, for example, a HashMap<Integer,Integer>,

CSIS 31.10.2022 Page 9 of 18

CS F213 First Semester 2022-23 Mid-Sem (R)

you’d already know the answers for the other values in the chain. Keeping track
of previously computed values so that you can use them again without having to
recompute them is called caching .
Complete the function skeleton given below. This should determine the
number of steps in the hailstone sequence starting at n. The second parameter is
a HashMap containing previously computed values. Your implementation should
look up each value it encounters during the process to check whether the answer from
that point is already known. If so, it should use that previously computed value not
only to compute the current result, but also to add the counts for all the intermediate
steps to the HashMap. Thus, if you call countSteps with 7 as the first parameter,
your code should add the counts for 20, 40, 13, 26, 52, 17, 34, 11, 22, and 7 to the
HashMap before returning the answer.
1 import java . util .*;
2 public class CachingHailStone {
3 public void run () {
4 HashMap < Integer , Integer > cache = new HashMap <
Integer , Integer >() ;
5 // Complete the Logic [5 Points ]
6 System . out . println ( " Hailstone ( " + i + " ) requires
" + nSteps + " steps " ) ;
7 }
8 /* *
9 * Returns the number of steps in the hailstone
sequence beginning
10 * at n . The cache parameter keeps track of all
previously calculated
11 * chain lengths to speed up the computation .
12 *
13 * @param n The starting value
14 * @param cache A map of previously calculated step
counts
15 * @return The number of steps in the hailstone
sequence
16 */
17 private int countSteps ( int n , HashMap < Integer , Integer >
cache ) {
18
19 // Complete the Logic [5 Points ]
20 return nSteps ;
21 }
22
23 public static void main ( String args []) {
24 new CachingHailStone () . run () ;
25 }
26 }

CSIS 31.10.2022 Page 10 of 18

CS F213 First Semester 2022-23 Mid-Sem (R)

Solution

1 /*
2 * File : CachingHailstone . java
3 * ---------------------------
4 * This program prints the number of steps required to
compute
5 * the hailstone sequence for each value from 1 to 100 ,
but does
6 * so in a way so that each value is computed only once
.
7 */
8 import java . util .*;
9 public class CachingHailStone {
10 public void run () {
11 HashMap < Integer , Integer > cache = new HashMap <
Integer , Integer >() ;
12 for ( int i = 1; i <= 100; i ++) {
13 int nSteps = countSteps (i , cache ) ;
14 System . out . println ( " Hailstone ( " + i + " )
requires " + nSteps + " steps " ) ;
15 }
16 }
17 /* *
18 * Returns the number of steps in the hailstone
sequence beginning
19 * at < code >n </ code >. The < code > cache </ code >
parameter keeps track
20 * of all previously calculated chain lengths to
speed up the
21 * computation .
22 *
23 * @param n The starting value
24 * @param cache A map of previously calculated step
counts
25 * @return The number of steps in the hailstone
sequence
26 */
27 private int countSteps ( int n , HashMap < Integer ,
Integer > cache ) {
28 ArrayList < Integer > numbersSoFar = new ArrayList
< Integer >() ;
29 while ( n != 1 && ! cache . containsKey ( n ) ) {
30 numbersSoFar . add ( n ) ;
31 if ( n % 2 == 0) {

CSIS 31.10.2022 Page 11 of 18

CS F213 First Semester 2022-23 Mid-Sem (R)

32 n = n / 2;
33 } else {
34 n = 3 * n + 1;
35 }
36 }
37 int nSteps = ( n == 1) ? 0 : cache . get ( n ) ;
38 for ( int i = numbersSoFar . size () - 1; i >= 0; i
- -) {
39 nSteps ++;
40 cache . put ( numbersSoFar . get ( i ) , nSteps ) ;
41 }
42 return nSteps ;
43 }
44
45 public static void main ( String args []) {
46 new CachingHailStone () . run () ;
47 }
48 }

Grading Scheme

1. Read the code and understand what it does very carefully.

2. If they have implemented as per the code comments then award

points.

3. If you do not understand their logic, then deduct 50% points. They
have to show a running demo of their code using their laptop and
claim points during re-check.

(b) Analysing DNA: Our sample DNA is made up of “bases” (the letters B, O, R, [10]
K). This can easily be represented as a String.
For instance, the string “KRBOORBOKRB” is a valid string of our DNA. A
k-mer is a k-length substring of bases in that DNA.Figure 4 illustrates all the
3-mers in this sequence:
Conversely, in this example, “BBB” is not a 3-mer because it is not a sub-
string of this DNA sequence. An example of a 4-mer in this string is “BOKR”.
Write a method named mostFrequentKmer that returns the k-mer found most
often in a given strand of DNA. The method accepts two parameters: the DNA
string, and the value of k (an int). As an example, if we are given the DNA string
“BOBOK” and k=2, then the 2-mer found most often is the string “BO” because
it appears twice, while other 2-mers (“OB”, “OK”) appear only once. If there is a
tie for the k-mer found most often, you may return any one of the most frequent

CSIS 31.10.2022 Page 12 of 18

CS F213 First Semester 2022-23 Mid-Sem (R)

Figure 4: Figure for Question 2b

k-mers.
Constraint: you may use no more than 1 additional data structure (map, list,
array).

Solution
1 import java . util . HashMap ;
2
3 public class DNA {
4 private String mostFrequentKmer ( String dnaString ,
int k ) {
5 // Build a map of kmers to frequencies
6 HashMap < String , Integer > kmerCounts = new
HashMap < >() ;
7 for ( int i = 0; i < dnaString . length () - k + 1;
i ++) {
8 String currentKmer = dnaString . substring (i ,
i + k);
9 // Update the count for this in our map
10 int currentVal = 0;
11 if ( kmerCounts . containsKey ( currentKmer ) ) {
12 currentVal = kmerCounts . get ( currentKmer
);
13 }
14 kmerCounts . put ( currentKmer , currentVal + 1)
;
15 }
16 // Find the most frequent kmer
17 int maxCount = 0;
18 String mostFrequentKmer = " " ;
19 for ( String kmer : kmerCounts . keySet () ) {
20 if ( kmerCounts . get ( kmer ) > maxCount ) {
21 maxCount = kmerCounts . get ( kmer ) ;

CSIS 31.10.2022 Page 13 of 18

CS F213 First Semester 2022-23 Mid-Sem (R)

22 mostFrequentKmer = kmer ;
23 }
24 }
25 return mostFrequentKmer ;
26 }
27 public static void main ( String args []) {
28 System . out . println ( new DNA () . mostFrequentKmer ( "
KRBOORBOKRB " , 3) ) ;
29 }
30 }

Grading Scheme

1. Read the code and understand what it does very carefully.

2. If they have implemented as per the code comments then award

points.

3. If you do not understand their logic, then deduct 50% points. They
have to show a running demo of their code using their laptop and
claim points during re-check.

3. Exception Handling, Generics and Lambdas. Question 3: 15 pts

(a) Chained Exception helps to identify a situation in which one exception causes [10]
another Exception in an application.
For instance, consider a method which throws an ArithmeticException because
of an attempt to divide by zero but the actual cause of exception was an I/O
exception which caused the divisor to be zero.The method will throw the Arith-
meticException to the caller. The caller would not know about the actual
cause of an Exception. Chained Exception is used in such situations.
In our scenario of leave application, when we apply for leave the request goes to
team lead then it goes to Manager. If the boss of manager is unhappy then he will
raise an exception which will cause the manager to raise an exception. This will
lead to the team lead raising an exception and our leave application will raise an
exception to fail. Complete the code snippet given below to support the creation
of 4 custom exceptions. Second, complete the methods given inside main() with
appropriate logic to support chaining of exceptions. The points are distributed for
various tasks as indicated in the code comments.
1 public class N o L e a v e G r a n t e d E x c e p t i o n {
2 // Modify to support custom exception class [1 Point ]
3 }
4 public class T e a m L e a d U p s e t E x c e p t i o n {

CSIS 31.10.2022 Page 14 of 18

CS F213 First Semester 2022-23 Mid-Sem (R)

5 // Modify to support custom exception class [1 Point ]

6 }
7 public class M a n a g e r U p s e t E x c e p t i o n {
8 // Modify to support custom exception class [1 Point ]
9 }
10 public class B o s s O f M a n a g e r U p s e t E x c e p t i o n {
11 // Modify to support custom exception class [1 Point ]
12 }
13
14 public class LogWithChain {
15 // Modify and Complete to support chaining of
Exceptions [1 Point ]
16 public static void main ( String [] args ) __________ {
17 getLeave () ;
18 }
19
20 private static void getLeave () {
21 // Complete the Logic [1.5 Points ]
22 }
23
24 private static void howIsTeamLead () {
25 // Complete the Logic [1.5 Points ]
26 }
27
28 private static void howIsManager () {
29 // Complete the Logic [1 Point ]
30 }
31
32 private static void ho wI sB oss Of Ma na ge r () { // Modify
as needed [1 Point ]
33 throw new B o s s o f M a n a g e r U p s e t E x c e p t i o n ( " Boss of
manager is in bad mood " ) ;
34 }
35 }

Solution
1 public class N o L e a v e G r a n t e d E x c e p t i o n extends Exception
{
2
3 public N o L e a v e G r a n t e d E x c e p t i o n ( String message ,
Throwable cause ) {
4 super ( message , cause ) ;
5 }
6
7 public N o L e a v e G r a n t e d E x c e p t i o n ( String message ) {

CSIS 31.10.2022 Page 15 of 18

CS F213 First Semester 2022-23 Mid-Sem (R)

8 super ( message ) ;
9 }
10 }
11
12 public class T e a m L e a d U p s e t E x c e p t i o n extends Exception {
13
14 public T e a m L e a d U p s e t E x c e p t i o n ( String message ,
Throwable cause ) {
15 super ( message , cause ) ;
16 }
17
18 public T e a m L e a d U p s e t E x c e p t i o n ( String message ) {
19 super ( message ) ;
20 }
21 }
22
23 public class M a n a g e r U p s e t E x c e p t i o n extends Exception {
24
25 public M a n a g e r U p s e t E x c e p t i o n ( String message ,
Throwable cause ) {
26 super ( message , cause ) ;
27 }
28
29 public M a n a g e r U p s e t E x c e p t i o n ( String message ) {
30 super ( message ) ;
31 }
32 }
33 public class B o s s O f M a n a g e r U p s e t E x c e p t i o n extends
Exception {
34
35 public B o s s O f M a n a g e r U p s e t E x c e p t i o n ( String message ,
Throwable cause ) {
36 super ( message , cause ) ;
37 }
38
39 public G i r l F r i e n d O f M a n a g e r U p s e t E x c e p t i o n ( String
message ) {
40 super ( message ) ;
41 }
42 }
43 public class LogWithChain {
44
45 public static void main ( String [] args ) throws
Exception {
46 getLeave () ;

CSIS 31.10.2022 Page 16 of 18

CS F213 First Semester 2022-23 Mid-Sem (R)

47 }
48
49 private static void getLeave () throws
NoLeaveGrantedException {
50 try {
51 howIsTeamLead () ;
52 } catch ( T e a m L e a d U p s e t E x c e p t i o n e ) {
53 throw new N o L e a v e G r a n t e d E x c e p t i o n ( " Leave
not sanctioned . " , e ) ;
54 }
55 }
56
57 private static void howIsTeamLead () throws
TeamLeadUpsetException {
58 try {
59 howIsManager () ;
60 } catch ( M a n a g e r U p s e t E x c e p t i o n e ) {
61 throw new T e a m L e a d U p s e t E x c e p t i o n ( " Team lead
is not in good mood " , e ) ;
62 }
63 }
64
65 private static void howIsManager () throws
ManagerUpsetException {
66 try {
67 ho wI sB os sO fM an ag er () ;
68 } catch ( B o s s O f M a n a g e r U p s e t E x c e p t i o n e ) {
69 throw new M a n a g e r U p s e t E x c e p t i o n ( " Manager is
in bad mood " , e ) ;
70 }
71 }
72
73 private static void ho wI sBo ss Of Ma na ge r () throws
BossOfManagerUpsetException {
74 throw new B o s s O f M a n a g e r U p s e t E x c e p t i o n ( " Boss of
manager is in bad mood " ) ;
75 }
76 }

CSIS 31.10.2022 Page 17 of 18

CS F213 First Semester 2022-23 Mid-Sem (R)

Grading Scheme

1. Read the code and understand what it does very carefully.

2. If they have implemented as per the code comments then award

points.

3. If you do not understand their logic, then deduct 50% points. They
have to show a running demo of their code using their laptop and
claim points during re-check.

(b) What are constructor references in Java? Discuss how constructor references to [5]
generic classes can be defined and used with the help of an example code-snippet.

********

(Don’t let fear get the better of you. All the best!)

CSIS 31.10.2022 Page 18 of 18