Computer Science Notes

Problem Definition

Big J’s Jerk Restaurant is located in, Hatfield, Mandeville, Jamaica. It is a well-
established business that ensures that community members have access to quality
meals at an affordable price. The restaurant severs 1000s of customers per week.
The restaurant not only offers food for sale but beverage, desserts. The
restaurant, Big J’s Jerk Restaurant, uses a printed or a paper-based menu. This is
useful as it allows multiple people to have access to it. This method used to
provide meals, prices and drinks has a number of inefficiencies, chief of which is
the fact that the paper-based menus could be destroyed by food or drinks,
misplaced. If any of these situations occur, Big J will have to reprint them which
would be costly.

In order to remedy the inefficiencies of the current system at the restaurant, a

proposal was made to Big J to create a program specifically for the restaurant that
will facilitate the entering, viewing and searching of records pertaining to
business inventory. This program will be done using C program language. The new
system will ensure that the accessing of data is more efficient since the current
system is time-consuming.

The new system will also electronically calculate the sales price for the products
and output it to the user. The program will allow the user to add, view and delete
information on each goods which will provide a more reliable method of managing
customers orders. Better management of customers’ orders is expected to result in
increased business productivity.

The C program should have the following features: Menu utilising the switch
case
must have at
least 5 functions
Must use
arrays
Must use the
struct feature
Must use
files

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_PRODUCTS 100
#define FILENAME "inventory.txt"

// Define a struct to represent a product/item.

typedef struct {
char name[50];
float price;
int quantity;
} Product;

// Function declarations
void addProduct(Product products[], int *count);
void viewProducts(Product products[], int count);
void searchProduct(Product products[], int count);
void deleteProduct(Product products[], int *count);
void saveProductsToFile(Product products[], int count);
void loadProductsFromFile(Product products[], int *count);
int main() {
int choice;
Product products[MAX_PRODUCTS];
int count = 0;

// Load existing products from file (if any)

loadProductsFromFile(products, &count);

do {
printf("\nBig J's Jerk Restaurant Inventory Management\n");
printf("1. Add Product\n");
printf("2. View Products\n");
printf("3. Search Product\n");
printf("4. Delete Product\n");
printf("5. Exit\n");
printf("Enter your choice: ");
scanf("%d", &choice);
getchar(); // Consume newline character left by scanf

switch (choice) {
case 1:
addProduct(products, &count);
break;
case 2:
viewProducts(products, count);
break;
case 3:
searchProduct(products, count);
break;
case 4:
deleteProduct(products, &count);
break;
case 5:
saveProductsToFile(products, count);
printf("Exiting program. Data saved to file.\n");
break;
default:
printf("Invalid choice. Please try again.\n");
}
} while (choice != 5);

return 0;
}

// Function to add a product record

void addProduct(Product products[], int *count) {
if (*count >= MAX_PRODUCTS) {
printf("Inventory is full.\n");
return;
}
printf("Enter product name: ");
fgets(products[*count].name, sizeof(products[*count].name), stdin);
products[*count].name[strcspn(products[*count].name, "\n")] = '\0'; // Remove
newline

printf("Enter product price: ");

scanf("%f", &products[*count].price);

printf("Enter product quantity: ");

 scanf("%d", &products[*count].quantity);
getchar(); // Clear the newline

(*count)++;
printf("Product added successfully!\n");
}

// Function to view all products in the inventory

void viewProducts(Product products[], int count) {
if (count == 0) {
printf("No products to display.\n");
return;
}
printf("\nCurrent Inventory:\n");
printf("%-20s %-10s %-10s\n", "Product Name", "Price", "Quantity");
int i;
for (i = 0; i < count; i++) {
printf("%-20s %-10.2f %-10d\n", products[i].name, products[i].price,
products[i].quantity);
}
}

// Function to search for a product by name

void searchProduct(Product products[], int count) {
char searchName[50];
printf("Enter product name to search: ");
fgets(searchName, sizeof(searchName), stdin);
searchName[strcspn(searchName, "\n")] = '\0';

int found = 0;
int i;
for (i = 0; i < count; i++) {
if (strcmp(products[i].name, searchName) == 0) {
printf("Product found:\n");
printf("Name: %s\n", products[i].name);
printf("Price: %.2f\n", products[i].price);
printf("Quantity: %d\n", products[i].quantity);
found = 1;
break;
}
}
if (!found) {
printf("Product not found.\n");
}
}

