University of Delhi

India · UGCF 2022

University of Delhi

42 lab practicals for the Delhi University syllabus.

Delhi University’s B.Sc. (Hons.) Computer Science under UGCF 2022: C++ data structures, Python OOP, algorithms and DBMS. Every lesson is stepped, compiled and checked by a real toolchain on your own machine — the model reviews your code afterwards, it does not decide whether you passed.

Download GroutCodeAll syllabuses

Updated

Semester by semester

Programme: B.Sc. (Hons.) Computer Science. Scheme: UGCF 2022 (NEP). Open a course to see its practical units and the lab lesson GroutCode ships for each.

  1. Semester 1

    1 course6 lab lessonsPython
    • DSC01Python

      Object Oriented Programming using Python

      6

      lessons

      • From problem to program — ten small algorithms in Python
      • Python building blocks — literals, operators, functions and control flow
      See all 6 lessons
      1. 1From problem to program — ten small algorithms in PythonUnit 1 · Introduction to Programming
      2. 2Python building blocks — literals, operators, functions and control flowUnit 2 · Creating Python Programs
      3. 3Strings, lists, tuples, sets and dictionaries — Python's built-in data structuresUnit 3 · Built-in data structures
      4. 4Classes that model things — points, employees, accounts and shapes in Python OOPUnit 4 · Object Oriented Programming
      5. 5Files and exceptions — text statistics, config parsing and error handling in PythonUnit 5 · File and exception handling
      6. 6The DSC01 practical list in Python: from quadratic roots to validated classesUnit LAB · Suggested Practical List

  2. Semester 2

    1 course6 lab lessonsC++
    • DSC04C++

      Object Oriented Programming with C++

      6

      lessons

      • First C++ programs: from free functions to a Rectangle class
      • C++ fundamentals: series, arrays, searching and command-line arguments
      See all 6 lessons
      1. 1First C++ programs: from free functions to a Rectangle classUnit I · Introduction to C++
      2. 2C++ fundamentals: series, arrays, searching and command-line argumentsUnit II · Programming Fundamentals
      3. 3Classes in C++: encapsulation, constructors, inheritance, templates and a MatrixUnit III · Object Oriented Programming
      4. 4Pointers and references in C++: string routines, dynamic arrays and virtual dispatchUnit IV · Pointers and References
      5. 5Exceptions you define and files you can trustUnit V · Exception and File Handling
      6. 6The C++ practical list, end to endUnit LAB · Suggested Practical List

  3. Semester 3

    2 courses13 lab lessonsC++C
    • DSC07C++

      Data Structures

      7

      lessons

      • Measuring growth and solving recurrences
      • Lists, stacks and queues from raw nodes
      See all 7 lessons
      1. 1Measuring growth and solving recurrencesUnit 1 · Growth of Functions, Recurrence Relations
      2. 2Lists, stacks and queues from raw nodesUnit 2 · Arrays, Linked Lists, Stacks, Queues
      3. 3Linear and binary recursion, measuredUnit 3 · Recursion
      4. 4Binary and general trees — building, measuring and traversingUnit 4 · Trees, Binary Trees
      5. 5Binary search trees and AVL trees — insert, search, delete, rebalanceUnit 5 · Binary Search Trees, Balanced Search Trees
      6. 6Binary min-heap on an array — push, pop, build, sort and selectUnit 6 · Binary Heap
      7. 7Data Structures lab — lists, stacks, queues and expression evaluationUnit LAB · Suggested Practical List
    • DSC08C

      Operating Systems

      6

      lessons

      • What an OS does — dual mode, system calls, multiprogramming and resource management
      • A miniature kernel: protection bits, file system calls and a pipe
      See all 6 lessons
      1. 1What an OS does — dual mode, system calls, multiprogramming and resource managementUnit 1 · Introduction
      2. 2A miniature kernel: protection bits, file system calls and a pipeUnit 2 · Operating System Structures
      3. 3CPU schedulers and the banker's algorithmUnit 3 · Process Management
      4. 4Paging, segmentation, fits and page replacementUnit 4 · Memory Management
      5. 5Disk schedulers, directory paths and a file-allocation tableUnit 5 · File System and Mass Storage Structure
      6. 6The OS practical list in C: wc, grep, chmod, cp, fork, exec, pipes and PthreadsUnit LAB · Suggested Practical List

  4. Semester 4

    2 courses12 lab lessonsC++SQL
    • DSC10C++

      Design and Analysis of Algorithms

      5

      lessons

      • Searching, sorting and divide and conquer in C++
      • Graph traversals and greedy algorithms in C++
      See all 5 lessons
      1. 1Searching, sorting and divide and conquer in C++Unit 1 · Searching, Sorting and Divide and Conquer
      2. 2Graph traversals and greedy algorithms in C++Unit 2 · Graphs and Greedy Algorithms
      3. 3Dynamic programming: interval scheduling, knapsack and subset sum in C++Unit 3 · Dynamic Programming
      4. 4Hash tables: hash functions, chaining and open addressing in C++Unit 4 · Hashing
      5. 5DAA practical list: counted sorts, Strassen, graph traversals, MST, shortest paths and DPUnit LAB · Suggested Practical List
    • DSC11SQL

      Database Management Systems

      7

      lessons

      • From a flat file to a database: schemas, integrity and data independence
      • From an ER diagram to tables: entities, relationships and constraints
      See all 7 lessons
      1. 1From a flat file to a database: schemas, integrity and data independenceUnit 1 · Introduction to Database
      2. 2From an ER diagram to tables: entities, relationships and constraintsUnit 2 · Entity Relationship Modeling
      3. 3Relational algebra in SQL: operators, keys and integrity constraintsUnit 3 · Relational Data Model
      4. 4SQL end to end: DDL, update behaviours, DML, aggregation and viewsUnit 4 · Structured Query Language (SQL)
      5. 5Normalisation in practice: 1NF, 2NF, 3NF and BCNF decompositionsUnit 5 · Database Design
      6. 6Indexes, transactions and log-based recovery in SQLiteUnit 6 · File indexing and Transaction Processing
      7. 7The student-society database: DDL, joins, grouping, division, views and DML in SQLiteUnit LAB · Suggested Practical List

  5. Semester 5

    1 course5 lab lessonsC++
    • DSC13C++

      Algorithms and Advanced Data Structures

      5

      lessons

      • Amortized analysis and NP: dynamic arrays, counters, certificates and reductions
      • KMP, standard, compressed and suffix tries, a search engine, and Ford-Fulkerson max flow
      See all 5 lessons
      1. 1Amortized analysis and NP: dynamic arrays, counters, certificates and reductionsUnit 1 · Advanced Analysis of Algorithms and Intractability
      2. 2KMP, standard, compressed and suffix tries, a search engine, and Ford-Fulkerson max flowUnit 2 · Algorithms on Strings and Flows
      3. 3Union-Find, Kruskal, Bellman-Ford, and B-trees with 2-4 trees as the t = 2 caseUnit 3 · More on Trees and Graphs
      4. 4Randomized quicksort, randomized select and a skip listUnit 4 · Randomization
      5. 5KMP, tries, Kruskal, Bellman-Ford, suffix tries and B-treesUnit LAB · Suggested Practical List

