Course Code : PEC-CS-501I

Course Title : Data Communication

Credit : 3

Course Outcome:

1. Students will be able to provide students with a comprehensive understanding of the

concepts and principles underlying data communication.
2. Students will be able to familiarize students with different network architectures and
protocols.
3. Students will be able to develop practical skills in designing and analyzing data
communication systems.
4. Students will be able to introduce students to network security concepts and issues.

5. Students will be able to enable students to apply their knowledge to solve real-world data
communication problems.

Course Topics:

Module 1:

• Introduction to Data Communication

o Definitions and concepts
o Components of a data communication system
o Data communication models
• Networking Protocols
o TCP/IP protocol suite
o OSI model and its layers
o Protocol functions and services

Module 2:

• Network Architectures
o Local Area Networks (LANs)
o Wide Area Networks (WANs)
o Metropolitan Area Networks (MANs)
o Network topologies and configurations
• Data Encoding and Modulation Techniques
o Digital data representation
o Analog and digital signals
o Modulation techniques (Amplitude, Frequency, Phase)
• Error Detection and Correction
o Error detection codes (parity, checksum, CRC)
o Error correction codes (Hamming codes, Reed-Solomon codes)

Module 3:

• Multiplexing Techniques
 o Frequency division multiplexing (FDM)
o Time division multiplexing (TDM)
o Code division multiplexing (CDM)
• Switching Techniques
o Circuit switching
o Packet switching
o Message switching

Module 4:

• Network Security
o Cryptography and encryption techniques
o Authentication and access control
o Network threats and countermeasures
• Emerging Trends in Data Communication
o Wireless and mobile communication
o Internet of Things (IoT)

o Cloud computing and virtualization

Textbooks:

1. "Data Communications and Networking" by Behrouz A. Forouzan

2. "Computer Networks" by Andrew S. Tanenbaum and David J. Wetherall

References:

1. "Data and Computer Communications" by William Stallings

2. "Computer Networking: A Top-Down Approach" by James F. Kurose and Keith W. Ross

Course Code : PCC CS 504
Course Title : Software Engineering
Credit : 2

Course Outcome
On completion of the course,

Students will be able to decompose the given project in various phases of a life cycle as well as various cost-benefit analysis.
CO1.
Students will be able to choose appropriate process model depending on the user requirements and implement proper design,
CO2. coding and testing methodologies.

CO3. Students will be able to know various processes used in all the phases of project management.
Students can apply the knowledge of various static and dynamic models and UML diagrams on account of project
CO4. development.

Module
Content Hrs./Unit CO
No.

Overview of System Analysis & Design, Business System Concept, System

1 Development Life Cycle, Waterfall Model, Spiral Model, Feasibility Analysis, 10 1
Technical Feasibility, Cost- Benefit Analysis, COCOMO model.

System Design – Context diagram and DFD, Problem Partitioning, Top-Down and
Bottom-Up design; Decision tree, decision table and structured English; Functional vs.
Object- Oriented approach.

2 Coding & Documentation – Structured Programming, OO Programming, Information 17 2

Hiding, Reuse, System Documentation.

Testing – Levels of Testing, Integration Testing, Test case Specification, Reliability

Assessment, Validation & Verification, Metrics, Monitoring & Control.

Software Project Management – Project Scheduling, Staffing, Software Configuration

3 8 3
Management, Quality Assurance, Project Monitoring.

Static and dynamic models, why modeling, UML diagrams: Class diagram, interaction
4 diagram: collaboration diagram, sequence diagram, state chart diagram, activity 7 4
diagram, implementation diagram.

Text book and Reference books:

1. Pressman, Software Engineering: A practitioner’s approach– (TMH)

2. Pankaj Jalote, Software Engineering- (Wiley-India)
3. N.S. Gill, Software Engineering – (Khanna Publishing House)
4. Rajib Mall, Software Engineering- (PHI)
5. Agarwal and Agarwal, Software Engineering – (PHI)
6. Sommerville, Software Engineering – Pearson
7. Martin L. Shooman, Software Engineering – TMH
Course - Database Management System
Course Code- PCC-CS 501
Credit – 3

