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

NLTK Text Processing Examples

Experiment 4: Basic Text Preprocessing

This section demonstrates fundamental text preprocessing steps using NLTK, including tokenization, stop word removal, filtering for alphabetic tokens, and stemming.

import nltk
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
from nltk.stem import PorterStemmer
from nltk.corpus import words

text = "Random sampling is a method of choosing a sample of observations from a population to make assumptions about the population"

tokens = word_tokenize(text)
stop_words = set(stopwords.words('english'))
stemmer = PorterStemmer()

# 1. Lowercase and filter for alphabetic tokens
alpha_tokens = [token.lower() for token in tokens if token.isalpha()]

# 2. Filter

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++ Pointer and Array Operations

This collection demonstrates fundamental C++ techniques for handling pointers, arrays, and memory management.

Core Functions

void squareByPointer(int* n) { 
    *n = (*n) * (*n);
}

void capitalizeFirst(char* word) { 
    word[0] = toupper(word[0]);
}

void fillWithSquares(int* arr, int size) {
    for (int i = 0; i < size; i++)
        arr[i] = i * i;
}

int sumArray(const int* arr, int size) {
    int sum = 0;
    for (int i = 0; i < size; i++)
        sum += arr[i];
    return sum;
}

void swap(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

int* makeFilledArray(int size, int val) {
    int* arr = new int[size];
    for (int i = 0; i < size; i++)
        arr[i] = val;
    return

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" »

Expressions and Operators Fundamentals

Expressions Defined

What constitutes a valid expression in programming?

Understanding Operators

Operator Definition and Types

An operator is a symbol that represents a computation. What are the three primary types of operators?

• Unary: Operates on one operand (e.g., -x).
• Binary: Operates on two operands (e.g., x + y).
• Ternary: Operates on three operands (e.g., (a > b) ? a : b).

Order of Operation and Precedence

How is the order of operation determined? What mechanisms can be used to change the default order of operation?

Order is typically governed by Operator Precedence Rules and Associativity Rules (e.g., left-to-right). Parentheses can be used to override the default order.

Conditional Expressions

What is a conditional... Continue reading "Programming Language Concepts: Expressions, Control Flow, and Subprograms" »

Digital Logic Circuits

Flip-Flops

Clocked RS Flip-Flop Drawbacks

Clocked RS flip-flops have some drawbacks, such as susceptibility to race conditions, where the output can become unpredictable if the inputs change too close to the clock edge. They also require careful handling of the inputs to avoid metastability issues, which can lead to incorrect output states. Additionally, they can have higher power consumption compared to other flip-flop types due to the need for a clock signal.

JK Flip-Flop Operation

Content about JK Flip-Flop operation, characteristic table, characteristics equation, circuit diagram, and timing diagram would be added here.

Magnitude Comparator

What is a Magnitude Comparator?

A magnitude comparator is a digital circuit that compares... Continue reading "Digital Logic Circuits: Flip-Flops, Comparators, Decoders, and Registers" »

Race Conditions in JK Flip-Flops

What is a race condition in a JK flip-flop and how can it be overcome?

In a JK flip-flop, a race condition occurs when both J and K inputs are high (1) while the clock pulse is active. This leads to unpredictable behavior, where the output state toggles rapidly and does not settle to a stable value because the propagation delay is shorter than the clock pulse width.

To overcome this, you can use clocked JK flip-flops or edge-triggered designs. This ensures that inputs are only processed during a specific clock edge, making the output stable and effectively avoiding race conditions.

Master-Slave JK Flip-Flop Configuration

Explain the master-slave flip-flop using a JK flip-flop with logic circuits, truth tables, and