// Function to delete a product record by name

void deleteProduct(Product products[], int *count) {
char deleteName[50];
printf("Enter product name to delete: ");
fgets(deleteName, sizeof(deleteName), stdin);
deleteName[strcspn(deleteName, "\n")] = '\0';

int index = -1;

int i;
for (i = 0; i < *count; i++) {
if (strcmp(products[i].name, deleteName) == 0) {
index = i;
break;
 }
}
if (index == -1) {
printf("Product not found.\n");
return;
}
// Shift elements to remove the product from the array
for (i = index; i < (*count) - 1; i++) {
products[i] = products[i + 1];
}
(*count)--;
printf("Product deleted successfully!\n");
}

// Function to save products to a file

void saveProductsToFile(Product products[], int count) {
FILE *fp = fopen(FILENAME, "w");
if (fp == NULL) {
printf("Error opening file for writing.\n");
return;
}
int i;
for (i = 0; i < count; i++) {
fprintf(fp, "%s,%f,%d\n", products[i].name, products[i].price,
products[i].quantity);
}
fclose(fp);
}

// Function to load products from a file

void loadProductsFromFile(Product products[], int *count) {
FILE *fp = fopen(FILENAME, "r");
if (fp == NULL) {
// File may not exist on first run
return;
}
while (fscanf(fp, " %[^,],%f,%d\n", products[*count].name,
&products[*count].price, &products[*count].quantity) == 3) {
(*count)++;
if (*count >= MAX_PRODUCTS)
break;
}
fclose(fp);
}
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------

Computer Science Notes

Modular programming, also known as the divide-and-conquer approach, involves
continuously breaking or dividing a problem into successively smaller problem sets
or sub-problems. Each module is then further broken down into a set of tasks, and
each task is then broken down into a set of actions.
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------
Computer science notes
2/17/2025
//structure

Struct [structure tag]

{
//member variable 1
//member variable 2
//member variable 3
...
}[structure variables];

