Please include all inputs and outputs in details with pictures:

General rules: Create homework, compose specifications or any text by using a common document-creation tool, such as Microsoft^® Word.

Detailed Hints: Refer to the wwweb or lecture notes for this class to design, implement, and debug solid SW solutions. Be concise, complete, and precise.

Abstract: Compute the performance data for the schedulers of three types of Operating Systems. Do not get scared! Only the timing for each scheduler is of interest. You can compute these timing data by hand or by actually implementing a simulator. Either solution is feasible and permitted. The simulator measures key performance data, such as throughput, wait time, and turn-around time. You may also manually compute these numbers without having to run them in a simulation environment.

If you chose to “manually” compute the data, i.e. without implementing a SW simulator, the amount of “generated performance data” is allowed to be way less detailed than what is suggested here.

One OS is a strict batch system with a non-preemptive First Come First Serve (FCFS) scheduler. The second OS uses a non-preemptive, high-priority first (HPF) scheduler, while the third OS uses a preemptive round robin (RR) scheduler with a variable time-quantum with varying context switch overhead. Design meaningful input data, run them through all schedulers, generate output data, and interpret and discuss the results. To start your simulations, use the sample data from this HW assignment. In addition, provide 2 additional, meaningful input scenarios, more complex than the samples given here.

Detail: HomeWork 1 consists of the following parts with equal weight each:

• Compute performance data for the scheduler of a non-preemptive FCFS batch system
• Ditto for a non-preemptive HPF batch system, and
• Ditto for a preemptive RR scheduler; you’ll vary time quantum and overhead.
• Invent meaningful input data; run them through your schedulers to produce output
• Discuss the generated data. Hand in your discussion in typed form

Input: Input to the schedulers is a list of processes, for which you happen to know the execution time in milliseconds. For your program input, each process is represented by a triple of decimal numbers id, time, priority. These multiple processes are scheduled and compete for the CPU resource. Here id is the name of the process; time is the time in milliseconds that process id needs to run to completion, and priority is the priority of process id. A plausible input sample for two processes with process id 1 and process id 4 is:

1          2          3

4          50        6

Depending on the scheduler, priority may be ignored. The meaning of triples is as follows:

1   2 3          process 1 uses 2 milliseconds to run, has priority 3

4 50 6           process 4 uses 50 milliseconds, has priority 6, with 0 being the highest

Use the definitions below to compute for each process Throughput, Wait Time, and Turn-around Time. Compute these for each of the 3 schedulers; also compute the average for all processes.

For the preemptive RR scheduler, vary the time quantum q from 1 to 5 milliseconds (ms). Also, for each q selected, vary the overhead o of a context switch from 0 ms up to q itself. There is no need to vary the o beyond q. When a process scheduled by the RR system has received all time needed to completion, do not add a final o unit in the computation of the total time for that process. Also the first time around, act as if the initial schedule overhead o is 0. Use the sample outputs below as a guide for the detail you should generate for this HW.

Definitions:

Throughput:                    Number of jobs (processes) completed per time unit

Waiting Time:                  The total time a process is in Ready Queue

Average Waiting Time:    Average Waiting Time of n processes is: total waiting time by n

Turn-around Time:          span of time of submission to completion time

Example 1:

Enter triples: process id, time in ms, and priority:

For example:

1 12 0

3 9 1

2 99 9

process 1 needs 12 ms and has priority 0, very high,

process 3 needs 9 ms and has priority 1.

and so on ...

1 2 3

2 1 2

Process list in FCFS order as entered:

1 2 3

2 1 2

End of list.

fcfs wait of p1 = 0

fcfs wait of p2 = 2

average wait for 2 procs = 1

fcfs turn-around time for p1 = 2

fcfs turn-around time for p2 = 3

average turn-around for 2 procs = 2.5

fcfs throughput for 2 procs = 0.666667 proc/ms

<><> end FCFS <><>

Process list in HPF order:

2 1 2

1 2 3

End of list.

hpf wait of p2 = 0

hpf wait of p1 = 1

average wait time for 2 procs = 0.5

hpf turn-around for p2 = 1

hpf turn-around for p1 = 3

average turn-around for 2 procs = 2

hpf throughput for 2 procs = 0.666667 proc/ms

<><> end HPF schedule <><>

Process list for RR in order entered:

1 2 3

2 1 2

End of list.

preemptive RR schedule, quantum = 1 overhead = 0

