Okay, here's a crash preparation material for Computer Science XII based on the syllabus you

provided (Annexure-B6). This is designed to be concise and exam-focused, hitting the key
points.

Computer Science XII - Crash Preparation Material (2024-25)​

(Based on Reduced Syllabus - Annexure-B6)

Goal: To quickly revise key concepts and prepare for the Computer Science XII exam based on
the reduced syllabus. Focus on understanding the core ideas and practicing programming.

How to Use This Material:

●​ Review each section: Read through the explanations and key points for each topic.
●​ Study the examples: Understand the code examples provided. They are designed to
illustrate the concepts.
●​ Practice the questions: Attempt the MCQs and short answer/coding questions at the
end of each section. This is crucial for exam preparation.
●​ Focus on syntax: Pay close attention to the syntax of C programming as it's heavily
emphasized in the syllabus.
●​ Time Management: Allocate your time effectively to cover all topics. Prioritize topics you
find challenging.
●​ Don't skip practice! Programming is a skill best learned by doing.

Sections:

1. Introduction and History of C Language

●​ Key Points:
○​ History: Briefly know the origins of C (Bell Labs, Dennis Ritchie, based on B,
influenced by ALGOL 60). Understand its purpose (system programming initially).
○​ Importance of C: Why is C still relevant? (Foundation for many languages,
system programming, embedded systems, performance).
○​ Generations of Programming Languages (Briefly): Machine Language,
Assembly Language, High-Level Languages (C is High-Level).
●​ Example Question (MCQ):
○​ C language was developed at:​
a) Microsoft​
b) Apple​
c) Bell Laboratories (Correct)​
d) IBM

2. Basic Structure/Block Structure of C Program

●​ Key Points:
○​ Preprocessor Directives: #include <stdio.h>, #include <conio.h>. Purpose of
#include. What are header files? (e.g., stdio.h for standard input/output
functions).
○​ main() function: The entry point of every C program. int main(), void main().
Return type of main.
○​ Opening and Ending Delimiters (Braces): { and }. Block of code within braces.
○​ Source Code: Human-readable instructions written in C.
○​ Compilation & Execution (Briefly): Source code -> Compiler -> Object Code ->
Linker -> Executable -> Execution.
●​ Example Code Structure:

#include <stdio.h> // Preprocessor directive

int main() { // main() function - start of program

printf("Hello, World!\n"); // Statement
return 0; // Return value from main
} // End of main function

●​ Practice Question (Short Answer):

○​ Explain the purpose of #include <stdio.h> in a C program.
○​ What is the main() function? Why is it important?

3. Explain (Variables, Identifiers, Token, Constant)

●​ Key Points:
○​ Variables: Named storage locations to hold data. Declaration (e.g., int age;).
Initialization (e.g., int age = 20;). Data types associated with variables.
○​ Identifiers: Names given to variables, functions, etc. Rules for identifiers (start
with letter or underscore, can contain letters, digits, underscores, case-sensitive).
○​ Tokens: Smallest individual units in a program. Categories of tokens:
■​ Keywords: Reserved words (e.g., int, float, if, else, for, while).
■​ Identifiers: User-defined names.
■​ Constants: Fixed values (e.g., 10, 3.14, "Hello").
■​ Operators: Symbols that perform operations (e.g., +, -, *, /, =, ==).
■​ Special Symbols: ;, ,, (, ), {, } etc.
○​ Constants: Fixed values that don't change during program execution. Types of
constants:
■​ Integer Constants: (e.g., 10, -5, 0)
■​ Floating-Point Constants (Real Constants): (e.g., 3.14, -2.5, 0.0)
■​ Character Constants: Single characters enclosed in single quotes (e.g.,
'A', 'b', '$')
■​ String Constants: Sequences of characters enclosed in double quotes
(e.g., "Hello", "Computer Science")
●​ Example Question (MCQ):
○​ Which of the following is a valid identifier in C?​
a) 1variable​
b) my variable​
c) _my_variable (Correct)​
d) int

4. Data Types with Sizes

