Home > Posts > Beginner's Guide to Pascal

Beginner's Guide to Pascal

January 15, 2025 · 24 min read

Introduction to Pascal #

What is Pascal? #

Pascal is a general-purpose, imperative programming language originally developed by Niklaus Wirth in the early 1970s. It’s known for its structured programming approach, emphasizing code readability and maintainability. This structured nature makes it an excellent language for learning fundamental programming concepts such as variables, data types, control structures (loops and conditionals), procedures, and functions. While not as widely used in industry as languages like Java or Python, its clear syntax and emphasis on good programming practices make it a valuable tool for beginners to grasp the core principles of programming before moving on to more complex languages. Many of the concepts you learn in Pascal will directly translate to other programming languages.

Why Learn Pascal? #

Learning Pascal offers several advantages for aspiring programmers:

Structured Programming Fundamentals: Pascal enforces a structured programming style, forcing you to organize your code logically, which is crucial for writing clean, understandable, and maintainable programs. This contrasts with less structured languages where code can become disorganized and difficult to debug.
Strong Typing: Pascal’s strong typing system helps catch errors during compilation, preventing runtime surprises. This early error detection is invaluable for learning good programming habits.
Readability: Pascal’s syntax is designed to be clear and easy to read, making it a great language for understanding how code works. This readability facilitates both learning and collaboration.
Solid Foundation: The concepts learned in Pascal—variables, data types, control flow, procedures, functions, and data structures—are fundamental to almost all programming languages. Mastering Pascal provides a solid foundation for learning more advanced languages later.

Setting up your Pascal Environment #

To start programming in Pascal, you’ll need a Pascal compiler and an editor (or IDE). There are several options available, both free and commercial. Popular choices include:

Free Pascal (FPC): A powerful, open-source, and cross-platform Pascal compiler. It’s a good choice for beginners due to its availability and extensive documentation. You can typically download it from the Free Pascal website and follow the installation instructions for your operating system.
Turbo Pascal (older, but still functional): While dated, Turbo Pascal is still used by some for its simplicity and nostalgic value. However, it’s not actively developed and lacks modern features.
Integrated Development Environments (IDEs): Several IDEs provide integrated support for Pascal, offering features such as syntax highlighting, code completion, and debugging tools. These can significantly enhance your programming experience. Lazarus is an example of an IDE that works well with Free Pascal.

Once you have your compiler installed, you might need to configure your system’s PATH environment variable (depending on your operating system) to allow you to run the compiler from your command line or terminal. Consult your compiler’s documentation for specific instructions.

First Pascal Program: Hello, World! #

The traditional introductory program in any language is the “Hello, World!” program. Here’s how to write it in Pascal:

program HelloWorld;
begin
  writeln('Hello, World!');
end.

This program consists of:

program HelloWorld;: This line declares the program’s name.
begin: Marks the beginning of the program’s executable code.
writeln('Hello, World!');: This line prints the text “Hello, World!” to the console. writeln is a built-in procedure that adds a newline character after printing the text.
end. : Marks the end of the program. The period is crucial.

To compile and run this program:

Save the code in a file named HelloWorld.pas (or a similar name with the .pas extension).
Open your command line or terminal.
Navigate to the directory where you saved the file.
Use your Pascal compiler’s command-line interface to compile the code (e.g., fpc HelloWorld.pas for Free Pascal). This will generate an executable file.
Run the executable file. You should see “Hello, World!” printed on your console.

Basic Syntax and Data Types #

Program Structure #

A Pascal program has a specific structure. The basic elements are:

Program Header: This line begins with the keyword program followed by the program’s name and a semicolon (;). The program name should be descriptive and follow the rules for identifiers (letters, numbers, and underscores, starting with a letter). Example: program MyFirstProgram;
Declaration Section: This section declares variables, constants, procedures, and functions that will be used in the program. Declarations must appear before the main program body.
Main Program Body: This section, enclosed between begin and end., contains the executable statements that perform the program’s tasks. The end statement is followed by a period (.).
Comments: Pascal uses curly braces {} or the sequence (* ... *) to enclose comments, which are ignored by the compiler but help to explain the code.

