Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.
Implement the MinStack class:
MinStack() initializes the stack object.
void push(int val) pushes the element val onto the stack.
void pop() removes the element on the top of the stack.
int top() gets the top element of the stack.
int getMin() retrieves the minimum element in the stack.
You must implement a solution with O(1) time complexity for each function.
time complexity is O(1)
space complexity is O(N)
This one is a head scratcher. It took a bit to figure it out. My brain immediately went to heaps, but they don’t support a last-inserted operation. Plus insert is log(N).
After a while I figured out that I can keep a running min and do some code gymnastics to keep it up-to-date.
I’ve seen solutions that have two stacks, one for the val and one for min. The code is simpler but needs twice the space.
class MinStack:
def __init__(self):
self.stack = []
self.min_val = None
def push(self, val: int) -> None:
if self.min_val == None:
self.min_val = val
self.min_val = min(self.min_val, val)
self.stack.append((val, self.min_val))
def pop(self) -> None:
ret = self.stack.pop()[0]
if len(self.stack) == 0:
self.min_val = None
else:
self.min_val = max(self.min_val, self.stack[-1][1])
return ret
def top(self) -> int:
return self.stack[-1][0]
def getMin(self) -> int:
return self.stack[-1][1]
ChatGPT can solve this problem correctly but does the inefficient two stack solution. I suspect that is the reason why most submissions on LeetCode use two stacks…
class MinStack:
def __init__(self):
self.stack = []
self.min_stack = []
def push(self, val: int) -> None:
self.stack.append(val)
# If min_stack is empty or the new value is less than or equal to the current minimum, push it onto min_stack
if not self.min_stack or val <= self.min_stack[-1]:
self.min_stack.append(val)
def pop(self) -> None:
if self.stack:
val = self.stack.pop()
# If the value being popped is the current minimum, pop it from min_stack as well
if val == self.min_stack[-1]:
self.min_stack.pop()
def top(self) -> int:
if self.stack:
return self.stack[-1]
return None
def getMin(self) -> int:
if self.min_stack:
return self.min_stack[-1]
return None
A linked list of length n is given such that each node contains an additional random pointer, which could point to any node in the list, or null.
Construct a deep copy of the list. The deep copy should consist of exactly n brand new nodes, where each new node has its value set to the value of its corresponding original node. Both the next and random pointer of the new nodes should point to new nodes in the copied list such that the pointers in the original list and copied list represent the same list state. None of the pointers in the new list should point to nodes in the original list.
time complexity is O(N)
space complexity is O(N)
You could do this in three passes, but this solution compresses pass #1 and pass #2 into one.
Each object in python has a unique id. In other languages we could use the address in memory or the object directly.
I don’t like using objects as keys in maps, so I opted for a simple unique key derived from the id.
The logic is as follow:
The solution beats 95% of submissions.
class Solution:
def copyRandomList(self, head: 'Optional[Node]') -> 'Optional[Node]':
random_mapping = {}
id_mapping = {} # new to old
object_mapping = {} # old to new object
copy_root = None
ptr = head
previous_copy_ptr = None
while ptr != None:
copy_object = Node(ptr.val)
id_mapping[id(copy_object)] = id(ptr)
object_mapping[id(ptr)] = copy_object
if copy_root == None:
copy_root = copy_object
if ptr.random != None:
random_mapping[id(ptr)] = id(ptr.random)
ptr = ptr.next
if previous_copy_ptr != None:
previous_copy_ptr.next = copy_object
previous_copy_ptr = copy_object
ptr = copy_root
while ptr != None:
# find new to old
old_id = id_mapping[id(ptr)]
old_random_id = random_mapping.get(old_id)
if old_random_id != None:
new_object = object_mapping[old_random_id]
ptr.random = new_object
ptr = ptr.next
return copy_root
ChatGPT can solve this problem correctly but slowly. I suspect that the map operations are slower. I do like the logic of setting all pointers in the second pass. It is conceptually easier to grasp.
class Solution:
def copyRandomList(self, head: 'Optional[Node]') -> 'Optional[Node]':
if not head:
return None
# Dictionary to hold old nodes as keys and new nodes as values
old_to_new = {}
# First pass: create all the new nodes and store them in the dictionary
current = head
while current:
old_to_new[current] = Node(current.val)
current = current.next
# Second pass: assign next and random pointers
current = head
while current:
if current.next:
old_to_new[current].next = old_to_new[current.next]
if current.random:
old_to_new[current].random = old_to_new[current.random]
current = current.next
# Return the head of the new list
return old_to_new[head]
ou are given two integer arrays nums1 and nums2, sorted in non-decreasing order, and two integers m and n, representing the number of elements in nums1 and nums2 respectively.
Merge nums1 and nums2 into a single array sorted in non-decreasing order.
The final sorted array should not be returned by the function, but instead be stored inside the array nums1. To accommodate this, nums1 has a length of m + n, where the first m elements denote the elements that should be merged, and the last n elements are set to 0 and should be ignored. nums2 has a length of n. Write a function called merge in python.
time complexity is O(N+M)
space complexity is O(1)
I’ve seen the use of sort in a lot of the solutions but that puts us at O(nlogn) which we want to avoid.
We can’t start from the beginning because that would require moving things around in nums1.
This submission used less memory than most others.
from typing import List
def merge(nums1: List[int], m: int, nums2: List[int], n: int):
idx1 = m-1
idx2 = n-1
for tail in range(m+n-1, -1, -1):
if idx1 < 0:
nums1[tail] = nums2[idx2]
idx2 -= 1
elif idx2 < 0:
nums1[tail] = nums1[idx1]
idx1 -= 1
elif nums1[idx1] >= nums2[idx2]:
nums1[tail] = nums1[idx1]
idx1 -= 1
else:
nums1[tail] = nums2[idx2]
idx2 -= 1
ChatGPT can solve this problem correctly and efficiently:
def merge(nums1, m, nums2, n):
"""
Merges two sorted arrays nums1 and nums2 into one sorted array within nums1.
Parameters:
nums1 (List[int]): The first sorted array with a length of m + n.
m (int): The number of elements in nums1 that should be merged.
nums2 (List[int]): The second sorted array.
n (int): The number of elements in nums2.
"""
# Start from the end of nums1 and nums2
i = m - 1
j = n - 1
k = m + n - 1
# While there are still elements in both nums1 and nums2
while i >= 0 and j >= 0:
if nums1[i] > nums2[j]:
nums1[k] = nums1[i]
i -= 1
else:
nums1[k] = nums2[j]
j -= 1
k -= 1
# If there are still elements in nums2, copy them
while j >= 0:
nums1[k] = nums2[j]
j -= 1
k -= 1
# Example usage:
nums1 = [1, 2, 3, 0, 0, 0]
m = 3
nums2 = [2, 5, 6]
n = 3
merge(nums1, m, nums2, n)
print(nums1) # Output should be [1, 2, 2, 3, 5, 6]
In the ever-evolving landscape of software engineering, the digital nomad lifestyle has emerged as an exciting path for those seeking freedom, flexibility, and personal growth. As a passionate software engineer who has embraced this nomadic journey, I am thrilled to extend a helping hand to aspiring developers on their own quests for excellence. This blog post delves into the transformative power of digital nomad software engineering mentorship, highlighting the unique offerings I bring to the community.
Having embarked on my own digital nomad adventure, I intimately understand the challenges and triumphs of maintaining a coding rhythm amidst changing landscapes. Through personalized mentorship, I provide insights that resonate with the nomadic spirit – guidance that spans time zones, adapts to varying work environments, and celebrates the exhilarating fusion of cultures and technology.
Digital nomads are exceptional multitaskers, seamlessly blending work and exploration. Drawing from my experiences, I help mentees strike the delicate balance between delivering high-quality code and savoring the world around them. Together, we will navigate the art of time management, task prioritization, and crafting innovative solutions – all while embracing the freedom of the nomadic lifestyle.
In the realm of software engineering, knowledge is key. Drawing from my expertise, I provide hands-on guidance, assisting mentees in algorithm design, tackling complex challenges, and staying attuned to industry trends.
Embracing the exhilarating digital nomad lifestyle, I’m on a mission to explore every nook and cranny of our incredible world. Join me on an extraordinary journey of wanderlust and discovery as I strive to traverse every corner of our globe. Follow our adventure-packed escapades, cultural immersions, and unconventional lifestyle on ElTruckito.com, where the thrill of exploration meets the awe-inspiring landscapes of our planet.
Embracing the digital nomad lifestyle while pursuing a career in software engineering is a remarkable journey. As a mentor, I am honored to offer my expertise, experiences, and unwavering support to a community of aspiring developers who share this vision. Through personalized guidance, a focus on practicality, and a commitment to nurturing both technical and personal growth, I am dedicated to helping digital nomads thrive as they code their way across the globe. Together, we embark on a transformative partnership that amplifies potential, sparks innovation, and paves the way for a new era of tech-savvy nomads.
Take the next step by booking a mentorship session with me today! Let’s collaborate, conquer coding challenges, and craft innovative solutions together. Your adventure in tech awaits – book your session now at ADPList.org and let’s embark on this exciting journey of growth and discovery!
]]>For two strings A and B, we define the similarity of the strings to be the length of the longest prefix common to both strings. For example, the similarity of strings “abc” and “abd” is 2, while the similarity of strings “aaa” and “aaab” is 3.
Calculate the sum of similarities of a string S with each of it’s suffixes.
time complexity is O(N)
space complexity is O(n)
The stringSimilarity function calculates the similarity of each suffix of the input string s with the original string using the Z algorithm. This algorithm maintains two pointers ‘l’ and ‘r’ that define the substring with the longest similarity seen so far. For each character ‘i’ in the string s, the algorithm calculates the similarity of the suffix starting at ‘i’ using the Z algorithm. It then updates ‘l’ and ‘r’ if the similarity of the current suffix exceeds that of the current substring with the longest similarity. Finally, the algorithm returns the sum of all similarities plus the length of the original string, since the similarity of the entire string is equal to its length.
#!/bin/python
#!/bin/python3
import math
import os
import random
import re
import sys
#
# Complete the 'stringSimilarity' function below.
#
# The function is expected to return an INTEGER.
# The function accepts STRING s as parameter.
#
def stringSimilarity(s):
n = len(s)
similarities = [0] * n
l, r = 0, 0
for i in range(1, n):
if i <= r:
similarities[i] = min(r-i+1, similarities[i-l])
while i+similarities[i] < n and s[similarities[i]] == s[i+similarities[i]]:
similarities[i] += 1
if i+similarities[i]-1 > r:
l = i
r = i + similarities[i] - 1
return sum(similarities) + n
if __name__ == '__main__':
fptr = open(os.environ['OUTPUT_PATH'], 'w')
t = int(input().strip())
for t_itr in range(t):
s = input()
result = stringSimilarity(s)
fptr.write(str(result) + '\n')
fptr.close()
When I first started my blog on WordPress, I had a rather unusual setup - the site was hosted on a server in a friend’s basement. While it may sound like a bit of a “ghetto” arrangement, it seemed like a cost-effective solution at the time. However, it soon became apparent that this setup came with its fair share of problems.
One of the biggest issues was the server’s reliability. For reasons that were never quite clear, the server seemed to go down regularly, without any good explanation. This meant that my site was often inaccessible for hours or even days at a time, frustrating both myself and my readers.
To make matters worse, the site’s loading times were notoriously slow. This was likely due in part to the server’s less-than-optimal location and setup, but it also meant that visitors to my site had to endure lengthy wait times just to access my content. And as we all know, in the world of online content, every second counts.
As my blog began to grow and attract more readers, the maintenance of the site became an increasingly daunting task. With the server regularly going down and loading times being so slow, I found myself spending more and more time just trying to keep the site running smoothly. This detracted from the time and energy I wanted to devote to creating new content and engaging with my readers.
Eventually, in 2020, I began to investigate the possibility of moving my site to a proper hosting solution, such as AWS. However, as I quickly discovered, this option came with a hefty price tag. The cost of a properly hosted server, combined with the need for a distributed database, made this option simply unfeasible for me at the time.
It’s not just about hosting, maintaining WordPress can be a headache. While it’s an amazing system, opting for a static website can offer several advantages. It’s faster, easier to maintain, and more secure, making it a smart choice for those who value efficiency and security.
In the end, I realized that something had to be done to address the ongoing issues with my site’s performance and reliability. After careful consideration and research, I made the decision to migrate my site to Jekyll, a static site generator that promised faster load times and a more streamlined maintenance process. And while the process of migrating my site was not without its challenges, I can now say that I am thrilled with the improved performance and ease of use that Jekyll has brought to my blog.
I chose GitHub Pages as my hosting solution, as I regularly use Git and GitHub in my daily work, and the added bonus of open-sourcing the content was a nice benefit for the community.
When I stumbled upon Swizec’s article on migrating from WordPress to Markdown, I was initially excited. His straightforward breakdown of the process made it seem like a simple task that could be completed in an afternoon. “Pfft, an afternoon of work at worst,” he wrote, listing off the steps like they were nothing: export from WordPress, find a script, sip margaritas.
It all sounded so easy and straightforward, and I couldn’t help but agree with Swizec’s assessment. “That sounds about right,” I thought to myself, feeling confident that I could tackle this migration with ease.
But then, Swizec hit me with a dose of reality. “Suddenly it’s 6 months later and you’re losing your mind,” he wrote. His words were a stark reminder that even the simplest tasks can often become complex and time-consuming.
As an optimist, however, I refused to be discouraged. Sure, the process might not be as straightforward as I initially thought, but surely it couldn’t be that difficult, right?
So, being the lazy optimist that I am, I decided to explore my options. I turned to Fiverr, hoping to find someone who could handle the migration for me. I was shocked to discover that most of the quotes I received ranged from $1500 to $8000. That seemed like an exorbitant amount of money for something that sounded like it should only take a few hours.
One freelancer even warned me that it could take 2-3 months to complete the migration, although he optimistically suggested that it might only take a month.
The whole experience left me feeling a bit frustrated and overwhelmed. But despite the initial setbacks, I remained determined to find a solution that would allow me to migrate my site without breaking the bank or losing my mind in the process. And while it might take a bit more time and effort than I initially anticipated, I’m confident that I’ll be able to find a way to make it work.
Perhaps I was a bit fortunate that I had recently teamed up with Juraj to create a brand new website for Nomadic Workplace, my umbrella company that enables me to pursue my digital nomad lifestyle while remaining legally employed in the US.
When it comes to martinkysel.com, I can confidently say that it boasts two significant advantages over other blogs out there. Firstly, the vast majority of its content follows a similar pattern and covers similar topics. This consistency makes it easier to script a migration without having to deal with a lot of edge cases.
Secondly, all of the comments on the blog are saved in Disqus. This means that they can be easily transferred and integrated into a new platform, without the risk of losing valuable feedback and engagement from readers.
Finally, let’s be honest - the old blog design was pretty unappealing. So, any improvement in this area would be a massive gain for both myself and my readers. With the new Jekyll-based site, I was able to create a much cleaner, more streamlined design that not only looks better but also makes it easier for readers to navigate and engage with the content.
So, how did the whole migration process actually go? Well, to start with, I discovered a migration tool developed by Lonekorean over on Github, which was almost perfect for my needs. However, there were a couple of essential components that it was missing.
Firstly, it didn’t have the ability to deal with [code] blocks, which seemed to be a non-standard feature of my old Wordpress site. This was a bit of a headache, but as is often the case with internet problems, I was able to find someone who had already struggled with and solved the issue in the past. In this case, it was a user called mxro, who had written some incredibly simple Typescript code to handle the preprocessing.
The second issue I encountered was with images. Thankfully, there were only a few scattered throughout the entire blog, so I was able to handle them all manually. While this was a bit time-consuming, it ultimately wasn’t a huge deal in the grand scheme of things.
Of course, the migration process wasn’t just about transferring content from one platform to another. I also had to select a new theme for the site, add some new icons, turn the banner into an avatar, and reset DNS entries. While these tasks weren’t necessarily difficult, they did require some careful attention to detail in order to ensure that everything was working smoothly and looking great.
The entire process took only four hours - no joke. I started around 8PM and got so absorbed in it that I barely noticed the time passing. I remember making a fresh batch of argentinean mate while working away. By around 11PM, I decided the website was good enough and made the move to switch the DNS entries over to the new website. Of course, there may be some kinks to iron out over the next few days as I discover any issues that may have gone wrong or missing, but overall, it was nowhere near the month or six months I was anticipating. And if you don’t believe me, you can check the git history. The blog’s source is open on GitHub Pages.
Reflecting on this experience, I have come to realize that there are a few key takeaways that I believe are worth sharing with others.
Firstly, when it comes to using standard tools, the integration with existing systems can be seamless. In my case, because I was using widely accepted tools for the migration process, such as WordPress and Markdown, the transition was relatively smooth. However, the process could have been complicated if I had relied on more obscure or specialized tools.
Secondly, keep it simple stupid. Pick a system that requires the least maintenance.
Thirdly, it is important to approach time estimates with a healthy dose of skepticism. I was initially quoted a range of 1-3 months for the migration process by one service provider, which turned out to be completely off-base. It is essential to use common sense and T-shirt sizing estimates.
Lastly, be wary if your customer is another software engineer. Trying to “bullshit” your way through a negotiation will only lead to frustration and disappointment for both parties. Other engineers are highly skilled professionals who understand the complexities of building and maintaining software systems. They know what is feasible and what is not, and inaccurate estimates should alarm them to sketchy behavior.
]]>Wordpress to Jekyll and Github pages.
There are several benefits to this migration: 1) Faster load times: Jekyll generates static pages, which means that there is no need to query a database or run server-side scripts to serve up content. This has resulted in much faster page load times and a better user experience for you, the readers. 2) Improved security: As Jekyll doesn’t require a database or server-side scripting, there is less potential for security vulnerabilities, which makes my life much easier. 3) Simpler design: Jekyll is based on templates, which has hopefully resulted in a more consistent and visually appealing design. This should make it easier for readers to navigate the site and find the information they are looking for. 4) Easier updates: Jekyll makes it easier to update the content on a website since it separates content from presentation.
Overall, the migration to Jekyll has resulted in a faster, more secure, and more user-friendly website, which should improve the overall experience for readers of martinkysel.com.
I hope that the decision to remove ads from this blog will be a positive move for everyone involved. For readers, the absence of ads can result in a more enjoyable reading experience, free from distractions and slow loading times caused by ad content. Maybe this improved experience can encourage readers to spend more time on the site, engaging with content and potentially sharing it with others.
If you still wanna buy me a coffee, you can click the sponsorship button on GitHub!
The ads sucked anyway…
Simpler pages are typically easier to navigate because they present information in a clear and concise manner, with fewer distractions or unnecessary elements. When a page is cluttered or overly complex, users may struggle to find the information they are looking for, leading to frustration and potentially causing them to leave the site. The WordPress site was an old mess of fully of crappy elements from 2015.
By contrast, simpler pages tend to have a clear visual hierarchy that makes it easier for users to scan and locate the information they need. This was achieved through the use of white space, consistent typography, and clear navigation menus that now guide users to the most important content.
And man, this page really needed to be simplified!
If you see a bug in any of the pages, just head over to Github and file an issue. I am happy to incorporate any and all feedback.
If anything broke, please let me know! Either in the Disqus system or on GitHub.
You can read more about the migration in my post From Ugly to Beautiful: The Transformation of Martinkysel.com.
]]>Consider a string, s, consisting only of the letters a and b. We say that string s is balanced if both of the following conditions are satisfied:
a and b.a and b differ by at most 1.Your task is to write a regular expression accepting only balanced strings.
Substrings can differ by at most 1 which means that the string must consist of either “ab” or “ba”. Write a regex as such.
Regex_Pattern = r"^((ab)|(ba))*$" # Do not delete 'r'.
You are a real estate broker in ancient Knossos. You have m unsold houses, and each house j has an area, xj, and a minimum price, yj. You also have n clients, and each client i wants a house with an area greater than ai and a price less than or equal to bi.
Each client can buy at most one house, and each house can have at most one owner. What is the maximum number of houses you can sell?
time complexity is O(NlogN + MlogM + N\*M)
space complexity is O(1)
This challenge sounds pretty complex, but this greedy solution works perfectly. Sort houses by size, start selling the smallest houses first. Bigger houses can always be sold since there is a bigger pool of buyers for them. Sell each house to the buyer that has the smallest pool of money available.
Don’t overcomplicate the problem with graph algorithms :)
#!/bin/python
from __future__ import print_function
import os
import sys
#
# Complete the realEstateBroker function below.
#
def realEstateBroker(clients, houses):
houses = sorted(houses)
clients = sorted(clients, key = lambda x: x[1])
sold = 0
for house in houses:
for client in clients:
if house[0] >= client[0] and house[1] <= client[1]:
sold += 1
clients.remove(client)
break
return sold
if __name__ == '__main__':
fptr = open(os.environ['OUTPUT_PATH'], 'w')
nm = raw_input().split()
n = int(nm[0])
m = int(nm[1])
clients = []
for _ in xrange(n):
clients.append(map(int, raw_input().rstrip().split()))
houses = []
for _ in xrange(m):
houses.append(map(int, raw_input().rstrip().split()))
result = realEstateBroker(clients, houses)
fptr.write(str(result) + '\n')
fptr.close()
Neo has to save the world one last time. One of the battles has cost Neo his eyes. He has to fight the battle with the Deus ex machina.
In front of Neo is a set of N balls, each ball is color coded 0/1. Deus ex machina wants Neo to figure out which ball’s color is the majority ( appears more than > N/2 ). If his choice of ball is correct, Deus ex machina will reach a truce and let humans live and if Neo fails to identify the ball with the majority, the entire human race would be put back into matrix.
Neo being blind won’t be able to see the balls let alone figure out the ball with the majority. He seeks the Oracle’s help. Neo picks any two balls from the set and asks Oracle if they are of the same color or not. If they are the same color, the Oracle answers YES and if they are not, Oracle answers NO. We will call b_0/1 as ball b with color _0/1 respectively. Majority exists in this set, i.e.,
time complexity is O(N^2)
space complexity is O(1)
Soha
I use exceptions to simplify the flow of the algorithm. The algorithm itself can be tested locally if you replace the areEqual function and create an array locally. This abstraction should make the flow of the algorithm clearer.
Disclaimer: the code gets 16/23 points. There must be more improvements possible. I am open to suggestions in the comments below.
The algorithm itself assumes that if two groups of elements of equal size are not equal they become irrelevant. Let’s say that we know that elements 0 and 1 are different. Hence we never have to look at them again.
Otherwise the algorithm uses an adapted N(logN) algorithm to compare all elements.
#!/usr/bin/py
class MissingElementException(Exception):
def __init__(self, a, b):
self.a = a
self.b = b
def areEqual(query, a ,b):
if not a in query or not b in query[a]:
raise MissingElementException(a, b)
return query[a][b]
def algo(n, query):
relevant_groups = []
for i in xrange(0, n, 2):
group = [i, i+1]
relevant_groups.append(group)
while relevant_groups:
group_a = relevant_groups.pop(0)
group_len = len(group_a)
if areEqual(query, group_a[0], group_a[group_len//2]):
while relevant_groups:
group_b = relevant_groups.pop(0)
group_len_b = len(group_b)
if areEqual(query, group_b[0], group_b[group_len_b//2]):
if areEqual(query, group_a[0], group_b[0]):
group = group_a
group.extend(group_b)
relevant_groups.append(group)
break
else:
if group_len > group_len_b:
relevant_groups.append(group_a)
break
elif group_len < group_len_b:
relevant_groups.append(group_b)
break
else:
break
if not relevant_groups:
# this should be the answer
return group_a[0]
return query
def nextQuestion(n, plurality, lies, color, exact_lies, query):
try:
print algo(n, query)
except MissingElementException as e:
print "%ld % ld" % (e.a, e.b)
if __name__ == '__main__':
vals = [int(i) for i in raw_input().strip().split()]
query_size = input()
query = {}
for i in range(vals[0]):
query[i] = {}
for i in range(query_size):
temp = [j for j in raw_input().strip().split()]
if temp[2] == "YES":
query[int(temp[0])][int(temp[1])] = 1
query[int(temp[1])][int(temp[0])] = 1
else:
query[int(temp[0])][int(temp[1])] = 0
query[int(temp[1])][int(temp[0])] = 0
nextQuestion(vals[0], vals[1], vals[2], vals[3], vals[4], query)