RR TA time for finished p2 = 2, needed: 1 ms, and: 1 time slices.

RR TA time for finished p1 = 3, needed: 2 ms, and: 2 time slices.

RR Throughput, 2 p, with q: 1, o: 0, is: 0.666667 p/ms, or 666.667 p/us

Average RR TA, 2 p, with q: 1, o: 0, is: 2.5

preemptive RR schedule, quantum = 1 overhead = 1

RR TA time for finished p2 = 3, needed: 1 ms, and: 1 time slices.

RR TA time for finished p1 = 5, needed: 2 ms, and: 2 time slices.

RR Throughput, 2 p, with q: 1, o: 1, is: 0.4 p/ms, or 400 p/us

Average RR TA, 2 p, with q: 1, o: 1, is: 4

preemptive RR schedule, quantum = 2 overhead = 0

RR TA time for finished p1 = 2, needed: 2 ms, and: 1 time slices.

RR TA time for finished p2 = 3, needed: 1 ms, and: 1 time slices.

RR Throughput, 2 p, with q: 2, o: 0, is: 0.666667 p/ms, or 666.667 p/us

Average RR TA, 2 p, with q: 2, o: 0, is: 2.5

preemptive RR schedule, quantum = 2 overhead = 1

RR TA time for finished p1 = 2, needed: 2 ms, and: 1 time slices.

RR TA time for finished p2 = 4, needed: 1 ms, and: 1 time slices.

RR Throughput, 2 p, with q: 2, o: 1, is: 0.5 p/ms, or 500 p/us

Average RR TA, 2 p, with q: 2, o: 1, is: 3

preemptive RR schedule, quantum = 2 overhead = 2

RR TA time for finished p1 = 2, needed: 2 ms, and: 1 time slices.

RR TA time for finished p2 = 5, needed: 1 ms, and: 1 time slices.

RR Throughput, 2 p, with q: 2, o: 2, is: 0.4 p/ms, or 400 p/us

Average RR TA, 2 p, with q: 2, o: 2, is: 3.5

<><> end preemptive RR schedule <><>

Example 2:

Enter triples: process id, time in ms, and priority:

For example:

1 12 0

3 9 1

2 99 9

process 1 needs 12 ms and has priority 0, very high,

process 3 needs 9 ms and has priority 1.

and so on ...

1 10 5

2 8 1

3 12 7

Process list in FCFS order as entered:

1 10 5

2 8 1

3 12 7

End of list.

fcfs wait of p1 = 0

fcfs wait of p2 = 10

fcfs wait of p3 = 18

average wait for 3 procs = 9.33333

fcfs turn-around time for p1 = 10

fcfs turn-around time for p2 = 18

fcfs turn-around time for p3 = 30

average turn-around for 3 procs = 19.3333

fcfs throughput for 3 procs = 0.1 proc/ms

<><> end FCFS <><>

Process list in HPF order:

2 8 1

1 10 5

3 12 7

End of list.

hpf wait of p2 = 0

hpf wait of p1 = 8

hpf wait of p3 = 18

average wait time for 3 procs = 8.66667

hpf turn-around for p2 = 8

hpf turn-around for p1 = 18

hpf turn-around for p3 = 30

average turn-around for 3 procs = 18.6667

hpf throughput for 3 procs = 0.1 proc/ms

<><> end HPF schedule <><>

Process list for RR in order entered:

1 10 5

2 8 1

3 12 7

End of list.

preemptive RR schedule, quantum = 1 overhead = 0

RR TA time for finished p2 = 23, needed: 8 ms, and: 8 time slices.

RR TA time for finished p1 = 27, needed: 10 ms, and: 10 time slices.

RR TA time for finished p3 = 30, needed: 12 ms, and: 12 time slices.

RR Throughput, 3 p, with q: 1, o: 0, is: 0.1 p/ms, or 100 p/us

Average RR TA, 3 p, with q: 1, o: 0, is: 26.6667

preemptive RR schedule, quantum = 1 overhead = 1

RR TA time for finished p2 = 45, needed: 8 ms, and: 8 time slices.

RR TA time for finished p1 = 53, needed: 10 ms, and: 10 time slices.

RR TA time for finished p3 = 59, needed: 12 ms, and: 12 time slices.

RR Throughput, 3 p, with q: 1, o: 1, is: 0.0508475 p/ms, or 50.8475 p/us

Average RR TA, 3 p, with q: 1, o: 1, is: 52.3333

