Python + Java Practice

🐍 Python — Day 3

5 questions · List, Tuple, Set, Dict, OOP, File Handling · Difficulty 2/5

Daily Expense Tracker 💰

PYTHON LIST FILE EASY ~30 min

📖 Scenario

You want to track your daily expenses. Each expense is stored as a dictionary with "item" and "amount". You need to save them to a file and load them back — just like a real expense app saves your data!

💡 New concept: File Handling
open("file.txt", "w") → write mode (creates file)
open("file.txt", "a") → append mode (adds to existing)
open("file.txt", "r") → read mode
Always use with open(...) as f: — it auto-closes the file!

Starter Data

expenses = [
    {"item": "Lunch",    "amount": 120},
    {"item": "Bus",      "amount": 30},
    {"item": "Coffee",  "amount": 60},
    {"item": "Dinner",  "amount": 200},
    {"item": "Snacks",  "amount": 45},
]

# Write your functions below
        

Your Tasks

Write a save_expenses(expenses, filename) function that saves each expense as a line: Lunch,120 Use "w" mode. Write item and amount separated by comma.
Write a load_expenses(filename) function that reads the file back and returns a list of dicts Split each line by comma, convert amount to int
Write a summary(expenses) function that returns: total spent, most expensive item, cheapest item Use max() and min() with key=lambda
Save expenses to expenses.txt, load it back, and print the summary

Expected Output

Saved to expenses.txt!
Loaded 5 expenses.
Total spent: ₹455
Most expensive: Dinner (₹200)
Cheapest: Bus (₹30)

💡 One Hint

To write: f.write(f"{e['item']},{e['amount']}\n") for each expense.
To read back: line.strip().split(",") gives you ["Lunch", "120"]

Movie Rating System 🎬

PYTHON TUPLE DICT EASY ~25 min

📖 Scenario

You are building a movie rating system like IMDb. Each movie is stored as a tuple — (title, genre, rating). Tuples are used because movie data shouldn't change once recorded. You need to filter, group, and analyze them.

Starter Data

movies = [
    ("Inception",    "Sci-Fi",  8.8),
    ("The Godfather", "Drama",   9.2),
    ("Interstellar",  "Sci-Fi",  8.6),
    ("Coco",          "Animation",8.4),
    ("Parasite",      "Drama",   8.6),
    ("Toy Story",     "Animation",8.3),
]
# movie[0]=title, movie[1]=genre, movie[2]=rating
        

Your Tasks

Find all movies with rating above 8.5 — return their titles only
Group movies by genre — return a dict: {"Sci-Fi": [...], "Drama": [...]} Each value is a list of movie titles in that genre
Find the highest rated movie in each genre Return dict: {"Sci-Fi": ("Inception", 8.8), ...}
Calculate the average rating of all movies

Expected Output

Above 8.5: ['Inception', 'The Godfather', 'Interstellar', 'Parasite']
Genre groups: {'Sci-Fi': ['Inception','Interstellar'], 'Drama': ['The Godfather','Parasite'], 'Animation': ['Coco','Toy Story']}
Best per genre: {'Sci-Fi': ('Inception',8.8), 'Drama': ('The Godfather',9.2), 'Animation': ('Coco',8.4)}
Average rating: 8.65

💡 One Hint

For grouping by genre, use dict.setdefault(genre, []).append(title) — this creates the key if it doesn't exist and appends to the list!

Course Enrollment Checker 🎓

PYTHON SET DICT EASY ~20 min

📖 Scenario

A university has students enrolled in different courses. Using sets, you can instantly find which students are in multiple courses, who is only in one course, and how many unique students there are — no loops needed!

Starter Data

python_class = {"Rahul", "Priya", "Arjun", "Sneha", "Karan"}
java_class   = {"Priya", "Arjun", "Vikram", "Neha"}
ml_class     = {"Sneha", "Vikram", "Rahul", "Divya"}
        

Your Tasks

Find students enrolled in both Python AND Java
Find students in Python only (not in Java or ML)
Find all unique students across all 3 courses
Find students enrolled in all 3 courses at once
Count how many students are in exactly one course Hint: use symmetric difference or manual checking

