Programming Languages Unit 1 Notes – AKTU B.Tech 1st Year

Programming Languages Unit 1 Notes introduce the foundations of C programming: program structure, compilation, data types, variables, constants, operators, formatted input/output and type conversion.

These ACS101 notes for AKTU B.Tech 1st Year, Semester I follow the supplied Programming Basics (C) unit, which lists CSE, EE, ECE, CE, ME, BT, CH, TX and AG streams. Worked programs, diagrams, dry runs and revision questions explain how a formula becomes an executable C program.

Topics Covered

1.1 C as a Problem-Solving Language

A program describes operations that a computer can carry out. C is a general-purpose, statically typed language: declared objects have types, and those types affect how expressions behave.

C is used in embedded controllers, microcontrollers and operating-system software. The examples in this unit use a hosted environment, where execution begins through main. Device-specific embedded startup can differ.

Input, Processing and Output

• Input: Values supplied to a calculation.
• Processing: Operations performed on those values.
• Output: The result displayed or otherwise produced.

For adding 12 and 8:

Input: 12, 8 → Processing: 12 + 8 → Output: 20

Algorithm Before Code

1. Step 1: Identify the required result and its units.
2. Step 2: List the inputs and select suitable types.
3. Step 3: Write the calculation with clear grouping.
4. Step 4: Display the answer and test a known case.

If lengths are in metres, an area result must be labelled in square metres. A correct numerical value with the wrong unit is an incorrect engineering result.

1.2 Structure of a C Program

#include <stdio.h>

int main(void) { printf(“Hello, NotesGallery!\n”); return 0; }

The header does not itself print anything. void in this parameter list means that the function takes no parameters.

Do not place a semicolon after the include directive or the main function header.

First Execution

1. The host calls main.
2. printf writes the greeting and a newline.
3. return 0 completes the function successfully.

The printed message and return status are different results.

Complete Addition Program

#include <stdio.h>

int main(void) { int first = 12; int second = 8; int sum = first + second;

printf(&quot;Sum = %d\n&quot;, sum); return 0;

}

Output: Sum = 20

The addition initializes sum; printf displays its current value. A later assignment cannot change output already produced.

Layout Checks

• Match every opening brace with a closing brace.
• End declarations and statements correctly.
• Spell names consistently, including capitalization.
• Match opening and closing string quotes.
• Use indentation to make the block readable.

1.3 From Source File to Execution

A source file contains text. A toolchain translates it into executable instructions.

Source → Preprocessing → Compilation → Assembly → Linking → Execution

An object file is not normally a standalone program. A compiler driver can coordinate the stages in one command.

Compile and Run: Step by Step

Step 1: Save the source as hello.c, not hello.c.txt.

Step 2: Open a terminal in its folder.

Step 3: Build with diagnostics enabled:

gcc -std=c17 -Wall -Wextra -pedantic hello.c -o hello

Step 4: Fix the earliest relevant diagnostic and rebuild.

Step 5: Run on a POSIX-style terminal:

./hello

With a suitable Windows C toolchain, name the output hello.exe and run .\hello.exe in PowerShell.

Editor, Compiler and IDE

• An editor changes source text.
• A compiler translates source text.
• An IDE can provide an editor and invoke a toolchain.

Error Categories

For a = 7 and b = 8, a + b / 2.0 gives 11.0. The intended mean is (a + b) / 2.0, giving 7.5.

After a failed build, an older executable may remain. Run only after confirming that the current build succeeded.

1.4 Tokens and Naming Rules

A token is a basic lexical element of a program, such as a keyword, identifier, constant, string literal or punctuator.

Identifier Rules

• Use letters, digits and underscores; starting with a letter is a safe beginner convention.
• Do not begin with a digit.
• Do not include spaces or use a keyword.
• C is case-sensitive: total and Total differ.
• Avoid reserved names and leading underscores.

Comments

// Inputs are lengths in metres.

/* A comment can span more than one line. */

Comments should explain purpose, assumptions or units. Block comments do not nest.

Escape Sequences

Literals and Quotes

An ordinary character constant such as ‘A’ has type int in C. It can initialize a suitable char object. A string literal is a different construct.

Write 1000, not 1,000, for the C17 numeric examples here.

printf(“Quote: \”C\”\n”); printf(“Path: C:\\notes\n”); printf(“Rate: 5%%\n”);