A simple example illustrating the structure:

program SimpleExample;
var
  number : integer;  // Variable declaration
begin
  number := 10;     // Assignment statement
  writeln(number);   // Output statement
end.

Variables and Constants #

Variables: Variables are named storage locations that hold data values. They must be declared before use, specifying their data type. The declaration assigns a name and a type to the variable. Example: var count : integer;
Constants: Constants are values that remain unchanged throughout the program’s execution. They are declared using the const keyword. This improves code readability and maintainability. Example: const pi = 3.14159;

Data Types (Integer, Real, Boolean, Char) #

Pascal supports several fundamental data types:

Integer: Represents whole numbers (e.g., -2, 0, 10, 1000).
Real: Represents numbers with fractional parts (e.g., 3.14, -2.5, 0.0). There are different precision options available depending on your Pascal compiler.
Boolean: Represents truth values; either true or false.
Char: Represents a single character enclosed in single quotes (e.g., ‘A’, ‘b’, ‘5’, ‘$’).

Example declarations:

var
  age : integer;
  price : real;
  isAdult : boolean;
  initial : char;

Operators and Expressions #

Pascal uses standard arithmetic operators (+, -, *, /, div, mod), comparison operators (=, <>, <, >, <=, >=), logical operators (and, or, not), and assignment operator (:=).

div: Integer division (returns the quotient).
mod: Modulo operator (returns the remainder of integer division).

Example expressions:

x + y
x * 2.5
(a > b) and (c < d)
i := i + 1  // Increment i

Input and Output (Readln, Writeln) #

Writeln: This procedure displays output to the console. You can include variables or expressions within the parentheses, separated by commas. It adds a newline character at the end. Example: writeln('The value of x is: ', x);
Readln: This procedure reads input from the console. It typically reads data into variables. The variables to receive input are listed within the parentheses, separated by commas. Example: readln(name, age);

Example showing both:

program InputOutput;
var
  name : string;
  age : integer;
begin
  writeln('Enter your name:');
  readln(name);
  writeln('Enter your age:');
  readln(age);
  writeln('Hello, ', name, '! You are ', age, ' years old.');
end.

Remember that string is a data type for text; it may require including a unit (like SysUtils) depending on your Pascal implementation. Consult your compiler’s documentation for details.

Control Structures #

Conditional Statements (if-then-else) #

Conditional statements allow you to execute different blocks of code based on whether a condition is true or false. Pascal uses the if-then-else structure.

if statement: The simplest form checks a condition. If the condition is true, the code within the then block is executed.

if condition then
  statement;

if-then-else statement: This form executes one block of code if the condition is true and another if it’s false.

if condition then
  statement1
else
  statement2;

if-then-elseif-else statement: You can chain multiple else if conditions to check for several possibilities.

if condition1 then
  statement1
else if condition2 then
  statement2
else
  statement3;

Example:

program CheckAge;
var
  age : integer;
begin
  writeln('Enter your age:');
  readln(age);
  if age < 18 then
    writeln('You are a minor.')
  else
    writeln('You are an adult.');
end.

Looping Statements (for, while, repeat-until) #

Loops allow you to repeatedly execute a block of code. Pascal offers several looping constructs:

for loop: This loop iterates a specific number of times. It’s used when you know in advance how many iterations are needed.

for counter := startValue to endValue do
  statement;  // or downto for decreasing counter

Example:

for i := 1 to 10 do
  writeln(i);

while loop: This loop continues as long as a specified condition is true. The condition is checked before each iteration. If the condition is false initially, the loop body won’t execute at all.

while condition do
  statement;

Example:

var count : integer;
begin
  count := 0;
  while count < 5 do
  begin
    writeln(count);
    count := count + 1;
  end;
end.

repeat-until loop: This loop executes the block of code at least once. The condition is checked after each iteration. The loop continues until the condition becomes true.