preemptive RR schedule, quantum = 2 overhead = 0

RR TA time for finished p2 = 22, needed: 8 ms, and: 4 time slices.

RR TA time for finished p1 = 26, needed: 10 ms, and: 5 time slices.

RR TA time for finished p3 = 30, needed: 12 ms, and: 6 time slices.

RR Throughput, 3 p, with q: 2, o: 0, is: 0.1 p/ms, or 100 p/us

Average RR TA, 3 p, with q: 2, o: 0, is: 26

preemptive RR schedule, quantum = 2 overhead = 1

RR TA time for finished p2 = 32, needed: 8 ms, and: 4 time slices.

RR TA time for finished p1 = 38, needed: 10 ms, and: 5 time slices.

RR TA time for finished p3 = 44, needed: 12 ms, and: 6 time slices.

RR Throughput, 3 p, with q: 2, o: 1, is: 0.0681818 p/ms, or 68.1818 p/us

Average RR TA, 3 p, with q: 2, o: 1, is: 38

preemptive RR schedule, quantum = 2 overhead = 2

RR TA time for finished p2 = 42, needed: 8 ms, and: 4 time slices.

RR TA time for finished p1 = 50, needed: 10 ms, and: 5 time slices.

RR TA time for finished p3 = 58, needed: 12 ms, and: 6 time slices.

RR Throughput, 3 p, with q: 2, o: 2, is: 0.0517241 p/ms, or 51.7241 p/us

Average RR TA, 3 p, with q: 2, o: 2, is: 50

preemptive RR schedule, quantum = 3 overhead = 0

RR TA time for finished p2 = 23, needed: 8 ms, and: 3 time slices.

RR TA time for finished p1 = 27, needed: 10 ms, and: 4 time slices.

RR TA time for finished p3 = 30, needed: 12 ms, and: 4 time slices.

RR Throughput, 3 p, with q: 3, o: 0, is: 0.1 p/ms, or 100 p/us

Average RR TA, 3 p, with q: 3, o: 0, is: 26.6667

preemptive RR schedule, quantum = 3 overhead = 1

RR TA time for finished p2 = 30, needed: 8 ms, and: 3 time slices.

RR TA time for finished p1 = 36, needed: 10 ms, and: 4 time slices.

RR TA time for finished p3 = 40, needed: 12 ms, and: 4 time slices.

RR Throughput, 3 p, with q: 3, o: 1, is: 0.075 p/ms, or 75 p/us

Average RR TA, 3 p, with q: 3, o: 1, is: 35.3333

preemptive RR schedule, quantum = 4 overhead = 0

RR TA time for finished p2 = 20, needed: 8 ms, and: 2 time slices.

RR TA time for finished p1 = 26, needed: 10 ms, and: 3 time slices.

RR TA time for finished p3 = 30, needed: 12 ms, and: 3 time slices.

RR Throughput, 3 p, with q: 4, o: 0, is: 0.1 p/ms, or 100 p/us

Average RR TA, 3 p, with q: 4, o: 0, is: 25.3333

preemptive RR schedule, quantum = 5 overhead = 0

RR TA time for finished p1 = 20, needed: 10 ms, and: 2 time slices.

RR TA time for finished p2 = 23, needed: 8 ms, and: 2 time slices.

RR TA time for finished p3 = 30, needed: 12 ms, and: 3 time slices.

RR Throughput, 3 p, with q: 5, o: 0, is: 0.1 p/ms, or 100 p/us

Average RR TA, 3 p, with q: 5, o: 0, is: 24.3333

some outputs I have to cut because Chegg say the question is long

{
/* Write a program in C++ to find the perfect numbers between 1 and 500.
The perfect numbers between 1 to 500 are:
6
28
496*/
   int sum = 0;
   int i = 1;
   int j = 1;
   for (i ; i <= 100; i++)
   {
       for (j; j <= 100; j++)
       {
           if (j < i)//Line 55
           {
              
           if (i % j == 0)
               sum = sum + j;
           }
          
       }

       if (sum == i)
      
           cout << i << " ";
       j = 1;//line 66
       sum = 0;
      
   }
  
   return 0;
}

Can someone please explain the code above and how it works. what is the purpose of the comparison on line 55 and I on line 66?

1. Based upon the pseudocode given in “Background”, solve the three versions of add up to K problems: ◦ all pairs of numbers that add up to K ◦ all triples (set of three) that add up to K ◦ all possible subsets of numbers that add up to K: recursive version is given, you are asked to solve it iteratively. 2. Test the three functions using given test cases. 3. Measure the running time of algorithms under various input sizes.

