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

This document presents Java code snippets demonstrating two distinct functionalities: user name generation and management, and a car repair scheduling system. Each section includes method implementations with explanations of their purpose and logic.

User Name Management System

The UserName class is designed to generate and manage potential user names based on a user's first and last names. It also provides functionality to filter out names that are already in use.

UserName Class Constructor

This constructor initializes a UserName object, populating a list of possible user names. It assumes that firstName and lastName are valid strings containing only letters and have a length greater than zero.

import java.util.ArrayList;

public class UserName {

RPA Governance and Demand Pipeline Management

Demand Pipeline Prioritization Steps

Which of the following does not describe the “Prioritization” step as part of managing the demand pipeline?

R: Helping a friend

Head of Robotic Automation Role and Responsibility

Which of the following statements are true when describing the role and responsibility of the Head of Robotic Automation?

R: All of the above

RPA Governance Board Objectives

Select from the below which statement best describes the Demand Generation objective within the RPA Governance Board?

R: Identify quality RPA automation opportunities

Select from the below which statement best describes the Demand Management objective within the RPA Governance Board?

R: Responsible for defining and prioritizing

BPSK Signal Generation

This section demonstrates the generation of a Binary Phase Shift Keying (BPSK) signal using Python.

import numpy as np
import matplotlib.pyplot as plt

def bpsk_detect(modulated_signal, carrier):
    return np.sign(modulated_signal * carrier)

message_frequency = 10
carrier_frequency = 20
sampling_frequency = 30 * carrier_frequency
t = np.arange(0, 4/carrier_frequency, 1/sampling_frequency)
message = np.sign(np.cos(2 * np.pi * message_frequency * t) + np.random.normal(scale = 0.01, size = len(t)))
carrier = np.cos(2 * np.pi * sampling_frequency/carrier_frequency * t)
modulated_signal = carrier * message
detected_message = bpsk_detect(modulated_signal, carrier)

plt.figure(figsize=(12, 8))
plt.subplot(4, 1, 1)
plt.plot(t,

Manual Installation:
Current State (Tests are Conducted in ESXi5):

1. Download OmniOS (Bloody or Stable)
2a. Option: Run on ESXi, create a new VM (Solaris 10-64) with e1000 or install on hardware (15 GB disk minimum)

2b. Run on Hardware:
You can install Omni + Napp-IT onto SATA or fast USB sticks >=16 GB (absolute minimum=8 GB when needed).
If you use USB, the best are external USB3 enclosures with a SATA SSD >=16 GB inside.
(Prefer USB3; they are mostly even faster on USB2)

3. Install with defaults from CD or USB install media, login as root (no password)

4. Setup Network. Network is set to (by default): network/physical:default,
so login as root (no password)

4.1 Create Interface
- List available interfaces and use link name, e.g., e1000g0:
dladm... Continue reading "Step-by-Step Installation of OmniOS with Napp-IT" »

Core Concepts in Compiler Design

Compiler

Compiler: Translates entire source code to target code before execution. It requires a full parse and upfront error checking, then executes the generated target code.

Interpreter

Interpreter: Executes source code incrementally (line-by-line or statement-by-statement). It translates and executes on the fly, and may partially execute ill-formed programs until an error is encountered.

LVar vs. x86 Architecture

LVar: Features nested expressions, implicit control flow (represented by an Abstract Syntax Tree - AST), and an unlimited number of logical variables.

x86: Characterized by flat instructions, atomic operands (registers/memory), explicit control flow (jumps), and a limited set of registers. Compilation passes... Continue reading "Core Concepts in Compiler Design and Language Runtime" »

Algorithm Implementations in C#

Coin Change: Number of Ways

Calculates the number of ways to make change for amount N using given coin denominations.

• Time Complexity: O(N * C), where C is the number of coins.
• Space Complexity: O(N).

static long GetNumberOfWays(long N, long[] Coins)
{
    long[] ways = new long[(int)N + 1];
    ways[0] = 1;
    for (int i = 0; i < Coins.Length; i++)
    {
        for (int j = 0; j < ways.Length; j++)
        {
            if (Coins[i] <= j)
            {
                ways[j] = ways[j] + ways[(int)(j - Coins[i])];
            }
        }
    }
    return ways[(int)N];
}

Coin Change: Minimum Number of Coins

Determines the minimum number of coins needed to make change for a given amount.

• Time Complexity: O(

Introduction to OOP Concepts

This document presents practical code examples demonstrating fundamental Object-Oriented Programming (OOP) concepts in both Delphi (Pascal) and C++. It covers class definitions, object instantiation, properties, events, static members, inheritance, polymorphism, memory management, and exception handling.

Delphi Object-Oriented Programming

The following Delphi code illustrates the creation of classes, properties, events, and static members, along with their usage in a console application.

program Cheat;
{$APPTYPE CONSOLE}

uses
  SysUtils, Classes;

type
  TNotify = procedure(Sender: TObject) of object;

  TEngine = class
    procedure Start;
    begin
      Writeln('Engine Started');
    end;
  end;

  TCar = class

C Linked List Implementations for Student Data

This document presents two distinct C language implementations for managing student records using linked lists: a singly linked list and a circular linked list. Both examples demonstrate fundamental data structure operations such as adding, deleting, searching, and displaying student information.

1. Singly Linked List Implementation

This section details a student management system built using a singly linked list. Students are stored in ascending order of their roll numbers, and duplicate roll numbers are prevented.

Core Structure and Global Head

The Student structure defines the data for each node, including roll number, total marks, average, and a pointer to the next student. The head pointer always... Continue reading "C Linked List Student Data Management Systems" »

C++ Recursive Function Examples

countUp — Print Increasing Numbers

#include <iostream>
using namespace std;

void countUp(int n) {
    if (n == 0) return;
    countUp(n - 1);
    cout << n << " ";
}

int main() {
    int n;
    cout << "Enter a positive integer: ";
    cin >> n;
    countUp(n);
    return 0;
}

summation — Sum of 1 to n

#include <iostream>
using namespace std;

int summation(int n) {
    if (n == 0) return 0;
    return n + summation(n - 1);
}

int main() {
    int n;
    cout << "Enter a positive integer: ";
    cin >> n;
    cout << summation(n);
    return 0;
}

power — Exponentiation (Recursive)

#include <iostream>
using namespace std;

int power(int n, int e)

Journaling Motivation and Necessity

File System Check (FSck) ensures metadata consistency after crashes but is slow and requires deep file system knowledge. Recovery time should ideally depend on the number of recent writes.

File System Transactions and ACID Properties

Transactions provide ACID guarantees:

• Atomicity
• Consistency
• Isolation
• Durability

These are used to treat file system operations (like file creation) as transactions. Recovery ensures committed transactions are applied and uncommitted ones are discarded.

ext3 Journaling File System

ext3 is a journaling file system using physical redo logging, adding journaling to existing ext2 structures.

Redo Logging Mechanism in ext3

The process involves writing updates to a journal first, then committing... Continue reading "File System Journaling: Mechanisms, ext3, and NTFS Recovery" »