DEV Community: Nathan Kurz

Find the Length of the Last Word in a String - javascript

Nathan Kurz — Wed, 31 May 2023 20:06:52 +0000

Let's solve a coding challenge. We will discuss how to find the length of the last word in a string using javascript as our programming language.

First the problem statement:
Given a string, return the length of the last word in the string.

To understand how to solve the problem, let's start with an example. Let's say this is our string:

const str = 'hello i am a string'

We need to isolate the last word in the string, find its length, and return it. Let's start by isolating the last word. We can separate all of the words in this string and store them in an array. In javascript we use split for this.

const words = str.split(' ');

We pass a space into the function as the delimiter. This will separate the words into the array by the spaces. Once we have our array, we need to target the last element of the array and get it's length.

const lastWordLength = words[words.length - 1].length;

We can then return this value and our function is complete. There are two edge cases we inspect. What if there are extra spaces in our string?

str = ' hello i am a string ';

To account for this edge case, we need to trim the extra space from the string before we split it. The code would change to this.

const words = str.trim().split(' ');

The other edge case is if the string is an empty string. In this case, we would just return 0;

Now we have accounted for our edge cases and the problem is effectively solved. This is what the completed function could look like.

function lengthOfLastWord(s) {
    if (s.length === 0) {
        return 0;
    } else {
        const words = s.trim().split(' ');
        const lengthOfLastWord = words[words.length - 1].length;
        return lengthOfLastWord;
    }
};

That's it! Have a wonderful day!

Longest Palindromic Substring: JavaScript

Nathan Kurz — Wed, 13 Apr 2022 16:37:38 +0000

A palindrome is any set of characters that read the same forwards and backwards. For example: 'noon' is a palindrome, and 'loon' is not. Both of these strings contain palindromic substrings 'oo'.

Objective

Find the longest set of characters in a string that is a palindrome, or the 'longest palindromic substring'.

Solutions

Solution 1

There are a few different ways to solve this, but I am going to stick to the two that I used personally. My initial thoughts were to get every possible substring and check if they were palindromes. If the string is a palindrome, check the length. If the length is greater than the length of the current longest, set the current longest equal to the current string.

This solution is straightforward and definitely works, however there is a glaring issue. It's very slow for large strings. You have a nested loop to get every possible substring which has a O(n^2) runtime, and you have to check each substring to see if it is a palindrome which is O(n) giving you a total runtime of O(n^3). I tested this solution using node on my terminal and it worked fine, but when I went to submit the solution it failed because it exceeded the time limit. Just in case you are curious I will show a copy of this solution below, but we will be looking at a much faster option next.

/**
 * @param {string} s
 * @return {string}
 */
var longestPalindrome = function (s) {
    // check base case
    // examine every possible substring
    // if substring and length is longer than current longest, set to longest
    // return longest
    if (isPalindrome(s)) {
        return s;
    }

    let current = '';

    for (let i = 0; i < s.length; i++) {
        for (let j = i + 1; j <= s.length; j++) {
            let ss = s.substring(i, j);
            if (isPalindrome(ss)) {
                if (ss.length > current.length) {
                    current = ss;
                }
            }
        }
    }
    return current;
};

function isPalindrome(s) {
    let reverse = s.split('').reverse().join('');
    if (s === reverse) {
        return true;
    } else {
        return false;
    }
}

Solution 2

I had to research a few different ways of solving this problem. I chose to research an algorithm that appeared to be the least convoluted. I wrote out some pseudocode and went through a few iterations by hand to better understand the algorithm.

There is no need to check every possible substring. Instead, we can iterate through the string once. At each index, we check to see if the positions to the left and right of the current index are equal. If they are equal, then the substring is a palindrome. We continue incrementing and decrementing the left and right pointers until the substring is no longer a palindrome. If the substring is not a palindrome, we exit the inner loop and continue to the next index in the string (outer loop).

Below is a snippet of the code used in this solution.

var longestPalindrome = function (s) {
    let longest = '';

    // loop through string once
    for (let i = 0; i < s.length; i++) {
        // use two different starting positions to
        // account for even or odd strings
        checkLeftAndRight(i, i);
        checkLeftAndRight(i, i + 1);
    }

    function checkLeftAndRight(left, right) {
        while (left >= 0 && right < s.length && s[left] === s[right]) {
            // subtract left from right and add one to get current
            // length of substring
            if (right - left + 1 > longest.length) {
                // set longest to current substring
                longest = s.slice(left, right + 1);
            }
            left--;
            right++;
        }
    }

    return longest;
};

Conclusion

This was an interesting problem. My goal in practicing and analyzing these solutions is to one day have a big enough toolkit that I can think of multiple solutions for many of the problems I come across without having to research them. Hope this helps someone out there :)

LeetCode 26: Remove Duplicates from Sorted Array

Nathan Kurz — Fri, 08 Apr 2022 05:27:51 +0000

Let's talk about removing duplicates. Normally, removing duplicates from a sorted array would be quick work. You just add each value to a set. Since all values in sets must be unique you simply return the values contained in the set. This was not a valid solution for this problem.