Expected Output

Python ∩ Java: {'Priya', 'Arjun'}
Python only: {'Karan', 'Rahul'} (not in Java or ML... wait Rahul is in ML! → {'Karan'})
All students: {'Rahul','Priya','Arjun','Sneha','Karan','Vikram','Neha','Divya'}
In all 3: set() (nobody!)
In exactly 1 course: {'Karan', 'Neha', 'Divya'} → 3 students

💡 One Hint

"Python only" means in python_class but NOT in java_class and NOT in ml_class:
python_class - java_class - ml_class

Library Book System 📚

PYTHON OOP LIST EASY ~35 min

📖 Scenario

Build a simple library system. A Book class stores book info. A Library class manages a collection of books — you can add books, search by author, and check out (borrow) a book. If a book is already borrowed, show an error!

💡 New OOP concept: Composition
One class can contain objects of another class!
Library has a list of Book objects — that's composition.
It's like a school that contains students — school IS NOT a student, but it HAS students!

Starter Template

class Book:
    def __init__(self, title, author, pages):
        pass  # store title, author, pages, is_borrowed=False

    def __str__(self):
        pass  # return "Title by Author (pages pg)"

class Library:
    def __init__(self):
        self.books = []

    def add_book(self, book): pass
    def search_by_author(self, author): pass
    def checkout(self, title): pass
    def return_book(self, title): pass
        

Your Tasks

Complete Book.__init__ — store title, author, pages. Add is_borrowed = False
Complete Book.__str__ — returns a readable string like "Atomic Habits by James Clear (320 pg)"
Complete Library.add_book — append book to self.books list
Complete Library.search_by_author — return list of all books by that author
Complete checkout — if not borrowed → mark as borrowed. If already borrowed → print "Already checked out!" Also complete return_book — reverse of checkout

Expected Output

lib.add_book(Book("Atomic Habits", "James Clear", 320))
lib.checkout("Atomic Habits") → "Checked out: Atomic Habits"
lib.checkout("Atomic Habits") → "Already checked out!"
lib.return_book("Atomic Habits") → "Returned: Atomic Habits"
lib.search_by_author("James Clear") → [Atomic Habits by James Clear (320 pg)]

💡 One Hint

In checkout, loop through self.books to find the book by title. Use book.is_borrowed to check status and set it to True when borrowed.

Word Frequency Counter 📝

PYTHON DICT FILE LIST EASY ~25 min

📖 Scenario

You are building a tool that reads a paragraph from a file and counts how many times each word appears — like Google's word analysis tool. This combines file reading with dictionary counting!

Starter Code

# First create sample.txt with this content:
text = """python is great python is easy
java is also great programming is fun
python and java are both popular"""

with open("sample.txt", "w") as f:
    f.write(text)

# Now write these functions:
        

Your Tasks

Write count_words(filename) — reads file, returns dict of word frequencies Lowercase all words. Split by spaces. Count each word.
Write top_n_words(freq_dict, n) — returns top N most frequent words as list of tuples Sort by count descending, return first n items
Write words_appearing_once(freq_dict) — returns list of words that appear exactly once
Save the frequency results back to word_report.txt — one word per line: python: 3

Expected Output

count_words → {'python':3, 'is':4, 'great':2, 'easy':1, 'java':2, 'also':1, 'programming':1, 'fun':1, 'and':1, 'are':1, 'both':1, 'popular':1}
top_3 → [('is',4), ('python',3), ('great',2)]
appearing once → ['easy','also','programming','fun','and','are','both','popular']

💡 One Hint

For counting: freq[word] = freq.get(word, 0) + 1 — this adds 1 to existing count or starts at 0 if word is new. No need to check if key exists!

☕ Java — Day 3

5 questions · ArrayList, HashMap, HashSet, OOP, File I/O · Difficulty 2/5

Student Grade Manager 📝

JAVA ARRAYLIST HASHMAP EASY ~30 min

📖 Scenario

You are building a grade management system. Student names and marks are stored in a HashMap. You need to find the topper, calculate average, and get pass/fail lists — just like a school portal!

