UGC NET Paper 2: Computer Science 8th Oct 2022 (Previous Year Paper)

Concept:

Using a transaction log, or journal, journaling improves the filesystem's dependability and enables rapid crash recovery. The journal is an on-disk log of metadata, or data about the filesystem, which is kept current as the filesystem is modified. Without journaling, filesystems save changes to updates in memory.

Explanation:

A journal means a record that is kept over time, like a diary. Instead of changing the structure of the file system, adding new directories, or making files bigger, the first thing the file system does is collect these changes into a series of transactions and add them to a log file. Then, these transactions can be sent to the actual file system by processes that run in the background. If there is a crash, the file system can recover immediately and start committing transactions already in the journal. However, the last entry will probably be corrupt and will be dropped. All of these things mean that the file system won't change. This kind of file system, like ZFS, will help protect both data and metadata, and it won't need programs like fsck that try to fix broken files.

Hence, File saving as transaction is called Journaling in Linux operating system.

Concept:

Transformation refers to the mathematical operations or rules that are applied to a graphical image consisting of the number of lines, circles, and ellipses to change its size, shape, or orientation. It can also reposition the image on the screen. Transformations play a very crucial role in computer graphics.

Types of Transformations:

There are various types of transformations in computer graphics through which an image can be processed, edited ad altered. Some basic and most commonly used types of these transformations are

• Translation
• Rotation
• Scaling
• Reflection
• Shearing

A transformation that slants the shape of an object is called the Shear Transformation. There are two shear transformations X-Shear and Y-Shear. One shifts the X coordinate values and the other shifts the Y coordinate values. However, in both cases, only one coordinate changes its coordinates and the other preserves its values. Shearing is also termed Skewing.

In a three-dimensional plane, the object size can be changed along the X direction, Y direction as well as Z direction.So, there are three versions of shearing.

They are

1)Shearing in x-axis

2. shearing in y-axis

3. shearing in z-axis

$\left[\begin{array}{l}\rm\bar{x} \\rm \bar{y} \ \rm\bar{z} \\rm\bar{w}\end{array}\right]=\left[\begin{array}{llll}\rm a_1 & \rm b_1 & \rm c_1 & \rm d_1 \ \rm a_2 & \rm b_2 & \rm c_2 & \rm d_2 \ \rm a_3 & \rm b_3 & \rm c_3 & \rm d_3 \ \rm e & \rm f & \rm g & \rm h \end{array}\right]\left[\begin{array}{c} \rm x \ \rm y \ \rm z \ 1 \end{array}\right]$ is called Shear Transformation.

The Correct Answer is option 2.

Correct answer: P ∨ Q

• In boolean logic, the negation of a variable P is denoted as P̅, and the logical operators "and" (∧) and "or" (∨) have specific meanings. The "and" operator is true only when both operands are true, and the "or" operator is true when at least one of the operands is true.
• The expression (P̅ ∧ Q) ∨ (P ∧ Q̅) ∨ (P ∧ Q) can be thought of as a series of conditions separated by the "or" operator. The first condition (P̅ ∧ Q) states that P is false and Q is true. The second condition (P ∧ Q̅) states that P is true and Q is false. The third condition (P ∧ Q) states that both P and Q are true.
• Since the "or" operator is true when at least one of its operands is true, the entire expression is true whenever any one of these conditions is true. That is, the expression is true when either P is false and Q is true, or when P is true and Q is false, or when both P and Q are true.
• On the other hand, the equivalent expression P ∨ Q states that either P is true or Q is true, or both.
• This is exactly the same as the original expression, since whenever either P is false and Q is true, or when P is true and Q is false, or when both P and Q are true, either P is true or Q is true (or both).
• we can use the truth table method. A truth table lists all possible combinations of truth values (true or false) for the variables in the expression and the resulting value of the expression

Here's the truth table for the original expression:

P  Q  P̅     (P̅ ∧ Q)        Q̅              (P ∧ Q̅)        (P ∧ Q)              (P̅ ∧ Q) ∨ (P ∧ Q̅)                   (P̅ ∧ Q) ∨ (P ∧ Q̅) ∨ (P ∧ Q)

-----------------------------------------------------------------------------------------------------------------------------------------------------------

T  T    F         F               F                  F               T                                     F                                                 T

T  F    F         F               T                  T               T                                     T                                                 T

F  T    T         T               F                  F               F                                     T                                                 T

F  F    T         F               T                  F               F                                     F                                                 F

P  Q  (P̅ ∧ Q) ∨ (P ∧ Q̅) ∨ (P ∧ Q)

--------------------------------------

T  T    T

T  F    T

F  T    T

F  F    F

And here's the truth table for the equivalent expression P ∨ Q:

P  Q  P ∨ Q

--------------

T  T    T

T  F    T

F  T    T

F  F    F

As we can see, the two tables are identical, which means that the two expressions are equivalent.

Correct answer: (A) and (C) only

(A) (α ∧ (β ∨ γ)) ≡ ((α ∧ β) ∨ (α ∧ γ))

This logical equivalence says that the expression (α ∧ (β ∨ γ)) is logically equivalent to the expression ((α ∧ β) ∨ (α ∧ γ)). This can be thought of as the associative law of conjunction, which states that the order of the variables in conjunction does not affect the truth value of the conjunction. In other words, grouping the variables in a different way does not change the truth value of the expression.

(B) (α ∨ β) ≡ −α ∨ β

This logical equivalence says that the expression (α ∨ β) is logically equivalent to the expression −α ∨ β. However, this is not a correct equivalence because the negation of a logical variable (in this case α) is not equivalent to the logical variable itself. For example, if α is true, then −α is false, and therefore the two expressions have different truth values.

(C) (α ⇒ β) ≡ (¬β ⇒ ¬α)

This logical equivalence says that the expression (α ⇒ β) is logically equivalent to the expression (¬β ⇒ ¬α). This can be thought of as the contrapositive law, which states that the contrapositive of a logical implication is logically equivalent to the original implication. In other words, if we change the antecedent and consequent of a logical implication and negate both, the resulting expression is logically equivalent to the original implication.

(D) (¬(α ∨ β)) ≡ (¬α ⇒ ¬β)

This logical equivalence says that the expression (¬(α ∨ β)) is logically equivalent to the expression (¬α ⇒ ¬β). However, this is not a correct equivalence because the negation of a disjunction (α ∨ β) is not equivalent to a material implication (¬α ⇒ ¬β). For example, if α is true and β is false, then the expression (α ∨ β) is true and its negation (¬(α ∨ β)) is false. On the other hand, the expression (¬α ⇒ ¬β) is false because ¬α is false and ¬β is true, and therefore the two expressions have different truth values

Solution:

Statement I: True

Conservative Two-Phase Locking (2PL) protocol requests all required locks at once, and proceeds only if all are granted. This avoids circular wait, thereby ensuring a deadlock-free execution.

Statement II: False

Thomas's write rule is used to ignore obsolete writes in timestamp-based concurrency control. While it improves concurrency, it does not enforce conflict serializability. It can allow schedules that are not conflict-serializable.

Statement III: True

Timestamp ordering protocol ensures conflict serializability by ordering all operations based on their assigned timestamps. Transactions are executed in a way that maintains the logical timestamp order.

Final Answer:

Option 2: Statement I and III are true, Statement II is false.

The correct answer: (A) and (B) only true.

• A relation is said to be reflexive if every element in the set is related to itself. In this case, for any element x in R2, |x - x| = 0, which is less than ∈, meaning that (x, x) is in the relation Re. So Re is reflexive.
• A relation is said to be symmetric if, for any ordered pair (x, y) in the relation, the ordered pair (y, x) is also in the relation. In this case, if (x, y) is in Re, meaning |x - y| < ∈, then |y - x| = |x - y| < ∈, meaning (y, x) is also in Re. So Re is symmetric.
• However, Re is not transitive. Consider the following counterexample: let x = 0, y = 0.0004, and z = 0.0009. Then |x - y| = |0 - 0.0004| = 0.0004 < ∈, |y - z| = |0.0004 - 0.0009| = 0.0005 < ∈, but |x - z| = |0 - 0.0009| = 0.0009 ≠ |x - y| + |y - z|, meaning (x, z) is not in Re.
• Therefore, Re is reflexive and symmetric but not transitive.

CFL's are closed under union, concatenation, and Kleene closure. Also, under reversal, homomorphisms and inverse homomorphisms.

But Context-free languages are not closed under:

• Intersection − If L₁ and L₂ are context free languages, then L₁ ∩ L₂ is not necessarily context free.
• Complement − If L₁ is a context free language, then L₁' may not be context free.

Hence only Statement I is True.

Correct answer is Option 3

Explanation:

The BR (branch) field includes 2 bits. It can be used by connecting with the AD (address) field.

The reason for connecting with the AD field is to select the address for the next microinstruction.

The table illustrates the various branch fields and their functions.

Branch Field Symbols and Descriptions

Any combination of strings in set {ab, aa, baa} will be in L*. 

Consider each option one by one:

Option 1) baaaaabaaaab

It cannot be partitioned as a combination of strings in set {ab, aa, baa}. 