repeat
  statement;
until condition;

Example:

var count : integer;
begin
  count := 0;
  repeat
    writeln(count);
    count := count + 1;
  until count = 5;
end.

Nested Loops and Conditional Statements #

You can nest loops and conditional statements within each other to create more complex control flows. This allows you to handle situations requiring multiple levels of iteration or decision-making.

Example of nested loops:

for i := 1 to 3 do
begin
  for j := 1 to 2 do
    writeln('i = ', i, ', j = ', j);
end;

Example of a conditional statement within a loop:

for i := 1 to 10 do
begin
  if i mod 2 = 0 then
    writeln(i, ' is even.')
  else
    writeln(i, ' is odd.');
end;

Nested structures can become complex quickly; clear indentation and comments are crucial for readability and maintainability.

Arrays and Strings #

Declaring and Initializing Arrays #

Arrays are used to store collections of elements of the same data type. In Pascal, you declare an array by specifying its name, type, and size (number of elements).

Declaration:

var
  myArray : array[1..10] of integer; // An array of 10 integers, indexed from 1 to 10
  anotherArray : array[0..9] of real; // An array of 10 reals, indexed from 0 to 9
  booleanArray : array[1..5] of boolean; //An array of 5 booleans

The index range (e.g., 1..10 or 0..9) defines the valid indices for accessing array elements.

Initialization:

You can initialize arrays directly during declaration (limited support in some compilers) or in the program body using assignment statements:

var
  numbers : array[1..5] of integer = (10, 20, 30, 40, 50); //Direct initialization (compiler dependent)

  myLetters : array[1..4] of char;
begin
  myLetters[1] := 'A';
  myLetters[2] := 'B';
  myLetters[3] := 'C';
  myLetters[4] := 'D';
end.

Accessing Array Elements #

Array elements are accessed using their index within square brackets []. Remember that indices start from the lower bound defined during declaration. Attempting to access an element outside the defined index range will lead to a runtime error.

var
  scores : array[1..5] of integer;
begin
  scores[1] := 85;
  scores[3] := 92;
  writeln(scores[1]); // Accesses the first element (85)
  writeln(scores[3]); // Accesses the third element (92)
end.

String Manipulation #

In Pascal, strings are treated as arrays of characters. Standard string manipulation often involves working with individual characters within the string. However, many Pascal implementations offer built-in functions and procedures that simplify string operations.

Basic operations:

You can access individual characters within a string using indexing similar to arrays:

var
  myString : string;
begin
  myString := 'Hello';
  writeln(myString[1]); // Outputs 'H'
  writeln(myString[5]); // Outputs 'o'
end.

Concatenation:

To combine strings you can use the + operator:

var
  str1, str2, combined : string;
begin
  str1 := 'Good';
  str2 := ' Morning';
  combined := str1 + str2;
  writeln(combined); // Outputs 'Good Morning'
end.

Working with String Functions #

Many Pascal compilers provide string functions to simplify common tasks. These functions might vary slightly depending on your Pascal implementation; consult the documentation for your specific compiler. Some common string functions include:

Length(str): Returns the length of a string.
Concat(str1, str2, ...): Concatenates multiple strings. (Often equivalent to using the + operator)
Copy(str, index, count): Extracts a substring.
Pos(substring, str): Finds the starting position of a substring within a string.
Delete(str, index, count): Removes a substring.
Insert(substring, str, index): Inserts a substring into a string.

Example using Length and Pos:

var
  myText : string;
  position : integer;
begin
  myText := 'This is a sample string.';
  writeln('Length of the string: ', Length(myText));
  position := Pos('sample', myText);
  writeln('Position of "sample": ', position); //Output will be 11 (assuming 1-based indexing)
end.

Note: The availability and exact names of these functions might differ slightly depending on your Pascal compiler (Turbo Pascal, Free Pascal, etc.). Refer to your compiler’s documentation for precise details.

Functions and Procedures #

Defining Functions and Procedures #

