Problem Solving Techniques Notes
Subject Overview
Problem Solving Techniques is BCA's introductory programming paper, teaching logic development (flowcharts, decision tables, pseudocode) before moving into C: data types, operators, control statements, functions, arrays, strings, structures/
Subject at a glance
4
Units
41
Topics
3
Credits
4
Infographics
Unit-wise Syllabus
4 units — open any unit for detailed topic-wise notes, diagrams and important exam questions
- Data representation
- flowcharts
- problem analysis
- decision trees/tables
- pseudocode and algorithms
- character set
- identifiers and keywords
- data types
- constants
- variables
- expressions
- statements
- symbolic constants
- arithmetic/unary/relational/logical/assignment/conditional operators
- library functions
- 1Understand the problem
Inputs, outputs and constraints
- 2Design the algorithm
Write steps in plain language or pseudocode
- 3Draw a flowchart
Visualise decisions and loops
- 4Code in C
Translate the design into statements
- 5Test and debug
Run with sample and edge-case inputs
Study guide
Before writing code you learn to think like a programmer: represent data, analyse a problem, draw flowcharts, and write pseudocode and algorithms. You then meet the building blocks of C: character set, identifiers, keywords, data types, constants and variables, and the arithmetic, relational, logical, assignment and conditional operators. Get comfortable turning a word problem into steps on paper first; the C syntax is then easy.
- Formatted and unformatted input/output
- while
- do-while and for statements
- nested loops
- if-else
- switch
- break-continue statements
Condition checked
Before each iteration
After each iteration
Minimum runs
Zero
One
Syntax ends with
Closing brace
while(condition);
Typical use
Unknown number of repetitions
Menus that must show at least once
Study guide
This unit makes your programs interactive and decision-making. You learn formatted and unformatted input and output, the three loops (while, do-while, for) including nested loops, the if-else and switch decision statements, and break and continue. Trace small programs by hand, writing down the value of each variable after every step, to build real understanding.
- Defining and accessing functions
- passing arguments
- argument data types
- function prototypes
- recursion
- defining and processing arrays
- passing arrays to a function
- multi-dimensional arrays
- string declaration and manipulation
- storage classes (automatic, external, static)
What is passed
A copy of the value
The address (pointer) of the variable
Original variable
Unchanged
Can be modified
Memory
Extra copy created
No copy of the data
C example
swap(a, b) fails to swap
swap(&a, &b) works
Study guide
Functions let you break a large program into reusable parts, and arrays let you handle collections of data. You learn to define and call functions, pass arguments, use prototypes and recursion, then work with one-dimensional and multi-dimensional arrays and strings, and understand storage classes (auto, extern, static). Recursion becomes easy once you can draw the call stack for a small example such as factorial.
- Defining and processing a structure
- user-defined data types
- structures and pointers
- passing structures to functions
- unions
- pointer declaration and initialization
- accessing a variable through its pointer
- pointers and arrays
- file operations and processing a data file
Memory
Sum of all members
Size of the largest member
Members in use
All at the same time
One at a time
Keyword
struct
union
Use
Records such as a student
Saving memory when only one value is needed
Study guide
Structures group related data of different types, unions share memory between members, and pointers store memory addresses. You learn to define and process structures, pass them to functions, declare and use pointers, relate pointers and arrays, and read and write data files. Pointers are the hardest topic in C, so draw boxes-and-arrows diagrams of memory until the idea is natural.
Why Problem Solving Techniques Matters
C is the foundation language of computer science. The logic you develop here transfers directly to Java, Python and every language you will learn later, and it prepares you for Data Structures, Operating Systems and placement coding rounds, where problem-solving ability is what interviewers actually test.
How to Prepare for Problem Solving Techniques
- Write programs by hand and then type them in; the exam is on paper but the learning is on the computer.
- Dry-run every program with sample inputs and note variable values at each step.
- Learn the standard programs thoroughly: prime check, factorial, Fibonacci, palindrome, matrix operations and string functions.
- Draw memory diagrams for pointers, arrays and structures.
Problem Solving Techniques: Frequently Asked Questions
Is C the first programming language in BCA?
Yes. This paper introduces programming through C, starting from algorithms and flowcharts, so no prior programming experience is required.
What is the hardest topic in C for beginners?
Most students find pointers hardest. Drawing memory diagrams and practising small programs makes them much easier to understand.
Why learn flowcharts and pseudocode before coding?
They let you plan the logic independently of syntax, which is how professional programmers design solutions before writing code.