Option 2) abaabaaabaa

It can be partitioned as a combination of strings in set {ab, aa, baa}. The partitions are “ab aa baa ab aa”.

Option 3) aaaabaaaa

It can be partitioned as a combination of strings in set {ab, aa, baa}. The partitions are “aa ab aa aa”. 

<br>

Option 4) baaaaabaa

It can be partitioned as a combination of strings in set {ab, aa, baa}. The partitions are “baa aa ab aa”. 

Hence only baaaaabaaaab is NOT in L*.

Correct answer: namespace

• A namespace in XML provides a way to associate an element name with a specific namespace, which is identified by a URI (Uniform Resource Identifier).
• This allows organizations to specify globally unique names as element tags in documents, as each element name can be associated with a different namespace.
• The namespace declaration is usually done in the root element of an XML document, and the URI can be any string that identifies the namespace, such as a URL.
• For example, the following XML document declares a namespace with the prefix "book" and associates it with the URI "http://book.example.com":

           <book:library xmlns:book="http://book.example.com">

              book:book

              book:titleThe Great Gatsby</book:title>

               book:authorF. Scott Fitzgerald</book:author>

               </book:book>

            </book:library>

• the namespace "http://book.example.com", so all elements with the "book" prefix in the document belong to this namespace.

The language accepted by the NPDA is L = {a²ⁿbⁿ ∶ n ≥ 0}.

Explanation:

• The NPDA starts in the initial state q0 with the stack symbol z. When it reads the first symbol a, it pushes two 1's on the stack (δ(q0, a, z) = {(q1, 11z)}). Then, every time it reads another a, it pushes another 1 on the stack (δ(q1, a, 1) = {(q1, 111)}). This way, the stack stores the number of a's that have been read so far.
• When the NPDA reads a b, it pops one 1 from the stack (δ(q1, b, 1) = {(q1, λ)}). When the stack becomes empty (i.e., when all the a's have been paired with b's), the NPDA transitions to the final state qf (δ(q1, λ, z) = {(qf, z)}).
• Therefore, the NPDA accepts the language L = {a²ⁿbⁿ ∶ n ≥ 0}, which consists of strings of a's followed by an equal number of b's. The other options are not accepted by the NPDA.

The correct answer is 4) (A), (C) and (D) only.

Explanation:

The depth-first search (DFS) algorithm visits all the vertices of a graph by exploring as far as possible along each branch before backtracking.

In a graph with multiple connected components, the DFS will be performed for each component separately.

In the given graph, the DFS order can be different depending on the starting vertex and the order in which the edges are traversed.

(A) abcghf is a valid DFS order, starting at vertex "a".

(C) abfhgc is also a valid DFS order, starting at vertex "a".

(D) afghbc is a valid DFS order, starting at vertex "a".

However, (B) abfchg is not a valid DFS order, as the edge from "g" to "f" is not visited.

Therefore, the correct answer is (A), (C) and (D) only.

The correct answer is option 2.

Important Points

Certainty Factor (CF) is a numeric value that tells us how likely an event or a statement is supposed to be true.

This value is similar to probability, but with only probability value of any event agent cannot decide what to do. This certainty factor is decided through which the agent can decide whether to declare the statement true or false based on the probability and other knowledge that the agent has.

Dynamic Certainty for a Conclusion :

CF(C) = CF(H) x CF(R) , C is the conclusion

CF(H) = calculated Certainty Factor for Hypothesis.

R = given rule , "if H then C with certainty CF(R)"

Conjunction and Disjunction of Hypotheses:

CF (P1 and P2) = MIN { CF(P1) , CF(P2) }

CF (P1 or P2) = MAX { CF(P1) , CF(P2) }

Here, P1 , P2 are premises.

Given Rule is (P1 and P2) or P3

R1 and R2 are conclusions of rules.

CF(R1)= 0.8 

CF(R2)=0.3

CF(P1)=0.5  , CF(P2)=0.8 , CF(P3)=0.2

Where P1,P2,P3 are premises.

Now the CF of given rule ((P1 and P2) or P3)=   MAX  { MIN{CF(P1),CF(P2)} , CF(P3) } 

= MAX { MIN { 0.5,0.8} ,0.2}

=MAX { 0.5 , 0.2 }

= 0.5

Now, CF of R1 based on premises = 0.5 × CF(R1) =0.5 × 0.8 =0.40

Now, CF of R2 based on premises = 0.5 ×  CF(R2) =0.5 × 0.3 =0.15

The correct answer: Acceptance Testing

Alpha and Beta testing are forms of:

Acceptance Testing

Important Points

Alpha Testing is usually done by internal staff before the product is released to external testers. It is a type of acceptance testing that's done in a lab environment and not by the end users. It helps identify all possible issues and problems in the system before it goes for Beta testing. 

Beta Testing is performed by actual users or potential customers in their own environment. It is the second phase of testing in which a sampling of the intended audience tries the product out before it is officially released to the general public. This is the final test before shipping the product. Problems that were not discovered during Alpha testing may be identified here.

These types of tests are done to make sure that the system is working as expected and will be accepted by the end users. They are types of User Acceptance Testing (UAT) and are very important in software development processes.

Correct Answer: unicast address

• In computer networking, there are three types of addresses used to identify devices: unicast, multicast, and broadcast. Each type of address has a specific purpose and is used for different types of communication.
• A unicast address is a unique address assigned to a single device on a network. When a device wants to send a packet of data to another device, it uses the unicast address of the target device as the destination address. The packet is then sent over the network and is only delivered to the device with the matching unicast address.
• A multicast address is used to send a single data frame to multiple devices simultaneously. This is useful when a device wants to send a message to a group of devices, such as a video stream to a group of viewers. In this case, the sender uses a multicast address as the destination address, and the message is delivered to all devices that have joined the multicast group.
• A broadcast address is used to send a data frame to all devices on a network. This is useful for communication that should be received by every device on the network, such as a request for all devices to respond with their IP addresses. In a broadcast transmission, the destination address is set to the broadcast address of the network, and all devices on the network receive the message.
• In IPv6, the first 3 bits of an address determine the type of address. If the first 3 bits are 001, the address is a unicast address. If the first 3 bits are 111, the address is a multicast address. Broadcast addresses do not exist in IPv6.

So, to summarize, the destination address 4A ∶ 30 ∶ 10 ∶ 21 ∶ 10 ∶ 1A is a unicast address because its first 3 bits are 010, indicating that it is a unique address assigned to a single device on a network. This address is used for communication between two specific devices, and the data frame is only delivered to the device with this exact address.

The correct option is 4) (A) - (IV), (B) - (I), (C) - (II), (D) - (III).

(A) Firmware - (IV) ROM: Firmware is software that is stored in a Read-Only Memory (ROM) chip, which is a non-volatile memory used to store permanent data.

(B) Batch file - (I) Number of logical records into physical blocks: A batch file is a text file containing a series of commands that are executed in sequence. It is used to automate repetitive tasks, such as dividing the number of logical records into physical blocks.

(C) Packing - (II) ASCII format: Packing refers to the process of converting data into a compact format for storage or transmission. ASCII is a format for representing characters as numerical values, which can be used for packing data.

(D) Banker's Algorithm - (III) Resource allocation: The Banker's Algorithm is a resource allocation and deadlock avoidance algorithm used in operating systems. It is used to ensure that the allocation of resources is done in a safe and efficient manner, which is essentially resource allocation.

The correct answer is 4) (A) - (III), (B) - (IV), (C) - (II), (D) - (I).

Activation record - Subroutine call

Location counter- Assembler

Reference counts- Garbage collection

Address relocation- Linking loader

Key Points

• When a sub-routine is called, its activation record is created.
• An assembler uses location counter value to give address to each instruction which is needed for relative addressing as well as for jump labels.
• Reference count is used by garbage collector to clear the memory whose reference count becomes
• Linker Loader is a loader which can load several compiled codes and link them together into a single executable. Thus it needs to do relocation of the object codes.

The correct answer is 64 kbps

To determine the maximum throughput for the given satellite channel, we need to consider the protocol window size and the round-trip time (RTT) of the satellite communication. However, the problem statement only provides the error-free channel capacity (64 kbps), the data frame size (512 bytes), and the window size (15).

Given:

• Channel capacity = 64 kbps
• Data frame size = 512 bytes
• Window size = 15

First, convert data frame size to bits: $512 \text{ bytes} \times 8 \text{ bits/byte} = 4096 \text{ bits}$

Since the window size is 15, we can have at most 15 frames in transit before an acknowledgment is required. Therefore, the maximum amount of data that can be in transit is: $15 \text{ frames} \times 4096 \text{ bits/frame} = 61440 \text{ bits}$

If the channel capacity is 64 kbps (which is 64000 bps), the maximum throughput is constrained by the channel capacity because the theoretical maximum throughput cannot exceed the channel capacity.

Therefore, regardless of other factors, the maximum throughput achievable on this channel, even with a window size of 15, is the same as the channel capacity because frames can be sent continuously without waiting for acknowledgments (assuming very short acknowledgment packets do not significantly impact the bandwidth).