Functions and procedures are fundamental building blocks of structured programming. They help organize code into reusable modules, improving readability and maintainability.

Procedures: Procedures are blocks of code that perform a specific task. They don’t return a value.
Functions: Functions are similar to procedures but they return a single value.

Syntax:

procedure MyProcedure(parameters);
var
  localVariables;
begin
  // Procedure body
end;

function MyFunction(parameters) : returnType;
var
  localVariables;
begin
  // Function body
  MyFunction := returnValue; // Assign the return value
end;

Example:

procedure Greet(name : string);
begin
  writeln('Hello, ', name, '!');
end;

function Add(x, y : integer) : integer;
begin
  Add := x + y;
end;

program UsingProceduresAndFunctions;
var
  sum : integer;
begin
  Greet('Alice');
  sum := Add(5, 3);
  writeln('Sum: ', sum);
end.

Parameters and Arguments #

Parameters are variables listed in the procedure or function declaration. Arguments are the actual values passed to the procedure or function when it’s called.

Value Parameters: A copy of the argument’s value is passed to the parameter. Changes made to the parameter within the procedure/function do not affect the original argument.
Var Parameters: The parameter acts as an alias for the argument. Changes made to the parameter do affect the original argument. Use var before the parameter in the declaration.

Example:

procedure ModifyValue(x : integer; var y : integer);
begin
  x := x * 2; // x is a value parameter, changes won't affect the caller's variable
  y := y + 10; // y is a var parameter, changes will affect the caller's variable
end;

program ParameterExample;
var
  a, b : integer;
begin
  a := 5;
  b := 10;
  ModifyValue(a, b);
  writeln('a = ', a, ', b = ', b); // a will be 5, b will be 20
end.

Return Values #

Functions return a single value using an assignment statement within their body. The data type of the return value is specified in the function declaration (e.g., : integer, : real, : boolean, : string). Procedures do not return values.

Procedural Programming Concepts #

Procedural programming emphasizes breaking down a program into procedures and functions. This modular approach promotes code reusability, improves readability, and simplifies debugging. Data is often passed between procedures and functions via parameters.

Scope and Lifetime of Variables #

Scope: The scope of a variable determines which parts of the program can access it.
- Local Variables: Declared within a procedure or function. They are only accessible within that procedure or function.
- Global Variables: Declared outside any procedure or function. They are accessible from anywhere in the program after their declaration. Overuse of global variables can make code harder to understand and maintain.
Lifetime: The lifetime of a variable is the period during which it exists in memory.
- Local Variables: Created when the procedure or function is called and destroyed when it finishes execution.
- Global Variables: Created when the program starts and destroyed when the program ends.

Using local variables whenever possible promotes better code structure and reduces the risk of unintended side effects.

Records and Sets #

Defining Records #

Records are composite data types that group together data elements of different types under a single name. They are useful for representing complex data structures.

Syntax:

type
  PersonRecord = record
    firstName : string;
    lastName : string;
    age : integer;
    isMarried : boolean;
  end;

var
  person1 : PersonRecord;

This defines a record type PersonRecord with fields for first name, last name, age, and marital status. A variable person1 of this record type is then declared.

Accessing Record Fields #

Individual fields within a record are accessed using the dot operator (.).

person1.firstName := 'Alice';
person1.lastName := 'Smith';
person1.age := 30;
person1.isMarried := true;

writeln(person1.firstName, ' ', person1.lastName, ' is ', person1.age, ' years old.');

Set Operations #

Sets are unordered collections of distinct elements of the same type. Pascal supports several set operations:

Set Union (+): Combines two sets, including all elements from both.
Set Intersection (*): Returns the elements common to both sets.
Set Difference (-): Returns the elements in the first set but not in the second.
Set Inclusion (in): Checks if an element is a member of a set.

Example:

var
  setA, setB, setC : set of 1..10; // Set of integers from 1 to 10
