The first problem describes a scenario where there are three students and one

teacher, and the students need three items (pen, paper, and question paper) to
complete their assignments. The teacher has an infinite supply of all three items.
The teacher places two of the items on a shared table, and the student with the
third item completes their assignment and informs the teacher. This cycle
continues.

To synchronize the teacher and students, a solution is needed that allows each
student to acquire the necessary items for their assignment without interference
from other students. One possible solution is to use semaphores to control access
to the items. For example, the teacher can initialize three semaphores, one for
each item, with a value of 1 to indicate that the item is available.

Each student process can use a wait() operation on their required item's semaphore
to acquire the item. Once the student has acquired their item, they can use a
signal() operation to release the semaphore. The teacher process can use a wait()
operation on any two of the semaphores to place those items on the table. Once a
student completes their assignment, they can inform the teacher by sending a
message or signal.

The second problem describes a scenario where there are two types of people in a
library - students and teachers. They both search for books and get them issued by
going to a single CPU that processes book issuing. Two queues are there, one for
students and one for teachers. If a student is being serviced and a teacher arrives
at the counter, the teacher gets priority service. If two teachers arrive at the
same time, they will stand in their queue to get service.

To ensure that the system works in a non-chaotic manner, a solution is needed that
ensures fairness and priority for teachers while minimizing the waiting time for
students. One possible solution is to use two separate queues, one for teachers and
one for students, and implement a priority-based non-preemptive scheduling
algorithm.

In this algorithm, when a teacher arrives at the counter and a student is being
serviced, the teacher is allowed to join the front of the student queue. However,
if another teacher arrives during this time, they will join the front of the
teacher queue. Once the current student is serviced, the CPU will check if there
are any teachers in the teacher queue. If there are, the CPU will service the
teacher next. If not, it will service the next student.

To minimize the waiting time for students when a teacher is being served, the
system can use a preemptive algorithm that temporarily suspends the teacher's
service when a student arrives at the counter. The student will be allowed to join
the front of the student queue, and once all students are serviced, the teacher's
service will resume. This ensures that students do not have to wait for an extended
period while teachers are being serviced.