BCA 101T Programming for Problem Solving using C Notes cover all 4 units of the GGSIPU BCA Semester 1 C paper in 129 pages, with 114 programs and their output, 88 two-mark answers and 43 ten-mark questions. They follow the official syllabus for batches admitted from 2024-25.
Written by Prateek Talwar, Founder, Unnati Educations · Reviewed by Ritik Rawat, B.Tech, Senior Full Stack Developer · Checked against the GGSIPU BCA first-year syllabus PDF on ipu.ac.in · Updated 12 October 2026 · Editorial policy
Scheme: GGSIPU BCA scheme of examination and first-year syllabus | Applies to: batch admitted in 2024-25 onwards | Verified against: syll4yrBCA240124.pdf and syllBCA1styr240124.pdf (ipu.ac.in)
BCA 101T Programming for Problem Solving using C at a glance: GGSIPU BCA Sem 1 credits, units and exam pattern
BCA 101T is the first programming paper of the BCA programme at GGSIPU (also called IPU), and these GGSIPU BCA Sem 1 C programming notes follow it unit by unit. It sits with six other GGSIPU BCA Semester 1 papers.
Item | Detail |
|---|---|
Paper code and title | BCA 101T Programming for Problem Solving using C |
Course and semester | BCA, Semester 1 |
Category and credits | Core course theory (CCT), 4 lecture hours a week, 4 credits |
Marks | 100: 40 internal + 60 end-term |
Applies to | Batch admitted in 2024-25 onwards |
End-term pattern | Q1 compulsory: 10 short questions of 2 marks, at least 2 from each unit. Then two 10-mark questions per unit, attempt one from each unit (20 + 40 = 60 marks). |
Exam duration | 3 hours (as printed on past BCA 101T end-term papers) |
Units | 4 |
Paired lab | BCA 101P Programming for Problem Solving using C Lab (core practical, 4 hours a week, 2 credits, 100 marks) |
BCA 101T paper snapshot from the official GGSIPU syllabus
Item
Paper code and title
Detail
BCA 101T Programming for Problem Solving using C
Item
Course and semester
Detail
BCA, Semester 1
Item
Category and credits
Detail
Core course theory (CCT), 4 lecture hours a week, 4 credits
Item
Marks
Detail
100: 40 internal + 60 end-term
Item
Applies to
Detail
Batch admitted in 2024-25 onwards
Item
End-term pattern
Detail
Q1 compulsory: 10 short questions of 2 marks, at least 2 from each unit. Then two 10-mark questions per unit, attempt one from each unit (20 + 40 = 60 marks).
Item
Exam duration
Detail
3 hours (as printed on past BCA 101T end-term papers)
Item
Units
Detail
4
Item
Paired lab
Detail
BCA 101P Programming for Problem Solving using C Lab (core practical, 4 hours a week, 2 credits, 100 marks)
BCA 101T Programming for Problem Solving using C Notes unit-wise: 114 solved programs across 4 units
These C programming notes in English end every unit with a revision sheet, 22 two-mark answers for Question 1 and 10-mark questions for the unit section. Notes for every other BCA paper: GGSIPU BCA notes.
BCA 101T Unit 1: C Basics, Operators and Control Structures
Pages 4 to 44. Tokens, data types with format specifiers, constants and the six-section structure of a C program, then operators, the if-else family, switch, loops and jump statements. 34 programs.
Quick look: factorial with a for loop (from page 33)
long long fact = 1;
for (i = 1; i <= n; i++)
fact = fact * i;
printf("Factorial of %d = %lld\n", n, fact);Sample run: input 6 prints Factorial of 6 = 720.
BCA 101T Unit 2: Functions, Macros, Storage Classes, Arrays, Strings and Pointers
Pages 45 to 81. Functions with recursion and a call-stack diagram, #define macros with the # and ## operators, the four storage classes, 1D and 2D arrays, strings, pointers, pointers to functions and dynamic memory. 37 programs.
Feature |
|
|
|
|
|---|---|---|---|---|
Storage | Memory (stack) | Data segment | Data segment | CPU register, if available |
Default value | Garbage | Zero | Zero | Garbage |
Lifetime | Till control stays in the block | Till the program ends | Till the program ends | Till control stays in the block |
Quick look: the four storage classes of C (from page 55)
Feature
Storage
autoMemory (stack)
externData segment
staticData segment
registerCPU register, if available
Feature
Default value
autoGarbage
externZero
staticZero
registerGarbage
Feature
Lifetime
autoTill control stays in the block
externTill the program ends
staticTill the program ends
registerTill control stays in the block
BCA 101T Unit 3: Structures, Unions, Enum, typedef and File Handling
Pages 82 to 106. Structures, passing structures to functions, typedef, unions with a shared-memory diagram, enum and self-referential structures (the base for linked lists in BCA 106T Data Structures and Algorithms), then text and binary files, access modes and fseek(), ftell() and rewind(). 22 programs.
Basis | Structure | Union |
|---|---|---|
Memory | Each member has its own memory | All members share the same memory |
Size | Sum of all members (plus padding) | Size of the largest member |
Values at a time | All members hold values together | Only one member holds a valid value |
Quick look: structure vs union (from page 90)
Basis
Memory
Structure
Each member has its own memory
Union
All members share the same memory
Basis
Size
Structure
Sum of all members (plus padding)
Union
Size of the largest member
Basis
Values at a time
Structure
All members hold values together
Union
Only one member holds a valid value
BCA 101T Unit 4: Standard Library Functions and Command Line Arguments
Pages 107 to 129. Seven header files, then command line arguments with an argc/argv diagram. 21 programs.
Quick look: ceil() and floor() from math.h (from page 115)
ceil(4.2) = 5.0 ceil(-4.2) = -4.0
floor(4.8) = 4.0 floor(-4.2) = -5.0ceil() rounds up to the smallest integer not less than x; floor() rounds down.
Call by value vs call by reference in C: excerpt from page 52 of the BCA 101T notes
Excerpt from page 52
Call by value
The values (copies) of the actual arguments are passed to the formal parameters. The function works on the copies, so changes made inside the function do not affect the original variables. This is the default method in C.
Call by reference (call by address)
The addresses of the actual arguments are passed using the & operator, and the formal parameters are pointers. The function works directly on the original memory locations, so changes made inside the function affect the original variables.
Program 6: swap two numbers, call by value vs call by reference
#include <stdio.h>
void swapValue(int x, int y) /* call by value */
{
int t = x; x = y; y = t;
printf("Inside swapValue : x = %d, y = %d\n", x, y);
}
void swapRef(int *p, int *q) /* call by reference */
{
int t = *p; *p = *q; *q = t;
}
int main()
{
int a = 10, b = 20;
swapValue(a, b);
printf("After call by value : a = %d, b = %d\n", a, b);
swapRef(&a, &b);
printf("After call by reference : a = %d, b = %d\n", a, b);
return 0;
}Output
Inside swapValue : x = 20, y = 10
After call by value : a = 10, b = 20
After call by reference : a = 20, b = 10What the output shows
Inside swapValue() the copies x and y are swapped, which is why the first line prints 20 and 10. Back in main(), a and b are still 10 and 20, because only the copies changed. swapRef() receives the addresses &a and &b, so *p and *q are the original variables themselves, and the swap is visible after the call. The page pairs this program with Fig. 2.3, a memory diagram of both calls side by side.
Do the BCA 101T notes cover the full GGSIPU syllabus?
Yes. Every official BCA 101T topic has its own section in the notes.
Unit | Official topics (GGSIPU syllabus) | Where in the notes | Status |
|---|---|---|---|
Unit I | C basics: character set, identifiers and keywords, data types, constants, symbolic constants, variable declarations, structure of a basic C program, first C program, #include, expression and compound statements, operators including shorthand assignment, conditional, bitwise and comma. Control structures: if, if-else, else-if ladder, while, do-while, for, switch, nested structures; break, continue, goto, exit. | Unit 1, sections 2 to 14, pages 5 to 37 | Covered |
Unit II | Functions: declaration, definition and scope, recursion, call by value and reference. #define, macros with arguments, nested macros, # and ## operators. Storage classes. Arrays (1D, 2D), strings. Pointers: basics, arithmetic, pointer to pointer, arrays and pointers, array of pointers, pointers to functions, returning pointers, dynamic memory allocation. | Unit 2, sections 1 to 7, pages 46 to 74 | Covered |
Unit III | Structures, unions, enumeration, passing structures to functions, arrays and structures, typedef, structure vs union, self-referential structure (introduction). Text and binary files, file I/O, access modes, file pointers, fseek, ftell, rewind. | Unit 3, sections 1 to 6, pages 83 to 100 | Covered |
Unit IV | Standard library functions from stdio.h, stdlib.h, conio.h, ctype.h, math.h, string.h, process.h; command line arguments. | Unit 4, sections 1 to 9, pages 108 to 125 | Covered |
Official BCA 101T syllabus mapped to sections and pages of the notes
Unit
Unit I
Official topics (GGSIPU syllabus)
C basics: character set, identifiers and keywords, data types, constants, symbolic constants, variable declarations, structure of a basic C program, first C program, #include, expression and compound statements, operators including shorthand assignment, conditional, bitwise and comma. Control structures: if, if-else, else-if ladder, while, do-while, for, switch, nested structures; break, continue, goto, exit.
Where in the notes
Unit 1, sections 2 to 14, pages 5 to 37
Status
Covered
Unit
Unit II
Official topics (GGSIPU syllabus)
Functions: declaration, definition and scope, recursion, call by value and reference. #define, macros with arguments, nested macros, # and ## operators. Storage classes. Arrays (1D, 2D), strings. Pointers: basics, arithmetic, pointer to pointer, arrays and pointers, array of pointers, pointers to functions, returning pointers, dynamic memory allocation.
Where in the notes
Unit 2, sections 1 to 7, pages 46 to 74
Status
Covered
Unit
Unit III
Official topics (GGSIPU syllabus)
Structures, unions, enumeration, passing structures to functions, arrays and structures, typedef, structure vs union, self-referential structure (introduction). Text and binary files, file I/O, access modes, file pointers, fseek, ftell, rewind.
Where in the notes
Unit 3, sections 1 to 6, pages 83 to 100
Status
Covered
Unit
Unit IV
Official topics (GGSIPU syllabus)
Standard library functions from stdio.h, stdlib.h, conio.h, ctype.h, math.h, string.h, process.h; command line arguments.
Where in the notes
Unit 4, sections 1 to 9, pages 108 to 125
Status
Covered
Sources: GGSIPU BCA first-year syllabus (batch admitted 2024-25 onwards) and the GGSIPU BCA scheme of examination. Unit names on this page are the notes' own; the PDF numbers units only. Every course in GGSIPU notes is mapped to its official PDF the same way.
How to write BCA 101T answers: program-with-output two-mark answers and ten-mark answers with diagrams
A neat program with output beats a long paragraph. A ten-mark answer runs definition, syntax, flowchart or table, program with output, then a difference table. Practise this format on GGSIPU BCA important questions.
Unit 2 pointer answers need a memory box diagram (variable, address, value), and recursion needs a dry run. Unit 3: check fopen() for NULL in every file program. Unit 4: answer header-file questions as a table of function, purpose and result, and for command line arguments draw argv and use atoi().
Worked two-mark example from Unit 1: Evaluate 10 + 8 % 3 * 2 - 4 / 2. %, * and / run first, left to right: 8 % 3 gives 2, 2 * 2 gives 4, 4 / 2 gives 2. So 10 + 4 - 2 = 12.
BCA 101T exam corner: 88 two-mark answers and 43 ten-mark questions by unit
Unit | Short answers (2 Marks Each) | Long answer questions (10 Marks) | Programs with output |
|---|---|---|---|
Unit 1 | 22 | 12 | 34 |
Unit 2 | 22 | 12 | 37 |
Unit 3 | 22 | 10 | 22 |
Unit 4 | 22 | 9 | 21 |
Total | 88 | 43 | 114 |
Exam questions and programs in the BCA 101T notes, unit by unit
Unit
Unit 1
Short answers (2 Marks Each)
22
Long answer questions (10 Marks)
12
Programs with output
34
Unit
Unit 2
Short answers (2 Marks Each)
22
Long answer questions (10 Marks)
12
Programs with output
37
Unit
Unit 3
Short answers (2 Marks Each)
22
Long answer questions (10 Marks)
10
Programs with output
22
Unit
Unit 4
Short answers (2 Marks Each)
22
Long answer questions (10 Marks)
9
Programs with output
21
Unit
Total
Short answers (2 Marks Each)
88
Long answer questions (10 Marks)
43
Programs with output
114
The BCA 101T notes answer 88 two-mark questions and list 43 ten-mark questions across 4 units, plus 114 programs with output.
One real question per unit:
Unit 1: What is the difference between
whileanddo-while? Pointer:whilechecks the condition first;do-whileruns the body at least once and ends with a semicolon.Unit 2: Why is an array name called a constant pointer? Pointer: it holds the fixed base address (
aequals&a[0]), soa++is an error.Unit 3: What is the size of
union { int i; double d; char c; }? Pointer: a union takes the size of its largest member, here adoubleof 8 bytes.Unit 4: If a program is run as
./add 5 7 9, what areargcandargv[2]? Pointer:argcis 4 andargv[2]is the string "7".
The notes carry no year tags, so these are exam-style questions, not past papers. More practice sits in the BCA 101T important questions.
BCA 101T C programming notes FAQs
Is BCA 101T the C programming paper of GGSIPU BCA Semester 1?
Yes. BCA 101T Programming for Problem Solving using C is the theory paper where BCA students first learn C in Semester 1, with 4 credits and 100 marks (40 internal, 60 end-term). It covers basics and control structures, functions to pointers, structures and file handling, and library functions with command line arguments. Its practical half is BCA 101P, the C lab.
What is the difference between BCA 101T and BCA 101P?
BCA 101T is the theory paper, tested in a written exam with short and long answers. BCA 101P is the lab, where you write, run and record C programs and face a viva. The topics match: the 20 practicals in the BCA 101P notes come from the same four units, so a student who revises 101T programs is already preparing for most 101P practicals.
Which BCA 101T unit has the most programs to practise?
Unit 2 has the most, with 37 programs covering functions, recursion, call by value and reference, arrays, strings, pointers and dynamic memory allocation. Unit 1 follows with 34 programs on operators, decisions and loops. Units 3 and 4 have 22 and 21 programs, mostly on structures, files, library functions and command line arguments. Every program in the BCA 101T notes is printed with its output.
Are these BCA 101T notes as per the latest GGSIPU syllabus?
Yes. The notes follow the GGSIPU BCA first-year syllabus that applies to batches admitted from 2024-25 onwards, published on ipu.ac.in. We checked every topic of all four units against that PDF, including nested macros, pointers to functions and passing structures to functions, and each one has its own section in the notes, as the syllabus map on this page shows.
What is the passing mark in BCA 101T?
BCA 101T is marked out of 100: 40 internal and 60 in the end-term exam. The GGSIPU BCA scheme of examination (2024-25) states pass marks as 40%, which is 40 out of 100. The detailed rules on internal and end-term minimums and re-appear sit in GGSIPU Ordinance 11, so check its current version on ipu.ac.in before the exam.
Get the full BCA 101T Programming for Problem Solving using C Notes on WhatsApp
What the full BCA 101T notes PDF contains
Unit
Pages in the notes
4 to 44 (41 pages)
Programs with output
34
Short / long questions
22 / 12
Unit
Pages in the notes
45 to 81 (37 pages)
Programs with output
37
Short / long questions
22 / 12
Unit
Pages in the notes
82 to 106 (25 pages)
Programs with output
22
Short / long questions
22 / 10
Unit
Pages in the notes
107 to 129 (23 pages)
Programs with output
21
Short / long questions
22 / 9
The BCA 101T Programming for Problem Solving using C Notes come as one 129-page PDF, in English, delivered on WhatsApp within one hour after successful payment.
Get the full BCA 101T notes on WhatsApp (4 units, 129 pages)
Unnati Educations is an independent education provider based in Vikaspuri, Delhi. We are not affiliated with, authorised by, or endorsed by Guru Gobind Singh Indraprastha University (GGSIPU). 'GGSIPU' and 'IPU' are used only to describe the syllabus our notes follow. For official information, visit ipu.ac.in.
Ready for the full notes?
Discuss coverage and delivery with our team.