Course Outcomes:
CO1: To remember different aspects of a database management system.
CO2: To understand different issues involved in the design and
implementation of a database system.
CO3: To apply the knowledge of a database system for writing queries,
normalizing a database, applying techniques to serialize transaction
schedules in concurrent or parallel databases and also applying security
techniques for data warehousing and data mining.
CO4: To analyse a database architecture, query methods suitable to it, finding
suitability of normalization degrees, storage strategies in terms of time-space
trade off, analyzing the performance of a concurrency control scheme, and
suitability of the security technique pertaining to the use cases of the
database.
CO5: To evaluate the performance of a database in terms of its architecture,
design, data storage, concurrency control and security.
CO6: To design and build a new architectural model for a simple database
system and demonstrate competence with the fundamental tasks involved
with modelling, designing, and implementing a DBMS.
Syllabus:
Module 1 [6L]
Database system architecture: Data Abstraction, Data Independence, Data
Definition Language (DDL), Data Manipulation Language (DML).
Data models: Entity-relationship model, network model, relational and object
oriented data models, integrity constraints, data manipulation operations.
Module 2 [13L]
Relational query languages: Relational algebra, Tuple and domain relational
calculus, SQL, DDL and DML constructs, Open source and Commercial
DBMS - MYSQL, ORACLE, DB2, SQL server.
Module 3 [6L]
Relational database design: Domain and data dependency, Different
anomalies in designing database, Normalization using functional dependency,
Armstrong’s axioms, Decomposition, Normal forms, Dependency
preservation, Lossless design.
Query processing and optimization: Evaluation of relational algebra
expressions, Query equivalence, Join strategies, Query optimization
algorithms.
Module 4 [3L]
Storage strategies: Indices, B-trees, hashing.
Module 5 [5L]
Transaction processing: Concurrency control, ACID property, Serializability
of scheduling, Locking and timestamp based schedulers, Multi-version and
optimistic Concurrency Control schemes, Database recovery.
Module 6 [3L]
Database Security: Authentication, Authorization and access control, DAC,
MAC and RBAC models, Intrusion detection, SQL injection.
Advanced topics: Object oriented and object relational databases, Logical
databases, Web databases, Distributed databases, Data warehousing and
data mining.

Text book and Reference books:

1. “Database System Concepts”, 6th Edition by Abraham Silberschatz, Henry
F. Korth, S. Sudarshan,McGraw-Hill.
2. “Principles of Database and Knowledge – Base Systems”, Vol 1 by J. D.
Ullman, Computer SciencePress.
3. “Fundamentals of Database Systems”, 5th Edition by R. Elmasri and S.
Navathe,
4. PearsonEducation “Foundations of Databases”, Reprint by Serge Abiteboul,
Richard Hull, Victor Vianu, Addison-Wesley
5. Database Management Systems, R.P. Mahapatra, Khanna Publishing
House

CO-PO Mapping
PO1 PO2 PO3 PO4 PO5 PO6 PO7 PO8 PO9 PO10 PO11 PO12

CO1 3 3 2 2 1 0 0 0 0 0 0 0

CO2 3 3 2 2 1 1 0 0 0 0 0 1

CO3 3 3 2 2 1 1 0 0 0 0 0 1

CO4 3 3 2 2 1 1 0 0 0 0 0 1

CO5 3 3 2 2 1 1 1 0 0 1 1 1

CO6 3 3 3 3 2 1 1 0 0 1 1 1
 PO Competency Indicator CO1 CO2 CO3 CO4 CO5 CO6

PO1: Engineering 1.2 1.2.1 Apply YES YES YES YES YES YES
knowledge: Apply Demonstrate the knowledge
the knowledge of competence in of discrete
mathematics, mathematical structures,
science, modelling linear algebra,
engineering statistics and
fundamentals, numerical
and an techniques to
engineering solve problems
Specialization to
the solution of
complex 1.2.2 Apply the YES YES YES YES YES YES
engineering concepts of
problems. probability,
statistics and
queuing theory
in modelling of
computer based
system, data
and network
protocols.

1.5 1.5.1 Apply YES

Demonstrate laws of natural
competence in science to an
basic sciences engineering
problem

1.6 1.6.1 Apply YES YES YES YES YES

Demonstrate engineering
competence in fundamentals
engineering
fundamentals

1.7 1.7.1 Apply YES YES YES YES YES

Demonstrate theory and
competence in principles of
specialized computer
engineering science and
knowledge to engineering to
the program solve an
engineering
problem