The problem states that you have to modify the array in place. That means I can't create another data structure to store my values when I find any duplicates. Admittedly, the solution is still straightforward. I have not had the pleasure of using the splice() function in JavaScript too many times, so it took me a bit longer than I would have liked until I rediscovered it.

Now we will build the solution. I'll explain it first with some pseudocode, and then present the actual code below.

Loop through the array
The array size will change when we remove an element, so we need to use a variable to store the initial array length
check if i is greater than or equal to array.length
break if true
check if i equals i+1
if true, remove element at index i with splice()
decrement i to recheck that same position in case of further duplicates

Like I said, pretty straightforward. I tend to overthink these algorithm problems. That's why I'm practicing!

Solution:

var removeDuplicates = function(nums) {
    let numsLength = nums.length;
    for (let i = 0; i < numsLength; i++) {
        if (i >= nums.length) {
            break;
        }
        if (nums[i] === nums[i + 1]) {
            nums.splice(i, 1);
            i--;
        }
    }
};

Hope you learned something!! Have a great day and remember to GO OUTSIDE :)

LeetCode 1313. Decompress Run-Length Encoded List - Javascript Algorithm Practice

Nathan Kurz — Fri, 24 Jul 2020 15:54:48 +0000

Hello everyone!

Practicing LeetCode is one of my favorite ways to keep my mind and coding skills sharp. I don't think I would have been able to pass my interview questions without the help of LeetCode. I believe they provide a great service for developers everywhere. Without further ado, let's solve this thing!

The official problem statement:

We are given a list nums of integers representing a list compressed with run-length encoding.

Consider each adjacent pair of elements

[freq, val] = [nums[2*i], nums[2*i+1]]

with

i >= 0

For each such pair, there are freq elements with value val concatenated in a sublist. Concatenate all the sublists from left to right to generate the decompressed list.

Return the decompressed list.

Analysis

At first, this sounded a bit confusing to me, but it's basically just saying each pair of elements in the array represents a frequency and a value that needs to be stored in the new array. So if we were given an array

nums = [1, 2, 4, 6]

then our first pair would be (1, 2) and our second pair would be (4, 6). So from our first pair, we would store the value 2, one time. We would store the value 4, six times from the second pair.

The solution

The way I went about solving this was straightforward. We need to go through the list one pair at a time, get the values for each pair, and append the appropriate values the correct amount of times. We will go through it step by step!

Iterate over the list

We need to iterate over the given list of numbers one pair at a time. To do this, we can use a for loop that increments by two every iteration.

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var decompressRLElist = function(nums) {
    for (let i = 0; i < nums.length; i = i + 2) {

    }
};

Grab 'freq' and 'val' from the corresponding indices.

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var decompressRLElist = function(nums) {
    for (let i = 0; i < nums.length; i = i + 2) {
        let freq = nums[i];
        let val = nums[i + 1];
    }
};

Store 'val' in a new array 'freq' amount of times

I approached this portion by adding another loop (nested) to add the value the appropriate amount of times!

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var decompressRLElist = function(nums) {
    // create new array (decompressed list)
    let dcomList = [];
    for (let i = 0; i < nums.length; i = i + 2) {
        let freq = nums[i];
        let val = nums[i + 1];

        while (freq !== 0) {
            dcomList.push(val);
            freq--;
        }
    }
};

Return the new decompressed list

The last thing to do is to return dcomList!

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var decompressRLElist = function(nums) {
    // create new array (decompressed list)
    let dcomList = [];
    for (let i = 0; i < nums.length; i = i + 2) {
        let freq = nums[i];
        let val = nums[i + 1];

        while (freq !== 0) {
            dcomList.push(val);
            freq--;
        }
    }

    return dcomList;
};

Thoughts

My solution is a basic one, but it definitely gets the job done. I always like to solve these problems the simplest way I can, and then I go and look at the discussion page to see all the different ways other people go about solving them. This is probably what helps me grow most as a problem solver. It allows me to work through problems on my own, and then I can expand that knowledge through the work of others!

Bonus solution

Here is a solution written by LeetCode user ahmedengu that drastically reduces the number of lines of code (to just one)!

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var decompressRLElist = function(nums) {
    return nums.reduce((acc, v, i) => i % 2 == 0 ? acc.concat(_.times(v, _.constant(nums[i + 1]))) : acc, []);
};

I see this type of solution to these problems on LeetCode all the time. I want to keep practicing and memorize the builtin javascript methods so that I can better utilize them to come up with unique solutions like this!

Happy Coding!

Transitioning from C++ Windows App Development to Modern JavaScript Based Web Development

Nathan Kurz — Thu, 14 May 2020 04:49:45 +0000

A Little History

I'm writing about my current experience in the software development industry. I graduated from a four-year university in May of 2019. There I studied Computer Science with the hopes of landing a job in the field. Through luck and perseverance, I was able to obtain a wonderful position with an insurance company as part of the software division.

This opportunity was amazing. I was met with a brilliant team to mentor me. They offered a SAAS (Software as a Service) product, so they had a fairly large IT program. My managers were extremely helpful and would work with me whenever they could to help me with issues. The same can be said of my teammates. The software I worked on was written in C++ using the MFC framework for the GUI components.