💡 Java equivalent of Python dict → HashMap
Python: {"Rahul": 72}
Java: HashMap<String, Integer> grades = new HashMap<>();
Add: grades.put("Rahul", 72);
Get: grades.get("Rahul");
Loop: for (Map.Entry<String,Integer> e : grades.entrySet())

Starter Code

import java.util.*;

public class GradeManager {
    public static void main(String[] args) {

        HashMap<String, Integer> grades = new HashMap<>();
        grades.put("Rahul",  72);
        grades.put("Priya",  85);
        grades.put("Arjun",  40);
        grades.put("Sneha",  91);
        grades.put("Vikram", 55);

        // Write your code here
    }
}
        

Your Tasks

Calculate and print the average marks of the class
Print names of all students who passed (marks >= 50)
Print names of all students who failed (marks < 50)
Find and print the topper's name (highest marks) Loop through entrySet() and track the max manually

Expected Output

Average: 68.6
Passed: [Rahul, Priya, Sneha, Vikram]
Failed: [Arjun]
Topper: Sneha with 91 marks

💡 One Hint

To loop through a HashMap: for (Map.Entry<String,Integer> entry : grades.entrySet()) { entry.getKey(); entry.getValue(); }

Common Friends Finder 👫

JAVA HASHSET EASY ~20 min

📖 Scenario

Same Instagram mutual friends concept — but in Java! HashSet is Java's equivalent of Python's set. It automatically removes duplicates and supports set operations like intersection and union.

💡 Java Set operations
Python A & B → Java: setA.retainAll(setB) (modifies setA!)
Python A - B → Java: setA.removeAll(setB) (modifies setA!)
Python A | B → Java: setA.addAll(setB) (modifies setA!)
Important: Always work on a COPY → new HashSet<>(setA)

Starter Code

import java.util.*;

public class FriendFinder {
    public static void main(String[] args) {

        HashSet<String> rahulFriends = new HashSet<>(
            Arrays.asList("Amit","Priya","Rohan","Sneha","Karan")
        );
        HashSet<String> priyaFriends = new HashSet<>(
            Arrays.asList("Rohan","Sneha","Ankit","Divya")
        );

        // Write your code here — use copies!
    }
}
        

Your Tasks

Find common friends (intersection) Make a copy of rahulFriends first, then use retainAll(priyaFriends)
Find friends that are only Rahul's (difference)
Find all friends combined (union, no duplicates)
Print total count of unique friends

Expected Output

Common: [Rohan, Sneha]
Only Rahul's: [Amit, Priya, Karan]
All friends: [Amit, Priya, Rohan, Sneha, Karan, Ankit, Divya]
Total unique: 7

💡 One Hint

Always copy before modifying: HashSet<String> common = new HashSet<>(rahulFriends); then common.retainAll(priyaFriends);. If you don't copy, you'll destroy the original set!

Simple Bank Account 🏦

JAVA OOP INHERITANCE EASY ~35 min

📖 Scenario

Build a bank account system in Java. A BankAccount class handles deposits and withdrawals. A SavingsAccount subclass adds interest logic. This is exactly like Python's class/inheritance — just different syntax!

💡 Python vs Java OOP comparison
Python: class SavingsAccount(BankAccount):
Java: class SavingsAccount extends BankAccount

Python: super().__init__(name, balance)
Java: super(name, balance);

Python: raise Exception("msg")
Java: throw new Exception("msg");

Starter Template

public class BankAccount {
    protected String name;
    protected double balance;

    public BankAccount(String name, double balance) {
        // store name and balance
    }

    public void deposit(double amt)  { /* add to balance */ }
    public void withdraw(double amt) { /* subtract if enough */ }
    public void display()           { /* print name + balance */ }
}

class SavingsAccount extends BankAccount {
    public SavingsAccount(String name, double balance) {
        super(name, balance); // call parent constructor
    }
    public void addInterest() { /* add 5% interest */ }
}
        

Your Tasks

Complete BankAccount constructor — store name and balance using this.name = name
Complete deposit — add amt to balance and print "Deposited: X | Balance: Y"
Complete withdraw — if amt > balance print "Insufficient funds!", else subtract and print balance
Complete display — print account holder name and current balance
Complete SavingsAccount.addInterest — multiply balance by 1.05 and print new balance