Thus, the maximum throughput is: $64 \text{ kbps}$

So, the correct answer is: 3) 64 kbps

LR parsing is one sort of bottom up parsing. It is used to parse a broad category of grammars. "L" denotes left-to-right scanning of the input in LR parsing, "R" signifies the reverse construction of a right-most derivation and "K" is the number of input symbols used to determine the number of parsing decisions.

LR parsing consists of four different parts: LR (0) parsing, SLR parsing, CLR parsing, and LALR parsing.

LR parsers in term of power:

CLR > LALR > SLR > LR(0)

Therefore, Option 3) is correct option.

Concept:

If we are establishing a connection between client and server using TCP, it offers a number of features, including the fact that TCP is well-suited for applications that demand high dependability and transmission time is less important. It is utilized by protocols such as HTTP, HTTPs, FTP, SMTP, and Telnet. TCP rearranges data packets according to the requested order. There is an absolute guarantee that the transferred data will arrive undamaged and in the same order as it was sent. TCP utilizes Flow Control and requires three packets to establish a socket connection prior to sending any user data. TCP controls both dependability and congestion. It also does error detection and recovery. From the source to the destination, incorrect packets are retransmitted.

Explanation:

TCP Server – 

• using socket(), Create a TCP socket.
• using bind(), Bind the socket to the server address.
• using listen(), put the server socket in a passive mode, where it waits for the client to approach the server to make a connection
• using accept(), At this point, the connection is established between the client and server, and they are ready to transfer data.

Hence, option 2) is correct.

Concept:

To calculate the time required to write 600000 bytes of data with a blocking factor of 10 and a record size of 100 characters (or 100 bytes assuming one byte per character) using a magnetic tape drive with a transport speed of 200 inches per second and a recording density of 1600 bytes per inch, we can use the following formula:

Time = Amount of data / (Transport speed x Recording density)

Explanation:

Blocking factor = 10

Number of records per block = 10

Number of bytes per block = 1000 (100 characters x 10 records per block)

Number of blocks required = 600 (600000 bytes / 1000 bytes per block)

<br>

The length of tape required for one block can be calculated as follows:

Length of tape required for one block = (Number of bytes per block) / (Recording density)

= 1000 / 1600

= 0.625 inches

<br>

Therefore, the total length of tape required for 600 blocks is:

Total length of tape required = (Length of tape required for one block) x (Number of blocks)

= 0.625 x 600

= 375 inches

<br>

Now, we can calculate the time required to write this length of tape:

Time required = (Length of tape) / (Transport speed)

= 375 / 200

= 1.875 seconds

Therefore, the time required to write 600000 bytes of data grouped in 100 characters record with a blocking factor of 10 is 1.875 seconds.

The correct option is 1) Only PCP in X has a solution.

Post correspondence Problem

• The Post Correspondence Problem (PCP) is a mathematical problem that asks whether it is possible to form a string by concatenating elements of two given lists A and B, such that the resulting string is equal to another string in the other list.
• In more detail, given two lists A = {n1, n2, . . . , nk} and B = {x1, x2, . . . , xk} of strings over the alphabet Σ, the task is to find a sequence of integers i1, i2, . . . , im (where m ≥ 1 and repetition of indices is allowed) such that ni1 ni2 . . . nim = xi1 xi2 . . . xim.
• 1. For example, if Σ = {0, 1}, A = {1, 10111, 10}, and B = {111, 10, 0}, there exists a solution, m = 4, i1 = 2, i2 = 1, i3 = 1, i4 = 3, such that ni1 ni2 ni3 ni4 = 1011110.
• However, not all instances of PCP have solutions.
• 2. For example, if Σ = {0, 1}, A = {10, 011, 101}, and B = {101, 11, 011}, there is no solution because it's not possible to form the strings from the elements of the lists.
• In general, PCP is a well-known problem in computational theory and is known to be undecidable, meaning that there is no algorithm that can determine whether a solution exists for all instances of the problem in a finite amount of time.

option 4 is the correct answer.

• The expression !(num - 65) evaluates to true if num is not equal to 65, and false if num is equal to 65.
• However, this expression is not equivalent to num! = 65, since the factorial of other numbers besides 65 can also produce the same result as 65.
• Options 1 and 3 are also not valid replacements for num! = 65, since they do not check if the factorial of num is equal to 65.
• Option 2 is the only option that is equivalent to num! != 65, but it is not the correct answer since the question asks for a replacement that is NOT equivalent to num! = 65.

Concept:

Cohesion quantifies the degree to which the module's elements are functionally related. It is the extent to which an element contains all elements necessary for performing a single task. Cohesion is essentially the internal adhesive that holds the module together. The cohesion of a quality software design will be high.

Explanation:

Logical Cohesion: The relationship between the elements is logical, not functional. Ex- An element receives inputs from tape, disc, and the network. Each function's code resides in the same component. The operations and functions are related, but significantly distinct.

Sequential Cohesion: An element's output becomes the input for another element, i.e. data flow between the parts. It is a characteristic of functional programming languages.

Procedural Cohesion: Elements of procedural cohesion guarantee the proper order of execution. Actions continue to be loosely coupled and unlikely to be re-usable. Ex- calculate student GPA, print student record, calculate cumulative GPA, print cumulative GPA.

Communicational Cohesion: Two elements interact with the same input data or contribute to the same output. For example, update the database record and send it to the printer.

Hence the correct answer is option 4.

The correct answer is θ(n lg n).

This can be determined using the Master Theorem.

The Master Theorem is a general formula used to solve recurrence relations of the form T(n) = aT(n/b) + f(n), where a, b > 0 are constants, and f(n) is an asymptotically positive function.

In the given recurrence relation, a = 3, b = 4, and f(n) = n lg n.

Using the Master Theorem, we can see that the solution to the recurrence is T(n) = θ(n lg n), since log4 ³ = 1 and f(n) = n lg n = Θ(n lg n).

Therefore, the correct answer is θ(n lg n).

Interrupts

• It is of two types: Hardware interrupts, and Software interrupts.
• The hardware interrupt occurs by the interrupt request signal from peripheral circuits. On the other hand, the software interrupt occurs by executing a dedicated instruction.
• The hardware interrupt has an external interrupt and an internal interrupt. The external interrupt occurs when a specified signal is input to the dedicated external interrupt terminal. The internal interrupt occurs by an interrupt request signal from a peripheral circuit built into the microcontroller.
• Machine check interrupts are caused by machine malfunctions. When an interrupt occurs, the hardware saves pertinent information about the program that was interrupted and, if possible, disables the processor for further interrupts of the same type. The hardware then routes control to the appropriate interrupt handler routine.

Stack overflow is an Internal interrupt.

Timer is an External interrupt.

Invalid opcode is a Software interrupt.

Superior call is a Machine check interrupt.

Hence, option 2) is correct.

S→AB |CA

B→BC |AB

A→a

C→aB | b

Here B is not derive any terminal string so remove productions contains B

S→CA

A→a

C→b 

Hence above grammar is Reduced grammar.

Memcached

It is a high-performance, user-friendly in-memory data store. It provides a mature, scalable, open-source solution for sub-millisecond response speeds, which makes it suitable as a cache or session store. Memcached is widely used to power real-time Web, Mobile Apps, Gaming, AdTech, and E-Commerce systems.

Couch DB

The prominent big data analytics tools that use non-relational databases are MongoDB, Cassandra, Oracle No-SQL, and Apache CouchDB.

CouchDB is a NoSQL database for document storage. It provides the ability to store documents with unique names, as well as an API is known as RESTful HTTP API for reading and modifying (adding, editing, and deleting) database documents. Documents are the fundamental unit of data in CouchDB, and they also contain metadata.

Infinite graph

InfiniteGraph is a distributed graph database developed in Java and C++. It belongs to a class of "Not Only SQL" (NOSQL) database systems that emphasize graph data structures. InfiniteGraph is used by developers to discover useful and frequently hidden relationships in highly connected, complex big data sets.

Hence, option 2) is the most appropriate answer.

Concept:

Elevator algorithm (also SCAN) is a disk-scheduling algorithm to determine the motion of the disk's arm and head in servicing read and write requests.This algorithm is named after the behavior of a building elevator, where the elevator continues to travel in its current direction (up or down) until empty, stopping only to let individuals off or to pick up new individuals heading in the same direction.

A Process Scheduler schedules different processes to be assigned to the CPU based on particular scheduling algorithms. These algorithms are either non-preemptive or preemptive. Non-preemptive algorithms are designed so that once a process enters the running state, it cannot be preempted until it completes its allotted time, whereas preemptive scheduling is based on priority where a scheduler may preempt a low-priority running process anytime when a high-priority process enters into a ready state.

 

A stack-based algorithm is one for which it can be shown that the set of pages in memory for N frames is always a subset of the set of pages that would be in memory with N+1 frames. For LRU replacement, the set of pages in memory would be the n most recently referenced pages. If the number of frames increases then these n pages will still be the most recently referenced and so, will still be in the memory. While in FIFO, if a page named b came into physical memory before a page a then priority of replacement of b is greater than that of a, but this is not independent of the number of page frames and hence, FIFO does not follow a stack page replacement policy and therefore suffers Belady’s Anomaly. 

 

