To master basic skills in programming in C over a two-week period with dedicated time slots from

9:00 AM to 12:00 PM and from 6:00 PM to 9:00 PM, you can follow a structured plan. This plan
will cover fundamental concepts, practical exercises, and project-based learning to solidify your
understanding. Here's a detailed plan:

Week 1: Foundations of C Programming

Day 1: Introduction to C and Development Environment

• 9:00 AM - 12:00 PM:

• Install a C compiler (GCC) and an IDE or text editor (e.g., Visual Studio Code).
• Study the structure of a C program (functions, main function, etc.).
• Write your first "Hello, World!" program.
• 6:00 PM - 9:00 PM:
• Study the structure of a C program (functions, main function, etc.).
• Learn about basic data types (int, float, char) and variables.
• Practice by writing simple programs to declare and initialize variables.

Day 2: Control Structures

• 9:00 AM - 12:00 PM:

• Study and practice if , else if , and else statements.
• Learn about relational and logical operators.
• Write programs that use conditional statements.
• 6:00 PM - 9:00 PM:
• Study and practice switch statements.
• Write programs that use switch statements for decision-making.

Day 3: Loops

• 9:00 AM - 12:00 PM:

• Study and practice while loops.
• Write programs using while loops.
• 6:00 PM - 9:00 PM:
• Study and practice for loops.
• Write programs using for loops, including nested loops.

Day 4: Functions

• 9:00 AM - 12:00 PM:

• Learn about function declaration and definition.
• Study parameter passing and return values.
• Write simple functions and call them from main .
 • 6:00 PM - 9:00 PM:
• Practice writing and using functions for different tasks.
• Explore scope of variables and lifetime.

Day 5: Arrays

• 9:00 AM - 12:00 PM:

• Study array declaration, initialization, and access.
• Write programs that use arrays to store and manipulate data.
• 6:00 PM - 9:00 PM:
• Practice more complex array operations (e.g., finding the max/min, sum).
• Write programs that involve multi-dimensional arrays.

Day 6: Pointers

• 9:00 AM - 12:00 PM:

• Introduction to pointers and pointer arithmetic.
• Study and practice using pointers to access and modify variables.
• 6:00 PM - 9:00 PM:
• Learn about arrays and pointers.
• Write programs that use pointers and arrays together.

Day 7: Strings

• 9:00 AM - 12:00 PM:

• Study string manipulation using character arrays.
• Practice basic string functions (e.g., strlen , strcpy , strcat ).
• 6:00 PM - 9:00 PM:
• Write programs to handle and manipulate strings.
• Explore advanced string operations.

Week 2: Advanced Topics and Project-Based Learning

Day 8: Structs and Enums

• 9:00 AM - 12:00 PM:

• Study and practice defining and using structs.
• Write programs that create and manipulate structs.
• 6:00 PM - 9:00 PM:
• Learn about enumerations (enums).
• Write programs using enums for better code readability.
Day 9: File I/O

• 9:00 AM - 12:00 PM:

• Introduction to file handling in C.
• Study and practice using fopen , fclose , fprintf , and fscanf .
• 6:00 PM - 9:00 PM:
• Write programs to read from and write to files.
• Explore error handling in file operations.

Day 10: Dynamic Memory Allocation

• 9:00 AM - 12:00 PM:

• Study malloc , calloc , realloc , and free .
• Practice dynamic memory allocation and deallocation.
• 6:00 PM - 9:00 PM:
• Write programs that use dynamic memory for arrays and structs.

Day 11: Advanced Pointers

• 9:00 AM - 12:00 PM:

• Learn about pointers to pointers.
• Study and practice pointer arrays and function pointers.
• 6:00 PM - 9:00 PM:
• Write programs that use advanced pointer concepts.
• Explore pointer manipulation in more depth.

Day 12: Recursion

• 9:00 AM - 12:00 PM:

• Study the concept of recursion.
• Practice writing simple recursive functions (e.g., factorial, Fibonacci).
• 6:00 PM - 9:00 PM:
• Write more complex recursive functions.
• Explore problems that can be solved using recursion.

Day 13: Debugging and Optimization

• 9:00 AM - 12:00 PM:

• Learn basic debugging techniques using gdb (GNU Debugger).
• Practice identifying and fixing common programming errors.
• 6:00 PM - 9:00 PM:
• Study code optimization techniques.
• Refactor previous code to improve efficiency.
Day 14: Mini Project

• 9:00 AM - 12:00 PM:

• Start a mini project that combines the concepts learned.
• Plan and design the project structure.
• 6:00 PM - 9:00 PM:
• Implement the project.
• Test and debug the project to ensure it works as expected.

Example Mini Projects

• Text-based game: Create a simple text-based adventure game.
• Library management system: Build a system to manage book records, including adding,
deleting, and searching for books.
• Simple calculator: Develop a calculator that can perform basic arithmetic operations.

Tips for Success

• Consistent Practice: Practice coding every day to reinforce your learning.
• Study Resources: Use online tutorials, books, and documentation to supplement your
learning.
• Ask Questions: Join programming forums and communities to ask questions and seek help
when needed.
• Review and Reflect: Regularly review what you’ve learned and identify areas where you
need more practice.
Day 1: Introduction to C and Development Environment

Basic Command Line Guide

Introduction
The command line interface (CLI) is a powerful tool that allows you to interact with your
computer's operating system using text commands. This guide will cover the basics of navigating
directories and creating files.

Navigating Directories
1. Opening the Command Line
• Windows : Open Command Prompt or PowerShell.
• macOS/Linux : Open Terminal.

2. Current Directory
• Command : pwd (Print Working Directory)
• Usage : Displays the current directory you are in.
pwd

3. Listing Files and Directories

• Command : ls
• Usage : Lists the files and directories in the current directory.

ls

4. Changing Directories
• Command : cd (Change Directory)
• Usage : Moves to a specified directory.

cd directory_name

• Example : Move to the Documents directory.

sh
Copy code
 cd Documents

• Parent Directory : Move up one level in the directory hierarchy.

cd ..

5. Creating Directories
• Command : mkdir (Make Directory)
• Usage : Creates a new directory.

mkdir new_directory

6. Viewing Hidden Files

• Command : ls -a
• Usage : Lists all files, including hidden files (files starting with a dot . ).

ls -a

Creating Files
1. Creating a File
• Command : touch
• Usage : Creates an empty file.

touch filename.txt

2. Editing a File
• Command : nano , vim , or vi (Text Editors)
• Usage : Opens a text editor to create or edit a file.

nano filename.txt

vim filename.txt
3. Displaying File Contents
• Command : cat
• Usage : Displays the contents of a file.

cat filename.txt

4. Copying Files
• Command : cp (Copy)
• Usage : Copies a file to a new location.

cp source_file.txt destination_file.txt

5. Moving/Renaming Files
• Command : mv (Move)
• Usage : Moves or renames a file.

mv old_name.txt new_name.txt

6. Deleting Files
• Command : rm (Remove)
• Usage : Deletes a file.

rm filename.txt

Practical Examples
Example 1: Navigate to the Documents Directory and Create a File

cd Documents
touch myfile.txt
ls

Example 2: Create a Directory and Move into It

mkdir my_new_directory
cd my_new_directory
Example 3: Create and Edit a File Using Nano

nano mytextfile.txt

Example 4: Copy and Rename a File

cp mytextfile.txt newfile.txt
mv newfile.txt renamedfile.txt

Example 5: Delete a File

rm renamedfile.txt

Conclusion
This guide provides a foundation for using the command line to navigate directories and manage
files. Mastering these basic commands will enhance your efficiency and capability in managing
your computer's file system. For more advanced usage, explore the manual pages of each command
using the man command (e.g., man ls ).

•Write your first "Hello,

World!" program.

// hello.c
#include <stdio.h>

int main() {
printf("Hello, World!\n");
return 0;
}

How to Run
1. Save the file as hello.c .
2. Open the terminal.
3. Navigate to the directory where hello.c is saved.
 4. Compile the program:

gcc hello.c -o hello

Run the compiled program

./hello
Study the structure of a C program (functions, main function, etc.).

Introduction
Understanding the structure of a C program is fundamental to becoming proficient in C
programming. This guide covers the key components of a C program, including functions, the
main function, preprocessor directives, variables, and basic I/O operations.

