✅ Solution

💻 Try to do it by yourself before you check the solutions.

🚀 Two Pointers Problems upcoming! 🧑‍💻➡️👨‍💻
✅ A2SV Prep 💻

🌟🚀 @AceCoding Presents! 🚀🌟

💻 Topic: Two Pointers

✅ The following questions should be done sequentially. Level 1 and Level 2

🟡 2079. Watering Plants This an Easy Medium

⏳ This costed me 5 min

class Solution:
    def wateringPlants(self, plants: List[int], capacity: int) -> int:
        steps = 0
        can = capacity 
        for i, plant in enumerate(plants):

            if plant > can:
                steps += (2 * i)
                can = capacity

            steps += 1
            can -= plant
            
        return steps

👉 Problem link : https://leetcode.com/problems/watering-plants/

🟡 2105. Watering Plants II This one is also an easy medium but it has more edge cases so watch out before you hit submit 😁

⏳ This costed me 15 min; if there is anyone who did this under 10 minutes Excellent, Great job

class Solution:
    def minimumRefill(self, plants: List[int], capacityA: int, capacityB: int) -> int:
        refill = 0
        L, R = 0, len(plants) - 1
        alice, bob = capacityA, capacityB
        while L < R:
            if plants[L] > alice:
                alice = capacityA
                refill += 1
            if plants[R] > bob:
                bob = capacityB
                refill += 1
            alice -= plants[L]
            bob -= plants[R]
            L += 1
            R -= 1

            if L == R:
                max_water = max(alice, bob)
                if plants[L] > max_water:
                    refill += 1
        
        return refill

👉 Problem link : https://leetcode.com/problems/watering-plants-ii/description/

Applications are Open for A2SV G6 Education!

The time has come for A2SV to welcome new members! We’re looking for team-oriented individuals with a never-give-up mentality, ready to drive tech excellence and solve impactful challenges.

📅 Application opens: November 14, 2024
📅 Deadline: November 20, 2024, at 11:59 PM EAT

🎓 Eligibility

Open to current students from Addis Ababa University (AAU), Addis Ababa Science and Technology University (AASTU), and Adama Science and Technology University (ASTU). If you're not from these schools or have already graduated, stay tuned for future remote applications!

🔍 Requirements

- Familiarity with at least one programming language
- Experience with platforms like LeetCode or Codeforces
- Completed at least 40 problems on LeetCode or Codeforces

🤖 Selection Process

- First Round Filtering: Initial application review
- Technical & Behavioral Interviews: For selected candidates, to assess skills and fit for the program

⌛️ Don’t wait! Start your application early to ensure a standout submission. 🎯

🔗 Apply now: link

#A2SV #TechEducation #EmpoweringAfrica #ApplyNow

🚨 Last call the deadline is today

💻A2SV prep: Sliding window problem

🟡 2024. Maximize the Confusion of an Exam

Straight forward solution

class Solution:
    def maxConsecutiveAnswers(self, answerKey: str, k: int) -> int:
        n = len(answerKey)
        max_length = 0

        flips = k
        l, r = 0, 0
        # F -> T
        while r < n:
            if answerKey[r] == 'F':
                flips -= 1
            if flips < 0:
                if answerKey[l] == 'F':
                    flips += 1
                l += 1

            max_length = max(max_length, r - l + 1)
            r += 1

        flips = k
        l, r = 0, 0
        # T -> F
        while r < n:
            if answerKey[r] == 'T':
                flips -= 1
            if flips < 0:
                if answerKey[l] == 'T':
                    flips += 1
                l += 1

            max_length = max(max_length, r - l + 1)
            r += 1

        return max_length

As you have noticed there are some repetions in the code so I have modularized it into one single function that can calculate the possible maximum length.

class Solution:
    def maxConsecutiveAnswers(self, answerKey: str, k: int) -> int:

        def calculateLength(ans: str):
            flips = k 
            max_length = 0

            n = len(answerKey)
            l, r = 0, 0

            while r < n:
                if answerKey[r] == ans:
                    flips -= 1
                if flips < 0:
                    if answerKey[l] == ans:
                        flips += 1
                    l += 1

                max_length = max(max_length, r - l + 1)
                r += 1

            return max_length

        return max(calculateLength('T'), calculateLength('F'))

https://leetcode.com/problems/maximize-the-confusion-of-an-exam/description/

📣 A2SV Interview Format 📣

Get ready for an exciting and comprehensive interview process! Here’s what to expect:

🕒 Total Duration: 1 Hour 30 Minutes

💎 Behavioral Interview (First 45 Minutes)
This part of the interview will focus on your past experiences, skills, and motivations.
Be prepared to discuss situations where you demonstrated leadership, teamwork, and problem-solving abilities.
They might ask questions like:
⭐️ Tell me about yourself.
⭐️ What do you know about A2SV and why do you want to join us?
⭐️ Describe a time when you had to step out of your comfort zone to achieve something.