begin
  setA := [1, 3, 5, 7, 9];
  setB := [2, 4, 6, 8, 10];
  setC := setA + setB; // Union
  writeln('Union: ', setC);

  setC := setA * setB; // Intersection (empty set in this case)
  writeln('Intersection: ', setC);

  setC := setA - [3,5]; //Difference
  writeln('Difference: ', setC);

  if 5 in setA then
    writeln('5 is in setA');
end.

Using Records and Sets in Programs #

Records and sets are powerful tools for structuring data. Records are suitable when you need to group related data items of different types, while sets are useful for representing collections of unique elements and performing set operations efficiently. They often enhance the organization and efficiency of your programs.

Example combining records and sets:

type
  StudentRecord = record
    name : string;
    courses : set of 1..5; // Assuming 5 courses maximum
  end;

var
  student1 : StudentRecord;
begin
  student1.name := 'Bob';
  student1.courses := [1, 3, 5]; // Taking courses 1,3, and 5

  if 2 in student1.courses then
    writeln(student1.name, ' is taking course 2.')
  else
    writeln(student1.name, ' is not taking course 2.');
end.

Remember to adapt the range of the set (e.g., 1..5) to fit the specific number of courses or elements in your application.

Files #

Working with Files #

Files provide a way to store and retrieve data persistently, beyond the lifetime of a program. In Pascal, you work with files using file variables and procedures. Before you can use a file, you must declare a file variable and then associate it with an actual file on the disk using the assign procedure. After using the file, it’s important to close it using the close procedure to ensure data is properly written and resources are released.

Basic File Operations:

Declaration: Declare a file variable of the appropriate type (e.g., TextFile for text files).
Assignment: Associate the file variable with a filename using the assign procedure.
Opening: Open the file for reading (reset) or writing (rewrite).
Processing: Read from or write to the file using appropriate procedures (e.g., readln, writeln for text files).
Closing: Close the file using the close procedure.

File Input and Output #

Text Files: Text files store data as sequences of characters. They are human-readable. The standard procedures for reading and writing text files are read, readln, write, and writeln.

var
  myFile : text;
  line : string;
begin
  assign(myFile, 'myfile.txt');
  rewrite(myFile); // Open for writing
  writeln(myFile, 'This is the first line.');
  writeln(myFile, 'This is the second line.');
  close(myFile);

  reset(myFile);  //Open for reading
  while not eof(myFile) do
  begin
    readln(myFile, line);
    writeln(line);
  end;
  close(myFile);
end.

Binary Files: Binary files store data in a format that is not directly human-readable. They are typically more efficient for storing large amounts of numerical or structured data. You’ll use different procedures for working with binary files, and the data must be written and read in a structured way appropriate to its format. Example procedures are blockread and blockwrite for transferring data in blocks. The exact methods will depend on your Pascal compiler and how the data is structured.

Text Files and Binary Files #

Text Files:

Advantages: Human-readable, easy to create and inspect using simple text editors.
Disadvantages: Less efficient for storing numerical data (because numbers are represented as strings), can be larger than binary files for the same data.

Binary Files:

Advantages: More compact and efficient for storing numerical and structured data. Faster for I/O operations with large datasets.
Disadvantages: Not human-readable; require specific code to read and write the data.

The choice between text and binary files depends on the nature of your data and the priorities of your application (human readability vs. storage efficiency and processing speed). For simple data or where human readability is important, text files are often sufficient. For large datasets or complex data structures, binary files are generally more appropriate. Remember to handle potential errors (like the file not existing or permission issues) using error handling mechanisms provided by your Pascal environment.

Pointers #

Understanding Pointers #

A pointer is a variable that holds the memory address of another variable. Think of it as a label that points to a specific location in your computer’s memory where data is stored. Pointers are powerful but can be tricky to use correctly, as misuse can lead to memory leaks or program crashes. They are essential for advanced programming tasks such as dynamic memory allocation and data structure manipulation (like linked lists).

Declaring and Using Pointers #

Declaration:

To declare a pointer, use the ^ symbol after the data type. The ^ indicates that the variable will hold a memory address.