#include <iostream>
#include <bitset>
#include <vector>
#include <time.h>
using namespace std;

const double BILLION = 1E9;

 /* Print ALL pairs of number from the given array a[0...a_len-1] that adds up to K 
    @param intList: the list of int values 
    @param K: the sum we want to make
   */
void PairsAddupToK (int a[], int a_len,  int K)
{
 //TODO by you
}
   
/* Print ALL triples of numbers from the given array a[0...a_len-1] that adds up to K 
@param intList: the list of int values 
@param K: the sum we want to make
*/
void TriplesAddupToK (int a[], int a_len, int K)
{
        //todo by you
}
   
/* Print ALL subsets of numbers from the given array, a[0...a_len-1 that adds up to K 
this function solves the problem iteratively 
NOTE: WE assume a_len<32 (so that we can use int (which uses 32 or 64 bits) 
  as code to decide subset  
@param intList: the list of int values 
@param K: the sum we want to make
*/
void SubsetsAddupToK (int a[], int a_len, int K)
{
        //todo by you
}

            
        
//Recursive solution to SubsetAddupToK 
/* This functions tries to use numbers from a[left...right] to make sum 
 @param a[] array of int
 @n: a[left...right] is the list of numbers to use
 @currentSum: current sum we have made using numbers in numsUsed
 @finalSum: final sum that we need to make
 @numsUsed: numbers that are used to get us here */
bool SubsetsAddupToK (int  a[], int left, int right, int currentSum, int finalSum, vector<int> numsUsed)
{
        //Three base cases: 
        //case 1: what remains to make is negative: we have overshot... 
        if (currentSum>finalSum)
                return false; 

        //case 2: we made it! 
        // Result is only displayed at the base case. 
        if (currentSum==finalSum)
        {
                cout <<"Solution:";
                for (int i=0;i<numsUsed.size();i++)
                        cout <<numsUsed[i]<<",";
                cout <<endl;
                return true;
        }

        //case 3: we don't have any number to use: fails. 
        if (left>right && currentSum < finalSum)
                return false;


        //General calse: what remains to make is positive, and we have numbers to use 
        bool res1=false, res2=false;

        // Explore both possibilities: Use a[left] or not 
        //  1) include a[left] in the sum, i.e., make sum-a[left] using a[left+1...right]  
        vector<int> newNums = numsUsed;
        newNums.push_back (a[left]); //now a[left] is used ... 

        res1 = SubsetsAddupToK(a, left+1, right, currentSum+a[left], finalSum,newNums);
            // here the currentSum is increased by a[left], a[left] is added into list of 
            // numbers used... 

        //  2) do not include a[left] in the sum, i.e., make sum using a[left+1...right]  
        //     currentSum, finalSum, numsUsed is not changed 
        res2 = SubsetsAddupToK (a, left+1, right, currentSum, finalSum, numsUsed);
                                    //^+1 so that a[left] is not considered any more

        //if either of the above two succeeded, return true 
        if (res1 || res2)
                return true;
        else
                return false;
}


/* Compare the running time of three functions for input size n 
 @param n: the length of vecotr/list
 */ 
void  MeasureRunningTime (int a[], int a_len)
{
        struct timespec start, finish;
        double r1, r2, r3, r4;


           clock_gettime (CLOCK_REALTIME, &start);
           PairsAddupToK (a, a_len, 100);
           clock_gettime (CLOCK_REALTIME, &finish);
           r1 = (finish.tv_sec - start.tv_sec)+
                        (finish.tv_nsec-start.tv_nsec)/BILLION;


           clock_gettime (CLOCK_REALTIME, &start);
           TriplesAddupToK (a, a_len, 100);
           clock_gettime (CLOCK_REALTIME, &finish);
           r2 = (finish.tv_sec - start.tv_sec)+
                        (finish.tv_nsec-start.tv_nsec)/BILLION;

           clock_gettime (CLOCK_REALTIME, &start);
           SubsetsAddupToK (a, a_len, 100); 
           clock_gettime (CLOCK_REALTIME, &finish);
           r3 = (finish.tv_sec - start.tv_sec)+
                        (finish.tv_nsec-start.tv_nsec)/BILLION;

           clock_gettime (CLOCK_REALTIME, &start);
           vector<int> results;
           SubsetsAddupToK (a, 0, a_len, 0, 100, results); 
                                        //^ current sum=0, final sum=100
           clock_gettime (CLOCK_REALTIME, &finish);
           r4 = (finish.tv_sec - start.tv_sec)+
                        (finish.tv_nsec-start.tv_nsec)/BILLION;

           cout <<"n="<<a_len<<"\t";
           cout <<"Pairs"<<"\t"<< r1<<"s\t";
           cout <<"Triples"<<"\t"<< r2<<"s\t";
           cout <<"Subsets"<<"\t"<< r3<<"s\t";
           cout <<"SubsetsR"<<"\t"<< r4 <<"s\t"<<endl;
}