E.G.
struct student
{
char name[40];
int age;
char branch[10];
// F for female and M for male
char gender;
} student1={''Jim", 41,Business, M};

struct student student2={''Tim", 51, PR, M};

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

Global declaration is outside the main function. The who program has access to
these variables
Local declaration is inside the main function. Only a part of the program has
access to these variables

The grocer Needs to store data about some products using a C program. Each product
has an id(int), Name(char), quantity in stock(int) and a price(float)
A. Write a declaration for a C struct productrec that can store the record
for each product.
B. Declare 2 variables, item1 and item2, associated with the structure
declared in part A.
C. Write C code to put data in Item1 and Item2 declared in part B. Use values
that you like.
D. Display the results to the user.
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------

#include <stdio.h>
#include <string.h>

// A. Declaration of the struct productrec.

struct productrec {
int id; // Product ID
char name[50]; // Product name (assumed to be a string up to 49 characters)
int quantity; // Quantity in stock
float price; // Price
};
int main(void) {
// B. Declare two variables of type struct productrec.
struct productrec item1, item2;

// C. Assign values to item1 and item2.

// For item1:
item1.id = 101;
strcpy(item1.name, "Milk"); // using strcpy from <string.h> to assign a string
item1.quantity = 20;
item1.price = 2.50f;

// For item2:
item2.id = 102;
strcpy(item2.name, "Bread");
item2.quantity = 15;
item2.price = 1.75f;

// D. Display the results.

printf("Item1:\n");
printf(" ID: %d\n", item1.id);
printf(" Name: %s\n", item1.name);
printf(" Quantity: %d\n", item1.quantity);
printf(" Price: $%.2f\n\n", item1.price);

printf("Item2:\n");
printf(" ID: %d\n", item2.id);
printf(" Name: %s\n", item2.name);
printf(" Quantity: %d\n", item2.quantity);
printf(" Price: $%.2f\n", item2.price);

return 0;
}
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------

#include <stdio.h>

struct productrec {
int id; // Product ID
char name[50]; // Product name (string)
int quantity; // Quantity in stock
float price; // Price
};

int main(void) {
// Declaration and initialization without using <string.h>
struct productrec item1 = {101, "Milk", 20, 2.50f};
struct productrec item2 = {102, "Bread", 15, 1.75f};

// Display the results.

printf("Item1:\n");
printf(" ID: %d\n", item1.id);
printf(" Name: %s\n", item1.name);
printf(" Quantity: %d\n", item1.quantity);
printf(" Price: $%.2f\n\n", item1.price);
 printf("Item2:\n");
printf(" ID: %d\n", item2.id);
printf(" Name: %s\n", item2.name);
printf(" Quantity: %d\n", item2.quantity);
printf(" Price: $%.2f\n", item2.price);

return 0;
}
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------

#include <stdio.h>

// A. Write a declaration for a C struct productrec that can store

// the record for each product.
struct productrec {
int id; // Product ID
char name[50]; // Product Name
int quantity; // Quantity in stock
float price; // Price
};

int main(void) {
// B. Declare 2 variables, item1 and item2, associated with
// the structure declared in part A.
struct productrec item1, item2;

// C. Prompt user to input data for item1 and item2.

// (Use any values or prompts that you like.)
printf("Enter details for item1:\n");
printf(" ID: ");
scanf("%d", &item1.id);
printf(" Name (no spaces): ");
scanf("%s", item1.name);
printf(" Quantity: ");
scanf("%d", &item1.quantity);
printf(" Price: ");
scanf("%f", &item1.price);

printf("\nEnter details for item2:\n");

printf(" ID: ");
scanf("%d", &item2.id);
printf(" Name (no spaces): ");
scanf("%s", item2.name);
printf(" Quantity: ");
scanf("%d", &item2.quantity);
printf(" Price: ");
scanf("%f", &item2.price);

// D. Display the results to the user.

printf("\n---- Product Information ----\n");
printf("Item1:\n");
printf(" ID: %d\n", item1.id);
printf(" Name: %s\n", item1.name);
printf(" Quantity: %d\n", item1.quantity);
printf(" Price: %.2f\n\n", item1.price);
 printf("Item2:\n");
printf(" ID: %d\n", item2.id);
printf(" Name: %s\n", item2.name);
printf(" Quantity: %d\n", item2.quantity);
printf(" Price: %.2f\n", item2.price);

return 0;
}
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------

#include <stdio.h>

// A. Declaration of the struct productrec.

struct productrec {
int id; // Product ID
char name[50]; // Product name (a string stored in a character array)
int quantity; // Quantity in stock
float price; // Price
};

int main(void) {
// B. Declare two variables, item1 and item2, and initialize them directly.
struct productrec item1 = {1001, "Milk", 50, 1.25f};
struct productrec item2 = {1002, "Bread", 30, 1.75f};

// C. Data has already been put into item1 and item2 using initialization.

// D. Display the results to the user.

printf("Item1:\n");
printf(" ID: %d\n", item1.id);
printf(" Name: %s\n", item1.name);
printf(" Quantity: %d\n", item1.quantity);
printf(" Price: $%.2f\n\n", item1.price);

printf("Item2:\n");
printf(" ID: %d\n", item2.id);
printf(" Name: %s\n", item2.name);
printf(" Quantity: %d\n", item2.quantity);
printf(" Price: $%.2f\n", item2.price);

return 0;
}
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------

/*
Documentation Section
Program Name:Stuct Practice
Author:Pierce-Mikal McNamee
Date:2/18/2025

(i)Write a C declaration for a struct in C that can hold the record of a customer.
Each record contains a customer ID (integer) and a customer balance (float). Note
that balance represents the amount of money a customer has for making purchases. \
[3 marks\]

(ii)Declare two variables to represent two customers, Andrew and Jamie. Next, set
their record values as follows:

| | ID | Balance |
|-------|--------|---------|
| Andrew| 1200 | 2000 |
| Jamie | 1500 | 3000 |

\[4 marks\]

(iii) Assume that Andrew pays full price for any purchases made and Jamie gets a
10% discount on all purchases. Write C code to read two values representing the
purchases of Andrew and Jamie respectively, from the keyboard. Next, adjust each
customer’s balance based on the purchases. \[3 marks\]

(iv) Write C code to interchange the records of Andrew and Jamie. \[3 marks\]
*/

#include <stdio.h>

// (i) Declare a struct to hold a customer record.

struct Customer {
int ID; // Customer ID
float balance; // Current balance (money available for purchases)
};

int main(void) {
// (ii) Declare two variables for Andrew and Jamie
struct Customer Andrew, Jamie;

// Set their record values

Andrew.ID = 1200;
Andrew.balance = 2000.0f; // Andrew starts with 2000
Jamie.ID = 1500;
Jamie.balance = 3000.0f; // Jamie starts with 3000

// (iii) Prompt for and read the purchase amounts for Andrew and Jamie
float purchaseAndrew, purchaseJamie;

printf("Enter purchase amount for Andrew: ");

scanf("%f", &purchaseAndrew);

printf("Enter purchase amount for Jamie: ");

scanf("%f", &purchaseJamie);

// Andrew pays full price

Andrew.balance -= purchaseAndrew;

// Jamie gets a 10% discount, so only 90% of purchase is deducted

Jamie.balance -= (purchaseJamie * 0.9f);

// Display updated balances before swapping

printf("\nBalances before swapping:\n");
printf("Andrew: ID = %d, Balance = %.2f\n", Andrew.ID, Andrew.balance);
printf("Jamie : ID = %d, Balance = %.2f\n", Jamie.ID, Jamie.balance);
 // (iv) Interchange (swap) the records of Andrew and Jamie
struct Customer temp;
temp = Andrew;
Andrew = Jamie;
Jamie = temp;

// Display the results after swapping

printf("\nBalances after swapping:\n");
printf("Andrew: ID = %d, Balance = %.2f\n", Andrew.ID, Andrew.balance);
printf("Jamie : ID = %d, Balance = %.2f\n", Jamie.ID, Jamie.balance);

return 0;
}

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

Computer Science
2/20/2025
The processor
-----------------------------------------------------------------------------------
-------------------------------
The central processing unit/processor is the brain of the computer. It handles all
processing and controls all activities of a computer system. the main functions of
the CPU are:
1. To fetch data and instructions from memory (RAM).
2. To decode and coordinate instructions and data received.
3. To execute and perform instructions on data received.
4. To send the results of execution to storage (RAM or secondary storage).

Activities of an instruction cycle

-----------------------------------------------------------------------------------
-------------------------------
A CPU's instruction cycle consists of the fetching, decoding, executing and storage
of data.
<Fetching is the process of obtaining programming instructions and data from
memory.
<Decoding is the process of translating programing instructions into a form
that the computer can execute.
<Executing is the process of carrying out programing instructions.
<Storing is the process of writing the results of execution into memory (RAM)
or on a storage device.

CPU Components
-----------------------------------------------------------------------------------
-------------------------------
Them main components of a CPU are:
<Busses
<Arithmetic Logic Unit
<Registers
<Control Unit
<CPU Clock

Control Units
-----------------------------------------------------------------------------------
-------------------------------
The functions of the control unit are
 1.To process input instructions and data given to the computer.
2.To control and coordinate all activities of the computer.
3.To fetch data and instructions from memory.
4.To execute and perform instructions on data given to the computer.
5.To decode and coordinate instructions on data received.

Arithmetic Logic Units

-----------------------------------------------------------------------------------
-------------------------------
The functions of the ALU are:
1.To perform all arithmetic calculations.
2.To perform logic operations.
3.The ALU does the actual computation o processing of data.

Bus
-----------------------------------------------------------------------------------
-------------------------------
A bus is an electrical pathway that transports bits of instructions and data
between the different parts of the CPU.

Registers
-----------------------------------------------------------------------------------
-------------------------------
Registers are high speed storage locations in the CPU which temporarily holds the
next data or instructions needed for processing.

CPU Clock
-----------------------------------------------------------------------------------
-------------------------------
The CPU Clock manages the speed of the CPU. The clocks speed is an internal timing
in the processor which is measured in Megahertz

Factors to consider when selecting a CPU

-----------------------------------------------------------------------------------
-------------------------------
1.Clock speed
>Clock speed refers to the speed at which a computer performs basic
operations. The frequency of vibration of a clock determines the speed of a
computer. The number of signals per second generated by the clock sets the pace for
the processor to carry out its functions. Clock speed can be measured in Megahertz
(millions of pulses per second) and Gigahertz (billions of pulses per second). Note
that if a clock speed of a computer is double and all hardware remains unchanged,
the processing speed does not necessarily double. This is because the type of
processor, the Bus architecture and the instructions set all combine to determine a
computer's processing ability.

2.Instructions set
>Instruction set is the basic number of commands or instructions that a
processor understands or executes. The instructions set is also called command set.

3.Instruction size
>Instruction size refers to how many instructions or commands a
processor can hold.

4.Cache memory
>Cache memory refers to a temporary storage location that speeds up
access to frequently used data. It plays a vital role to a computers overall
performance.
Content of an Instruction Set
-----------------------------------------------------------------------------------
-------------------------------
An instruction set consists of opcode (operation code) which specifies the
operation to be performed such as to add content to memory; it also contains 0 or
more OPERAND specifiers. The operand specifies registers, memory locations or
literal data. Computer instructions indicate the operation to be performed and the
operand to use. The operands May come from memory, from registers or from the
instruction itself.

Addressing Modes for Instructions

-----------------------------------------------------------------------------------
-------------------------------
This refers to the different ways one can access operands
1.Imediate addressing
>With this addressing mode the value to be referenced immediately
follows the opcode in the instructions.

2.Register addressing
>In this addressing mode a register in stead of memory is used to
specify the operand. this is very similar to direct addressing except that instead
of a memory address the address field contains a register reference.

3.Indirect addressing
>In this addressing mode the bits in the address field specify a memory
address that is to be used as a pointer. The address of the OPERAND is found by
going to the memory address.

Terminologies
-----------------------------------------------------------------------------------
-------------------------------
1.Disk caching
>Disk Caching is a type of caching that involves the use of buffers to
separate operations that vary significantly in speed, so that the slower operation
does not hold up to the faster operation. The purpose of disk cache
is to improve processing speed.

2.Buffer
>A buffer is an internal memory area used for temporary storage of data
during input and output operations. This storage area is usually found in RAM.

3.Word size
>Word size refers to how much bits of instructions can be stored in
memory. A word is the amount of data and instructions the CPU can process or
manipulate at one time.

4.Word length
>Word Length refers to the number of bits the CPU can process at any
one time.

5.Surge protectors
>Surge protectors guards the computer equipment against spike in
electricity. They allow multiple components to be plugged into one power outlet.

6.Bolted regulator
>This is an electronic circuit used to maintain a constant level amount
of voltage in an electrical line. It eliminates power surges, spikes and brown outs
(low voltage).
Memory features
-----------------------------------------------------------------------------------
-------------------------------
Memory is determined by the following;
<speed
>speed refers to how fast data can be retrieved from memory.
<size
>the storage capacity of memory .
<volatility
>The ability of memory to change its content.
<word size

Storage devices should be selected based on the following factors;

<storage capacity
>storage capacity refers to the amount of data a storage device can
hold.
<access speed
>access speed refers to the rate at which a device can store data or
retrieve the stored data.
<access method
>access method refers to the means used to get the data.
<portability
>portability refers to the ablility of a storage device to move from
one device to another without a problem.

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

Computer Science
3/3/2025

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_PRODUCTS 100
#define FILENAME "inventory.txt"

// Define a struct to represent a product/item.

typedef struct {
char name[50];
float price;
int quantity;
} Product;

// Function declarations
void addProduct(Product products[], int *count);
void viewProducts(Product products[], int count);
void searchProduct(Product products[], int count);
void deleteProduct(Product products[], int *count);
void saveProductsToFile(Product products[], int count);
void loadProductsFromFile(Product products[], int *count);

int main() {
int choice;
Product products[MAX_PRODUCTS];
int count = 0;
 // Load existing products from file (if any)
loadProductsFromFile(products, &count);

do {
printf("\nBig J's Jerk Restaurant Inventory Management\n");
printf("1. Add Product\n");
printf("2. View Products\n");
printf("3. Search Product\n");
printf("4. Delete Product\n");
printf("5. Exit\n");
printf("Enter your choice: ");
scanf("%d", &choice);
getchar(); // Consume newline character left by scanf

switch (choice) {
case 1:
addProduct(products, &count);
break;
case 2:
viewProducts(products, count);
break;
case 3:
searchProduct(products, count);
break;
case 4:
deleteProduct(products, &count);
break;
case 5:
saveProductsToFile(products, count);
printf("Exiting program. Data saved to file.\n");
break;
default:
printf("Invalid choice. Please try again.\n");
}
} while (choice != 5);

return 0;
}

// Function to add a product record

void addProduct(Product products[], int *count) {
if (*count >= MAX_PRODUCTS) {
printf("Inventory is full.\n");
return;
}
printf("Enter product name: ");
fgets(products[*count].name, sizeof(products[*count].name), stdin);
products[*count].name[strcspn(products[*count].name, "\n")] = '\0'; // Remove
newline

printf("Enter product price: ");

scanf("%f", &products[*count].price);

printf("Enter product quantity: ");

scanf("%d", &products[*count].quantity);
getchar(); // Clear the newline

(*count)++;
 printf("Product added successfully!\n");
}

// Function to view all products in the inventory

void viewProducts(Product products[], int count) {
if (count == 0) {
printf("No products to display.\n");
return;
}
printf("\nCurrent Inventory:\n");
printf("%-20s %-10s %-10s\n", "Product Name", "Price", "Quantity");
for (int i = 0; i < count; i++) {
printf("%-20s %-10.2f %-10d\n", products[i].name, products[i].price,
products[i].quantity);
}
}

// Function to search for a product by name

void searchProduct(Product products[], int count) {
char searchName[50];
printf("Enter product name to search: ");
fgets(searchName, sizeof(searchName), stdin);
searchName[strcspn(searchName, "\n")] = '\0';

int found = 0;
for (int i = 0; i < count; i++) {
if (strcmp(products[i].name, searchName) == 0) {
printf("Product found:\n");
printf("Name: %s\n", products[i].name);
printf("Price: %.2f\n", products[i].price);
printf("Quantity: %d\n", products[i].quantity);
found = 1;
break;
}
}
if (!found) {
printf("Product not found.\n");
}
}

// Function to delete a product record by name

void deleteProduct(Product products[], int *count) {
char deleteName[50];
printf("Enter product name to delete: ");
fgets(deleteName, sizeof(deleteName), stdin);
deleteName[strcspn(deleteName, "\n")] = '\0';

int index = -1;

for (int i = 0; i < *count; i++) {
if (strcmp(products[i].name, deleteName) == 0) {
index = i;
break;
}
}
if (index == -1) {
printf("Product not found.\n");
return;
}
// Shift elements to remove the product from the array
 for (int i = index; i < (*count) - 1; i++) {
products[i] = products[i + 1];
}
(*count)--;
printf("Product deleted successfully!\n");
}

// Function to save products to a file

void saveProductsToFile(Product products[], int count) {
FILE *fp = fopen(FILENAME, "w");
if (fp == NULL) {
printf("Error opening file for writing.\n");
return;
}
for (int i = 0; i < count; i++) {
fprintf(fp, "%s,%f,%d\n", products[i].name, products[i].price,
products[i].quantity);
}
fclose(fp);
}

// Function to load products from a file

void loadProductsFromFile(Product products[], int *count) {
FILE *fp = fopen(FILENAME, "r");
if (fp == NULL) {
// File may not exist on first run
return;
}
while (fscanf(fp, " %[^,],%f,%d\n", products[*count].name,
&products[*count].price, &products[*count].quantity) == 3) {
(*count)++;
if (*count >= MAX_PRODUCTS)
break;
}
fclose(fp);
}
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------

Computer science
3/11/2025

data type name ( )

{

body

int count (int size, int arr, int x)

{ int i, e;
for (i=a, i < size, CH)
{ if(arr[i] = x)
{
CH;
}
}return c;
}

struct brochrec
{
int Id;
int quality;
int price;
}
struct bookrec book1, book2

#include <iostream>

int larger(int x, int y) {

if (x > y)
return x;
else
return y;
}

int main() {
int result = larger(10, 20); // Example function call
std::cout << "Larger number: " << result << std::endl;
return 0;
}
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------

Computer Science
Port connectivity is the ability of a device to connect and communicate with other
devices and interfaces. Facilitating data communication.
E.g. connecting a laptop to a printer or a projector
-----------------------------------------------------------------------------------
-------------------------------
pda, laptop micro, mini, mainframe,
-----------------------------------------------------------------------------------
-------------------------------
instruction set
>number of commands or instructions the cpu can execute
-----------------------------------------------------------------------------------
-------------------------------
fetch
>retrive data from memory (RAM)
decode
>define what operation needs to be performed and by breaking down the
instruction into its opcodes and operands
excute
>processor performs the operation specified by the opcode on the operands
-----------------------------------------------------------------------------------
-------------------------------
>Opcode refers to a unique binary code that identifies the operation to be
performed(MOV-move, ADD-), while operands or registers that the instruction
operates
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------
>RAM is volatile and used for temporary storage, while ROM is non-volatile
stores essential instructions.
Read-Only Memory (ROM) stores firmware and system boot instructions and is
Non-volatile meaning it retains data when power is off while Random Access Memory
(RAM) temporarily stores data and instructions for active processes and is
Volatile meaning it loses data when power is off.
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------
>Erasable Programmable Read-Only Memory (EPROM) is Non-volatile memory that
can be erased using ultraviolet light and reprogrammed and is Non-volatile while
Electrically Erasable Programmable Read-Only Memory (EEPROM) is Non-volatile
memory that can be electrically erased and rewritten and is Non-volatile while
being Faster than EPROM, slower than RAM
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------
A supercomputer is the most powerful type of computer, designed to perform complex
computations at extremely high speeds while A microcomputer is a small, personal
computer designed for individual use. Desktops are the most common type of
microcomputer, featuring a separate monitor, keyboard, and CPU unit.

A multiplexer (often abbreviated as "mux") is a device that selects one of several

input signals and forwards it to a single output line, acting like a switch
controlled by a separate set of digital inputs called select lines.

>Problem: A problem in computer science refers to a task that requires a

computational solution.
>Algorithm: This is a sequence of specific instructions for solving a problem
in a set amount of time.
>Problem-solving: This is the process of using a structured way of solving a
problem using computer-based solution.

Problem definition: State clearly the problem that you want to solve.
 Problem analysis: Investigate the problem in detail by determining what the
input, process and output will be. Problem analysis involves identifying what the
inputs are and what process is needed to achieve a desired output or end result.
 Generating possible solutions: At this stage all possible solutions to the
problem is identified. This is important as it gives the development team options
in relation to solving the problem.
 Analyzing possible solutions: This stage will see the evaluation of each solution
generated in the previous stage in an effort to determine suitability to the
problem.
 Select and develop the best solution: Here the team determines the most suitable
solution and represents it using a pseudocode or flowchart.
 Implementation and review of solutions: At this stage the solution is developed
and deployed in the organization it is created for. Review is done to evaluate if
the solution effectively solves the problem.
ARRAY
-----------------------------------------------------------------------------------
-------------------------------
int variable_size(int arr[ ], int size, int n)
{
int counter, total;
for (counter [size];counter++)// For loop is iterating through the array
{
if (arr[counter]==n)
{
total++;// total =total + 1; is another way of incrementing by 1.
}
}
return total;
}

FUNCTION
-----------------------------------------------------------------------------------
-------------------------------
float CalculateVat(float price, float vat)
{
vat=0.165;
float newprice;
newprice=price+(price*vat);
return newprice;
}

STRUCTURE
-----------------------------------------------------------------------------------
-------------------------------
Struct BookRec
{
int Id;
int stock_quantity;
float price;
}
Struct BookRec book1, book2;
printf("enter Id for book 1 and book 2");
scanf("%d%d",&book1.Id, &book2.Id);

book1.price=book1.price+(book1.price*0.25);

Struct BookRec temp;

temp=book1;
book1=book2;
book2=temp;

write a C function named sum that takes

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------
Computer Science
Binary (base-2)
the binary number system uses only two digits: 0 and 1. It is the fundamental
system used in digital electronics and computing because it aligns with the on-off
states of electronic components.
Decimal (base-10)

The decimal system is the standard numbering system used in everyday life. It
consists of ten digits: 0, 1, 2, 3, 4, 5, 6, 7, 8 and 9.

octal (base-8)
The octal systems uses eight digits: 0-7. it is often used in computing as a
shorthand for binary representation, with each octal digit corresponding to three
binary digits.

Hexadecimal (base-16)
the hexadecimal system consist of sixteen symbols:0-9 and A-F where A= 10 B= 11 C=
12 D= 13 E= 14 F=15. It is widely ued in computing because it provides a more
compact representation of binary numbers, with each hex digit corresponding to four
binary digits.

Binary Conversion Steps

BINARY TO DECIMAL CONVERSION
--------------------------------------------------------------------------
To convert a binary number to decimal:
1.Write down the binary number.
2.Assign positional values, starting from 0 on the right.
3.Multiply each binary number by 2 to the power of its position.
4.Sum the results
e.g.
convert 1011 binary to decimal:
1 x 2^3+0x2^2+1x2^1+1x2^0
= 8+0+2+1
=11 (decimal)

e.g. Convert 10110110 (binary) to decimal

272^727= 128(1)| 262^626= 64(0)| 252^525= 32(1)| 242^424= 16(1)| 232^323= 8(0)|
222^222= 4(1)| 212^121= 2(1)| 202^020= 1(0)

128+32+16+4+2= 182

DECIMAL TO BINARY CONVERSION

--------------------------------------------------------------------------
To convert a decimal number to binary:
1.Divide the decimal number by 2.
2.Write down the remainder.
3.Repeat the process with the quotient until you reach 0.
4.Read the remainders in reverse

Cache memory is a smaller, faster memory component that stores frequently accessed
data and instructions, acting as a buffer between the CPU and the main memory (RAM)

This improves system performance by reducing the time it takes for the CPU to
access needed information, as it can retrieve data from the cache instead of the
slower RAM.

declarative languages are logic based rather than flow of control (what to do
instead of how to do it.) imperative are logic based and flow of control
focused(how instead of what)
START

DEFINE structure MenuItem:

- customername (string)
- meals (char), drink (char)
- price (float), c_total (float)
- quantity (int)
- choice, c, order (int)
- small, medium, large (int)

INITIALIZE global variables:

- arr[50], n, c, quantity, order (integers)
- orderCount = 0
- file (file pointer)

FUNCTION main:
OPEN "menu.txt" in write mode
IF file fails to open:
DISPLAY "Could not open file"
EXIT with error

DO
CLEAR the screen
DISPLAY menu options:
1. Add an order
2. View order
3. Search for an order
4. Delete Orders
5. Exit
READ user's choice

SWITCH based on choice:

CASE 1:
CALL addOrder()
CASE 2:
CALL viewOrder()
CASE 3:
CALL searchOrders()
CASE 4:
CALL deleteOrders()
CASE 5:
CALL exitProgram()
DEFAULT:
DISPLAY "Invalid choice"
 PAUSE for user input
WHILE choice is not 6

RETURN from main

FUNCTION addOrder:
DECLARE variables for meal and drink choices, quantities, prices, and totals
OPEN "menu.txt" in append mode
PROMPT for and READ customer name
PROMPT for meal choice and quantity
PROMPT for drink choice and quantity

SET mealPrice based on meal choice

SET drinkPrice based on drink choice

COMPUTE total cost as (mealPrice * mealQuantity + drinkPrice * drinkQuantity)

ADD to cumulative total

WRITE order details to "menu.txt"

DISPLAY confirmation and total cost
CLOSE file

FUNCTION viewOrder:
OPEN "menu.txt" in read mode
IF file not found:
DISPLAY "No orders found"
RETURN

DISPLAY table headers for order summary

WHILE not end of file:

READ order details
DISPLAY order in tabular format

IF no orders read:
DISPLAY "No orders found"

CLOSE file

FUNCTION searchOrders:
PROMPT for customer name to search
OPEN "menu.txt" in read mode
IF file not found:
DISPLAY "No orders found"
RETURN

SET found = false

WHILE not end of file:
READ order details
IF customer name matches:
DISPLAY the order
SET found = true
BREAK loop

IF not found:
DISPLAY "No order found for [name]"

CLOSE file
FUNCTION deleteOrders:
CLEAR screen
PROMPT for customer's name (as order number) to delete
OPEN "menu.txt" in read mode
OPEN "order.txt" in write mode (temp file)

IF order index is invalid:

DISPLAY "Invalid option"
ELSE
DISPLAY "Order was successfully deleted"
REMOVE selected order from arr

DISPLAY summary stats (e.g., totals for meal types and drinks)
CLOSE files

FUNCTION exitProgram:
DISPLAY exit message
TERMINATE program

END