var
  intPointer : ^integer;  // Pointer to an integer
  realPointer : ^real;    // Pointer to a real number
  charPointer : ^char;    // Pointer to a character

Memory Allocation and Dereferencing:

Before using a pointer, you must allocate memory for it to point to. This is usually done using dynamic memory allocation (discussed in the next section). Once memory is allocated, you can access the value stored at the memory address using the dereferencing operator (^).

var
  num : integer;
  ptr : ^integer;
begin
  new(ptr);      // Allocate memory for an integer
  num := 10;
  ptr^ := num;   // Assign the value of num to the memory location pointed to by ptr
  writeln(ptr^); // Access the value using the dereferencing operator
  dispose(ptr);   // Release the allocated memory
end.

new(ptr) allocates memory and assigns its address to ptr. ptr^ accesses the value stored at that address. dispose(ptr) releases the allocated memory. Failing to dispose allocated memory leads to memory leaks.

Dynamic Memory Allocation #

Dynamic memory allocation allows you to allocate memory during program execution, as opposed to static allocation where memory is allocated at compile time. This is crucial for situations where the amount of memory needed is not known beforehand (e.g., when working with linked lists or other dynamic data structures).

Pascal uses the new and dispose procedures for dynamic memory allocation.

new(ptr): Allocates a block of memory of the size needed for the data type pointed to by ptr and assigns the address of this block to ptr.
dispose(ptr): Releases the memory block pointed to by ptr. This is essential to prevent memory leaks. After dispose, the pointer becomes invalid and should not be dereferenced.

Example:

var
  ptr : ^integer;
  i : integer;
begin
  new(ptr);
  ptr^ := 50;
  writeln('Value: ', ptr^);
  dispose(ptr); // Free the allocated memory
  //ptr^ := 100; // This would cause an error because the memory has been freed
end.

Failure to properly manage dynamically allocated memory (using new and dispose correctly) is a common source of errors in programs that use pointers. Always ensure that memory allocated with new is eventually released with dispose when it’s no longer needed. Poor memory management can lead to memory leaks (where the program uses up more and more memory without releasing it) and eventually crashes.

Advanced Topics (Optional) #

Object-Oriented Programming in Pascal (brief overview) #

While Pascal is primarily known as a procedural language, some implementations (like Object Pascal, the basis of Delphi) support object-oriented programming (OOP) features. OOP allows you to organize code into reusable objects that encapsulate data (fields) and methods (procedures and functions) that operate on that data.

Key OOP concepts in Object Pascal (and similar extensions):

Classes: Blueprints for creating objects. They define the fields and methods.
Objects: Instances of classes.
Inheritance: Creating new classes (derived classes) based on existing classes (base classes), inheriting their fields and methods.
Polymorphism: The ability of objects of different classes to respond to the same method call in their own specific way.
Encapsulation: Bundling data and methods that operate on that data within a class, hiding internal details and protecting data integrity.

A very basic example (syntax may vary slightly based on the Pascal implementation):

type
  TAnimal = class
    private
      FName: string;
    public
      constructor Create(AName: string);
      procedure Speak;
      procedure SetName(AName: string);
      function GetName: string;
  end;

constructor TAnimal.Create(AName: string);
begin
  FName := AName;
end;

procedure TAnimal.Speak;
begin
  writeln(FName, ' makes a sound.');
end;

procedure TAnimal.SetName(AName: string);
begin
  FName := AName;
end;

function TAnimal.GetName: string;
begin
  Result := FName;
end;

var
  myDog: TAnimal;
begin
  myDog := TAnimal.Create('Rover');
  myDog.Speak; // Output: Rover makes a sound.
end.

Note: Full OOP capabilities are not part of standard Pascal; this is an extension found in dialects like Object Pascal.

Using Pascal Libraries #

Pascal libraries (units or modules) provide pre-written code for common tasks, saving you time and effort. They often contain functions and procedures for things like string manipulation, mathematical operations, file I/O, and more.