PO2: Problem 2.5 2.5.1 Evaluate YES YES YES YES YES YES
analysis: Identify, Demonstrate problem
formulate, research an ability to statements
literature, and identify and and identifies
analyse complex formulate objectives
engineering complex
problems engineering 2.5.2 Identify YES YES YES YES YES YES
reaching problem processes/mod
substantiated ules/
conclusions using algorithms of a
first principles of computer-
mathematics, based system
natural sciences, and
and parameters to
Engineering solve a
sciences. problem

2.5.3 Identify YES YES YES YES YES YES

mathematical
algorithmic
knowledge that
applies to a
given problem
2.6 2.6.1 Reframe
Demonstrate the computer-
an ability to based system
formulate a into
solution plan interconnected
and subsystems
methodology
for an 2.6.2 Identify YES YES YES YES
engineering functionalitie
problem s and
computing
resources.

2.6.3 Identify YES YES YES YES

existing
solution/
methods
to solve
the
problem,
including
forming
justified
approxi
mations
and
assumpt
ions

2.6.4 YES YES YES

Compare
and
contrast
alternative
solution/me
thods to
select the
best
methods

2.6.5 YES YES YES

Compare
and contrast
alternative
solution
processes to
select the
best
process.
 Competitive Programming | All You Need to Know to Get Started with Competitive Coding

What is Competitive Programming?

Competitive Coding/Programming is more or less like a competition, wherein you use your programming
skills to code and solve a given problem which is close to real-time problems. Unlike other coding contests,
here, programmers participate and write programs under specified limits (time, memory used, input range
etc).

How to get started with Competitive Programming?

As a beginner, if you are wondering what exactly you need to know to get started with competitive
programming, then here is all you need to know.

LEVEL 1: BEGINNER

At this level, you need to make sure you accomplish/complete all these things.

• Have an intermediate understanding of at least one among these languages -

C/C++/JAVA/Python/Perl/JavaScript. This will be the language that you would primarily use to
code in further levels.
• Solve all the beginner level basic programming challenges using the language you have chosen.
This will help with developing your logic building skills.

Note: This level is all about concept building & strengthening up your programming fundamentals. Also,
there is no one language that is considered best for competitive programming. However, a majority of the
programmers use C++, Java, Python.

LEVEL 2: INTERMEDIATE

Now is the time for you to take up some real challenges like those asked by Product companies. Before
this, you need to be thorough with the concepts & applications of:

• Arrays
• Basic Data Structures (Stack, Queue, LL)
• Advanced-Data Structures (Trees, Graphs, Hash Tables)
• Basic Searching & Sorting Techniques
• Disjoint Data Structures

Target: Once you build your conceptual knowledge, then quickly get into solving the intermediate level
problems from one of these websites.

• Hacker Earth
• Hacker Rank
• Code Chef
• Code forces
• Leetcode
• Techie Delight

LEVEL 3: ADVANCED

This stage is all about learning more advanced algorithms that will help you solve the problems in no- time.
Some of those algorithms are:

• Dynamic Programming
• Greedy Algorithm
• Graph Algorithms: Breadth-First Search (BFS), Depth First Search (DFS), Dijkstra's
Algorithm, Floyd Warshall, Flood Fill Algorithm, Prim & Kruskal Minimum Spanning Tree.
 • Backtracking
• Divide & Conquer

Target: Now go-ahead and practice all the advanced level problems given in the above-listed websites.

Common Terminologies used in Competitive Coding

Problem Statement: Programmers will be given with well-defined problem statement in the form of a story
which also consists of some assumptions, variables constraints, etc.

Note: Problem statement can be direct in some cases.

Input: The sample input values for the problem statement. Using this, a programmer will get some gist on
the structure of a program.

Output: The sample output that gets generated with the given input will be shown. This will help the
programmer find the logic of the program.

Constraints: Constraints will be given in terms of time, space, input range and the code must satisfy all.
Also, you must write the program using one of the specified sets of programming languages.

Evaluation: The program answers are evaluated by computers, not humans. So, no subjectiveness. There
are multiply ways to write a program for the given problem statement, but only those which satisfies the
given constraints will be considered correct.

Test cases: Test cases are the set of input and output values given for the problem to check whether the
program is executing correctly or not. Let’s look at an example to understand the test cases better.