int main()
{
        vector<int> numsUsed; //this is empty initially 

        int a5[5] = {50,90,20,30,10};
        int a10[10] = {50, 33, 90, 2, 20, 
                72, 30,10, 92, 8};
        int a20[20] = {50, 33, 11, 79, 90,
                2, 20, 72, 30,10, 
                92, 8, 99, 101, 25,
                71, 48, 72, 35, 9};
        int a30[30] = {50, 33, 11, 79, 90, 
                2, 20, 72, 30,10, 
                92, 8, 99, 101, 25, 
                71, 48, 72, 35, 9,
                37, 41, 55, 73, 67,
                66, 22, 11, 6, 4};

        //Testing 
        //Display all different ways to make 100 using a5[0...4]
        int SumToMake = 100;
        int curSum=0; 
        SubsetsAddupToK (a5, 0, 4, curSum, SumToMake, numsUsed);

        /* Measuring and comparing running time  
        MeasureRunningTime (a5, 5);
        MeasureRunningTime (a10, 10);
        MeasureRunningTime (a20, 20); */
        MeasureRunningTime (a30, 30);
}

Write a recursive function, max_in_list(my_list), which takes an non-empty list, my_list, of integers as a parameter. This function calculates and returns the largest value in the list. The base case will probably deal with the scenario where the list has just one value. The recursive case will probably call the function recursively using the original list, but with one item removed.

Note: This function has to be recursive; you are not allowed to use loops to solve this problem!

lst = [1, 4, 5, 9]
print(max_in_list(lst))

9

And

Write a recursive function, max_even_list(my_list), which takes a list, my_list, of integers as a parameter. This function calculates and returns the largest even number in the list. 0 is returned if there is no even number in the list.

Note: This function has to be recursive; you are not allowed to use loops to solve this problem!

lst = [1, 4, 5, 9]
print(max_even_list(lst))

4

Compute the 10,000th element of the pseudorandom sequence generated by the Middle-Square algorithm with seed=1003.

public class Lab1 {

public static void main(String[] args) {

int array [] = {10, 20, 31, 40, 55, 60, 65525};

System.out.println(findPattern(array));

}

private static int findPattern(int[] arr) {

for (int i = 0; i < arr.length - 2; i++) {

int sum = 0;

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

sum += Math.abs(arr[j] - arr[j + 1]);

}

if (sum == 20)

return i;

}

return -1;

}

}

QUESTION: Modify the given code such that the input array may wrap-around or over- flow.

Given the input array: data[] = {65515,65525,9,20,31,40,55} The function shall return: 0

Assignment for Health Information Technology

Search the web for an article related to a facility using patient generated health data(PGHD). Using a minimum of 125 words, tell me the type of healthcare setting, the type of of PGHD used, and if the facility found it beneficial/successful.

Provide the URL link to your article.
Use .org websites only (Ex. AHIMA.org, nln.nih.gov...etc)

write a recursive algorithm to find the maximum element in an array of n elements and analyze its time efficiency.

(I am using c++ programming language)

3. Be creative, but realistic: Describe an example (of your own creation) of a system that would be susceptible to a race condition, and what might happen to cause the race condition in your imagined system. Then explain what might be the effect of that race condition in your particular system. The goal in this last part is to imagine a real-world system and to describe it in a way that the marker can understand as well as showing how it could be affected by a race condition.

True or False

1.An association is a description of a group of links with common behaviors and semantics.

2.An association is a logical construct, of which a reference is a generalization alternative.

3.Multiplicity specifies the number of instances of one object.

4.An association class is an association that is also a class.

5.An association class may have attributes, operation and participant in associations.

6.A qualified association is an association in which the objects in a “many” generalization are partially disambiguated by a qualifier.

7.Generalization is an important construct for both conceptual modeling and implementation.