Havender’s Algorithm is the Elimination of “Mutual Exclusion” Condition The mutual exclusion condition must hold for non-shareable resources. That is, several processes cannot simultaneously share a single resource. This condition is difficult to eliminate because some resources, such as the tap drive and printer, are inherently non-shareable. Note that shareable resources like read-only-file do not require mutually exclusive access and thus cannot be involved in deadlock. Elimination of “Hold and Wait” Condition There are two possibilities for the elimination of the second condition. The first alternative is that a process request be granted all the resources it needs at once, prior to execution. The second alternative is to disallow a process from requesting resources whenever it has previously allocated resources. This strategy requires that all the resources a process will need must be requested at once. The system must grant resources on “all or none” basis. If the complete set of resources needed by a process is not currently available, then the process must wait until the complete set is available. While the process waits, however, it may not hold any resources. Thus the “wait for” condition is denied and deadlocks simply cannot occur.

The Correct Answer is option 1.

DES

DES is a block cipher that encrypts data in 64-bit blocks. This implies that 64 bits of plaintext are supplied to DES, which generates 64 bits of ciphertext. Encryption and decryption employ the same algorithm and key, with slight variations. The key is 56 bits long.

AES

AES is extensively used because it is significantly more secure than DES and triple DES, although being more difficult to implement.  The AES (Advanced Encryption Standard) is a block cipher.  Key size can be 128/192 or 256 bits. Encrypts data using 128-bit blocks.

3 DES

Triple DES is a method of encryption that employs three instances of DES on the same plaintext. It employs three distinct key selection strategies: in the first, all utilised keys are unique; in the second, two keys are identical and one is unique; and in the third, all used keys are identical. Triple DES is also vulnerable to meet-in-the middle attack because of which it give total security level of 2^112 instead of using 168 bit of key.

RSA

RSA is an asymmetrical cryptographic algorithm. Asymmetric implies that it operates on two distinct keys, namely the Public Key and the Private Key. As its name implies, the Public Key is made available to everyone, while the Private Key is kept secret. The public key is composed of two numbers, one of which is a product of two huge prime numbers. In addition, the private key is derived from the same pair of prime numbers. Consequently, the private key is compromised if someone can factorise the huge integer. Therefore, the encryption strength is entirely dependent on the size of the key, and if we double or triple the key size, the encryption strength increases exponentially. RSA keys typically consist of 1024 or 2048 bits.

Hence, option 2) is correct.

The correct answer is : Option 1) Both (A) and (R) are true and (R) is the correct explanation of (A)

Key Points

Given:

• p → q is true
• q is false

Apply logical inference:

The implication p → q is logically equivalent to ¬p ∨ q. For p → q to be true when q is false, ¬p must be true. That means p is false.

Therefore:

• Assertion (A): ¬p is true ✅
• Reason (R): p → q is true and q is false ⇒ ¬p is true ✅
• Hence, (R) is the correct explanation of (A)

Correct Answer: Option 1) Both (A) and (R) are true and (R) is the correct explanation of (A)

The correct answer is IEJFCGKLHDBA

Given: 

Preorder - ABCEIFJDGHKL

Inorder - EICFJBGDKHLA

Concept:

Since in preorder traversal root is visited first, then left child, later right child.

Explanation:

Given preorder and Inorder we can construct the complete tree as follows:-

we find the root using preorder and we find left and right child using Inorder

New root = B since preorder contains B next.

Now from this tree we find post order traversal, which is IEJFCGKLHDBA

n the case of a B-tree with a minimum number of keys, there is one key in the root, 2 nodes at depth 1 , 2tⁱ -1 nodes at depth i .   

Let h be the height of the tree and n be the number of nodes. Then

n>=1+(t-1) submission up h down i=1     2tⁱ-1

which works out to t^h<= (n+1) / 2. So we take the log_t of both sides.

 h <= log_t(n+1)/2 

Hence only h ≤ logt$\rm\frac{n+1}{2}$ is correct.

Concept:

The production of requirements stage of the software development process is Software Requirements Specifications (SRS) (also called a requirements document).

Characteristics of Software Requirement Specification:

Correctness: The SRS document is deemed to be correct if the requirements stated in it are expected from the system itself.

Clarity: SRS documentation should be easy to understand for all members of the development process, from stakeholders to developers and other specialists.

Viability: An SRS document should be created will all the current conditions and limitations in mind. They include budget, technical capabilities, team size, and deadline.

Compleness: Your SRS should be complete with details and cover most user scenarios so that your development team can use this document as their guide and avoid any confusion during the development.

Flexibility: A rare product stays unchanged throughout the whole development process, so your documentation should be flexible enough to accept changes. Try to keep all the information well-structured, so that you can make changes quickly in one section of the document.

Consistency: The requirements in your SRS document shouldn’t contradict each other, and you should use the same terminology across the documentation. The structure of your document should be clear and predictable.

Accuracy: The document should have clear requirements and instructions so that any team member can use it without having to ask any additional questions. Avoid ambiguity, loopholes, subjective suggestions, and so on.

The Correct Answer is option 4.

The Correct Answer is option 1.

Concept:

Multiplexers:

• Multiplexers are combinational circuits designed to select one of multiple data inputs and produce a single output
• They're commonly used in communication transmissions
• A multiplexer is Many to one data selector
• A multiplexer selects one of the many data available at its input depending on the bits on the select line
• For 2n inputs, there are n select lines that determine, which input is to be connected to the output.

Concept:

Requirement Engineering Process:

The process to gather software requirements from clients, analyzing and document them is known as requirement engineering.

The goal of requirement engineering is to develop and maintain a sophisticated and descriptive ‘System Requirements Specification’ document.

Requirement Engineering Process:

It is a four-step process, which includes 

• Feasibility Study
• Requirement Gathering
• Software Requirement Specification
• Software Requirement Validation

The Correct Answer is Requirement Engineering Process.

Concept:

Grammar:

It is a finite set of formal rules for generating syntactically correct sentences or meaningful correct sentences.

According to Noam Chomosky, there are four types of grammar.

They are Type0, Type1, Type2, Type3.

 

The Correct Answer is option 2.

The correct answer is option 2) reference value directly.

Key Points

• Option 1 – Find the address of a variable in memory: ✅ Pointers are designed to store the address of a variable using the & (address-of) operator.
• Option 2 – Reference value directly: ❌ Pointers do not reference values directly. To access the value at the memory address, you must use the * (dereference) operator. Hence, this is not a direct operation.
• Option 3 – Simulate call by reference: ✅ In languages like C and C++, pointers are used to pass variables by address to functions, effectively simulating call by reference.
• Option 4 – Manipulate dynamic data structure: ✅ Pointers are crucial for managing dynamic data structures such as linked lists, trees, and graphs.

Additional Information

• Pointers are a powerful tool in programming for indirect access to variables.
• However, they require explicit dereferencing to access the value stored at the memory location they point to.

Hence, the correct answer is: option 2) reference value directly

The correct answer is: option 3) (A) is true but (R) is false

Key Points

Assertion (A): A load-and-go assembler avoids the overhead of writing the object program out and reading it back in.

• This is true.
• A load-and-go assembler directly loads the object code into memory for execution, eliminating the need to save the code to disk and reload it later.

Reason (R): This can be done with either one-pass or two-pass assembler.

• This is false.
• Load-and-go assemblers are generally implemented as one-pass assemblers to allow immediate code generation and execution.
• A two-pass assembler reads the source code twice (once to build the symbol table, once to generate code), which is not suitable for load-and-go scenarios.

Therefore:

• Assertion (A) is true ✅
• Reason (R) is false ❌

Hence, the correct answer is: option 3) (A) is true but (R) is false

Given:

Let h(k) = k mod 11

Keys are 43,36,92,87,11,47,11,13,14.

h(1) = 43 % 11 = 10

h(2) = 36 % 11 = 3

h(3) = 92 % 11 = 4

h(4) = 87 % 11 = 10

Now, collision occurs due to index places is same.

The element is allotted next nearest place that is 0 index.

h(4) = 87 % 11 = 0

h(5) = 11 % 11 = 0

Now, collision occurs due to index places is same.

The element is allotted next nearest place that is 1 index.

h(5) = 11 % 11 = 1

h(6) = 47 % 11 = 3

Now, collision occurs due to index places is same.

The element is allotted next nearest place that is 4 index.

index 4 is already allotted to h(3).

The element is allotted next nearest place that is 5 index.

h(6) = 47 % 11 = 5

h(7) = 11 % 11 = 0

Now, collision occurs due to index places is same.

The element is allotted next nearest place that is 1 index.

index 1 is already allotted to h(5).

The element is allotted next nearest place that is 2 index.

h(7) = 11 % 11 = 2

h(8) = 13 % 11 = 2

Now, collision occurs due to index places is same.

The element is allotted next nearest place that is 3 index.

index 3 is already allotted to h(2).

The element is allotted next nearest place that is 4 index.

index 4 is already allotted to h(3).

