DEV Community: David Babalola

Building an Autonomous F1/10th Car #1: Intro and Why

David Babalola — Sat, 31 Jan 2026 20:02:21 +0000

In grad school, one of the classes I took was on Intelligent and Safe Robotics. In this class, I worked on the F1Tenth (now Roboracer) platform. In F1Tenth competitions, different teams compete with their autonomous racecars that are 1/10th the scale of an F1 car. This competition usually occurs in conferences like ICRA 2025.

Roboracer is a community of researchers, engineers, and enthusiasts. Roboracer develops an open-source platform for autonomous systems research, develop courses to teach autonomy foundations, and hold autonomous race car competitions involving teams from all over the world.
Read more about Roboracer here:

Here is a video hightlight that shows teams performing in head-to-head races.

Why this project?

Most Roboracer teams that compete use pricey components like the Traxxas 1/10 RC racecar, Nvidia Jetson Orin Nano, and Hokuyou UST-10-LX (or better) for their cars. My goal, however, is to attempt to recreate what they have done with pricey components, with relatively cheap components.

My idea is to use a Raspberry Pi 5 for computation and the Tamiya TT-02B (which I have purchased) as the chassis.
Understandably, I have no idea if it will work out very well, but I am hopeful. I will update the series as I purchase more components and build.

Let me know what you think. See you in the next one!

P.S.: The cover image was generated by Gemini 3 Pro.

LeetCode DSA Series #10: 83. Remove Duplicates from Sorted List

David Babalola — Fri, 16 Jan 2026 12:15:00 +0000

For this submission, I attempted 83. Remove Duplicates from Sorted List.

Given the head of a sorted linked list, delete all duplicates such that each element appears only once. Return the linked list sorted as well.

My initial attempt at this problem only deleted adjacent duplicate nodes; however, to solve this problem correctly, we have to keep deleting nodes until we have no duplicates.

Here is my solution:

class Solution:
    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
        temp = head

        if not head:
            return None

        while head.next is not None:      
            if head.val == head.next.val:
                head.next = head.next.next
            else:
                head = head.next

        return temp

LeetCode DSA Series #9: 19. Remove Nth Node From End of List

David Babalola — Thu, 15 Jan 2026 12:31:00 +0000

My ninth submission in my 2026 LeetCode series. This problem is 19. Remove Nth Node From End of List.

The problem is,

Given the head of a linked list, remove the nth node from the end of the list and return its head.

When I first attempted to solve this problem, I did not pay close attention to the phrase, end of list. I thought the goal - which is easier - was to delete the nth node in the LinkedList.

The actual problem is to delete the nth node from the end of the list. This requires that we know the number of nodes in the list. Once that is known, we can then keep track of the count of the current node we are on and how far we are from the end of the LinkedList.

Here is my solution:

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        if head.next is None and n == 1:
            head = head.next
            return head

        temp = head
        head_copy = head
        len_list = 0
        # Traverse List till end to get count of items
        while head_copy is not None:
            len_list += 1
            head_copy = head_copy.next

        # If nth node to delete is head node, set head to next node
        if n == len_list:
            head = head.next
            return head

        # Delete nth item from list while traversing    
        i = 0
        while head.next is not None:                   
            if len_list - i -1  == n:
                head.next = head.next.next
                break
            else:
                head = head.next
            i += 1

        return temp

What do you think about this? Is there a better way to do this?

LeetCode DSA Series #8: 1290. Convert Binary Number in a Linked List to Integer

David Babalola — Wed, 14 Jan 2026 16:30:16 +0000

This is my eighth submission to the challenge. The problem today is 1290. Convert Binary Number in a Linked List to Integer

Given head which is a reference node to a singly-linked list. The value of each node in the linked list is either 0 or 1. The linked list holds the binary representation of a number.
Return the decimal value of the number in the linked list.
The most significant bit is at the head of the linked list.

Here is my solution:

class Solution:
    def getDecimalValue(self, head: Optional[ListNode]) -> int:
        binary = ""
        while head.next:
            binary += str(head.val)
            head = head.next
        binary += str(head.val)

        decimal = 0
        size = len(binary)
        for i in range(0, size):
            decimal += int(binary[i]) * 2**(size - i - 1)     

        return decimal

