Answer:
8192
Explanation:
The question is pretty general. However, I will try to explain it in my way.
An IP address consists of 32 bit. It is always divided in two portion, net id and host id. Net id is a kind of identification while host id bits includes the possible number of host in the network of specific id.
My assumption is that you are using the classless CIDR.
In that case the first 19 bits would be the net id or identification of the network. Therefore, the net id would be 11111111.11111111.11100000.00000000
Or 255.255.224.00
Now, if we want to add a subnet in this IP, we can utilize the remaining bits from the host id. We are left with 13 bits in host id so the number of subnets will be depending on how many bits we will be using in host id with
.
In this equation, x represents the number of bits used to create the subnets.
So, maximum number of subnets would be 
so a description of a mask tool that is used like painters tape to section off a spot so you do not chage that area
hope this helps
-scav
Answer:
First one would be work ethic.
Second one would be communication.
Third one would be adaptability.
Fourth one would be creativity.
(These are all guesses tho, so i'm not 100% sure !!)
Explanation:
Answer:
int sumid=0; /* Shared var that contains the sum of the process ids currently accessing the file */
int waiting=0; /* Number of process waiting on the semaphore OkToAccess */
semaphore mutex=1; /* Our good old Semaphore variable ;) */
semaphore OKToAccess=0; /* The synchronization semaphore */
get_access(int id)
{
sem_wait(mutex);
while(sumid+id > n) {
waiting++;
sem_signal(mutex);
sem_wait(OKToAccess);
sem_wait(mutex);
}
sumid += id;
sem_signal(mutex);
}
release_access(int id)
{
int i;
sem_wait(mutex);
sumid -= id;
for (i=0; i < waiting;++i) {
sem_signal(OKToAccess);
}
waiting = 0;
sem_signal(mutex);
}
main()
{
get_access(id);
do_stuff();
release_access(id);
}
Some points to note about the solution:
release_access wakes up all waiting processes. It is NOT ok to wake up the first waiting process in this problem --- that process may have too large a value of id. Also, more than one process may be eligible to go in (if those processes have small ids) when one process releases access.
woken up processes try to see if they can get in. If not, they go back to sleep.
waiting is set to 0 in release_access after the for loop. That avoids unnecessary signals from subsequent release_accesses. Those signals would not make the solution wrong, just less efficient as processes will be woken up unnecessarily.
Answer:
A lot is wrong with the program given in the question. See the corrected version below:
<em>public class ANot {</em>
<em> public static void main(String[] args) {</em>
<em> int a, b, c;</em>
<em> //Three integers</em>
<em> a = 3; b = 4; c = a + b;</em>
<em> System.out.println("The value of c is " + c);</em>
<em> }</em>
<em>}</em>
Explanation:
Errors:
1. The main method had a semi colon after it. This is wrong
2. An open brace was supposed to follow the main method
3. The declaration of the variables was supposed to end with a semi colon
4. the correct comment style is // and not \\
5. Initialization of variables was supposed to end with semi colons
6. The output statement had C and not c which is the declared and initialized variable..Java is strictly typed
7. Open and closing braces for the class and method wrongly placed