💎 Technical Interview (Remaining 45 Minutes)
This segment will test your coding and problem-solving skills.
You’ll be given programming challenges to solve in real-time.
Much of this interview will utilize sharepad.io as the collaborative coding editor.
Example questions might include:
Write a function to solve a particular algorithm problem.
Explain your approach to solving a complex data structure challenge.

🔧 Preparation Tips:

💎 Practice Coding: Brush up on your data structures and algorithms. Websites like LeetCode and codeforce are great for practice.

💎 Stay Calm and Confident: Remember, they’re not just looking for the right answers but also how you approach problems and handle stress.


Prepare well and best of luck to everyone!🧨🚀

✅ Almost Identical question with the above 👆very easy if you did the above

💻A2SV prep: Sliding window problem
🟡 1004. Max Consecutive Ones III

⏳2 min on the clock PR for me 😅

class Solution:
    def longestOnes(self, nums: List[int], k: int) -> int:
        max_length = 0
        l = 0
        for r in range(len(nums)):
            if nums[r] == 0:
                k -= 1
            while k < 0:
                if nums[l] == 0:
                    k += 1
                l += 1

            max_length = max(max_length, r - l + 1)

        return max_length

🌟🚀 @AceCoding Presents! 🚀🌟

https://leetcode.com/problems/max-consecutive-ones-iii/description/

👨‍💻 PROGRESS ☕️

📡COA - Computer Organization and Architecture

Hardwired vs. Microprogrammed (Softwired) Logic

✅ The Teacher was stressing this topic (💰likely to come up on the exam)

Hardwired Logic:
Functionality is embedded directly into the hardware using fixed circuits. These systems are fast and efficient but lack flexibility, as changes require hardware redesign. This is common in specific-purpose computers, like appliances or embedded systems optimized for specific tasks (e.g., calculators).

Microprogrammed (Softwired) Logic:
Here, functionality is defined by software, making these systems flexible and adaptable but slightly slower due to software execution overhead. Softwired logic is a hallmark of general-purpose computers, like laptops or servers, which can handle multiple tasks by running different programs.

Takeaway:
Hardwired logic is best for specialized, high-speed tasks, while softwired logic is ideal for versatile, multi-functional systems.

🌟🚀 @AceCoding Presents! 🚀🌟

COA questions:

part 1 👉 click here
part 2 👉 click here

🌟🚀 @AceCoding Presents! 🚀🌟

🌟🚀 @AceCoding Presents! 🚀🌟

https://youtu.be/IrUHoXLx0G4?si=oiQZ5-lnf5iLNw9V

💻 A2SV prep: Sliding window problem

✅ The following questions should be done sequentially. Level 1 and Level 2

🟢 3206. Alternating Groups I Easy
🔗Link: Click here!

python 
class Solution:
    def numberOfAlternatingGroups(self, colors: List[int]) -> int:
        count = 0
        # check the end colors 
        if len(colors) > 2:
            if colors[0] != colors[1] and colors[1] == colors[-1]:
                count += 1
            if colors[-2] != colors[-1] and colors[-2] == colors[0]:
                count += 1
        
        l, r = 0, 0
        k = 3
        for r in range(len(colors)):
            if r - l + 1 == 3:
                l += 1
            if r < len(colors) - 1 and colors[l] == colors[r+1] and colors[l] != colors[r]:
                count += 1

        return count

📗 A more optimized version

class Solution:
    def numberOfAlternatingGroups(self, colors: List[int]) -> int:
        n = len(colors) # keep the orginal length for latter
        count = 0

        # extend the colors array to simulate a circular pattern 
        colors.extend(colors[:2])

        for r in range(n): 
            if colors[r] == colors[r+2] and colors[r] != colors[r+1]:
                count += 1
                
        return count

🟡 3208. Alternating Groups II ~ 1800 ( Hard medium )
🔗 Link: Click here!

python 
class Solution:
    def numberOfAlternatingGroups(self, colors: List[int], k: int) -> int:
        count = 0

        colors.extend(colors[:k-1]) # if k = 3 we add 2 numbers like the above question
        print(colors)

        L = 0
        for R in range(1, len(colors)):
            
            if colors[R] == colors[R-1]:
                L = R
            if R - L + 1 == k:
                count += 1
                L += 1

        return count

🌟🚀 @AceCoding Presents! 🚀🌟

✅ Explanation for 3208. Alternating Groups II

🌟🚀 @AceCoding Presents! 🚀🌟

💻 A2SV prep: Sliding window problem

🟡 3191. Minimum Operations to Make Binary Array Elements Equal to One I
🔗 Link: Click here

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n = len(nums)
        count = L =0
        for R in range(n - 2): 
            if nums[R] == 0:  
                nums[R] = 1 - nums[R]
                nums[R + 1] = 1 - nums[R + 1]
                nums[R + 2] = 1 - nums[R + 2]
                count += 1

            if nums[L] == 1: L+= 1
        
        for i in range(len(nums)):
            if nums[i] == 0:
                return -1
        return count

🌟🚀 @AceCoding Presents! 🚀🌟