8.To build complex systems, the developer must abstract different views of the system, build models using precise notations.

9.When analysts construct a model of the application, the detail implementation information will need to be considered.

10.The model has two dimensions – a view of a system and a stage of development.   

You have a 1 ft radius dartboard placed in the middle of a 2 ft x 2 ft square backboard. You can estimate the value of Pi by randomly throwing darts at the board, because the ratio of the darts hitting the dartboard compared to those hitting the backboard (i.e. all of them), will be equal to the ratio of the area of the dartboard to the area of the board. Or:

D_h / D_t = A_db / A_b

where:

D_h = number of darts that hit the dartboard
D_t = total number of darts thrown
A_db = Area of the dartboard
A_b = Area of the board

We can calculate A_db and A_b from the problem statement. You should be able to rearrange the resulting equation to solve for Pi, given the sizes of the dartboard and board, and the number of darts thrown and number that hit the dartboard.

Write a VBA program that will randomly generate a location (x and y) the dart will hit, determine if it hit the dartboard (hint: make the center of the dartboard x=0, y=0), and then estimate the value of Pi after each thrown dart). Stop once your estimated value is within 0.01 of the actual value of Pi (you can use 3.1416 as the actual value and the ABS() function may be useful here). Output the estimated value and the total number of darts thrown on the 1st worksheet (labeled "Darts")

Recommended: Output the number of darts thrown, number of darts that have hit, and the estimated value of Pi on a new row on your worksheet after each dart is thrown. Also, limit the total number of darts thrown, and exit with a message if you reach the limit.

Day of week

Write a program that asks the user for a date (year, then month, then day, each entered as a number on a separate line), then calculates the day of the week that date falls on (according to the Gregorian calendar) and displays the day name.

You may not use any date functions built into Python or its standard library, or any other functions that do this work for you.

Hint: Reverend Zeller may be useful, but his years start in a weird spot.

Give credit to your sources by including an exact, working URL in a comment at the top of your program.

LAB

C Programming question:

Develop a program named “sample” that prints the value of two functions:
1. Function f1 takes a single input argument of type int and returns the value of its input argument as float
2. Function f2 takes a single input argument of type char and returns an int. The output of f2 is the result of the sum of the values of the global variables, and the input
argument minus the value of char ‘a’ plus the value of char ‘A’

Structural Requirements:
1. Your executable must be named sample (your makefile must ensure this)
2. Your program should not take any arguments
3. Your solution must have at least two C source files (e.g., a main and file1.c), two header files (e.g., globals.h, and externs.h), and a makefile
4. Your program should define two global variables (e.g., p and q), both of type int, one with value 11 and the second with a value of 32
5. Your main should have two local variables: int i = 5; char c = ‘x’
6. Main should invoke f1 with the sum of i, p, and q as input, and pass the value of c to f2

#include <stdio.h>
#include <stdlib.h> // required for atoi
int main(void) {
    int i=0,n,num,filenum[100],pos;
    int c;
   char line[100]; //declaring string for storing data in the line of text
   FILE *fp; // declaring a FILE pointer
   fp=fopen("numbers.txt","r"); // open a text file for reading
   while(fgets(line, sizeof line, fp)!=NULL) {       // looping until end of the file
        filenum[i]=atoi(line); //converting data in the line to integer and storing it into array
       i++;
   }
   n=i;
   fclose(fp); //closing file
   printf("Enter a number: ");
   scanf("%d",&num);
   while(num!=EOF) //looping until user enters end of the file
   {
       pos=0;
       for(i=0;i<n;i++)
       {
           if(num==filenum[i])   //if num is equal to filenum[i]
           {
               pos=i+1;
           }
       }
       if(pos>0)
           printf("%d last appears in the file at position %d\n",num,pos);
       else
           printf("%d does not appear in the file\n",num);
       printf("Enter a number: ");
       scanf("%d",&num);  
              
   }
    return 0;
}

=====================================================

（does anyone can help me to change this program in C++ and add some comments)

numbers.txt:
10
23
43
5
12
23
9
8
10
1
16
9

you must to have all of following output:

Enter a number: 10
10 last appears in the file at position 9
Enter a number: 29
29 does not appear in the file
Enter a number: 9
9 last appears in the file at position 12
Enter a number:

Search the web to discover the 10 most common user-selected passwords, and store them in an array. Design a JAVA program that prompts a user for a password, and continue to prompt the user until the user has not chosen one of the common passwords.