These print a quoted C, a path containing one backslash, and a literal percent sign.

1.5 Data Types and Representation

A data type determines representation and permitted operations. Select it according to the quantity and required range.

Integer modifiers include short, long, long long, signed and unsigned. Plain char may be signed or unsigned depending on the implementation.

Size, Range and Precision

• Size: Storage measured in C bytes.
• Range: Representable values.
• Precision: Detail retained in the representation.

sizeof(char) is always 1. A C byte contains at least eight bits. Do not state a fixed int or long size as a universal rule.

#include <stdio.h> #include <limits.h>

int main(void) { printf(“int bytes: %zu\n”, sizeof(int)); printf(“double bytes: %zu\n”, sizeof(double)); printf(“Bits per byte: %d\n”, CHAR_BIT); printf(“int range: %d to %d\n”, INT_MIN, INT_MAX); return 0; }

sizeof produces size_t, printed here with %zu.

Floating-Point Precision

Ordinary binary floating-point cannot represent every decimal fraction exactly. Printing more decimal places does not increase stored precision or measurement accuracy.

double provides at least the precision of float. It is a useful starting choice for the introductory measurement calculations here.

Boolean Values

In conditions, zero is false and nonzero is true. Relational and logical operators produce int results of 0 or 1. C17 provides bool, true and false through <stdbool.h>.

The character ‘7’ is a character code; it is not the numeric value 7. Unsigned types are not an automatic solution for invalid negative input.

1.6 Variables, Constants and Storage

A variable is a named storage object. A declaration introduces its name and type; initialization supplies its first value.

int count; // Declaration int batch = 12; // Initialization count = 9; // Assignment

An uninitialized automatic local variable has an indeterminate value. Do not read it before successful assignment or input.

int count = 5; count = count + 4; // count becomes 9

The right-hand expression reads the old value, computes the result and stores it on the left.

Copying Does Not Create a Permanent Link

int first = 10; int copy = first; first = 20;

Now first is 20, while copy remains 10.

Constants and const

A macro is not a typed variable. A const object has a declared type.

Swap Two Variables

int a = 12, b = 8; int temp = a; a = b; b = temp;

Using only a = b; b = a; gives both variables the value 8; it does not swap them.

1.7 Arithmetic Operators

Integer Division and Remainder

When both operands are integers, division truncates toward zero.

For nonzero divisor and representable quotient:

a = (a / b) × b + a % b

% requires integer operands. Avoid zero divisors. Signed integer overflow has undefined behaviour; unsigned arithmetic is modular.

Worked Calculations

Changing the destination type does not repair an earlier integer division or overflowing multiplication. Check units, operand types and permitted input range before calculating.

1.8 Relational and Logical Operators

Relational and equality operators compare values and produce 1 for true or 0 for false.

Logical Operators

• Logical AND: True when both operands are nonzero.
• Logical OR: True when at least one operand is nonzero.
• Logical NOT: True when its operand is zero.

Their C symbols are &&, || and ! respectively.

!0 gives 1; !7 gives 0. 5 && 2 gives 1, not 2 or 5.

Short-Circuit Evaluation

For A && B, B is evaluated only if A is nonzero. For A || B, B is evaluated only if A is zero.

int d = 0; int ok = (d != 0) && (10 / d > 1);

Here ok is 0, and the division is skipped.

Range Tests

int inside = (x >= 10) && (x <= 20); int outside = (x < 10) || (x > 20);

Do not write 10 <= x <= 20. C evaluates the comparisons in stages rather than as a mathematical chained inequality.

Negation and Similar Symbols

• !(A && B) means not both.
• !A && !B means neither.
• !(A && B) is equivalent to !A || !B for ordinary truth conditions without side effects.
• !(A || B) is equivalent to !A && !B under the same assumption.

Logical && and || differ from bitwise & and |. Bitwise operators act on integer bits and do not provide logical short-circuiting.

1.9 Expressions and Evaluation

An expression combines operands and operators to produce a value or effect. Examples include length * width, a + b and x >= 10.

Selected Precedence Order

Precedence controls grouping, not the general order in which operands are evaluated. Avoid multiple unsequenced modifications of the same variable.

Assignment and Equality

• x = 5; stores 5 in x.
• x == 5 compares x with 5 without changing x.

Compact Updates