To use a library, you typically need to include a uses clause in your program. The specific syntax depends on the Pascal implementation, but it’s generally similar to:

program MyProgram;
uses MyLibrary; // Include the library

// ... rest of your program ...

The MyLibrary unit (or module) would need to be available in your Pascal compiler’s search path. Consult your compiler’s documentation for details on using libraries and locating available libraries.

Debugging and Error Handling #

Debugging is the process of finding and fixing errors in your code. Common techniques include:

Print Statements: Adding writeln statements at strategic points to display intermediate values and track the flow of execution.
Debuggers: Most Pascal IDEs (integrated development environments) provide debuggers. These allow you to step through your code line by line, inspect variable values, set breakpoints (points in the code where execution pauses), and more.
Static Analysis: Some tools can analyze your code without executing it, finding potential errors (like undeclared variables or type mismatches).

Error Handling:

Pascal provides mechanisms to handle runtime errors gracefully (errors that occur during program execution). The try-except block allows you to catch and respond to exceptions:

var
  x, y, result : integer;
begin
  try
    x := 10;
    y := 0;
    result := x div y; // This will cause a division by zero error
  except
    on EZeroDivide do
      writeln('Division by zero error!');
  end;
end.

This example catches the EZeroDivide exception. You can define other except blocks to handle different types of exceptions. Appropriate error handling prevents your program from crashing unexpectedly and allows you to recover from errors or inform the user about problems. The specific exceptions and how you handle them will vary depending on the Pascal implementation you’re using.

Practice Exercises #

These exercises are designed to help you solidify your understanding of Pascal programming. Remember to compile and run your code to check your solutions.

Beginner Exercises #

Temperature Converter: Write a program that converts temperatures between Celsius and Fahrenheit. The user should input a temperature and the unit (C or F), and the program should output the equivalent temperature in the other unit.
Simple Calculator: Create a program that performs basic arithmetic operations (addition, subtraction, multiplication, division) based on user input. Handle the case of division by zero gracefully.
Even or Odd: Write a program that asks the user for an integer and then prints whether the number is even or odd.
Grade Calculator: Develop a program that takes a numerical grade (0-100) as input and prints the corresponding letter grade (A, B, C, D, F) based on a standard grading scale.
Number Guessing Game: Create a simple number guessing game where the computer generates a random number between 1 and 100, and the user has to guess the number. The program should provide feedback (too high or too low) after each guess. (You might need to look up how to generate random numbers in your Pascal implementation).

Intermediate Exercises #

Student Average: Write a program that calculates the average grade of a student based on 5 test scores entered by the user. The program should store the scores in an array.
String Reversal: Create a program that takes a string as input and prints the reversed string.
Fibonacci Sequence: Write a program that generates and prints the first n numbers in the Fibonacci sequence (where n is provided by the user).
Prime Number Checker: Develop a program that checks if a given integer is a prime number.
File Word Counter: Write a program that reads a text file and counts the number of words in the file. (Handle potential file errors.)

Challenge Exercises #

Text Analyzer: Create a program that reads a text file, counts the occurrences of each word, and prints the most frequent words and their counts. (Ignore punctuation and capitalization).
Simple Database (using records): Design a simple database program to store information about books (title, author, ISBN, publication year). The program should allow the user to add new books, search for books by title or author, and display the book information. Use records to represent the book data.
Linked List Implementation: Implement a singly linked list data structure using pointers. The program should allow adding nodes to the beginning and end of the list, deleting nodes, and traversing the list to print the values.
Sorting Algorithm: Implement a sorting algorithm (e.g., bubble sort, insertion sort) to sort an array of integers.
Tic-Tac-Toe Game: Create a text-based Tic-Tac-Toe game where two players can take turns making moves. The program should check for a win or a draw after each move.

Remember that these are suggestions, feel free to adapt or expand upon them to create your own variations. The key is to practice consistently and challenge yourself to learn new concepts and techniques.

←

Beginner's Guide to Ballerina

Beginner's Guide to Raku

→