Partitioning allocate one contiguous piece of memory to each process.
Consequently, as processes start, it execute, and exit, the free space of memory can be broken into many useless little little chunks; this is called “external fragmentation.” The operating system allocates each process approximately the amount of space actually used by the process, there is little waste within each partition (“internal fragmentation”).
Hence option I is correct .
Paging views physical memory as a long series of small equally-sized pieces ( call page ) , and the operating system allocates pieces of physical memory to each processes on an as an when needed basis.
An extra level of indirection is required so that the memory space seen by the process appears contiguous, even if it actually resides in non-contiguous pieces of physical memory. Thus, any free piece of physical memory can be assigned when a request occurs, so there is no external fragmentation. On the other hand, processes can never receive less than a page of memory, so
there can be non-negligible internal fragmentation. Which makes option III correct.
In case of Segmentation , Each object of a program corresponds to a specific piece of contiguous memory.
For example, the stack might be in one piece of memory , while an array might be in another, and the text/code for a function might reside in another piece of memory location.
For the most part, this keeps the chunks allocated to a fairly small size, so there is usually a use for every chunk of free memory; this helps to reduce external fragmentation. Also, the objects generally fill most or all of their respective memory chunks, which helps to moderate internal fragmentation. But the compiler (or programmer) must have to keep track of the relationship between objects and segments. This makes option II correct.