C++ Development

I wrote C++ programs for eleven months. This allowed me to better understand memory management, passing by reference, and other concepts specific to C++. Before this experience, I had only used C++ for one semester in my Data Structures class. I basically went from being aware of these concepts to understanding them and using them on a regular basis.

I also learned some important software engineering principles from my colleagues. I was constantly being mentored on things like code structure, best practices, and different ways of solving new problems. The learning experience was incredible.

The Job Offer

Several months later, my friend from college told me there were openings at his much larger company. I didn't really think I had much chance of getting the job, but I did well in the interviews and got an offer. I was offered a significant amount more at the new company, and I thought the opportunity might benefit me more in the future.

I began working for my new company this year in January. My new team is completely different than my team at my last company. I'm not saying they are worse or better, but it's a completely different environment. My team consists of three individuals; myself and two others who are both younger than me. This hasn't proved to be an issue though, as I believe they are both brilliant individuals who consistently amaze me with their problem-solving skills. I feel grateful to have two people on my team like them.

The Transition to Web Dev

Another large change is the technology I use to write software. I'm writing web applications in javascript. I had only written a few basic websites before this as most of my education was in Java and C++ writing more traditional server or local applications. Learning web development is proving to have a pretty steep learning curve, but I'm learning and providing value every day.

No Types

One of the biggest obstacles was not using types in JavaScript. Writing in C++ had me constantly aware of the types of variables I was working with. It definitely led to confusion when trying to visually parse code in JS. Some of our projects are written in TypeScript, which felt much more familiar to me to look at.

Function Syntax

Another major difference I've noticed is the syntax in regards to a function declaration. The ultimate purpose of their creation remains the same, but the syntax is completely different. I had only heard of ES6 and didn't really understand it. The short function declarations looked extremely foreign when I first started seeing them. I rather like using it now though. The short versions are so much easier to write after getting used to them.

The fact that we are constantly passing functions in as parameters was another thing I struggled to completely understand. This coupled with the strange look of the new shortened function declarations caused me to miss the rigid structure I was used to in C++.

Engineering Principles

After eleven months of writing C++, I was developing a much better system of engineering my applications and managing my code. This was one thing that didn't suffer as much during the transition. After learning the basics of JavaScript, I find that I am able to implement a lot of the software engineering concepts I learned from my first company.

Visual Studio to Visual Studio Code

I wrote every bit of my code at my last company in the robust Visual Studio IDE. Every developer at the company used it, and it was the standard there for working with our software. This caused me to really get used to things like it's debugging and IntelliSense. As a web developer, I can pretty much use whatever IDE or text editor I want. My current team all use Visual Studio Code, so I'm sticking with that for now. Many aspects of these two pieces of software are similar, so the switch has not been so bad. I find that debugging the node applications though is not as intuitive or seamless as the experience was in Visual Studio.

Team Differences

This next challenge isn't as much with the technology as it is with my team. My first team was bigger, and it had much more seasoned developers with many years of experience working on the systems at that company. The developers I work with now, though extremely intelligent, are much less experienced. This definitely does cause different issues that I am not as used to working through.

My manager at company number one had about a decade of experience himself at that company. He also had a Masters in Computer Science from Georgia Tech. I don't mean to brag for him or put him on a pedestal. I only want to emphasize that when I got stuck on a problem that was proving very difficult for me to solve, he could usually help me with the issue extremely effectively. He understood the software stack so well that he knew sometimes what problems were and where they were in the code just by me describing the issues to him. His problem-solving skills were highly impressive to me.

My team now has much less experience than my other co-workers, and this leads to certain issues that I didn't have to face at my last company. I realized that my first manager was shielding me from the business side of the company. I very rarely had to sit in on meetings with clients discussing requirements for features, bug fixes, and things like that. He and other leaders would build the requirements. This is not the case with my new team. We all do very well in requirements translation and providing solutions, but when we all three run into issues we don't have a seasoned veteran that we can quickly turn to for assistance. There are benefits to this though. We have had to work through issues together as a team, so we all are learning from the problem-solving process. We haven't come across an issue that we haven't been able to solve yet, so I am extremely satisfied with our performance. Sometimes we have to reach out for assistance to other areas of the company, but we are really working to get the job done.

Final Thoughts

I don't mean to ramble, but the experience has been pretty insane and I could write about it all day. I am building a deeper appreciation for my work as I continue to learn new things every single day. I view both positions I have worked so far as extremely valuable. I wouldn't trade either of them for anything. As I continue to work and grow my knowledge and skills, I want to sometimes stop and remember just how much I have learned over the years. Sometimes I feel that the absolutely absurd amount of technical knowledge one could learn over the years puts me in this mental space where I feel like I just started. Then I tell myself that everybody else realizes this fact as well, and we are all just learning what we can and trying our best to provide reliable solutions for our companies.

I plan on being in this field for a while, and I feel extremely fortunate for the opportunities that I have been given. I love programming, and I'll probably be doing some form of it for the rest of my life. And I'm pretty happy with that for now.

P.S.

If you read this whole article I sincerely thank you for sticking with me.