Is there a better way to do this? Please let me know.

LeetCode DSA Series #7: 169. Majority Element

David Babalola — Fri, 09 Jan 2026 04:11:07 +0000

This is my run at day 7 of the challenge (I missed yesterday's submission). The problem today is 169. Majority Element.

Given an array nums of size n, return the majority element.
The majority element is the element that appears more than ⌊n / 2⌋ times. You may assume that the majority element always exists in the array.

Here is my solution to the problem:

from collections import Counter
class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        counts = Counter(nums)
        majority = len(nums) / 2

        for k, v in counts.items():
            if v > majority:
                return k

Time and space complexity are O(N).

LeetCode DSA Series #6: 268. Missing Number

David Babalola — Wed, 07 Jan 2026 03:12:20 +0000

The problem I solved is 268. Missing Number. It is also an easy problem.

For this problem, I solved it in three different ways, with one approach yielding a clear performance advantage.

Here is the code showing the 3 approaches.

class Solution:
    def missingNumber(self, nums: List[int]) -> int:
        n = len(nums)

        # Method 1
        # Runtime 8 ms Beats 27.81% | Memory 21.57MB Beats 5.11%
        #-----------------------------------------------
        sequence = range(0, n+1)
        sequence = set(sequence)

        diff = set(sequence) - set(nums)
        return diff.pop()


        # Method 2
        # Runtime: 1399 ms Beats 5.10% | Memory 20.65MB Beats 5.11%
        #--------------------------------------------------
        # for i in range(0, n+1):
        #     if i not in nums:
        #         return i

        # Method 3
        # Runtime 1506 ms Beats 5.10% | Memory 20.45MB Beats 5.11%
        #----------------------------------------------------

        # sequence = list(range(0, n+1))
        # for num in nums:
        #     sequence.remove(num)
        # return sequence[0]

What better ways could I have solved this? Please let me know

LeetCode DSA Series #5: 242. Valid Anagram

David Babalola — Mon, 05 Jan 2026 23:49:59 +0000

Given two strings s and t, return true if t is an anagram of s, and false otherwise.

You can find the problem here.

from collections import Counter
class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        counts_s = Counter(s)
        counts_t = Counter(t)

        if len(s) != len(t):
            return False
        for k, v in counts_t.items():
            if v != counts_s[k]:
                return False
        return True

For this problem, I used the Counter class from collections.
The final time and space complexity are O(n)

LeetCode DSA Series #4: 217. Contains Duplicate

David Babalola — Mon, 05 Jan 2026 02:30:51 +0000

Given an integer array nums, return true if any value appears at least twice in the array, and return false if every element is distinct.

You can find the problem here.

class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        seen = set()
        for num in nums:
            if num in seen:
                return True
            else:
                seen.add(num)
        return False

Time and space complexity are O(N).

LeetCode DSA Series #3: 202. Happy Number

David Babalola — Sun, 04 Jan 2026 01:54:13 +0000

This is also an easy problem. Find it here.

Here's my solution to the problem.

class Solution:
    def isHappy(self, n: int) -> bool:
        new_n = n
        seen = set()

        while True:
            sums = 0
            for i in str(new_n):
                sums += int(i) * int(i)
            new_n = sums

            if new_n == 1:
                return True

            if new_n in seen:
                return False
            else:
                seen.add(new_n)
        return False

The time and space complexity is O(log n).

Is there a better way to do this? Please let me know.

LeetCode DSA Series #2: 125. Valid Palindrome

David Babalola — Sat, 03 Jan 2026 04:11:43 +0000

This is a pretty easy one, finding a valid palindrome.

Here's my solution to the problem.

class Solution:
    def isPalindrome(self, s: str) -> bool:
        s = s.lower()
        new_s = ''
        for char in s:
            if char.isalnum(): 
                new_s += char
        if new_s == new_s[::-1]:
            return True
        else:
            return False

The time and space complexity is O(N)

LeetCode DSA Series #1: 191. Number of 1 Bits

David Babalola — Thu, 01 Jan 2026 21:18:56 +0000

It is a new year. Happy New Year!

On December 31, 2025, I saw a post on X (formerly Twitter) from someone who had solved LeetCode problems every day in 2025.

// Detect dark theme var iframe = document.getElementById('tweet-2006322352368279585-808'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2006322352368279585&theme=dark" }

This has inspired me to begin my own challenge in 2026. I honestly do not know if I have the drive to see it through. I will see how it goes.

My submission for Day 1 is 191. Number of 1 Bits

This is my solution

class Solution:
    def hammingWeight(self, n: int) -> int:
        n_binary  = ""
        while n > 0:
            remainder = n % 2
            n = n // 2
            n_binary += str(remainder)
        n_binary = n_binary[::-1]

        count = 0
        for char in n_binary:
            if char == '1':
                count += 1

        return count

Both time and space complexity are O(Log N).

Is there a better way to do this? Please let me know.

LeetCode 2. Add Two Numbers

David Babalola — Tue, 30 Jan 2024 17:21:07 +0000

This year, I am solving more data structures and algorithms.
P.S.: This post was first seen on Twitter. See the link below.

// Detect dark theme var iframe = document.getElementById('tweet-1752269225836572802-259'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1752269225836572802&theme=dark" }

The Problem is 2. Add Two Numbers from LeetCode. Check it out here.

You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

Example 1:

Input: l1 = [2,4,3], l2 = [5,6,4]
Output: [7,0,8]
Explanation: 342 + 465 = 807.

Example 2:
Input: l1 = [0], l2 = [0]
Output: [0]

Example 3:
Input: l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
Output: [8,9,9,9,0,0,0,1]

Constraints:
The number of nodes in each linked list is in the range [1, 100].
0 <= Node.val <= 9
It is guaranteed that the list represents a number that does not have leading zeros.

Here is my solution:

    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        current_l1 = l1
        current_l2 = l2
        l1_list, l2_list = [], []    

        # Convert both LinkedLists to Python Lists
        while current_l1 is not None or current_l2 is not None:            
            if current_l1 is not None:
                l1_list.append(str(current_l1.val))
                current_l1 = current_l1.next

            if current_l2 is not None:
                l2_list.append(str(current_l2.val))
                current_l2 = current_l2.next

        l1_list.reverse() # Reverse lists e.g. [2, 4, 3] -> [3, 4, 2]
        l2_list.reverse() # Reverse lists e.g. [2, 4, 3] -> [3, 4, 2]

        # Convert the lists to integers. e.g. [3, 4, 2] -> 342
        l1_value = int(''.join(l1_list))
        l2_value = int(''.join(l2_list))      

        sum_values = l1_value + l2_value
        sum_values = str(sum_values)

        # Create the head node
        head = ListNode(sum_values[-1])
        current = head

        # Insert the elements to LinkedList in reverse order
        for digit in sum_values[-2::-1]:
            current.next = ListNode(digit)
            current = current.next
        return head

Lines 2-3:
I create current_l1 and current_l2 to be nodes pointing to the heads of l1 and l2, respectively.
Line 4 creates empty lists l1_list and l2_list to store each digit of l1 and l2.

Lines 7-14:
I convert the linked lists l1 and l2 into Python lists (l1_list and l2_list) by traversing through them, extracting each digit from the linked lists and appending it to the respective lists.

Lines 16-17:
I reverse l1_list and l2_list lists. I do this because the digits are in reverse order in the linked lists

Lines 20-21:
I convert the reversed lists to integers (l1_value and l2_value) by using the join method to convert to a string and then to an integer ultimately

Lines 23-24:
I calculate the sum of both integers and then convert the sum back to a string (sum_values) to easily extract each digit.

Lines 27-34:
I create a head node (last digit of the sum), create a pointer to it, and iterate through the remaining digits of the sum in reverse order, creating new nodes for each digit in the sum string (sum_values). The head is then returned.

Here's the performance of my approach as of today:
Runtime: 54ms, beats 79.12% of users with Python3
Memory: 16.60MB, beats 67.14% of users with Python3

Do you have a better-performing approach? What problems would you want to see me solve?

Let me know in the comments.