int n = 10; n += 3; // 13 n *= 2; // 26 n -= 6; // 20

Write multiplication explicitly: 2 * r, not 2r. Use (a + b + c) / 3.0 for a fractional mean and 2.0 * (length + width) for perimeter.

1.10 Formatted Output with printf

printf writes formatted output. Its format string contains ordinary text, escapes and conversion specifications.

printf(“Count = %d\n”, count);

A float argument is promoted to double in this call. A format string does not convert an arbitrary mismatched argument into the required type.

Width, Precision and Notation

int n = 7; double x = 2.5;

printf(“[%4d]\n”, n); printf(“[%-4d]\n”, n); printf(“%.3f\n”, x); printf(“Progress: 90%%\n”);

[ 7] [7 ] 2.500 Progress: 90%

Width is a minimum, not a truncation limit. Formatting changes display, not the stored value.

Readable Engineering Report

double voltage = 12.5; double current = 0.8; double power = voltage * current;

printf(“%-10s %8s\n”, “Quantity”, “Value”); printf(“%-10s %8.2f V\n”, “Voltage”, voltage); printf(“%-10s %8.2f A\n”, “Current”, current); printf(“%-10s %8.2f W\n”, “Power”, power);

For this DC example, power is 10.00 W. Match every conversion to its argument and retain correct unit labels. %% consumes no value argument.

1.11 Formatted Input with scanf

scanf reads formatted input and stores converted values into destination objects. Basic scalar destinations normally require addresses.

int age = 0; scanf(“%d”, &age);

For input, %f requires float pointer and %lf requires double pointer. Adding & does not repair a conversion-type mismatch.

Return Value

scanf returns the number of assignments successfully performed. It can return EOF if input failure occurs before the first conversion.

int a = 0, b = 0; int matched = scanf(“%d %d”, &a, &b); printf(“Read: %d\n”, matched); printf(“Values: %d %d\n”, a, b);

A calculation should proceed only after confirming the required conversions. Full conditional input handling follows in Unit 2; the basic worked programs here assume valid, in-range input.

Whitespace and Character Input

int roll = 0; char grade = ‘?’;

scanf(“%d”, &roll); scanf(” %c”, &grade);

Numeric conversions such as %d skip leading whitespace. %c does not. Avoid unnecessary trailing whitespace such as scanf(“%d\n”, &n), which may wait for later non-whitespace input interactively.

printf and scanf Comparison

1.12 Type Conversion and Casts

Implicit conversion occurs automatically where required by an operation or assignment. An explicit cast requests a conversion in an expression.

int n = 5; double x = n; // 5.0 double y = n + 0.5; // 5.5

For these simple integer–double examples, the integer is converted for floating arithmetic.

Cast Before Division

int a = 7, b = 2; double wrong = a / b; double correct = (double)a / b;

wrong receives 3.0; correct receives 3.5. A double destination cannot undo fractional information already lost.

Integer Conversion and Promotions

• A representable finite floating value converted to integer loses its fractional part toward zero.
• This is truncation, not rounding to the nearest integer.
• A cast creates a converted value; it does not alter its operand.
• Small integer types undergo integer promotion before many operations.
• Loss of range or precision must be considered; an unrepresentable floating-to-integer conversion has undefined behaviour.

Mean and Percentage

int a = 70, b = 71, c = 75; int sum = a + b + c; double mean = (double)sum / 3;

The mean is 72.00. Also test 70, 71 and 74: the expected display is 71.67. A fractional test exposes integer-division mistakes.

Ensure the integer sum fits its type. An early conversion such as ((double)a + b + c) / 3.0 performs the additions in double.

int completed = 7, total = 8; double percentage = completed * 100.0 / total;

The result is 87.50%, assuming total is positive. (completed / total) * 100 would lose the fraction at the first division.

1.13 Worked Calculation Programs

The following input programs assume successful numeric conversions and inputs within appropriate ranges.

Program 1: Add Two Integers

#include <stdio.h>

int main(void) { int a = 0, b = 0; scanf(“%d %d”, &a, &b); printf(“Sum = %d\n”, a + b); return 0; }

Input: 12 8

Output: Sum = 20

Inputs and their sum must fit int.

Program 2: Rectangle Area and Perimeter

Area = length × width

Perimeter = 2 × (length + width)

#include <stdio.h>

