What is the MSBSHSE Class 12 Computer Science 2020 Sample Paper?
The MSBSHSE Class 12 Computer Science 2020 sample paper is a practice paper released by the state board to show you exactly how the HSC Computer Science exam was structured in that year. It is a model paper: the board sets it to demonstrate the expected question types, the section arrangement, the marks carried by each question, and the kind of answers examiners look for. It is built around the syllabus and the Balbharati textbook prescribed for the 2019-20 academic year.
Download the MSBSHSE Class 12 Computer Science 2020 Sample Paper (PDF)
One clarification saves a lot of confusion: this is not a previous year question paper. A previous year paper is the actual question paper that was handed out in a real board exam. A sample paper is a model released in advance to illustrate the pattern. So when you solve the 2020 sample paper, you are rehearsing the format, not reproducing the exact questions that appeared in the hall. If you want the real exam questions, work through the Maharashtra Board Class 12 Computer Science previous year papers alongside this.
What does "pattern" mean in practice? It means knowing that a particular question carries 2 marks and expects two distinct points, while a program-writing question carries 4 marks and expects working code with correct syntax. The sample paper shows this layout question by question, so you learn how much detail to write for each mark. For example, a typical question like "Write a C program to find the sum of the first n natural numbers" is not answered with the output alone; the marks sit in the correct header files, declarations, loop logic, and output statement.
Before you rely on the 2020 paper, check whether its pattern still matches the current syllabus. The state board revises syllabi and blueprints from time to time, so a question type or chapter in the 2020 paper may no longer be part of your course, or a new topic may have been added [verify]. Compare the 2020 paper against your current Maharashtra Board Class 12 Computer Science syllabus page and the latest exam pattern before you build a practice plan around it.
Sample Paper vs Previous Year Paper vs Model Paper: Know the Difference
These three terms get used loosely, and that causes real damage to preparation. A student who thinks a sample paper is the actual exam paper skips the real past questions. A student who thinks a model paper carries board authority trusts a pattern that may not exist. Here is what each one actually is in Computer Science.
Sample paper: released by the state board to show the exam pattern and marking scheme for a given year. It tells you that a program question on arrays carries 4 marks and expects a complete, compiling program with declarations, logic and output, not just the answer. The 2020 Computer Science sample paper is this type.
Previous year paper: the actual question paper used in a past board exam, exactly as students received it in the hall. Solving these shows you the real difficulty level and the kind of wording the board uses. Work through the Maharashtra Board Class 12 Computer Science previous year papers for this.
Model paper: usually created by publishers, coaching classes or schools as extra practice. Quality varies. Some follow the blueprint closely; others drift from it. Use them for volume practice, but check each one against the official exam pattern and marking scheme before trusting its structure.
| Type | Source | Purpose | How to use it |
|---|---|---|---|
| Sample paper | State board | Shows pattern and marking scheme | Learn the format and answer depth first |
| Previous year paper | State board (actual exam) | Shows real difficulty and wording | Solve under timed conditions |
| Model paper | Publishers, schools | Extra practice questions | Use after the first two types |
Solve all three, in this order: sample paper to learn the format, previous year papers to test yourself at real difficulty, then model papers for extra volume. A common mistake is solving ten model papers and zero previous year papers, which leaves you unfamiliar with how the board actually phrases questions like "explain with a suitable example" or "write the output of the following code".
Computer Science Paper Pattern and Marks Distribution (Based on 2020)
The Computer Science theory paper carries 80 marks and runs for 3 hours. Practical work and internal assessment add 20 marks, so the subject total is 100 [verify]. The 2020 sample paper was built on this split, and the questions inside it were arranged in ascending order of difficulty, starting with objective items and ending with programming problems.
Section-wise question types
The paper is divided into four sections. Marks per question rise as you move from Section A to Section D, so a wrong choice in Section D costs you far more than one in Section A.
- Section A (Q1): Objective questions, 1 mark each. Multiple choice, fill in the blanks, true or false, and match the pairs. These test definitions, syntax recall and small output predictions.
- Section B (Q2): Short answer questions, 2 marks each. Typical wording: "Explain with an example", "Differentiate between", "Write the syntax of".
- Section C (Q3 and Q4): Longer answers and program-based questions, 3 to 4 marks each. A 4-mark program question expects the full program with declarations, logic and output, not just the logic.
- Section D (Q5): Application and programming questions carrying the highest marks, including complete programs and output tracing.
The exact number of questions and the marks per section can shift slightly between years [verify against the current blueprint]. Treat the section names above as a guide to the style of question, not a fixed contract.
Chapter-wise weightage
The table below gives approximate marks per chapter area as seen in the 2020 paper. Use it to decide how much time each chapter deserves, not to skip any chapter entirely [verify exact marks distribution].
| Chapter area | Approximate marks | What is usually asked |
|---|---|---|
| Programming in C: basics, operators, control structures | 12 to 16 | Output prediction, syntax, small programs using loops and conditions |
| Arrays and strings | 8 to 12 | Programs to search, sort or reverse; output tracing |
| Functions and pointers | 8 to 12 | Function definitions, call by value vs call by reference, pointer arithmetic |
| Data structures: stacks, queues, linked lists | 10 to 14 | Definitions, operations, algorithms, applications |
| File handling in C | 6 to 8 | File modes, fopen/fclose syntax, reading and writing programs |
| OOP concepts and classes | 8 to 12 | Encapsulation, inheritance, polymorphism with examples |
| Databases and SQL basics | 6 to 10 | Queries, keys, normalisation definitions |
| Networking and web basics | 4 to 8 | Protocols, topologies, HTML tags |
Programming in C and data structures together account for roughly a third of the paper, so a student weak in these two areas loses marks fast. A typical 4-mark question asks you to write a C program to find the largest element in an array. Marks are usually split as: correct declarations (1), correct logic (2), correct output (1) [verify]. Writing only the logic gets you half the marks, which is why incomplete programs are such a common leak.
Cross-check this table with the Maharashtra Board Class 12 Computer Science syllabus page and the latest blueprint before you finalise your revision order, because the 2020 paper may differ in small ways from the current pattern.
How to Download the 2020 Computer Science Sample Paper
Start on our Maharashtra Board Class 12 Computer Science syllabus page or the download block at the top of this page. The steps are the same everywhere:
- Click the download link for the Computer Science 2020 sample paper. The PDF opens in a new tab or saves to your device.
- Save it with a clear file name, for example CS-2020-sample-paper.pdf, in a folder you will remember.
- Open the PDF and check the first page: it should name the subject, the year and the board. If any of these is missing, the file is probably not the official paper.
The paper is usually published in English, Marathi and Hindi mediums, so pick the medium you will write the exam in [verify]. Download the answer key or marking scheme alongside the paper if one is available [verify]. Solving without checking against the scheme leaves your mistakes uncorrected.
If the link does not work, try these sources:
- The official state board website, under the HSC model paper or download section.
- Your school or junior college, which usually keeps copies of board model papers.
- Trusted educational portals that host board papers.
Be careful with papers labelled "2020 Computer Science" on random websites. Some are typed from memory, carry wrong marks per question, or mix topics from other boards. Before you solve any paper, check that the marks add to 80, the time is 3 hours, and the question style matches the sections described above. If the structure does not match, discard it and use a verified copy. Once you finish the 2020 paper, move on to the previous year papers for wider practice.
Step-by-Step: Solve the 2020 Computer Science Paper in Exam Conditions
Before you start
Sit at a clear table with only the paper, a pen, pencil, eraser, and rough sheets. Keep the textbook, notes and phone out of reach, because a practice test only works if you cannot check answers midway. Set a timer for exactly 3 hours, the time allowed in the theory exam [verify].
Spend the first 10 minutes reading the whole paper without writing anything. Mark each question as E (easy), M (medium) or H (hard) in the margin. This single habit stops the panic that comes from meeting a long programming question on page 3 when you are still on page 1.
During the test
Follow a written time plan instead of guessing. A workable split for an 80-mark paper is roughly 15 minutes for MCQs, 60 minutes for short answers, 60 minutes for programming and long answers, and 30 minutes for checking [verify section-wise timing]. Write these cut-off times on the top of your rough sheet and glance at the clock after each section.
Attempt the easy questions first. If a question says "Write a program to find the sum of array elements", write the full program: header files, main(), variable declarations, loop, output statement. A half-written program with correct logic but missing #include or a closing brace often loses 1 or 2 marks in the marking scheme [verify].
Keep answers neat. Underline final answers, number every sub-part exactly as printed, and draw flowcharts with a pencil and ruler, labelling every box (Start, Input, Process, Decision, Stop). An unlabelled diagram is treated as incomplete.
After the test
Put the pen down when the timer rings, even if a question is unfinished. Now open the marking scheme and award marks strictly, step by step, the way an examiner would. Do not give yourself benefit of the doubt.
Keep a one-page error log with three columns: question number, what went wrong (wrong syntax, skipped step, misread question), and the correct method. For example, if you wrote for(i=0;i<=n;i++) for an array of n elements, note that the condition should be i<n. Revise this log before your next paper, and then move to the previous year papers for wider practice.
Marking Scheme and Answer Key for the 2020 Computer Science Paper
A marking scheme is the document that tells an examiner how to award marks for each question, step by step. It is not just a list of final answers. For a program, it may say: 1 mark for correct header files, 1 mark for variable declarations, 2 marks for the loop logic, 1 mark for the output statement. When you evaluate your own paper against it, you see exactly where your marks were lost, not just that the answer was wrong.
An answer key, when released, gives the correct final answers, usually for objective and short answer questions. The marking scheme goes further because it shows the split of marks. Check the official board website and your school for the 2020 answer key or marking scheme, as availability for a specific year is not guaranteed [verify]. If you cannot find the official one, ask your Computer Science teacher to mark your paper using the board's scheme.
Use the scheme the way an examiner does. Read the expected answer first, then your own answer, and award marks strictly. If a question asks you to "explain with an example", the example carries marks, so an explanation without one is incomplete. If it asks for a program, a correct logic with a missing #include line or an unclosed brace still loses marks under most schemes [verify].
Most marks in Computer Science are lost in predictable places:
- Programs written halfway, with the loop or output statement missing.
- Algorithms or flowcharts that skip steps such as initialisation or the stop box.
- Syntax errors: missing semicolons, wrong brackets, = used instead of ==.
- Answers that ignore the words "with example" or "with diagram".
After evaluating, write a personal error log: question number, the mistake in one line, and the correct method. For instance, "Q4(b): wrote i<=n for an array of n elements, should be i<n". Revise this log before your next attempt, and compare it with the exam pattern and marking scheme so you know which question types cost you the most.
Chapter-wise Weightage and Important Topics for Computer Science
The Class 12 Computer Science textbook prescribed by the state board is divided into chapters that move from programming basics to data structures and finally to object-oriented programming and databases. Before you plan revision, open the Computer Science syllabus page and tick off the chapters your school has completed. The table below lists the chapters and the approximate marks they carried in the 2020 paper [verify], along with the topics that appear most often as questions.
| Chapter | Approximate marks (2020) | Key concepts to master |
|---|---|---|
| Introduction to Programming and C | 6 to 8 [verify] | Structure of a C program, header files, data types, operators, input/output with printf and scanf |
| Control Structures | 8 to 10 [verify] | if-else, switch, for, while, do-while loops, nested loops, dry-run of a loop |
| Arrays | 8 to 10 [verify] | One-dimensional and two-dimensional arrays, traversal, searching, sorting logic |
| Functions | 8 to 10 [verify] | Function declaration, definition and call, parameters, return values, call by value, scope of variables |
| Pointers | 6 to 8 [verify] | Pointer declaration, address operator, dereferencing, pointers and arrays, pointer arithmetic |
| Structures and Unions | 6 to 8 [verify] | Defining a structure, accessing members, array of structures, difference between structure and union |
| File Handling | 6 to 8 [verify] | Opening and closing files, modes (r, w, a), reading and writing, EOF handling |
| Object-Oriented Concepts | 8 to 10 [verify] | Class and object, encapsulation, inheritance, polymorphism, comparison with procedural programming |
| Data Structures and Databases | 6 to 8 [verify] | Stack, queue, linked list basics, SQL queries, primary key and foreign key |
The exact split changes from year to year, so treat these ranges as a guide, not a guarantee. Cross-check with the latest blueprint on the exam pattern and marking scheme page before you finalise your revision order.
Start with the chapters that carry the most marks: Control Structures, Arrays, Functions and Object-Oriented Concepts. These four together account for a large share of the paper [verify], and they also feed into programming questions in other chapters, so weak logic here costs marks everywhere. A question like "write a program to find the largest element in an array" tests arrays and loops together, so practise such combined questions rather than reading chapters in isolation.
Do not skip the lower-weightage chapters. Pointers and File Handling often appear as short answer questions worth 2 or 3 marks each, and these are quick to score because the answers are short and definition-based. A student who ignores File Handling loses easy marks that take only an hour to secure. For each chapter, write one program, one definition-based answer and one difference table (for example, structure vs union, or while vs do-while) in your notebook. That single habit covers most question types the paper uses.
Chapter-wise Practice Checklist Linked to the Balbharati Textbook
A checklist works only if each tick means something specific. "Done Arrays" is not a tick, because reading a chapter is not the same as being able to answer a question from it. For every chapter, the tick should stand for a skill you can demonstrate on blank paper without opening the book. Use the table below as your tracker: print it or copy it into the first page of your notebook, and tick a row only when you can do all the listed skills in one sitting.
| Chapter | Skills to master before you tick | Textbook exercise done | Sample paper question done | Needs revision |
|---|---|---|---|---|
| Introduction to Programming and C | Write a complete C program with header files and main(); dry-run a program and write its output | |||
| Control Structures | Write a loop program (sum, factorial, table); convert an if-else chain into switch | |||
| Arrays | Traverse and print an array; write search and sort logic; handle a 2-D array | |||
| Functions | Write a function with parameters and return value; explain call by value with an example | |||
| Pointers | Declare and dereference a pointer; explain pointer arithmetic; link pointers to arrays | |||
| Structures and Unions | Define a structure and access members; write an array of structures; write the structure vs union difference table | |||
| File Handling | Open and close a file in all three modes; write a program that reads till EOF | |||
| Object-Oriented Concepts | Define class and object with an example; explain the four features; compare with procedural programming | |||
| Data Structures and Databases | Explain stack and queue with operations; write simple SQL queries; define primary and foreign key |
Two chapters a week is a realistic pace if you are also attending school. That gives you roughly five weeks for the full textbook with a week in hand for the difficult chapters. Pair one theory-heavy chapter with one programming-heavy chapter in the same week, for example Pointers with Functions, so that the week is not all reading or all coding. Solve the textbook exercise questions first, because they match the language of the board paper, and then attempt the matching questions from the 2020 sample paper. If an exercise answer does not match, check the textbook solutions before moving on.
Mark the "Needs revision" column honestly. A chapter where you needed the book open to write a program, or where your output was wrong on the first dry run, belongs there even if you ticked the other columns. In the last two weeks, revise only the marked rows and re-attempt one full paper from the previous year papers set. That keeps your final revision short and aimed at the places where you actually lose marks.
Time Management Strategy for the 3-Hour Computer Science Exam
Three hours sounds generous until you sit down with a paper that has a programming question worth six marks. The students who finish comfortably are not faster writers; they decide in advance how long each part will take and then protect that decision. Here is a working split for 180 minutes. Check it against the current paper pattern on the exam pattern and marking scheme page before you rely on the section names [verify].
- Reading the paper: 10 minutes. Read every question, mark the easy ones with a tick and the ones you will attempt later with a dot. Do not start writing in this time.
- Section A (objective/MCQ type): 20 minutes. Answer these first because they are quick and build confidence. If one question takes more than a minute, leave it and return.
- Section B (short answers): 40 minutes. Roughly 4 to 5 minutes per question. Write the definition first, then the example.
- Section C (long answers and programming): 60 minutes. This is where marks are won or lost. A six-mark program needs time for the logic, the code, and a sample output.
- Section D (remaining questions): 30 minutes.
- Revision: 20 minutes. Check syntax, semicolons, question numbers, and whether you attempted every part of every question.
If the section names in your 2020 paper differ, keep the proportions and rename the blocks. The principle matters more than the labels: objective questions first, heavy programming in the middle when your mind is fresh, and a fixed revision block at the end that you never give away to a stubborn question.
Space is part of time management. Leave two or three blank lines after every long answer so you can add a missed point during revision without rewriting the page. Draw flowcharts and diagrams in pencil, and keep a rough-work margin on the right of each page. A program answer that runs into the margin is hard for the examiner to read, and unclear presentation costs marks even when the logic is right.
Practise the split at least twice using papers from the previous year papers set. Set a timer for each block, not just for the full three hours, and note where you overshoot. Most students discover they lose 15 to 20 minutes on one programming question; once you see that on a practice run, you will drop it and move on in the real exam.
Computer Science Practical Exam and Internal Assessment
The 80-mark theory paper is not the whole subject. Computer Science also carries 20 marks of practical work and internal assessment, so the final score is out of 100 [verify]. The 2020 sample paper you are practising covers only the theory half. Practicals follow a separate guideline document issued by the board, and no sample paper can prepare you for them.
Your 20 marks usually come from four parts:
- Practical file or journal: a record of the programs you wrote through the year, with aim, algorithm, code, and output for each.
- Program execution in the lab: you are given a problem and asked to write and run the program on the computer within a set time.
- Viva voce: short oral questions on your programs, syntax, and concepts from the textbook.
- Project work: a small application or program set you build and explain.
Marks are lost in practicals for boring reasons, not hard ones. A journal with missing outputs, undated entries, or programs copied without running them gets cut even if the code is correct. Fix this by writing each journal entry the same week you write the program, and pasting the actual output, not a guessed one.
For the execution task, practise writing complete programs by hand first and then typing them, because in the lab you cannot look up syntax. A typical task might ask you to read 10 numbers into an array and print the largest, or to write a function that reverses a string. Time yourself at 20 to 25 minutes per program [verify the exact lab duration].
For the viva, prepare one-line answers to predictable questions: difference between while and do-while, what a pointer stores, why we use break, what a structure is. Read the board's Computer Science practical guidelines for the exact list of components and marking split for your batch [verify].
Common Mistakes to Avoid in the Computer Science Exam
Most marks lost in Computer Science are not lost because the student did not know the answer. They are lost in the last few minutes of writing, when a semicolon goes missing or a loop condition is copied wrongly. Read the following errors as a checklist and cross-check your own answer sheet against it before you submit.
Syntax errors in programs. In C, a missing semicolon, a wrong bracket, or writing Printf instead of printf makes the whole program wrong even if your logic is perfect. Examiners award step marks for correct logic, but a program that would not compile loses the output marks. Fix: after writing any program, read it once line by line only for syntax, not for logic.
Incorrect logic. A common example: asked to print the sum of the first 10 natural numbers, students write a loop that runs from 0 to 9 or forget to initialise sum = 0. Trace your loop with small values (n = 3) on rough paper before moving on.
Not reading the question fully. If the question says "explain with an example", an explanation without an example usually gets only half the marks. Underline the command words: define, explain, differentiate, write a program, give output.
Skipping steps in algorithms and flowcharts. An algorithm that jumps from "read the array" to "print the largest" without showing the comparison step loses marks. Flowcharts must use the correct symbols: parallelogram for input/output, diamond for decision, rectangle for process.
Poor time management. Spending 25 minutes on one 4-mark program leaves no time for the long answer at the end. If a question stalls you, mark it and return later.
No final revision. Keep the last 10 to 15 minutes to check that every question number is attempted, no answer is left half-written, and units or outputs match what the question asked. Solving previous year papers under a timer trains you to catch these slips early.
Quick Revision Tips and Resources for Computer Science
Revision in the last month works best when it is active, not passive. Reading the textbook again feels productive but teaches you very little. The five habits below force you to recall and apply, which is exactly what the exam asks for.
Build a one-page syntax sheet. Take a single ruled sheet and write down the exact syntax you keep getting wrong: the for loop header, an if-else if ladder, a function prototype, a structure declaration, file opening modes like "r", "w" and "a", and the % format specifiers for int, float and char. Keep this sheet beside you during practice and glance at it before the exam. One page only; if it grows to three pages you will not revise it.
Use flashcards for definitions and differences. Write a term on one side and its one-line definition on the other: compiler vs interpreter, call by value vs call by reference, array vs structure, primary key vs foreign key. Shuffle the cards and test yourself daily for ten minutes. This directly prepares you for the "differentiate between" questions that appear every year.
Solve at least three full papers before the exam. Use the 2020 sample paper for the first attempt, then move to actual previous year papers. Solving papers is where the real learning happens, because you meet the same question in unfamiliar wording. Download them from our Maharashtra Board Class 12 Computer Science previous year papers page and keep a record of your scores.
Check your method against the textbook and sample paper solutions. When you get a program wrong, do not just rewrite it. Compare your version with the textbook exercise solution or the marking scheme and note the exact line where your method differed. Our Maharashtra Board Class 12 Computer Science textbook solutions page is useful here, especially for programs from the Balbharati exercises.
Study in a small group for doubts. Three or four students explaining a concept to each other exposes gaps quickly. Give each person one chapter to explain aloud in ten minutes; if they cannot explain it without notes, that chapter needs another reading. Keep the group focused on doubts and past paper questions, not on re-reading chapters together.
Frequently Asked Questions
Where can I download the MSBSHSE Class 12 Computer Science 2020 sample paper?
Download it from the link on this page as a PDF. If you want an official copy, check the state board's website and your college's exam section, since schools usually circulate model papers before the HSC exam. Always confirm the paper matches your current syllabus before you start solving it.
Is the 2020 Computer Science sample paper enough for Maharashtra Board Class 12 preparation?
No. Treat it as one tool, not the whole plan. Use it to learn the pattern, then add the Balbharati textbook exercises, previous year question papers, and your own program practice. One sample paper cannot cover every chapter, so pair it with chapter-wise revision and at least two full previous papers.
What is the marks distribution for Maharashtra Board Class 12 Computer Science?
The paper is out of 100 marks, split into theory and practical components as per the board's scheme for that year. The exact split between theory, practical, and internal assessment can change with board circulars, so check the current blueprint on the board site or ask your teacher [verify].
How many questions are there in the Class 12 Computer Science paper and what are the sections?
The paper is divided into sections, typically starting with objective questions (MCQs, fill in the blanks, true or false), then short-answer questions of 2 marks, and longer questions of 3 to 4 marks including program writing. The exact number of questions and section names can change, so follow the current blueprint [verify].
Is the 2020 sample paper based on the current Computer Science syllabus?
Not necessarily. The board revises syllabi and blueprints from time to time, so a chapter or question type in the 2020 paper may have been dropped or a new topic added. Compare it with your current Balbharati textbook and the latest blueprint before relying on it [verify].
How should I practise the Computer Science sample paper in 3 hours?
Sit with a timer and no notes, exactly like the exam. Read the whole paper in the first 10 minutes, attempt objective questions first, then short answers, and keep program-writing questions for when your mind is fresh. Reserve the last 15 minutes to check syntax, headers, and output statements.