The full 20-course syllabus is transcribed in the app, including the theory courses. Lessons are authored against the course codes that have practical work, and the list grows with each release.

GroutCode is not affiliated with or endorsed by University of Delhi. Course codes and titles are transcribed from the institution’s published scheme documents.

How a practical runs

The same five steps for every lesson, in every language.

  1. 1

    Pick your syllabus

    Choose your university or board and the semester or class you are in. The course list is the transcribed official scheme, not an approximation.

  2. 2

    Open a lab lesson

    Each lesson is a stepped practical for a specific course, with a starter file you edit and a test file you do not.

  3. 3

    Write the code yourself

    The starter has the signatures and the TODOs. You implement them in the editor, in the language your course actually uses.

  4. 4

    Run the checks

    The toolchain compiles and runs the tests — 8 to 15 of them across the lesson, one per step, so you find out which change broke what.

  5. 5

    Get the review

    Once the tests pass, the model reads your implementation and tells you the input that breaks it. It never reports the pass or fail itself.

Why the compiler grades, not the model

The obvious way to build an AI lab tool is to let the model read the student’s code and say whether it is correct. It is also the way that produces a tool nobody can trust. A model will tell you your code works when the compiler says otherwise, and it will fail you for a style it happens to dislike.

So the two jobs are split:

  • The model designs the lesson, writes the starter and the tests, and — after the tests pass — reads what you actually wrote and tells you the input that breaks it.
  • The toolchain decides whether it compiles and whether each step passes. That verdict is not negotiable and the model never issues it.

And why steps instead of one big task

A 40-to-60 minute practical with a single Run at the end gives a beginner one bit of feedback an hour, and it arrives after every decision has already been made. Each lesson here is 8 to 15 steps, each with its own instruction and its own check, so you find out which change broke what while you still remember making it.

Frequently asked questions

Does GroutCode cover the Delhi University UGCF 2022?

Yes. GroutCode ships the transcribed Delhi University UGCF 2022 for B.Sc. (Hons.) Computer Science — 20 courses — with 42 authored lab lessons mapped to specific course codes. The syllabus was transcribed from the official documents, and the source and checksum of each one is recorded in the app.

Which languages do the Delhi University practicals use?

C++ (23 lessons), SQL (7 lessons), Python (6 lessons), C (6 lessons). The language is set per course code rather than guessed from the title, because the same subject is taught in different languages at different institutions.

Does the AI just write the practical for me?

No. The starter file has the signatures and the TODOs; you implement them. The toolchain — not the model — decides whether your code compiles and whether each step passes, so the AI cannot tell you your code works when the compiler disagrees. What it does afterwards is read your implementation and point out the input that breaks it.

Do the practicals work offline?

The lessons, the syllabus and the test runner are bundled in the app and run locally, so the compile-and-check loop works with no connection. The review step at the end uses a model, which can be a local one or a cloud one with your own key.

What do I need installed?

GroutCode detects which toolchains are present on your machine and tells you what is missing and what would fix it. You need the compiler or interpreter for the language your course uses — a C compiler, a JDK, Python, Node or SQLite.

Other syllabuses

APJ Abdul Kalam Technological University

KTU

APJ Abdul Kalam Technological University

The 2024 scheme for Kerala’s technological university, covering CSE, IT, AI & DS and ECE from semester three onwards.

85

lab lessons

2024 schemeC · Java · Node.js · Python
Visvesvaraya Technological University

VTU

Visvesvaraya Technological University

Karnataka’s 2022 scheme across CSE, ISE, AI-ML, AI-DS and ECE, including the dedicated lab courses.

123

lab lessons

2022 schemeC · Python · Java · C++
Anna University, Chennai

Anna University

Anna University, Chennai

Anna University’s Regulations 2021 B.E. CSE, from Python and C programming to the data structures and OOP laboratories.

31

lab lessons

R2021C · Python · Java · SQL

← All supported syllabuses

Do your Delhi University lab work with the checks built in

GroutCode is included in every Grout Suite license. Free download for Windows and macOS.

Download GroutCode