Expected Output

acc.deposit(500) → Deposited: 500.0 | Balance: 1500.0
acc.withdraw(200) → Withdrawn: 200.0 | Balance: 1300.0
acc.withdraw(5000) → Insufficient funds!
sav.addInterest() → Interest added! New balance: 2100.0

💡 One Hint

In Java, use this.balance += amt to add to the balance. The keyword this refers to the current object — same as Python's self!

Cricket Score Tracker 🏏

JAVA ARRAYLIST COLLECTIONS EASY ~25 min

📖 Scenario

Build a cricket scorecard in Java. Player scores are stored in an ArrayList of custom Player objects. You need to find the highest scorer, filter 50+ scorers, and calculate the team total — same logic as Python but Java syntax!

💡 Python List vs Java ArrayList
Python: scores = [] → scores.append(x)
Java: ArrayList<Player> scores = new ArrayList<>(); → scores.add(x);

Python: for p in scores:
Java: for (Player p : scores)

Starter Code

import java.util.*;

class Player {
    String name;
    int runs;
    public Player(String name, int runs) {
        this.name = name; this.runs = runs;
    }
}

public class CricketTracker {
    public static void main(String[] args) {
        ArrayList<Player> team = new ArrayList<>();
        team.add(new Player("Rohit",   83));
        team.add(new Player("Virat",   45));
        team.add(new Player("Dhoni",   67));
        team.add(new Player("Hardik",  32));
        team.add(new Player("Shubman", 91));
        // Write your code here
    }
}
        

Your Tasks

Calculate and print the total runs of the team
Find and print the highest scorer (name + runs)
Print all players who scored 50 or more runs
Calculate and print the team average

Expected Output

Total runs: 318
Highest scorer: Shubman - 91 runs
50+ scorers: Rohit(83), Dhoni(67), Shubman(91)
Team average: 63.6

💡 One Hint

To loop and find max manually: start with Player highest = team.get(0); then loop — if p.runs > highest.runs, update highest = p;

Student Record File Writer 📁

JAVA FILE I/O OOP EASY ~30 min

📖 Scenario

Write a program that saves student records to a file and reads them back. In Java, file handling uses FileWriter and BufferedReader — more verbose than Python but same idea. Write once, read many times!

💡 Python vs Java File Handling
Python write: with open("f.txt","w") as f: f.write(text)
Java write: FileWriter fw = new FileWriter("f.txt"); fw.write(text); fw.close();

Python read: with open("f.txt","r") as f: lines = f.readlines()
Java read: BufferedReader br = new BufferedReader(new FileReader("f.txt"));
Then: String line = br.readLine(); in a loop until null

Starter Template

import java.io.*;
import java.util.*;

public class StudentFileManager {

    static String[][] students = {
        {"Rahul", "72"},
        {"Priya", "85"},
        {"Arjun", "40"},
        {"Sneha", "91"}
    };

    public static void saveToFile(String filename) throws IOException {
        // Write each student as "Name,Marks" on each line
    }

    public static void readFromFile(String filename) throws IOException {
        // Read each line, split by comma, print name and marks
    }

    public static void main(String[] args) throws IOException {
        saveToFile("students.txt");
        readFromFile("students.txt");
    }
}
        

Your Tasks

Complete saveToFile — write each student as Rahul,72 on a new line using FileWriter
Complete readFromFile — read each line using BufferedReader, split by comma, print name and marks
In main, after reading, also print: total students count, and the name of the student with highest marks You'll need to parse marks to int using Integer.parseInt()

Expected Output

Saved 4 students to students.txt
--- Reading from file ---
Rahul: 72 marks
Priya: 85 marks
Arjun: 40 marks
Sneha: 91 marks
Total students: 4 | Topper: Sneha (91)

💡 One Hint

For FileWriter: FileWriter fw = new FileWriter(filename); fw.write(name + "," + marks + "\n"); fw.close();
For BufferedReader: String line; while ((line = br.readLine()) != null) { String[] parts = line.split(","); }

Python + Java Questions 💪

🐍 Python — Day 3

☕ Java — Day 3