The element is allotted next nearest place that is 5 index.

index 5 is already allotted to h(6).

The element is allotted next nearest place that is 6 index.

h(8) = 13 % 11 = 6

h(9) = 14 % 11 = 3

Now, collision occurs due to index places is same.

The element is allotted next nearest place that is 4 index.

index 4 is already allotted to h(3).

The element is allotted next nearest place that is 5 index.

index 5 is already allotted to h(3).

The element is allotted next nearest place that is 6 index.

index 6 is already allotted to h(8).

The element is allotted next nearest place that is 7 index.

h(9) = 14 % 11 = 7.

The Correct Answer is 7.

Concept:

• Localization is a characteristic of software that indicates the manner in which information is concentrated within a program. For example, conventional methods for functional decomposition localize information around functions, which are typically implemented as procedural modules.
• Abstraction is a mechanism that enables the designer to focus on the essential details of a program component with little concern for lower-level details.
• Encapsulation is to make sure that "sensitive" data is hidden from users and wrapping code and data together into a single unit.
• Information hiding is the ability to prevent certain aspects of a class or software component from being accessible to its clients and Suppressing the operational details of a program component.

The Correct Answer is option 3.

Correct answer is Option 3Explanation:

Omega Notation, Ω

The notation Ω(n) is the formal way to express the lower bound of an algorithm's running time.

It measures the best case time complexity or the best amount of time an algorithm can possibly take to complete.

For example, for a function f(n)

Ω(f(n)) ≥ { g(n) : there exists c > 0 and n0 such that g(n) ≤ c.f(n) for all n > n0. }

According to Transitive Property

 f(n) = o(g(n)) and g(n) = o(h(n)) ⇒ f(n) = o(h(n)) is Correct

Correct answer is Option1

Explanation:Use the union rule to replace

EF → G and EF → H 

EF → GH

F = { A → B  ABCD → E  EF → GH  ACDF → EG }

B is extraneous in ABCD → E because B ∈ ABCD and {A → B, ABCD → E, EF → GH, ACDF → EG}

logically implies {A → B, ACD → E, EF → GH, ACDF → EG}.

This is because every  ACD → E.

This FD can be derived using Armstrong’s Axioms from A → B and ABCD → E via transitivity rule

So remove B from ABCD → E.

F = { A → B ACD → E  EF → GH ACDF → EG }

E is extraneous in ACDF → EG because E ∈ EG and {A → B, ACD → E, EF → GH, ACDF → G}

logically implies {A → B, ACD → E, EF → GH, ACDF → EG}

remove E from ACDF → EG

F = { A → B ACD → E EF → GH ACDF → G}

G is extraneous in ACDF → G. Note that ACDF → G is already implied by ACD → E and EF → GH in F

remove ACDF → G from F.

None of the remaining FD's in F have extraneous attributes so the minimal cover is

A → B, ACD → E, EF → G, EF → H.

Hence the correct answer is option 1.

Given:

Four stage pipeline is used

Delay of stages = 150, 120, 160 and 140 ns

Delay due to each register = 5 ns

1000 data items or instructions are processed

Cycle Time:

Cycle Time =  Maximum delay due to any stage + Delay due to its register

⇒  Max { 150, 120, 160, 140 } + 5 ns

⇒  160 ns + 5 ns

⇒  165 ns

Process:

Pipeline time to process 1000 data items

⇒ Time taken for 1st data item + Time taken for remaining 999 data items

⇒  1 x 4 clock cycles + 999 x 1 clock cycle

⇒  4 x cycle time + 999 x cycle time

⇒  4 x 165 ns + 999 x 165 ns

⇒  660 ns + 164835 ns

⇒  165495 ns

⇒  165.5 μs

The Correct Answer is 165.5 μs

Correct answer is Option 4.

Explanation:

• RE languages or type-0 languages are generated by type-0 grammars.
• An RE language can be accepted or recognized by Turing machine.
• TM can loop forever for the strings which are not a part of the language.
• RE languages are also called as Turing recognizable languages.

Correct answer is Option 1

Explanation:Statement I: "Grandparent is a parent of one's parent".

Statement II: First Order Predicate Logic (FOPL) representation of above statement is

• ∀ g, c grandparent (g, c) ⇔ ∃ p parent (g, p) ∧ parent (p, c)
• Here: Statement 2 is First Order Predicate Logic (FOPL) representation of statement1
• ∃ p parent (g, p) means for at least one grandparent of parent
• parent (p, c) means parent of child
• conclusion: "Grandparent is a parent of one's parent".

FOPL is a mathematical language used to represent logical statements and relationships between entities.

• In FOPL, we use quantifiers to denote the scope of variables in a logical statement.
• The two main quantifiers are universal (∀) and existential (∃).
• In Statement II, the universal quantifier (∀) is used to represent all grandparent relationships.
• The variables g and c represent a grandparent and a grandchild, respectively.
• The FOPL representation asserts that for all grandparent (g, c) relationships, there exists a parent (p) such that p is a parent of c, and g is a parent of p.
• This representation accurately represents the grandparent relationship defined in Statement I.
• In summary, both Statement I and Statement II are true.
• Statement I provides an intuitive definition of the grandparent relationship, while Statement II provides a formal representation of the same relationship using FOPL.

Correct answer is Option 4

Explanation:

Software quality metrics are a subset of software metrics that focus on the quality aspects of the product, process, and project. 

These are more closely associated with process and product metrics than with project metrics.

Software metrics can be classified into three categories 

• Product metrics − Describes the characteristics of the product such as size, complexity, design features, performance, and quality level.
• Process metrics − These characteristics can be used to improve the development and maintenance activities of the software.
• Project metrics − This metrics describe the project characteristics and execution.

                                       Examples include the number of software developers, productivity.

Correct answer is Option 3

Explanation:Quick sort is a Divide and Conquer algorithm.

It picks an element as a pivot and partitions the given array around the picked pivot.

In Quick sort algorithm, partitioning of the list is performed using following steps...

• Step 1 - Consider the first element of the list as pivot (i.e., Element at first position in the list).
• Step 2 - Define two variables i and j. Set i and j to first and last elements of the list respectively.
• Step 3 - Increment i until list[i] > pivot then stop.
• Step 4 - Decrement j until list[j] < pivot then stop.
• Step 5 - If i < j then exchange list[i] and list[j].
• Step 6 - Repeat steps 3,4 & 5 until i > j.
• Step 7 - Exchange the pivot element with list[j] element

Worst Case : O(n2)

Best Case : O (n log n)

Average Case : O (n log n)

Correct answer is Option1**Concept:**G = (V,T,P,S)

1. G is a grammar, which consists of a set of production rules. It is used to generate the strings of a language.
2. T is the final set of terminal symbols. It is denoted by lower case letters.
3. V is the final set of non-terminal symbols. It is denoted by capital letters.
4. P is a set of production rules, which is used for replacing non-terminal symbols
5. S is the start symbol used to derive the string.

Explanation: Grammer G:

S → AbB

A → aAb ∣ λ

B → bB ∣ λ

language L is generated by grammer G is:

L = {anbm ∶ n ≥ 0, m > n}

String can be generated by grammer G is:

{b, bb, abb, abbb....} here an ∶ n ≥ 0 and bm ∶ m > n

Option 2: False

L = {anbm ∶ n ≥ 0, m ≥ 0}

Option 3: False

L = {anbm ∶ n ≥ m}

Option 4: False

L = {anbm ∶ n ≥ m, m > 0}

Correct answer is Option 4

Explanation:

• The 4GT begins with “Requirement Gathering”
• The customer could actually describe the requirements
• These would be directly translated into an operational prototype.
• If the product is a smaller product may be possible to move directly from
• Requirements gathering step to implementation using a non-procedural Fourth generation language (4GL)
• For larger products this procedure may little hard, therefore it’s necessary to use the design strategy in 4GT.
• Fourth Generation Technique (4GT) is a software development methodology that emphasizes using high-level programming languages and automated tools to expedite the software development process.
• 4GT techniques are designed to improve the productivity of developers and reduce the time and cost of software development.
• To achieve these goals, 4GT emphasizes the use of reusable code, modular design, and rapid prototyping.
• 4GT can help control the efforts, resources, and cost of software development by streamlining the development process and reducing the time and effort required to complete a project.

Benefits of the 4GT

1. Flexible
2. Scalable
3. Total Data Access
4. controls efforts
5. controls resources
6. controls cost of development

Correct answer is Option 2

Explanation:The Transport Layer in the Open System Interconnection (OSI) model is responsible for end-to-end delivery over a network.

Transport Layer uses some standard protocols to enhance its functionalities are

• TCP(Transmission Control Protocol),
• UDP( User Datagram Protocol),
• DCCP( Datagram Congestion Control Protocol), etc.

Functions of the transport layer

1. Service-point addressing
2. Segmentation and Reassembly
3. Connection Control
4. Multiplexing and Demultiplexing
5. Flow control Error Control

Correct answer is Option 2

Explanation:

Correct answer is Call by value is always more efficient than call by reference.