1. Basic Structure of a C Program

Example
c
Copy code
#include <stdio.h> // Preprocessor directive

// Function declaration
void greet();

int main() {
// Variable declaration and initialization
int number = 10;

// Function call
greet();

// Print statement
printf("Number: %d\n", number);

// Return statement
return 0;
}

// Function definition
void greet() {
printf("Hello, World!\n");
}

Components
1. Preprocessor Directives

• Begin with # and are processed before compilation.

 • Common directives include #include , #define , and #if .
• Example: #include <stdio.h> includes the Standard Input Output library.
2. Function Declaration

• Declares the function before its usage.

• Syntax: return_type function_name(parameter_list);
• Example: void greet();
3. main Function

• Entry point of every C program.

• Syntax: int main() { /* code */ return 0; }
• Returns an integer value, typically 0 for successful execution.
4. Variables

• Used to store data.

• Must be declared before use.
• Example: int number = 10;
5. Function Definition

• Provides the body of a function.

• Syntax: return_type function_name(parameter_list) { /*
code */ }
• Example:
c
Copy code
void greet() {
printf("Hello, World!\n");
}

6. Basic I/O Operations

• printf for output.

• scanf for input.
• Example:
c
Copy code
printf("Enter a number: ");
scanf("%d", &number);
2. Functions
Declaration vs. Definition
• Declaration : Specifies the function's name, return type, and parameters.
• Definition : Provides the actual body of the function.

Example
c
Copy code
#include <stdio.h>

void greet(); // Declaration

int main() {
greet(); // Function call
return 0;
}

void greet() { // Definition

printf("Hello, World!\n");
}

3. The main Function

Structure
c
Copy code
int main() {
// Declarations
// Statements
return 0;
}

Example
c
Copy code
#include <stdio.h>

int main() {
printf("Hello from the main function!\n");
return 0;
}
4. Preprocessor Directives
Common Directives
• #include for including libraries.
• #define for defining constants or macros.
• #if , #ifdef , #ifndef for conditional compilation.

Example
c
Copy code
#include <stdio.h>
#define PI 3.14

int main() {
printf("Value of PI: %f\n", PI);
return 0;
}

5. Variables and Data Types

Declaration
c
Copy code
int number;
float price;
char grade;

Initialization
c
Copy code
int number = 10;
float price = 99.99;
char grade = 'A';

Example
c
Copy code
#include <stdio.h>

int main() {
int number = 10;
float price = 99.99;
char grade = 'A';

printf("Number: %d\n", number);

 printf("Price: %.2f\n", price);
printf("Grade: %c\n", grade);

return 0;
}

6. Basic Input/Output
Output using printf
• Syntax : printf(format_string, variables);
• Example :
c
Copy code
printf("Hello, %s!\n", "World");
printf("Number: %d\n", 10);

Input using scanf

• Syntax : scanf(format_string, &variables);
• Example :
c
Copy code
int number;
printf("Enter a number: ");
scanf("%d", &number);
printf("You entered: %d\n", number);

Example
c
Copy code
#include <stdio.h>

int main() {
int number;
printf("Enter a number: ");
scanf("%d", &number);
printf("You entered: %d\n", number);
return 0;
}
7. Control Structures
If-Else
c
Copy code
#include <stdio.h>

int main() {
int number = 10;
if (number > 5) {
printf("Number is greater than 5\n");
} else {
printf("Number is 5 or less\n");
}
return 0;
}

For Loop
c
Copy code
#include <stdio.h>

int main() {
for (int i = 0; i < 5; i++) {
printf("i: %d\n", i);
}
return 0;
}

While Loop
c
Copy code
#include <stdio.h>

int main() {
int i = 0;
while (i < 5) {
printf("i: %d\n", i);
i++;
}
return 0;
}
Conclusion
Understanding the structure of a C program involves knowing how to use functions, the main
function, preprocessor directives, variables, and basic I/O operations. With this foundation, you can
start writing and exploring more complex C programs.

Follow-up Suggestions
a. Practice writing small C programs that utilize different control structures like if-else and
loops.
b. Explore functions in more detail, including passing arguments and returning values.