●​ Key Points:
○​ Primary Data Types (Fundamental Data Types):
■​ int: Integer (whole numbers). Size (typically 2 or 4 bytes, depends on
compiler).
■​ float: Floating-point (single-precision decimal numbers). Size (typically 4
bytes).
■​ char: Character (single character). Size (1 byte).
■​ double: Double-precision floating-point numbers. Size (typically 8 bytes).
■​ void: Represents the absence of data type.
○​ Derived Data Types (Briefly): Arrays, pointers, structures, unions (mention, but
focus on primary).
○​ Size of Data Types (Approximate): Understand that sizes can vary slightly
based on the compiler and system architecture, but know the typical sizes.
●​ Example Table (Data Types and Sizes - Typical):

Data Type Description Typical Size (Bytes)

int Integer 2 or 4

float Floating-point 4
 char Character 1

double Double-precision float 8

●​ ​
Practice Question (Short Answer):
○​ List the primary data types in C. What is the typical size of an int data type?

5. Operators and its Usages

●​ Key Points:
○​ Types of Operators:
■​ Arithmetic Operators: +, -, *, /, % (modulus - remainder).
■​ Relational Operators: == (equal to), != (not equal to), >, <, >=, <=.
Return boolean values (true/false - represented as 1/0 in C).
■​ Logical Operators: && (logical AND), || (logical OR), ! (logical NOT).
Operate on boolean expressions.
■​ Assignment Operators: = (simple assignment), +=, -=, *=, /=, %=
(compound assignment).
■​ Increment/Decrement Operators: ++ (increment), -- (decrement). Prefix
and postfix forms (++i vs i++).
■​ Conditional Operator (Ternary Operator): ? : (e.g., condition ?
value_if_true : value_if_false).
■​ Bitwise Operators (Mention briefly): &, |, ^, ~, <<, >> (if syllabus depth
requires, otherwise less important for crash course).
●​ Example Code (Operators):

int a = 10, b = 5;
int sum, diff, prod, quot, rem;
int result;

sum = a + b; // Arithmetic +
diff = a - b; // Arithmetic -
prod = a * b; // Arithmetic *
quot = a / b; // Arithmetic /
rem = a % b; // Arithmetic %

result = (a > b); // Relational > (result will be 1 - true)

result = (a > 5 && b < 10); // Logical AND

a++; // Increment operator

b--; // Decrement operator

int max = (a > b) ? a : b; // Conditional operator

●​ Practice Questions (MCQ & Short Answer):

○​ What is the modulus operator (%) in C used for?
○​ Explain the difference between prefix increment (++i) and postfix increment (i++).
○​ Write a C expression using the conditional operator to find the absolute value of a
number x.

6. Control Structures

●​ Key Points:
○​ Selection/Decision Making Structures:
■​ if statement: Basic if block.
 ■​ if-else statement: if block and else block.
■​ else-if ladder: Multiple conditions using else if.
■​ switch-case statement: Multi-way branching based on the value of an
expression. case, break, default.
○​ Iterative Structures (Loops):
■​ for loop: Initialization, condition, increment/decrement in the loop header.
■​ while loop: Condition checked before each iteration.
■​ do-while loop: Condition checked after each iteration (loop executes at
least once).
○​ Unconditional Control Statements:
■​ goto statement (Avoid if possible, but know it exists): Unconditional
jump to a labeled statement. Generally considered bad practice for
structured programming.
■​ return statement: Exits a function and returns a value (if any).
■​ break statement: Exits a loop or switch statement prematurely.
■​ continue statement: Skips the rest of the current iteration and goes to
the next iteration of a loop.
●​ Example Code (Control Structures - Snippets):
○​ if-else:

int age = 15;

if (age >= 18) {
printf("Adult\n");
} else {
printf("Minor\n");
}

●​ ​
​

○​ for loop:

for (int i = 1; i <= 5; i++) {

printf("%d ", i); // Output: 1 2 3 4 5
}

●​ ​
​

○​ while loop:

int count = 0;
while (count < 3) {
printf("Count: %d\n", count);
count++;
}

●​ ​
​

○​ switch-case:

char grade = 'B';

switch (grade) {
case 'A': printf("Excellent\n"); break;
case 'B': printf("Good\n"); break;
case 'C': printf("Average\n"); break;
default: printf("Other grade\n");
}
 ●​ ​
​

●​ Practice Questions (MCQ & Coding):

○​ What is the difference between a while loop and a do-while loop?
○​ Write a C program to check if a number is even or odd using if-else.
○​ Write a C program to print the first 10 natural numbers using a for loop.
○​ Write a C program using switch-case to simulate a simple calculator (for +, -, *, /
operations).

7. Functions

●​ Key Points:
○​ System-defined/Predefined Functions: Functions provided by the C library
(e.g., printf(), scanf(), sqrt(), pow(), strlen(), gets(), puts(), getch(), clrscr()).
Header files associated with them (e.g., stdio.h, math.h, string.h, conio.h).
○​ User-defined Functions: Functions created by the programmer to perform
specific tasks.
○​ Function Declaration (Prototype): Specifies function name, return type, and
parameters before function definition or main() function. (e.g., int add(int a, int
b);).
○​ Function Definition: Actual code block of the function that performs the task.
○​ Function Calling: Invoking a function to execute its code.
○​ Four Methods of User-defined Functions (Based on parameters and return
values):
1.​ No parameters, no return value: void myFunction(void)
2.​ Parameters, no return value: void myFunction(int x)
3.​ No parameters, return value: int myFunction(void)
4.​ Parameters, return value: int myFunction(int a, int b) (Most common)
●​ Example Code (Functions):

#include <stdio.h>

// Function declaration (prototype)

int add(int num1, int num2);

int main() {
int result = add(5, 3); // Function call
printf("Sum: %d\n", result); // Output: Sum: 8
return 0;
}

// Function definition
int add(int num1, int num2) {
int sum = num1 + num2;
return sum; // Return value
}

●​ Practice Questions (MCQ & Coding):

○​ What is the purpose of function declaration (prototype)?
○​ Explain the difference between function declaration and function definition.
○​ Write a C function to calculate the factorial of a given number.
○​ Write a C program that uses a user-defined function to check if a number is
prime.

8. Array and Strings

 ●​ Key Points:
○​ Arrays: Collection of elements of the same data type stored in contiguous
memory locations.
■​ Array Declaration: data_type array_name[array_size]; (e.g., int
numbers[5];).
■​ Array Initialization: During declaration (e.g., int numbers[5] = {1, 2, 3, 4,
5};) or later.
■​ Accessing Array Elements: Using index (subscript), starting from 0
(e.g., numbers[0], numbers[1]).
■​ 2D Arrays (Matrices): Arrays of arrays. Declaration: data_type
array_name[rows][columns]; (e.g., int matrix[3][4];). Initialization and
accessing elements (e.g., matrix[0][0]).
○​ Strings: Arrays of characters. Null-terminated (\0) character at the end to mark
the end of the string.
■​ String Declaration: char string_name[size]; (e.g., char name[20];).
■​ String Initialization: char name[] = "John"; or char name[20] = "John";
■​ String Input/Output: scanf("%s", name); (for single word), gets(name);
(for line of text, use with caution - buffer overflow risk), printf("%s",
name);, puts(name);.
■​ String Functions (from string.h):
■​ strlen(str): Returns the length of the string (excluding null
terminator).
■​ strcpy(dest, src): Copies string src to string dest.
■​ strcmp(str1, str2): Compares two strings lexicographically. Returns
0 if equal, negative if str1 < str2, positive if str1 > str2.
■​ strcat(dest, src): Concatenates (appends) string src to the end of
string dest.
■​ gets(): Reads a line of text from input (use with caution).
■​ puts(): Prints a string to the console.
■​ getc(), putc(): Character input/output (less string-specific, but can
be used for string manipulation).
●​ Example Code (Arrays & Strings):
○​ 1D Array:

int marks[5];
printf("Enter marks for 5 students:\n");
for (int i = 0; i < 5; i++) {
scanf("%d", &marks[i]);
}
printf("Marks are:\n");
for (int i = 0; i < 5; i++) {
printf("%d ", marks[i]);
}
printf("\n");

●​ ​
​

○​ 2D Array (Matrix):

int matrix[2][2] = {{1, 2}, {3, 4}};

printf("Matrix:\n");
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
printf("%d ", matrix[i][j]);
}
printf("\n");
}
 ●​ ​
​

○​ Strings:

char name[20];
printf("Enter your name: ");
gets(name); // Input string (use caution)
printf("Hello, %s!\n", name);
printf("Length of name: %d\n", strlen(name));

●​ ​
​

●​ Practice Questions (MCQ & Coding):

○​ What is an array? Why are arrays useful?
○​ What is a string in C? How is it terminated?
○​ Explain the purpose of strlen(), strcpy(), and strcmp() string functions.
○​ Write a C program to find the sum of elements in an array.
○​ Write a C program to reverse a given string.

9. Pointers (Initialization, Declaration with Example)

●​ Key Points:
○​ What are Pointers? Variables that store memory addresses of other variables.
○​ Declaration: data_type *pointer_name; (e.g., int *ptr; - pointer to an integer). * is
the dereference operator (when used in declaration, it indicates a pointer).
○​ Initialization:
■​ Address-of Operator (&): Get the address of a variable (e.g., ptr =
&variable;).
■​ Null Pointer: ptr = NULL; (Indicates pointer doesn't point to anything
valid).
○​ Dereferencing Operator (*): Access the value at the memory address pointed to
by the pointer (e.g., *ptr gives the value of the variable ptr is pointing to).
○​ Pointer Arithmetic (Briefly - if needed for syllabus depth):
Incrementing/decrementing pointers (moves pointer to next/previous memory
location of the data type it points to).
○​ Pointers and Arrays (Close Relationship - Array name acts as a pointer to
the first element).
●​ Example Code (Pointers):

#include <stdio.h>

int main() {
int num = 10;
int *ptr; // Pointer declaration

ptr = # // Pointer initialization - ptr now points to the address of num

printf("Value of num: %d\n", num); // Output: Value of num: 10

printf("Address of num: %p\n", &num); // Output: Address of num: (some memory address
in hexadecimal)
printf("Value of ptr: %p\n", ptr); // Output: Value of ptr: (same memory address as &num)
printf("Value pointed to by ptr: %d\n", *ptr); // Output: Value pointed to by ptr: 10
(dereferencing)

*ptr = 25; // Change value *through* the pointer

printf("New value of num: %d\n", num); // Output: New value of num: 25 (num is changed!)
 return 0;
}

●​ Practice Questions (MCQ & Short Answer):

○​ What is a pointer? What does it store?
○​ Explain the difference between the & (address-of) operator and the *
(dereference) operator.
○​ What is a null pointer? When is it used?
○​ Write a C program to swap two numbers using pointers.

Exam Tips:

●​ Practice, Practice, Practice: Code as many programs as you can. Work through
examples, modify them, and try writing programs from scratch.
●​ Understand Syntax: C is syntax-sensitive. Pay attention to semicolons, braces,
parentheses, etc.
●​ Trace Code: Practice tracing code execution on paper to understand how programs
work step-by-step.
●​ Focus on Concepts: Don't just memorize syntax. Understand the why and how of each
concept.
●​ Review Past Papers (if available): Get an idea of the question patterns and difficulty
level.
●​ Manage Time in Exam: Plan your time effectively. Don't spend too much time on one
question.

Resources:

●​ Textbooks: Refer to your Computer Science XII textbook.

●​ Online Tutorials: Websites like "Tutorialspoint," "GeeksforGeeks," "Learn C Online"
offer good C programming tutorials.
●​ Compiler: Use a C compiler (like GCC, Turbo C, Dev-C++) to compile and run your C
programs.

Best of luck with your exam preparation!