• Statement 3 (False): "Call by value is always more efficient than call by reference."
• Call by value is not always more efficient than call by reference.
• For small data types, call by value might be more efficient because it avoids the indirection associated with pointers.
• However, for large data types, call by reference can be more efficient because it avoids the overhead of copying large amounts of data, instead passing only the memory address, which saves memory and improves performance.

Additional Information

• Statement 1 (True): "All function calls in C pass arguments using call by value."
• In C, function arguments are passed by value by default. This means the called function receives a copy of each argument.
• Statement 2 (True): "Call by reference enables a called function to modify a variable in the calling function."
• Call by reference (or simulating it using pointers) allows the function to modify the original variable by accessing it through its memory address.
• Statement 4 (True): "Programmers use pointers and indirection operation to simulate call by reference."
• In C, programmers use pointers to pass the address of variables to functions. The function can then use these pointers to modify the original variables, effectively simulating call by reference.

Correct answer is Option 4

Explanation:

• Physical Layer: This layer is responsible for the physical connection between devices, including the cables, connectors, and physical characteristics of the transmission medium. It defines the physical specifications of the network, such as voltage levels, data rates, and the type of cable used.
• Data Link Layer: The data link layer provides reliable communication between two nodes on the same physical network. It is responsible for packetizing data, error detection and correction, flow control, and media access control. This layer ensures that data is transmitted without errors and is properly received by the destination device.
• Network Layer: The network layer provides logical addressing and routing of data between different networks. It decides how data packets are routed from the source to the destination, based on the network topology and traffic conditions. It also provides services such as fragmentation and reassembly of packets.
• Transport Layer: The transport layer ensures the reliable delivery of data between end systems. It provides end-to-end data transfer services such as flow control, error correction, and congestion control. It also ensures that data is transmitted in the correct order, and provides mechanisms for retransmission of lost packets.
• Session Layer: The session layer establishes, manages, and terminates communication sessions between applications on different devices. It provides services such as authentication, authorization, and synchronization of data flow between applications.
• Presentation Layer: The presentation layer ensures that data is presented in a format that is meaningful to the application layer. It handles data encryption, decryption, compression, and translation between different data formats.
• Application Layer: The application layer provides services to end-user applications, such as email, file transfer, and web browsing. It interacts directly with software applications and provides protocols for high-level services such as data transfer, remote file access, and email management.

The correct answer is Option 1Explanation:

• The evolutionary process model resembles the iterative enhancement model
• The same phases as the waterfall model are defined here in a cynical fashion.
• This model differs from the iterative enhancement model in the sense that this does not require a usable product at the end of each cycle.
• In evolutionary development, requirements are implemented by category rather than by priority.
• For example, in a simple database application, one cycle might implement the graphical user interface (GUI)
• Evolutionary development and iterative enhancement are somewhat interchanged.
• Evolutionary development should be used when it is not necessary to provide a minimal version of the system quickly.
• This model is useful for projects using new technology that is not well understood.

The correct answer is Option 4

Explanation:

• Value of Alpha and Beta will be passed to the nodes down below (Child nodes) in forward.
• Alpha–beta pruning can be applied to trees of any depth and it is possible to prune entire subtree rather than leaves.
• In backward movement in the tree, only node values will be passed on
• to the upper node as against Alpha and Beta values in the top to down
• Value of Alpha only will be updated in tree level assigned for
• Value of Beta only will be updated in tree level assigned for
• The best way to arrive at a good ordering is to start from the shallowest node and check the best nodes first
• Alpha: At each point along the Maximizer path, Alpha is the best option or the highest value . –∞ is the initial value for alpha.
• Beta: At every point along the Minimizer route beta is initially set to +∞.
• The condition for Alpha-beta Pruning is α >= β

The correct answer is Option 3

Explanation:

 Left Rotate = 1 ⇒   

Right Rotate = 1 ⇒

   

Left Rotate = 1 ⇒   

Left Rotate = 1 ⇒ 

Right Rotate = 1 ⇒

Correct answer is Option 3

Explanation: Using Least Recently Used(LRU) page replacement algorithm:

Frame size 3

total number of page fault=10

The correct answer is option 4

Explanation:Data Given:Tag field =9 bits

index field=12 bits

Main Memory address

total bits= 9+ 12 =21 bits

Calculation:

Size of Main memory

= 2²¹=2¹ * 2²⁰

=2*1024K

=2048k

Size of cache memory

= 2^index+offset

=2¹²⁺⁰

=2¹²

=4k

Correct answer is Option 4

Explanation:

• Fault-based testing aims to detect certain classes of known faults.
• Example: security testing for buffer overflows
• Mutation Testing Fault-based testing strategy
• It is used to evaluate test suite adequacy
• Measures the effectiveness of test cases
• Leads to creation of more effective tests
• Mutation Testing Faults are introduced into the program by creating versions of the program called mutants.

The correct answer is Option 2

Explanation:

• An approximation algorithm is a way of dealing with NP-completeness for an optimization problem. This technique does not guarantee the best solution.

The goal of the approximation algorithm is to come as close as possible to the optimal solution in polynomial time.

Such algorithms are called approximation algorithms or heuristic algorithms.

A vertex cover of an undirected graph is a subset of its vertices such that for every edge (u, v) of the graph, either ‘u’ or ‘v’ is in the vertex cover. Although the name is Vertex Cover, the set covers all edges of the given graph.

• Vertex Cover Problem is a known NP Complete problem, there is no polynomial-time solution for this unless P = NP.

There are approximate polynomial-time algorithms to solve the problem 2-approximation for vertex cover via greedy matchings.

2 - approximation for vertex cover via LP rounding.

Greedy O(log n) approximation for set-cover.

Approximation algorithms for MAX-SAT. 

• The traveling salesman problem is NP-complete.

The TSP problem is NP-complete even if we require the cost function to satisfy the triangle inequality.

The correct answer is Option 3**.**

• Explanation: Least Recently Used is Page replacement policy in cache memory.

It works on the concept that pages that have been highly used in the past are likely to be significantly used again in the future.

It removes the page that has not been utilized in the memory for the longest time.

• The critical section is a code segment where the shared variables can be accessed.

An atomic action is required in a critical section

i.e. only one process can execute in its critical section at a time.

All the other processes have to wait to execute in their critical sections.

• Loosely coupled multiprocessor system

A multiprocessor is that contains more than two processors in a system.

A system is known as a loosely connected multiprocessor if there is a very low degree of coupling between these CPUs.

• A distributed operating system (DOS) is an essential type of operating system.

Distributed systems use many central processors to serve multiple real-time applications and users.

It connects multiple computers via a single communication channel.

O/S routines are distributed among available processors.

The most appropriate answer is:

Neither (A) nor (B) true.

Commutative Property which is a * b = b * a is not true for semigroups.

The equation b * b = b is not true for all semigroups.

A semigroup is a set S equipped with a binary operation * that is associative, which means (a * b) * c = a * (b * c) for all a, b, c in S.

For a given semigroup, the equation b * b = b may or may not hold true. In fact, there are many semigroups where this equation is not satisfied.

For example, consider the set of non-negative integers under addition modulo 2. That is, we define a binary operation * on this set by a * b = (a + b) mod 2. This forms a semigroup, as * is associative. However, the equation b * b = b is not generally true in this semigroup. For instance, if b = 1, then 1 * 1 = 0, which is not equal to 1.

Therefore, the equation b * b = b is not generally true for all semigroups.

Concept: 

RSA Algorithm:

Step 1: Calculate value of n = p × q, where p and q are prime no.’s

Step 2: calculate Ø(n) = (p-1) × (q-1)

Step 3: consider d as a private key such that Ø(n) and d have no common factors. i.e  greatest common divisor (Ø(n) , d ) = 1

Step 4: consider e as a public key such that (e × d) mod Ø(n) = 1.

Step 5: Ciphertext = message i.e. me mod n.

Step 6: message= cipher text i.e. cd mod n.

Calculation:

To find the value of 'd' in the RSA algorithm, we need to calculate the modular multiplicative inverse of 'e' modulo φ(n), where n is the product of the two prime numbers p and q, and φ(n) is the Euler's totient function.

Given:

p = 13

q = 5

e = 7

ciphertext = 6

First, calculate n:

n = p × q

n = 13 × 5

n = 65

Next, calculate φ(n):

Ø(n) = (p - 1) × (q - 1)

Ø(n) = (13 - 1) × (5 - 1)

Ø(n)= 12 × 4

Ø(n) = 48

Now, we need to find the modular multiplicative inverse of 'e' modulo Ø(n). In other words, we need to find 'd' such that (e * d) mod Ø(n) = 1.

Using the extended Euclidean algorithm, we can find 'd':

Step 1: 

48 = 7 × 6 + 6

7 = 6 × 1 + 1

Step 2:

6 = 1 * 6 + 0

Since the remainder in the last step is 1, we can conclude that the greatest common divisor of 7 and 48 is 1. Therefore, 'd' exists, and it is the coefficient of 7 in the equation:

1 = 7 - 6 × 1

So, 'd' is equal to 7.

Now, to decrypt the ciphertext using the private key (d, n), we can use the formula:

plaintext = (ciphertext^d) mod n

Substituting the values:

plaintext = (6⁷) mod 65

Calculating this:

plaintext = 279936 % 65

plaintext = 46

Therefore, the value of 'd' is 7 and the plaintext (decrypted value) of the ciphertext '6' using the private key (d, n) is 46.

So, the correct answer is 7, 46.

Given:

IP address: 167.199.170.82/27.

Here, no. of mask bits = n = 27

In classless addressing, no. of address are given by 2^{32 - n}

No. of addresses = 232-27 = 2⁵ = 2 × 2 × 2 × 2 × 2 = 32

The Correct Answer is option 2.

Ontology engineering

It is a field which studies the methods and methodologies for building ontologies, which encompasses a representation, formal naming and definition of the categories, properties and relations between the concepts, data and entities.

Taxonomy hierarchy

A taxonomy in computer science is a method for organizing data. In such a taxonomy, different pieces of information are stored along with their relationships to other data in the taxonomy. This produces a hierarchy of data, which makes it easier for programmers and users to compute certain information.

Inheritance

Inheritance means one class can inherit properties and behavior of another class. This is one of principle of OOPs (Object Oriented Programming).

Probability model

A probability model is a mathematical representation of a random phenomenon. It is defined by its sample space, events within the sample space, and probabilities associated with each event.

Therefore,

(A) Ontological Engineering - (IV) Representing concepts, events, time, physical concepts of different domains

(B) Taxonomy Hierarchy - (II) Organizing knowledge into category and subcategory

(C) Inheritance - (I) Organizing subclass relations

(D) Probability model - (III) Attaches a number with each possibility

Hence, the correct answer is option 3.

Concept:

Normalization:- It is the process of organizing data in a database. There are two main objectives of the normalization process: eliminate redundant data and ensure data dependencies make sense.

1NF:- First normal form (1NF) is a relation in which the intersection of each row and column contains one and only one value.

2NF:- Second Normal Form (2NF) is based on the concept of fully functional dependency.

2 NF removes partial functional dependency.

3NF:- A relation is in the third normal form (3NF) if it is in the second normal form and no transitive dependencies exist.

3 NF removes Transitive dependencies.

4NF:- A group of tables that satisfies the first, second, and third normal forms are sufficiently well-designed.

4 NF removes multivalued dependency

BCNF (Boyce Codd Normal Form) is the advanced version of 3NF. A table is in BCNF if every functional dependency X→Y, X is the super key of the table. If R is found to be in BCNF, it can be safely deduced that the relation is also in 3NF, 2NF, and 1NF as the hierarchy shows.

• BCNF is the normal form that actually removes all transitive dependencies.
• It is a more restricted form of normalization so that the database does not end in anomalies.
• The stage at which a table is organized is known as its normal form (or a stage of normalization
• BCNF is not always dependency preserving.

The Correct Answer is option 3.

For a multiprocessor system, interconnection network - crossbar switch is an example of a non-blocking network.

A non-blocking network is a type of interconnection network in which concurrent communication can occur between multiple nodes without blocking. The crossbar switch is a non-blocking network because it can connect any input to any output without any blocking. This allows for efficient communication and data transfer between multiple processors, memory modules, and input/output devices in a multiprocessor system.

Henec, the correct answer is option 1.

Consider a binary heap of 7 nodes, i.e., n=7.

It would be a complete binary tree of height 2.

Number of nodes at height 0, i.e., at the lowest level = 4 = [$\rm\frac{7}{2^{0+1}}$].

Number of nodes at height 1 = 2 = [$\rm\frac{7}{2^{1+1}}$].

Number of nodes at height 2, i.e., at root level 1 = [$\rm\frac{7}{2^{2+1}}$]

So, the correct option is option 1) ceil[$\rm\frac{n}{2^{h+1}}$]

The given grammar is:

S → SbS | a

The string abababa can be derived using the:

(A) two parse trees 

(B) two left most derivative

First derivative

S → SbS

S → SbSbS

S → SbSbSbS

S → abSbSbS

S → ababSbS

S → abababS

S → abababa

Second derivative

S → SbS

S → abS

S → abSbS

S → ababS

S → ababSbS

S → abababS

S → abababa

(C) two right most derivative

First derivative

S → SbS

S → SbSbS

S → SbSbSbS

S → SbSbSba

S → SbSbaba

S → Sbababa

S → abababa

Second derivative

S → SbS

S → Sba

S → SbSba

S → Sbaba

S → SbSbaba

S → Sbababa

S → abababa

Hence, the correct answer is options 1.

Threading - It is a lightweight process that the operating system can schedule and run concurrently with other threads. The operating system creates and manages threads, and they share the same memory and resources as the program that created them. This enables multiple threads to collaborate and work efficiently within a single program.

Cascading Termination - It occurs in some systems, including VMS, which do not allow a child to exist if its parent has terminated. In such systems, if a process terminates either normally or abnormally, then all its children have to be terminated.

Zombie Termination - It is a process that has completed execution but still has an entry in the process table. This occurs for the child processes, where the entry is still needed to allow the parent process to read its child's exit status.

Process Killing - Terminating a process forcefully is called process killing.

Software measurement is considered as a management tool which if conducted in an effective manner, helps the project manager and the entire software team to take decisions that lead to successful completion of the project.

Direct measures - It includes software processes like cost and effort applied and products like lines of code produced, execution speed, and other defects that have been reported.

Indirect measures - It include products like functionality, quality, complexity, reliability, maintainability, and many more. -

It does depend on any of the cases i.e., X or Y as it is not satisfied any of the property of Boolean algebra.

We can solve the equation as shown below:

Hence, the correct answer is option 4.

Important Point - In Synchronous Access Organisation, the address lines are common at all the banks.

We know that -

• Distance at which address is spaced - 'm'
• Bank Cycle Time - 'T'
• Number of Banks - 'n'

 

Explanation - 

