Notes, summaries, assignments, exams, and problems for Computers

Arithmetic Mean

The following C++ code calculates the arithmetic mean of numbers from 1 to n:

int main() {
    int n;
    double suma = 0;
    cout << "Vnesi broj: ";
    cin >> n;
    if (n <= 0) {
        cout << "Brojot na elementi mora da bide pogolem od 0!" << endl;
        return 1;  
    }
    for (int i = 1; i <= n; i++) {
        suma += i;  
    }
    double sredina = suma / n;
    cout << "Aritmetichkata sredina na broevite od 1 do " << n << " e: " << sredina << endl;
    return 0;
}

Sum

The following C++ code calculates the sum of numbers from 1 to n:

int main() {
    int n, sum = 0;
    cout << "Vnesi broj n: ";
    cin >> n;
    for (int i = 1; i <= n; i++)

Understanding Variables & Data Types

Variables: Storing Data

Variables are containers used to store data. They are assigned values using the = operator (e.g., x = 5).

Essential Data Types

Python supports several fundamental data types:

• int: Represents integer numbers (e.g., 10, -5).
• float: Represents floating-point numbers (e.g., 3.14, -0.01).
• str: Represents strings of characters (e.g., "hello", "123").
• bool: Represents Boolean values, either True or False.

Type Casting: Converting Data Types

Type casting allows you to convert data from one type to another using functions like int(), float(), and str().

Example: x = int("5") converts the string "5" to an integer. y = float("3.14") converts the string "3.14" to a float.

Input and Output Operations

Getting

1) DIJKSTRA (SSSP) — STEP TABLE (PAST-PAPER INSTANCE A)

Given edges: a→b(2), a→c(7), a→e(10), b→d(2), c→d(1), c→g(2), d→f(2), e→g(1), f→g(2). Source = a.
Rule: Pick unsettled vertex with minimum dist; relax outgoing edges.

Vertices:   a   b   c   d   e   f   g

Init:
Dist      = 0   2   7   ∞  10   ∞   ∞
S = ∅

Step 1: Pick a (min=0), S={a}
Relax from a: already set b=2, c=7, e=10
Dist      = 0   2   7   ∞  10   ∞   ∞

Step 2: Pick b (min=2), S={a,b}
Relax b→d: dist(d) = dist(b)+2 = 2+2 = 4
Dist      = 0   2   7   4  10   ∞   ∞

Step 3: Pick d (min=4), S={a,b,d}
Relax d→f: dist(f) = 4+2 = 6
Dist      = 0   2   7   4  10   6   ∞

Step 4: Pick f (min=6), S={a,b,d,f}
Relax f→g: dist(g) = 6+2 = 8
Dist

SR Flip-Flop (Set-Reset Flip-Flop)

The SR flip-flop is one of the simplest sequential circuits and serves as a fundamental building block for more complex flip-flops. It is a 1-bit memory device with two inputs: Set (S) and Reset (R). It has two outputs, Q and its complement Q̅ (Q with overline).

Logic Diagram and Working

An SR flip-flop can be constructed using two cross-coupled NAND gates (or NOR gates). Below is the working principle for the NAND-gate implementation:

1. Set Condition (S = 0, R = 1):

   • When S = 0, the output of the top NAND gate (Q) is forced to 1 (since NAND is the inverse of AND).

   • This Q = 1 is fed into the bottom NAND gate with R = 1; the bottom gate's inputs become 1 and 1, so its output (Q̅) becomes 0.

   • The circuit is now in the

C printf Function: Format Specifiers Explained

The printf function in C is used to display formatted output to the standard output (usually the console). It allows programmers to control how data is presented by using **format specifiers**. Format specifiers are placeholders that define the type of data being printed and how it should be formatted. They begin with a % symbol, followed by a character that specifies the data type.

Role of Format Specifiers

Format specifiers serve two main purposes:

1. Data Type Identification: They inform the printf function about the type of data being passed as an argument. For example, %d is used for integers, while %f is used for floating-point numbers.
2. Formatting Control: They allow customization of how the data

1)A virtual-circuit network (VCN) is a hybrid network model that combines features of both circuit-switched and datagram networks. It provides a balance between connection-oriented and connectionless transmission methods :-Three Phases in a Virtual-Circuit Network In a virtual-circuit network, the communication between a source and destination involves three phases: setup, data transfer, and teardown. These phases ensure that a reliable path is established and maintained for the communication session. 1. Setup Phase: o The source and destination use their global addresses to establish a connection. During this phase, switches along the path create table entries to store information about the virtual circuit. This phase ensures that each switch... Continue reading "Core Concepts in Network Layer Protocols and Routing" »

Linux File System Structure: An archive of Linux is associated with 3 parts: superblock, inode table, and data blocks.

Network Ports: To see the ports assigned to services.

Display Active TCP/IP Connections: netstat -a

User Management:

• Create password: passwd (user)
• Add user to group: usermod -g group_name
• Disable: 60001
• Enable: 60002

Practical Commands:

Add User: adduser

1. Change folder privileges: chmod
2. Check privileges: ls -de (see if you changed privileges)

1. Create a user: useradd newuser
passwd newuser
2. Create a directory: The command mkdir is used to create directories:
   mkdir mydirectory
3. Create a report: ps -aux >> reporte.txt
4. Directories associated with the user: -d dirname
5. Changing permission: chmod 744 file.txt /file.txt
6. Change owner: chown
   Entering

############################### lAB 9 ####################3
import gymnasium as gym
import numpy as np
import tensorflow as tf

# Create the environment
env = gym.Make("CartPole-v1")

# Define a simple neural network model for the policy
model = tf.Keras.Sequential([
    tf.Keras.Layers.Dense(16, activation='relu', input_shape=(env.Observation_space.Shape[0],)),
    tf.Keras.Layers.Dense(env.Action_space.N, activation='softmax')
])

# Define the optimizer
optimizer = tf.Keras.Optimizers.Adam(learning_rate=0.01)

# Function to choose an action based on the current policy
def choose_action(state):
    """
    Chooses an action based on the probabilities output by the policy model.
    Args:
        state (np.Array): The current observation/state from... Continue reading "Implementing REINFORCE Policy Gradient for CartPole-v1" »

Fast File System (FFS)

Writes

Writes: Writes data to blocks chosen by cylinder groups. Tries to place related blocks near each other and rotationally optimize access. Metadata updates (inodes, directories) are also written in-place within the same group.

Reads

Reads: Very fast because data is grouped by cylinder, minimizing seeks. Sequential reads benefit from rotational optimization and large block sizes (4–8 KB). The first read goes through the inode, then the inode's data block pointers.

Appends

Appends: Allocates the next block near the previous one. Uses rotational delay tables to place the next block just in time for the disk head. Large blocks plus fragments allow efficient small-file appends.

Crash Recovery

Crash Recovery: Uses fsck to walk... Continue reading "File Systems, Kernels, and High-Performance Networking" »