int main(void) { double length = 0.0, width = 0.0; scanf(“%lf %lf”, &length, &width);

double area = length * width; double perimeter = 2.0 * (length + width); printf(&quot;Area = %.2f m^2\n&quot;, area); printf(&quot;Perimeter = %.2f m\n&quot;, perimeter); return 0;

}

Input: 4.5 2

Output: Area = 9.00 m²; perimeter = 13.00 m.

Also test 1.2 m and 0.5 m: expected area is 0.60 m².

Program 3: Celsius to Fahrenheit

F = C × (9.0 / 5.0) + 32.0

#include <stdio.h>

int main(void) { double celsius = 0.0; scanf(“%lf”, &celsius);

double fahrenheit = celsius * (9.0 / 5.0) + 32.0; printf(&quot;%.2f F\n&quot;, fahrenheit); return 0;

}

The grouped expression 9 / 5 would produce integer 1. Floating operands preserve 1.8.

Program 4: Simple Interest Expression

Interest = Principal × Annual rate × Time / 100

double principal = 1000.0; double rate = 5.0; double years = 2.0; double interest = principal * rate * years / 100.0;

The result is 100 currency units, with rate expressed as annual percent and time in years.

1.14 Debugging and Dry Runs

A dry run manually follows executed statements and records values. Debugging identifies the cause of incorrect translation or behaviour.

Trace a Complete Program

#include <stdio.h>

int main(void) { int a = 8, b = 3; int total = a + b * 2; double mean = (double)(a + b) / 2; int ok = (a > b) && (b != 0);

printf(&quot;%d %.1f %d\n&quot;, total, mean, ok); return 0;

}

Output: 14 5.5 1

Common Mistakes

Predict the Result

Read warnings about formats, conversions and uninitialized values. Successful compilation alone does not prove the intended formula is correct.

1.15 Quick Revision and Examination Practice

Essential Rules

• Use int main(void) for these hosted examples.
• Include <stdio.h> for standard I/O declarations.
• Initialize local variables before reading their values.
• Integer division truncates toward zero.
• Remainder requires integer operands and a nonzero divisor.
• Zero is false; nonzero is true.
• Relational and logical results are 0 or 1.
• = assigns; == compares.
• scanf needs matching destination types and addresses.
• Floating input uses %f for float and %lf for double.
• Floating output with %f receives double, including promoted float.
• Cast an operand before division to retain a fractional result.
• Precedence determines grouping, not general operand evaluation order.
• Test fractional values and boundary cases.

Short-Answer Questions

1. Define token, identifier, variable and constant with examples.
2. Explain the roles of main, stdio.h and return 0.
3. Distinguish initialization from assignment.
4. Why can the size of int vary?
5. Compare 7 / 2 with 7 / 2.0.
6. Why does scalar scanf input need an address?
7. Define short-circuit evaluation.
8. Why does a double destination not repair integer division?
9. Distinguish a character constant from a string literal.
10. Distinguish output precision from stored precision.

Long-Answer Questions

1. Explain C program structure with a labelled example and translation stages.
2. Compare arithmetic, relational and logical operators with evaluated examples.
3. Explain formatted input/output and matching conversion specifications.
4. Explain implicit and explicit conversions, including integer-division errors.
5. Explain variables, constants, assignment and swapping through a trace table.

Programming Practice

Frequently Asked Questions

What does Programming Languages Unit 1 cover?

It covers C program structure, compilation, tokens, data types, variables, constants, operators, expressions, printf, scanf, conversions and basic calculation programs.

Why does 5 / 2 produce 2?

Both operands are integers, so division truncates toward zero. Use 5.0 / 2 or cast an operand to obtain 2.5.

What is the difference between printf and scanf?

printf formats values for output. scanf reads input and stores converted values into destinations whose addresses are supplied.

Which specifier reads a double?

Use %lf with the address of a double in scanf. For printf, use a suitable floating conversion such as %f or %.2f.

Does compiling successfully mean a program is correct?

No. A valid program can use the wrong formula. Compare actual output with known expected results and inspect warnings.

How should these notes be revised?

Learn the rule, trace the types and values, compile a small example and test whole-number, fractional and boundary cases. Unit 2 builds on these foundations with control flow and functions.

Related B.Tech First Semester Study Materials

CSE 1st Year All Subject PYQs → CSE 1st Year All Subject Notes → CSE 1st Year All Subject Syllabus →