• When the distance at which address is spaced is very less than the number of banks, that is, m << n, then the average data access time per word access is - $m \rm \cdot \rm \frac{T}{n}$
• When the distance at which address is spaced is much more than the number of banks, that is, m >> n, then the average data access time per word access is - T
• Combining above two points, we get the average data access time per word access in synchronous organisation as - t = \(\left{\begin{array}{l} \rm m \cdot \rm\frac{T}{n} \text { for } \rm m<<n \ \rm T \text { for } m >> n \end{array}\right.\)

From the language L = {anbm ∶ n ≥ 4, m ≤ 3}, we can observe that

• In the regular expression, there should be at least 4 a(s).
• In the regular expression, there should be at most 3 b(s).
• In the regular expression, b(s) should come after a(s), not the other way around.
• From the options given above, aaaaa*(λ + b + bb + bbb), there are compulsarily 4 a(s) and then we have a*. After that, we have all possible combinations of b(s), which can be 0 to 3 at max.

Size Oriented Metrics - It has been derived by normalising quality and productivity Point Metrics measures by considering size of the software that has been produced. The organization builds a simple record of size measure for the software projects.

Function-Oriented Metrics - They are also known as Function Point Model. This model generally focuses on the functionality of the software application being delivered. These methods are actually independent of the programming language that is being used in software applications and based on calculating the Function Point (FP). A function point is a unit of measurement that measures the business functionality provided by the business product.

The hidden surface removal problem in computer graphics refers to the process of identifying which surfaces are visible and which are hidden from the viewer's perspective. Hidden Surface Removal (HSR) problem can also be solved using a Brute Force Rasterization algorithm in a minimal 3D graphics pipeline.

Brute force rasterization algorithm: This algorithm works by dividing the viewing window into small cells (pixels) and calculating the visibility of objects in each cell. This approach can be effective for removing hidden surfaces but can be computationally expensive for complex scenes.

Additional InformationPainter's algorithm: This algorithm works by painting surfaces in order of their distance from the viewer's viewpoint. The closest surface is painted first, followed by the next closest surface, and so on. This algorithm is relatively simple to implement and can work well for simple scenes, but it can produce incorrect results for more complex scenes.

Window Clipping algorithm: This algorithm works by defining a viewing window that only displays objects within the window. Objects that fall outside the viewing window are clipped and not displayed. This algorithm is effective for removing hidden surfaces and can work well for scenes with a limited number of object.

Flood fill algorithm: This algorithm is not typically used for hidden surface removal in 3D graphics, as it is primarily designed for 2D image processing tasks such as filling shapes with color.

The conversion of a primal linear programming problem to its dual problem is a standard technique in linear programming. Here's how it can be done:

1. Write the primal problem in standard form: Maximize the objective function subject to a set of constraints.
2. Create the dual problem by converting the primal constraints into dual variables and the primal objective function into the dual objective function. The constraints in the primal problem become the objective function in the dual problem, and the objective function in the primal problem becomes the constraints in the dual problem.
3. Replace each inequality constraint in the primal problem with an equality constraint, and each equality constraint with an inequality constraint.
4. Change the direction of the inequality constraints in the dual problem. If the primal constraint was a less-than-or-equal-to constraint, the dual constraint should be a greater-than-or-equal-to constraint, and vice versa.
5. Replace the primal variables with the dual variables, and vice versa.
6. Solve the dual problem to obtain the optimal dual variables, and then use these variables to obtain the optimal primal variables.

Therefore,  y1 ≥ 0, y2 ≥ 0

"Divide by zero" is NOT a logical error it is runtime error.

Runtime errors: These occur when the program is running and something goes wrong.

For example,

• If the program tries to divide a number by zero,
• If it tries to access a memory location that is not accessible

RAD - Rapid Application Development is an adaptive software development model based on prototyping and quick feedback with less emphasis on specific planning.

• In general, the RAD approach prioritizes development and building a prototype, rather than planning.
• With rapid application development, developers can quickly make multiple iterations and updates to the software without starting from scratch.
• It also helps in ensuring that the final outcome is more quality-focused and aligns with the end users’ requirements.

Transmission Control Protocol (TCP) - Transmission Control Protocol (TCP) is a standard that defines how to establish and maintain a network conversation by which applications can exchange data. TCP works with the Internet Protocol (IP), which defines how computers send packets of data to each other.

User Datagram Protocol (UDP) - User Datagram Protocol (UDP) is a communications protocol that is primarily used to establish low-latency and loss-tolerating connections between applications on the internet. UDP speeds up transmissions by enabling the transfer of data before an agreement is provided by the receiving party.

• UDP is a connectionless transport - layer protocol that belongs to the internet protocol family.

Routing Protocol (RP) - A routing protocol specifies how routers communicate with each other to distribute information that enables them to select routes between nodes on a computer network.

Datagram Control Protocol (DCP) - is a message-oriented transport layer protocol. It implements reliable connection setup, teardown, explicit congestion notification, congestion control and feature negotiation.

To represent the 4-bit code 1101 into a 7-bit, even parity Hamming code, we first need to add 3 parity bits to the 4 data bits. The parity bits are chosen so that the total number of 1's in each group of bits (including the parity bit) is even.

Hamming Code:

 

Given data 1101

i.e. d1 = 1, d2 = 1, d3 = 0, d4 = 1

We can write:

P1 = d1 ⊕ d2 ⊕ d4 = 1 ⊕ 1 ⊕ 1 = 1

P2 = d1 ⊕ d4 ⊕ d3 = 1 ⊕ 1 ⊕ 0 = 0

P3 = d2 ⊕ d4 ⊕ d3 = 1 ⊕ 1 ⊕ 0 = 0

Then transmitted final code is P1 P2 d1 P4 d2 d3 d4 which is 1010101

The total storage capacity of the floppy disk can be calculated by multiplying the number of tracks, the number of sectors per track, and the number of bytes per sector.

The number of tracks on the floppy disk is 80 and the number of bytes per sector is 128. Let's assume that the number of sectors per track is "S". Then, the total storage capacity of the floppy disk can be expressed as:

Total storage capacity = number of tracks x number of sectors per track x number of bytes per sector = 80 x S x 128

We know that the total storage capacity of the floppy disk is 163,840 bytes. Therefore, we can write:

80 x S x 128 = 163840

Solving for S, we get:

S = 163840 / (80 x 128) = 16

Therefore, the floppy disk has 16 sectors.

Hence, the correct answer is option 4.

Verifiable - an SRS is verifiable only if every stated requirement can be verified cost effectively. A requirement is verifiable if there is some method to quantifiably measure whether the final software meets that requirement. 

Traceable - an SRS is traceable if the origin of each of its requirements is clear and if it makes it easy to reference each requirement in future development.

Modifiable - an SRS must clearly identify each and every requirement in a systematic manner. If there are any changes, the specific requirements and the dependent ones can be modified accordingly without impact the others.

Complete - an SRS should contain all the features requested by a client.

Concept:

To determine the number of gate inputs required to realize an expression, you need to look at the number of terms and the number of literals (variables) in each term.

In the expression you've given: ABC + AB̅CD + EF̅ + AD

There are four terms and a total of nine literals:

• ABC has three literals.
• AB̅CD has four literals.
• EF̅ has two literals.
• AD has two literals.

Each literal requires input, and each term requires a separate AND gate (because the product implies AND operations), the inputs of which are the literals. The results of these AND gates then need to be ORed together, which requires one additional OR gate with four inputs.

So, in total, the number of gate inputs required would be:

1. AND gate inputs: 3 (for ABC) + 4 (for AB̅CD) + 2 (for EF̅) + 2 (for AD) = 11
2. OR gate inputs: 4 (because there are four terms)

So, the total number of gate inputs required is 11 (AND) + 4 (OR) = 15.

Note that the inputs A̅, B̅, etc., are usually achieved by passing the original inputs (A, B, etc.) through NOT gates. If you are considering these NOT gates also, then there will be an additional number of 2 inputs (for B̅, F̅) added to the total count making it 17.

To solve this question we will use Bayes Theorem to get reverse probability. 

Let first ball drawn is red and second ball drawn is white. Probability of choosing a box at random = 131313131313

=> Probability of drawing a red ball (R) from Box-1 (B1) = p(R | B1) = 494949494949

=> Probability of drawing a red ball (R) from Box-2 (B2) = p(R | B2) = 272727272727

=> Probability of drawing a red ball (R) from Box-3 (B3) = p(R | B3) = 383838383838

=> Probability of getting the ball from Box-1 if red ball is selected is given by - $P(B1 | R) = \frac{P(B1) \times p(R | B1)}{P(B1) \times p(R | B1)+P(B2) \times p(R | B2)+P(B3) \times p(R | B3)} = \frac{\frac{1}{3} \times \frac{4}{9}}{\frac{1}{3} \times \frac{4}{9} + \frac{1}{3} \times \frac{2}{7} + \frac{1}{3} \times \frac{3}{8}} = \frac{224}{557}$ ................ (1)

Now let us consider white ball is drawn second time.

=> Probability of drawing a white ball (W) from Box-1 = p(W | B1) = 28=1428=1428=1428=1428=1428=14

=> Probability of drawing a white ball (W) from Box-2 = p(W | B2) = 373737373737

=> Probability of drawing a white ball (W) from Box-3 = p(W | B3) = 48=1248=1248=1248=1248=1248=12

=> Probability of getting the ball from Box−1 if white ball is selected is given by - $P(B1 | W) = \frac{P(B1) \times p(W | B1)}{P(B1) \times p(W | B1)+P(B2) \times p(W | B2)+P(B3) \times p(W | B3)} = \frac{\frac{1}{3} \times \frac{1}{4}}{\frac{1}{3} \times \frac{1}{4} + \frac{1}{3} \times \frac{3}{7} + \frac{1}{3} \times \frac{1}{2}} = \frac{7}{33}$ ..........(2)

• Hence probability of getting the balls from Box-1 if red ball selected first time and white ball second time = 224557×733=156818381224557×733=156818381224557×733=156818381224557×733=156818381224557×733=156818381224557×733=156818381

  CodeCopy

     ​ ............................................(3)
  

 

 

Let us consider white ball is drawn the first time.

=> Probability of drawing a white ball (W) from Box-1 = p(W | B1) = 292929292929

=> Probability of drawing a white ball (W) from Box-2 = p(W | B2) = 373737373737

=> Probability of drawing a white ball (W) from Box-3 = p(W | B3) = 48=1248=1248=1248=1248=1248=12

=> Probability of getting the ball from Box−1 if white ball is selected is given by - $P(B1 | W) = \frac{P(B1) \times p(W | B1)}{P(B1) \times p(W | B1)+P(B2) \times p(W | B2)+P(B3) \times p(W | B3)} = \frac{\frac{1}{3} \times \frac{2}{9}}{\frac{1}{3} \times \frac{2}{9} + \frac{1}{3} \times \frac{3}{7} + \frac{1}{3} \times \frac{1}{2}} = \frac{28}{145}$ ..........(4)

Now let us consider red ball is drawn second time.

=> Probability of drawing a red ball (R) from Box-1 (B1) = p(R | B1) = 48=1248=1248=1248=1248=1248=12

=> Probability of drawing a red ball (R) from Box-2 (B2) = p(R | B2) = 272727272727

=> Probability of drawing a red ball (R) from Box-3 (B3) = p(R | B3) = 383838383838

=> Probability of getting the ball from Box-1 if red ball is selected is given by - $P(B1 | R) = \frac{P(B1) \times p(R | B1)}{P(B1) \times p(R | B1)+P(B2) \times p(R | B2)+P(B3) \times p(R | B3)} = \frac{\frac{1}{3} \times \frac{1}{2}}{\frac{1}{3} \times \frac{1}{2} + \frac{1}{3} \times \frac{2}{7} + \frac{1}{3} \times \frac{3}{8}} = \frac{28}{65}$ ................ (5)

Hence probability of getting the balls from Box-1 if white ball selected first time and red ball second time = 28145×2865=784942528145×2865=784942528145×2865=784942528145×2865=784942528145×2865=784942528145×2865=7849425

 

Using (3) and (6), probability of getting two balls from Box-2 if one of then red and other one is white = $\frac{1568}{18381} + \frac{784}{9425} = 0.0863 + 0.08418$ ~ 0.18