Merge pull request #1 from iamAntimPal/Daily-Task

Daily task

Author: Antim-IWP

.github/workflows/python-package-conda.yml

@@ -0,0 +1,34 @@
+name: Python Package using Conda
+
+on: [push]
+
+jobs:
+  build-linux:
+    runs-on: ubuntu-latest
+    strategy:
+      max-parallel: 5
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python 3.10
+      uses: actions/setup-python@v3
+      with:
+        python-version: '3.10'
+    - name: Add conda to system path
+      run: |
+        # $CONDA is an environment variable pointing to the root of the miniconda directory
+        echo $CONDA/bin >> $GITHUB_PATH
+    - name: Install dependencies
+      run: |
+        conda env update --file environment.yml --name base
+    - name: Lint with flake8
+      run: |
+        conda install flake8
+        # stop the build if there are Python syntax errors or undefined names
+        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
+        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+    - name: Test with pytest
+      run: |
+        conda install pytest
+        pytest

Python_Daily_Solutions/2140. Solving Questions With Brainpower/2140. Solving Questions With Brainpower.py

@@ -0,0 +1,10 @@
+class Solution:
+    def mostPoints(self, questions: List[List[int]]) -> int:
+        @cache
+        def dfs(i: int) -> int:
+            if i >= len(questions):
+                return 0
+            p, b = questions[i]
+            return max(p + dfs(i + b + 1), dfs(i + 1))
+
+        return dfs(0)

Python_Daily_Solutions/2140. Solving Questions With Brainpower/readme.md

@@ -0,0 +1,118 @@
+
+
+# 2140. Solving Questions With Brainpower
+
+## 📌 Problem Statement
+You are given a 0-indexed 2D integer array `questions` where `questions[i] = [pointsi, brainpoweri]`.  
+For each question, you must decide whether to **solve** it or **skip** it:
+- **Solve:** Earn `pointsi` points, but you must skip the next `brainpoweri` questions.
+- **Skip:** Move to the next question without earning any points.
+
+The goal is to maximize the total points earned by processing the questions in order.
+
+---
+
+## 📊 Table Structure
+
+Although this problem is algorithmic in nature and doesn't use a database, we can imagine a **Questions Table** that represents each question. For demonstration purposes, we’ll show a sample table structure similar to a "Teacher Table":
+
+### Teacher Table (Questions Table)
+| QuestionID | Points | Brainpower |
+| ---------- | ------ | ---------- |
+| 0          | 3      | 2          |
+| 1          | 4      | 3          |
+| 2          | 4      | 4          |
+| 3          | 2      | 5          |
+
+---
+
+## 📊 Example 1
+
+### Input: Teacher Table
+| QuestionID | Points | Brainpower |
+| ---------- | ------ | ---------- |
+| 0          | 3      | 2          |
+| 1          | 4      | 3          |
+| 2          | 4      | 4          |
+| 3          | 2      | 5          |
+
+### Output:
+```
+5
+```
+
+### Explanation:
+- **Solve question 0:** Earn 3 points, then skip questions 1 and 2.
+- **Solve question 3:** Earn 2 points.
+- **Total points:** 3 + 2 = 5.
+
+
+---
+
+## ✅ Approach: Python (Recursion with Memoization)
+We use a recursive depth-first search (DFS) with memoization to decide for each question whether to solve it or skip it.  
+For each question `i`:
+- **Solve:** Add `pointsi` and then jump to question `i + brainpoweri + 1`.
+- **Skip:** Move to question `i + 1`.
+
+The recurrence is:
+```python
+dfs(i) = max(pointsi + dfs(i + brainpoweri + 1), dfs(i + 1))
+```
+
+---
+
+## 🐍 Python (Pandas) Solution 1
+
+```python
+from functools import cache
+from typing import List
+
+class Solution:
+    def mostPoints(self, questions: List[List[int]]) -> int:
+        @cache
+        def dfs(i: int) -> int:
+            if i >= len(questions):
+                return 0
+            p, b = questions[i]
+            return max(p + dfs(i + b + 1), dfs(i + 1))
+        
+        return dfs(0)
+```
+
+## 🐍 Python (Pandas) Solution 2
+
+```python
+class Solution:
+    def mostPoints(self, questions: List[List[int]]) -> int:
+        @cache
+        def dfs(i: int) -> int:
+            if i >= len(questions):
+                return 0
+            p, b = questions[i]
+            return max(p + dfs(i + b + 1), dfs(i + 1))
+
+        return dfs(0)
+```
+
+### ✅ Approach Explanation:
+- **Recursion with Memoization:** The function `dfs(i)` computes the maximum points achievable starting from the `i`th question.
+- **Decision:** For each question, it chooses the maximum between solving the question (adding its points and skipping the next `brainpower` questions) and skipping the question.
+- **Efficiency:** The use of caching (`@cache`) ensures each state is computed only once.
+
+---
+
+## 📁 File Structure
+
+```plaintext
+.
+├── README.md          # This file
+└── solution.py        # Contains the Python solution implementation
+```
+
+---
+
+## 🔗 Useful Links
+- [LeetCode Problem 2140](https://leetcode.com/problems/solving-questions-with-brainpower/)
+- [Dynamic Programming - Wikipedia](https://en.wikipedia.org/wiki/Dynamic_programming)
+- [Python functools.cache Documentation](https://docs.python.org/3/library/functools.html#functools.cache)

Python_Daily_Solutions/2818. Apply Operations to Maximize Score/2818. Apply Operations to Maximize Score.py

@@ -0,0 +1,48 @@
+# Apply Operation to maximize Score
+import math
+from heapq import nlargest
+from collections import defaultdict
+
+MOD = 10**9 + 7
+
+def count_prime_factors(n):
+    """Returns the number of distinct prime factors of n."""
+    factors = set()
+    for i in range(2, int(math.sqrt(n)) + 1):
+        while n % i == 0:
+            factors.add(i)
+            n //= i
+    if n > 1:
+        factors.add(n)
+    return len(factors)
+
+def precompute_prime_scores(limit=10**5):
+    """Precomputes the prime scores for numbers from 1 to limit."""
+    prime_scores = [0] * (limit + 1)
+    
+    for i in range(2, limit + 1):
+        if prime_scores[i] == 0:  # `i` is a prime
+            for j in range(i, limit + 1, i):
+                prime_scores[j] += 1  # Mark multiples of `i`
+    
+    return prime_scores
+
+def maxScore(nums, k):
+    """Computes the maximum score using `k` operations."""
+    prime_scores = precompute_prime_scores(max(nums))
+
+    # Store elements as (prime_score, value, index)
+    elements = []
+    
+    for i, num in enumerate(nums):
+        elements.append((prime_scores[num], num, i))
+    
+    # Sort by (prime_score descending, value descending, index ascending)
+    elements.sort(reverse=True, key=lambda x: (x[0], x[1], -x[2]))
+
+    # Take `k` highest scoring elements
+    result = 1
+    for _, value, _ in elements[:k]:
+        result = (result * value) % MOD
+
+    return result