1
[Link] TOPIC PAGE NO.
1. Basic Python 3-7
Programming
2. Basic C 8 - 14
Programming
2
Introduction to Python for Problem Solving
Python is a versatile programming language with built-in functions and libraries that make it suitable
for solving algorithmic problems commonly found on platforms like LeetCode. It emphasizes code
readability and simplicity, allowing for efficient coding and debugging.
1. Variables and Data Types
Understanding different data types and how to use variables is crucial:
- Integer (int): Whole numbers used in calculations, e.g., 5, -10.
- Float: Decimal numbers for precision, e.g., 3.14, 0.001.
- String (str): Useful for manipulating text data, e.g., 'abc', '123'.
- List: Ordered collection for storing elements, e.g., [1, 2, 3].
2. Basic Operations
Python supports various operations that are essential for problem-solving:
- Arithmetic Operations: +, -, *, /, %, ** (exponentiation).
- List Operations: append(), pop(), len(), slicing (arr[start:end]).
- String Operations: concatenation (+), find(), replace(), split().
Arithmetic Operations: result = 3 + 4, power = 2 ** 3 (exponentiation), remainder = 10 % 3
List Operations: [Link](5), removed = [Link](), length = len(numbers), sublist =
numbers[1:3]
String Operations: full_name = "Alice" + " " + "Smith", index = full_name.find("Smith"), replaced =
full_name.replace("Alice", "Bob")
3. Control Flow
Using control flow statements to handle different cases and conditions is common in coding
challenges:
- If-else statements: Control which block of code executes based on a condition.
- For loops: Iterate over a range or elements of a list. Example: for i in range(n):
- While loops: Useful for problems where the number of iterations is not known beforehand.
If-else Statements example:
if age >= 18:
print("Adult")
else:
print("Minor")
Output:
For age = 20, output is "Adult"
For age = 15, output is "Minor"
3
For Loop example:
for i in range(5):
print(i,end=” “)
Output:
01234
While Loop example:
while count < 5:
print(count, end=” “)
count += 1
Output:
01234
4. Functions
Functions encapsulate reusable code blocks that can be called multiple times in different parts of a
solution:
Example:
def add(a, b):
return a + b
Using functions can help break down complex problems into smaller, manageable tasks.
Example:
def greet(name):
return f"Hello, {name}!" print(greet("Alice"))
Output:
"Hello, Alice!"
5. Basic Data Structures
Understanding basic data structures is essential for solving coding problems:
- List: Used for dynamic arrays.
- Dictionary: Key-value pairs useful for lookups. Example: {'name': 'John', 'age': 30}
- Set: Unordered collection with no duplicates, useful for membership tests.
Example:
List: fruits = ["apple", "banana", "cherry"]
Dictionary: person = {"name": "John", "age": 30}
Set: unique_numbers = {1, 2, 3, 2}
4
6. Built-in Functions and Libraries
Python's built-in functions like max(), min(), sorted(), and libraries like itertools, math, and collections
can simplify solving problems. They provide ready-to-use utilities for common tasks.
Example:
import math
result = max(10, 20, 5)
factorial = [Link](5)
Output:
result: 20
factorial: 120
7. List Comprehensions
List comprehensions provide a concise way to generate lists based on existing lists:
Example:
squares = [x**2 for x in range(10)]
This creates a list of squares, making it useful for transforming input data.
Example:
even_numbers = [x for x in range(10) if x % 2 == 0]
Output:
[0, 2, 4, 6, 8]
8. Lambda Functions and Sorting
Lambda functions offer a quick way to define small functions. Sorting with lambda can be useful for
solving problems involving custom sorting:
Example:
sorted_arr = sorted(arr, key=lambda x: x[1])
This sorts a list of tuples based on the second element.
Example:
students = [("Alice", 85), ("Bob", 75), ("Charlie", 90)]
sorted_students = sorted(students, key=lambda x: x[1])
Output:
[("Bob", 75), ("Alice", 85), ("Charlie", 90)]
9. Recursion
Recursion is solving a problem by having a function call itself. It is useful for problems like tree
traversal and backtracking:
5
Example:
def factorial(n):
if n == 0:
return 1
return n * factorial(n - 1)
Output:
120
10. Dynamic Programming
Dynamic programming (DP) is used for solving problems by breaking them down into overlapping
sub-problems:
- Use memoization to store results of expensive function calls.
- Example problem: Fibonacci numbers using DP. Memoize the results to avoid recalculating.
Example:
memo = {}
def fibonacci(n):
if n in memo:
return memo[n]
if n <= 1:
return n
memo[n] = fibonacci(n-1) + fibonacci(n-2)
return memo[n]
fibonacci(5)
Output:
11. Advanced Data Structures
- Stack: Last-In-First-Out, useful for problems like evaluating expressions.
- Queue: First-In-First-Out, used in breadth-first search (BFS).
- Heap: A binary heap can be used for problems involving priority queues.
6
Example:
Stack:
stack = []
[Link](1)
[Link](2)
last_item = [Link]()
Queue:
from collections import deque
queue = deque([1, 2, 3])
[Link](4)
first_item = [Link]()
Heap:
import heapq
nums = [3, 1, 4, 1, 5]
[Link](nums)
smallest = [Link](nums)
Outputs:
Stack:
stack: [1]
last_item: 2
Queue:
queue: [2, 3, 4]
first_item: 1
Heap:
nums: [1, 1, 4, 3, 5] (heapified list)
smallest: 1
12. Time Complexity Analysis
Understanding time and space complexity is critical for optimizing solutions:
- O(1): Constant time operations, e.g., accessing an element in an array.
- O(n): Linear time operations, e.g., looping through an array.
- O(log n): Logarithmic time operations, e.g., binary search.
- O(n^2): Quadratic time operations, e.g., nested loops.
7
INTRODUCTION TO C PROGRAMMING
WHAT IS C?
C IS A PROGRAMMING LANGUAGE THAT HELPS US COMMUNICATE WITH COMPUTERS TO SOLVE PROBLEMS . IT’S LIKE
TELLING THE COMPUTER WHAT TO DO, STEP BY STEP.
WHY LEARN C?
C IS IMPORTANT BECAUSE IT TEACHES YOU HOW PROGRAMMING WORKS AT A DEEPER LEVEL . IT IS USED IN SYSTEM
SOFTWARE, GAMES, AND APPLICATIONS.
BASIC STRUCTURE OF A C PROGRAM
N C, EVERY PROGRAM HAS A SPECIFIC STRUCTURE. AT A BASIC LEVEL, A C PROGRAM CONSISTS OF:
• PREPROCESSOR DIRECTIVES: THIS IS WHERE WE INCLUDE LIBRARIES THAT THE PROGRAM WILL USE. THE MOST
COMMON IS #INCLUDE <STDIO. H>, WHICH ALLOWS US TO USE THE STANDARD INPUT AND OUTPUT FUNCTIONS
LIKE PRINTF AND SCANF.
• MAIN FUNCTION: EVERY C PROGRAM MUST HAVE A MAIN () FUNCTION. THIS IS WHERE THE PROGRAM STARTS
EXECUTING.
• S TATEMENTS: INSIDE THE MAIN() FUNCTION, YOU WRITE THE INSTRUCTIONS FOR THE PROGRAM TO EXECUTE.
THESE INSTRUCTIONS ARE WRITTEN AS STATEMENTS AND USUALLY END WITH A SEMICOLON ;.
• RETURN STATEMENT: THE RETURN 0; STATEMENT INDICATES THAT THE PROGRAM HAS SUCCESSFULLY
COMPLETED. 0 MEANS "NO ERROR" IN MANY OPERATING SYSTEMS.
EXAMPLE:
#INCLUDE<STDIO.H> // PREPROCESSOR DIRECTIVE: INCLUDES THE STANDARD INPUT/OUTPUT LIBRARY
INT MAIN() { // MAIN FUNCTION: THE STARTING POINT OF EVERY C PROGRAM
PRINTF("HELLO, WORLD!"); // THIS STATEMENT PRINTS "HELLO, WORLD!" TO THE SCREEN
RETURN 0; // INDICATES THAT THE PROGRAM FINISHED SUCCESSFULLY
}
EXPLANATION OF THE EXAMPLE:
• #INCLUDE <STDIO.H>: THIS LINE INCLUDES THE STANDARD INPUT/OUTPUT LIBRARY, WHICH ALLOWS US TO
USE FUNCTIONS LIKE PRINTF TO DISPLAY OUTPUT.
• INT MAIN(): THIS IS THE MAIN FUNCTION , WHERE THE PROGRAM STARTS. INT MEANS THE FUNCTION WILL
RETURN AN INTEGER, WHICH IS USED TO INDICATE IF THE PROGRAM RAN SUCCESSFULLY.
• PRINTF("HELLO, WORLD!");: THIS IS THE INSTRUCTION TO PRINT THE MESSAGE "HELLO, WORLD!" ON THE
SCREEN. THE PRINTF FUNCTION COMES FROM THE STDIO . H LIBRARY.
• RETURN 0;: THIS INDICATES THAT THE PROGRAM HAS FINISHED RUNNING AND IS RETURNING 0, MEANING
EVERYTHING WENT WELL
DATA TYPES AND VARIABLES
WHAT ARE DATA TYPES?
IN C, A DATA TYPE DEFINES THE TYPE OF DATA A VARIABLE CAN HOLD. C IS A STATICALLY TYPED LANGUAGE, MEANING
YOU NEED TO DECLARE THE DATA TYPE OF A VARIABLE WHEN YOU CREATE IT. THIS TELLS THE COMPILER HOW MUCH
MEMORY TO ALLOCATE FOR THE VARIABLE AND WHAT KIND OF OPERATIONS CAN BE PERFORMED ON IT .
BASIC DATA TYPES:
C USES DATA TYPES TO TELL THE COMPUTER WHAT KIND OF INFORMATION WE WANT TO STORE . COMMON DATA TYPES
ARE:
8
- `INT` FOR WHOLE NUMBERS (E.G., 10, 25)
- `FLOAT` FOR DECIMAL NUMBERS (E.G., 3.14)
- `CHAR` FOR SINGLE CHARACTERS (E.G., 'A')
WHAT ARE VARIABLES?
A VARIABLE IS LIKE A CONTAINER THAT STORES DATA . YOU CAN THINK OF A VARIABLE AS A BOX WITH A LABEL (THE
VARIABLE’S NAME) WHERE YOU CAN STORE AND RETRIEVE DATA .
DECLARING VARIABLES
TO CREATE A VARIABLE IN C, YOU MUST:
1. CHOOSE A DATA TYPE (SUCH AS INT, FLOAT, ETC.).
2. GIVE THE VARIABLE A NAME.
3. OPTIONALLY, YOU CAN INITIALIZE THE VARIABLE BY ASSIGNING A VALUE TO IT.
EXAMPLE:
#INCLUDE <STDIO.H>
INT MAIN() {
INT AGE = 21; // INTEGER VARIABLE FOR AGE
FLOAT HEIGHT = 6.1; // FLOAT VARIABLE FOR HEIGHT IN FEET
CHAR NAME[] = "JOHN"; // CHARACTER ARRAY (STRING) FOR THE NAME
PRINTF("NAME: %S\N", NAME); // PRINTS THE NAME
PRINTF("AGE: %D\N", AGE); // PRINTS THE AGE
PRINTF("HEIGHT: %.1F FEET\N", HEIGHT) ; // PRINTS THE HEIGHT
RETURN 0;
}
OUTPUT:
NAME: JOHN
AGE: 21
HEIGHT: 6.1 FEET
CONSTANTS
A CONSTANT IS A VARIABLE WHOSE VALUE CANNOT CHANGE ONCE IT IS ASSIGNED . IN C, YOU CAN DEFINE CONSTANTS
USING TWO METHODS:
• #DEFINE PREPROCESSOR DIRECTIVE: THIS CREATES A CONSTANT THAT IS AVAILABLE THROUGHOUT THE
PROGRAM.
• CONST KEYWORD: THIS CREATES A CONSTANT VARIABLE THAT BEHAVES LIKE A REGULAR VARIABLE BUT CANNOT
BE CHANGED.
EXAMPLE:
#DEFINE PI 3.14159 // DEFINES PI AS A CONSTANT VALUE
CONST INT MAXAGE = 100; // MAXAGE IS A CONSTANT INTEGER
INPUT/OUTPUT FUNCTIONS
WHEN WRITING PROGRAMS, WE OFTEN NEED TO TAKE INPUT FROM THE USER AND STORE IT IN VARIABLES . C PROVIDES
THE SCANF() FUNCTION TO READ INPUT FROM THE USER AND STORE IT IN A VARIABLE
THE PRINTF() FUNCTION IS USED TO DISPLAY MESSAGES OR THE VALUE OF VARIABLES ON THE SCREEN . THIS IS AN
ESSENTIAL TOOL FOR PROVIDING FEEDBACK TO THE USER , SUCH AS PRINTING RESULTS OR INFORMATION .
9
COMMON FORMAT SPECIFIERS:
• %D: INTEGER (WHOLE NUMBERS)
• %F: FLOATING-POINT NUMBER (DECIMALS)
• %C: CHARACTER
• %S: STRING (ARRAY OF CHARACTERS)
• %. XF: THIS SPECIFIES THE NUMBER OF DECIMAL PLACES FOR FLOATING-POINT NUMBERS, WHERE X IS THE
NUMBER OF DIGITS TO DISPLAY.
EXAMPLE 1:
#INCLUDE <STDIO.H>
INT MAIN() {
INT NUM = 42;
FLOAT PI = 3.14159;
CHAR LETTER = 'A';
CHAR NAME[] = "ALICE";
PRINTF("NUMBER: %D\N", NUM);
PRINTF("PI: %.2F\N", PI); // LIMITS THE FLOAT TO 2 DECIMAL PLACES
PRINTF("L ETTER: %C\N", LETTER);
PRINTF("NAME: %S\N", NAME);
RETURN 0;
}
OUTPUT:
NUMBER: 42
PI: 3.14
LETTER: A
NAME: ALICE
EXAMPLE 2:
#INCLUDE <STDIO.H>
INT MAIN() {
INT AGE;
FLOAT HEIGHT;
PRINTF("ENTER YOUR AGE: ");
SCANF("%D", &AGE); // READS AN INTEGER INPUT
PRINTF("ENTER YOUR HEIGHT IN METERS: ");
SCANF("%F", &HEIGHT); // READS A FLOAT INPUT
PRINTF("YOU ARE %D YEARS OLD AND %.2F METERS TALL.\N", AGE, HEIGHT);
RETURN 0;
}
OUTPUT:
ENTER YOUR AGE:18
ENTER YOUR HEIGHT IN METERS: 160
YOU ARE 18 YEARS OLD AND 160 METERS TALL.
10
OPERATORS
ARITHMETIC OPERATORS:
OPERATORS PERFORM CALCULATIONS. COMMON ARITHMETIC OPERATORS ARE:
- `+` FOR ADDITION
- `-` FOR SUBTRACTION
- `*` FOR MULTIPLICATION
- `/` FOR DIVISION
- `%` FOR REMAINDER (MODULUS)
EXAMPLE:
INT A = 10, B = 3;
INT SUM = A + B; // SUM WILL BE 13
INT REMAINDER = A % B; // REMAINDER WILL BE 1
RELATIONAL AND LOGICAL OPERATORS:
- RELATIONAL: `==` CHECKS IF TWO VALUES ARE EQUAL, `!=` CHECKS IF THEY ARE NOT.
- LOGICAL: `&&` (AND), `||` (OR) ARE USED TO COMBINE CONDITIONS.
CONTROL FLOW
IF- ELSE STATEMENTS:
USED TO MAKE DECISIONS BASED ON CONDITIONS . IF SOMETHING IS TRUE, DO THIS, OTHERWISE, DO THAT.
EXAMPLE:
#INCLUDE <STDIO.H>
INT MAIN() {
INT SCORE = 85;
IF (SCORE >= 90) {
PRINTF("GRADE: A\N");
} ELSE IF (SCORE >= 80) {
PRINTF("GRADE: B\N");
} ELSE {
PRINTF("GRADE: C\N");
}
RETURN 0;
}
SWITCH CASE:
SWITCH CASE IS USED WHEN YOU HAVE MULTIPLE CONDITIONS TO CHECK .
EXAMPLE:
#INCLUDE <STDIO.H>
INT MAIN() {
INT DAY = 3;
SWITCH (DAY) {
CASE 1:
PRINTF("MONDAY\N");
BREAK;
CASE 2:
PRINTF("TUESDAY\N");
BREAK;
11
CASE 3:
PRINTF("WEDNESDAY\N");
BREAK;
DEFAULT:
PRINTF("I NVALID DAY\N");
}
RETURN 0;
}
LOOPS (FOR, WHILE):
LOOPS ALLOW YOU TO EXECUTE A BLOCK OF CODE MULTIPLE TIMES . C PROVIDES THREE TYPES OF LOOPS: FOR, WHILE,
AND DO- WHILE.
FOR LOOP
A FOR LOOP IS USED WHEN YOU KNOW IN ADVANCE HOW MANY TIMES YOU WANT TO REPEAT A BLOCK OF CODE.
EXAMPLE (FOR LOOP):
#INCLUDE <STDIO.H>
INT MAIN() {
FOR (INT I = 1; I <= 5; I++) {
PRINTF("%D\N", I);
}
RETURN 0;
}
WHILE LOOP
A WHILE LOOP REPEATS AS LONG AS A CONDITION IS TRUE.
EXAMPLE (WHILE LOOP):
#INCLUDE <STDIO.H>
INT MAIN() {
INT I = 1;
WHILE (I <= 5) {
PRINTF("%D\N", I);
I++;
}
RETURN 0;
}
DO- WHILE LOOP
A DO-WHILE LOOP EXECUTES THE CODE AT LEAST ONCE, AND THEN CONTINUES IF THE CONDITION IS TRUE.
EXAMPLE:
#INCLUDE <STDIO.H>
INT MAIN() {
INT I = 1;
DO {
PRINTF("%D\N", I);
I++;
} WHILE (I <= 5);
RETURN 0;
}
12
FUNCTIONS
WHY USE FUNCTIONS?
FUNCTIONS MAKE PROGRAMS MORE ORGANIZED AND REUSABLE. INSTEAD OF WRITING THE SAME CODE REPEATEDLY,
WE CAN CREATE A FUNCTION AND CALL IT WHEN NEEDED.
DECLARING AND CALLING FUNCTIONS:
A FUNCTION HAS A NAME, INPUT (PARAMETERS), AND SOMETIMES A RETURN VALUE.
EXAMPLE:
#INCLUDE <STDIO.H>
INT ADD(INT X, INT Y) {
RETURN X + Y;
}
INT MAIN() {
INT SUM = ADD(5, 10); // CALLS THE ADD FUNCTION
PRINTF("SUM: %D", SUM); // PRINTS SUM: 15
RETURN 0;
}
RETURNING VALUES
A FUNCTION CAN RETURN A VALUE TO THE PART OF THE PROGRAM THAT CALLED IT.
EXAMPLE:
INT MULTIPLY(INT X, INT Y) {
RETURN X * Y;
}
FUNCTION PARAMETERS
FUNCTIONS CAN TAKE MULTIPLE PARAMETERS (INPUTS). YOU CAN PASS VALUES TO FUNCTIONS WHEN CALLING THEM .
EXAMPLE:
VOID GREETUSER(CHAR NAME[]) {
PRINTF("HELLO, %S\N", NAME);
}
ARRAYS AND STRINGS
WHAT IS ARRAY?
AN ARRAY IS A COLLECTION OF VARIABLES THAT ARE ACCESSED WITH AN INDEX NUMBER . ALL ELEMENTS IN THE
ARRAY MUST BE OF THE SAME DATA TYPE.
SYNTAX:
DATATYPE ARRAYNAME[ ARRAYSIZE];
EXAMPLE:
#INCLUDE <STDIO.H>
INT MAIN() {
INT NUMBERS[5] = {1, 2, 3, 4, 5}; // DECLARES AND INITIALIZES AN ARRAY
PRINTF("FIRST NUMBER: %D\N", NUMBERS[0]); // ACCESSING ARRAY ELEMENTS
RETURN 0;
13
}
WHAT IS A STRING?
A STRING IS A SEQUENCE OF CHARACTERS, TYPICALLY ENDING WITH A NULL CHARACTER (\0). IN C, STRINGS ARE
ACTUALLY ARRAYS OF CHARACTERS .
EXAMPLE:
#INCLUDE <STDIO.H>
INT MAIN() {
CHAR GREETING[] = "HELLO, WORLD!";
PRINTF("%S\N", GREETING);
RETURN 0;
}
POINTER
WHAT IS A POINTER?
A POINTER IS A VARIABLE THAT HOLDS THE ADDRESS OF ANOTHER VARIABLE. YOU USE THE & OPERATOR TO GET
THE ADDRESS AND * TO DEREFERENCE (ACCESS THE VALUE AT THAT ADDRESS).
SYNTAX:
DATATYPE *POINTERNAME;
EXAMPLE:
#INCLUDE <STDIO.H>
INT MAIN() {
INT NUM = 10;
INT *PTR = &NUM; // POINTER TO NUM
PRINTF("VALUE OF NUM: %D\N", NUM);
PRINTF("ADDRESS OF NUM: %P\N", PTR); // %P PRINTS ADDRESS IN HEXADECIMAL FORMAT
PRINTF("VALUE AT ADDRESS: %D\N", *PTR); // DEREFERENCING POINTER
RETURN 0;
}
POINTER ARITHMETIC
YOU CAN PERFORM ARITHMETIC OPERATIONS ON POINTERS . FOR EXAMPLE, YOU CAN INCREMENT A POINTER TO MOVE
TO THE NEXT MEMORY ADDRESS.
POINTERS AND ARRAYS
POINTERS AND ARRAYS ARE CLOSELY RELATED. THE NAME OF AN ARRAY ACTS AS A POINTER TO THE FIRST ELEMENT OF
THE ARRAY.
EXAMPLE:
#INCLUDE <STDIO.H>
INT MAIN() {
INT NUMBERS[] = {1, 2, 3};
INT *PTR = NUMBERS; // POINTER TO THE ARRAY
PRINTF("FIRST ELEMENT: %D\N", *PTR); // PRINTS 1
RETURN 0;
}
14