Consider a program to check whether the given input value is positive or negative.

Test case Input Output

1 2 Positive Number
2 -2 Negative Number

In competitive programming, each problem will be given with some normal and hidden test cases. The
programmer's program should pass all the test cases given.

Hidden test cases are not visible to the programmers in the programming window whereas they will be
notified along with the normal test cases when they execute the program.

Marking scheme: Score to a particular problem depends on the competition rules. In certain competition,
the program must pass all the given test cases to get points for the problem. Whereas in another
competition, there will be partial points depending on how many test cases your program can pass. In some
other competition, each normal and hidden test cases will have some specific points.

Program modifications:

In some competition, the program does not read the input. Instead, the platforms will have the
implementation of a particular function/method. In such cases, the input will be available as the function
parameters.

In case of optimization problems, the evaluation does not rely on optimal answer. Instead, your score will
depend on how good your program is. The better your answer, the higher your score.
How to Approach a Competitive Programming Question

Step by Step Approach to Competitive Coding Question

Here is the step-by-step approach that will help you understand and interpret a given competitive
programming question. Also, let us consider a competitive coding question and apply this approach after
every step.

Competitive Coding Challenge: Maximum profit

Problem Statement: Assume, you own a departmental store. You will be given with stock prices of each
and every day. Write a program to determine the days in which you should buy and sell the stocks to get
the maximum profit.

Input: Input contains a sequence of values representing the stock prices for 7 days.

Sample Input:

100, 180, 260, 310, 40, 535, 695

The stock price for the 1st day is 100, 2nd day it is 180 and so on.

Output: Output should print whether you should buy or sell along with the day and price (in brackets).

Sample Output:

Buy stock on day 1 (100)

Sell stock on day 4 (310)

Buy stock on day 5 (40)

Sell stock on day 7 (695)

Constraints: Input should be in the range of 1< x < 10^3.

Test case 1:

Input: 50, 100, 120, 130, 250

Output:

Buy stock on day 1 (50)

Sell stock on day 5 (250)

Test case 2:

Input: 140, 20, 150, 10, 350

Output:

Buy stock on day 2 (20)

Sell stock on day 3 (150)

Buy stock on day 4 (10)

Sell stock on day 5 (350)

a) Understand the problem

Read the given problem statement twice or thrice (based on your understanding capability). If possible,
write it down on a piece of paper or try to relate it with real-time example.

From the problem: In this case, since the question is very direct, you can understand it after reading once
or twice. From the given problem statement, it is clear that we need to decide whether we need to buy or
sell stocks on a particular day. This is a real-time question and hence it is easy to comprehend. You need
to think of yourself as a manager and write the code to make a profit.

Analyze the problem

• Find out whether you can explain the question to a layman.

• What and how many inputs are required and? what would be the output for those inputs?
• Can you break down the problem into smaller chunks for easy implementation?

From the problem: Input contains the stock prices in a single line with which we need to decide the status
(buy or sell). For the given stock prices, the output should display the status (buy or sell) along with the day
and price.

For the given problem, we are provided with two test cases. So, keep in mind that the code has to pass
these test cases. Also, this problem can be broken down into chunks and we will do it in the later stage.

Understand I/O

Go through the examples (if any), sample inputs and outputs given. This will help you understand the
problem better and will give you a clear idea of how many test cases your code should handle, and what
all can be the possible outputs.

Break down the problem further

This is very helpful when the problem is too big. In such cases,

• Divide the problem into sub-problems

• Make separate methods/functions for each sub-problem
• Make a link between those functions by calling them in the required order (as one function/method
will call another)

Start solving the problem

So far you have understood the problem. Now, it’s time to write a solution for the problem. If you find
difficulty in solving the entire problem at once, try implementing the sub-problems.

From the question: Start writing the code with one main function and two sub-functions (to find the
maximum and the minimum stock price). Ensure that the print statement in your code prints the same output
as given in the test cases.

Go back and check

This can be done, only if you can complete the problem earlier and have much time to check whether you
can improve your code or not. Check whether your code satisfies all the given constraints.

Important Things to Make Note of While Approaching a Competitive Programming Question

Compile Time Errors:

Often you might find syntax errors in your code. One must be careful about these syntax errors as in a lot
of competitions that the number of times you can compile/run your code is restricted to a certain
number of times.

Run Time Exception:

Reasons for exception errors in your code could be:

• Declaring an array of size more than 10^8 can throw an exception as 10^8 is the maximum size
you can use. Also, this depends on the compiler.
• Dividing or taking modulo with zero
• Segmentation fault: Accessing memory address which is not declared
• Example:
• int arr[10];
• printf("%d", arr[11]);

Time Limit:

Consider the time limit given for a question is 10 secs. But if your code runs more than that, then it will not
be accepted by the online judge. So, in this case, try to write using another approach, reduce the number
of loops used in the program.

Memory:

Consider the space allocated for your program in online judge is 25 MB. But if your code occupies more
than that, then it will not be accepted by the online judge for evaluation. So, in this case, try to use a smaller
number of variables, ensure that required memory is allocated for array, list, etc.
 Competitive Coding Syllabus
Serial No. Content

01. Array

02. Backtracking

03. Binary Tree

04. Bit Manipulation

05. Binary Search Tree

06. Divide Conquer & Combine

07. Dynamic Programming

08. Graph

09. Heap

10. Linked List

11. Matrix

12. Programming Puzzles

13. Queue

14. Sorting

15. Stack

16. String

17. Trie
 Top 25 Algorithms Every Programmer Should Know
Good knowledge of standard algorithms is equally important as choosing the right data structure. The
following is a list of the top 25 algorithms every student should know.

1. Binary Search Algorithm

2. Breadth First Search (BFS) Algorithm

3. Depth First Search (DFS) Algorithm

4. Merge Sort Algorithm

5. Quicksort Algorithm

6. Kruskal’s Algorithm

7. Floyd Warshall Algorithm

8. Dijkstra’s Algorithm

9. Bellman Ford Algorithm

10. Kadane’s Algorithm

11. Lee Algorithm

12. Flood Fill Algorithm

13. Floyd’s Cycle Detection Algorithm

14. Union Find Algorithm

15. Topological Sort Algorithm

16. KMP Algorithm

17. Insertion Sort Algorithm

18. Selection Sort Algorithm

19. Counting Sort Algorithm

20. Heap Sort Algorithm

21. Kahn’s Topological Sort Algorithm

22. Huffman Coding Compression Algorithm

23. Quick Select Algorithm

24. Boyer–Moore Majority Vote Algorithm

25. Euclid’s Algorithm

***************************************************************
Course Code: PCCCS502 - Formal
Language and Automata Theory
Credit: 3
Detailed Syllabus:

Module 1: 5L
Introduction: Alphabet [1L], languages and grammar [1L], productions and derivation [1L], Chomsky
Hierarchy of Languages [1L].

Module 2: 10L
Regular languages and finite automata: Regular expressions and languages [1L], deterministic finite
automata (DFA) and equivalence with regular expressions [2L], nondeterministic finite automata (NFA) and
equivalence with DFA [2L], regular grammars and equivalence with finite automata [2L], properties of
regular languages [1L], pumping lemma for regular languages [1L], minimization of finite automata [1L].

Module 3: 12L
Context free languages and pushdown automata: Context free grammars (CFG) and languages (CFL)
[2L], Chomsky and Greibach normal forms [2L], nondeterministic pushdown automata (PDA) and
equivalence with CFG [2L], parse trees, ambiguity in CFG [2L], pumping lemma for context free languages
[2L], deterministic pushdown automata, closure properties of CFLs [2L].

Module 4: 4L
Context-sensitive languages and Turing machine: Context-sensitive grammars (CSG) and languages
[1L], linear bounded automata and equivalence with CSG [1L]. Turing machines: The basic model for
Turing machines (TM), Turing recognizable (recursively enumerable) and Turing decidable (recursive)
languages and their closure properties [1L], variants of Turing machines, nondeterministic TMs and
equivalence with deterministic TMs, unrestricted grammars and equivalence with Turing machines, TMs as
enumerators [1L].

Module 5: 5L
Undecidability: Church Turing thesis [1L], universal Turing machine, the universal and diagonalization
languages [2L], reduction between languages and Rice s theorem [1L], undecidable problems about
languages [1L].

Textbook and Reference books:

1. An Introduction to Formal Languages and Automata“ by Peter Linz.
2. Introduction to Theory of computation by M. Sipser.
3. Introduction to automata theory, languages and computation, J. Ullman and J. Hopcroft