DEV Community: Kwith Code

Selection Sort Algorithm

Kwith Code — Tue, 27 May 2025 08:17:46 +0000

How does a selection sort algorithm work?

When dealing with a sorting algorithm like a selection sort, there's a thin line between easy and confusing. However, you got on the right bus at the right station. Today we'll go through the steps towards achieving a good and basic selection sort algorithm.

Okay first thing we want to know is that a selection sort algorithm starts with first element assuming it's the smallest.

Always remember to work with index values, it's better that way. Then compares it to all other elements to see if it is.

For example, in the first iteration of the nested loop, the algorithm will take index y value and compare it with smallest value index, and if the current index value(y) is smaller than the smallest index value, then the algorithm will set y index as the smallest value index, and in the case that y is not, the algorithm will continue to the next index. Now the thing about the selection sort is that, when the iteration number of
the first loop increases the iterations of the second loop shortens.

So, for example if the first loop is on the 5th iteration and the length of the list is 9, the nested loop will only iterate in the of range (5+1, 9) which means it only iterates 3 times in the 5th phase.

How to apply that practically

Anyway, with all that explained, we move on to the practical part.

Create the main 'For Loop'

To begin, we'll create a variable storing our unsorted list, next we create a loop based on the length of the unsorted list, within the loop define a minimum index variable to store the smallest value index.

nums = [4,1,5,3,2,9,7]

for x in range(len(nums)):
    min_index = x

Add the nested 'For Loop'

Now within the loop, create another for loop iterating between the current iteration number of the first loop + 1 and the length of the unsorted list.

nums = [4,1,5,3,2,9,7]

for x in range(len(nums)):
    min_index = x
    for y in range(x+1, len(nums)):

Create conditional statements

In this loop we'll set a condition to determine if the current index value is less than the minimum index value. If that is the case, then we'll set the minimum index to the current index.

nums = [4,1,5,3,2,9,7]

for x in range(len(nums)):
    min_index = x
    for y in range(x+1, len(nums)):
        if nums[y] < nums[min_index]:
            min_index = y

After that, at the end of the nested loop, we'll swap the values of the minimum index(min_index) and the index determined by the first loop(x).

nums = [4,1,5,3,2,9,7]

for x in range(len(nums)):
    min_index = x
    for y in range(x+1, len(nums)):
        if nums[y] < nums[min_index]:
            min_index = y

    nums[x], nums[min_index] = nums[min_index], nums[x]

Test the code

print(nums)

And finally print out the sorted list.

Pig Latin - with Python

Kwith Code — Sun, 25 May 2025 16:59:38 +0000

Pig Latin Challenge

Looking for programming challenges? Try solo learn. Discover Amazing free courses, code bits and challenges.

Sololearn: Learn to Code

Sololearn is the world's largest community of people learning to code. With over 25 programming courses, choose from thousands of topics to learn how to code, brush up your programming knowledge, upskill your technical ability, or stay informed about the latest trends.

sololearn.com

What is Pig Latin?

Latin is a playful form of word transformation used for amusement and secretive communication. It has absolutely no direct relations with the Latin Language. The basic rule is to shift a word's first consonant or consonant cluster the end and add 'ay'.

Coding a Pig Latin Converter

First, we'll begin with a list of the alphabetical letters of English and create a list of vowels

alpha = list(map(chr, range(97, 123)))
vowels = ['a', 'e', 'i', 'o', 'u']

In the first stage we'll work on converting a word to pig Latin.

Latinize the word function

Now we create a function taking in any word through a parameter,
create an empty list that will hold the first consonants of a word once we break it.

def latinize(word):
    firstCon = []
    letters = list(word)

oh yeah, we'll need to break the word into a list in order to achieve our goal.

Next, create a list variable containing each letter of the word as an element. With the word converted to a list, we'll loop through the letters.

Create a 'for loop' looping through each letter. And in the loop, set a conditional statement to determine if the letter on iteration is a vowel or not using our vowel list.

def latinize(word):
    firstCon = []
    letters = list(word)
    for letter in letters:
        if letter in vowels:

Within the if statement create another 'if' (nested if) to decide on whether that vowel is the first letter of the word. In the case that it is, return the word as it is.

create the 'else' (for the nested if) to break the loop. Why? because in case we bumped into a vowel of a word that should be the end of the loop.

In the else statement of the first 'if' conditional statement, append the letter to the 'first consonant' list.

def latinize(word):
    firstCon = []
    letters = list(word)
    for letter in letters:
        if letter in vowels:
            if letters.index(letter) == 0:
                return word
            else:
                break
        else:
            firstCon.append(letter)

After that create another 'for loop', in this loop using the 'first consonant' list elements we'll move the first consonants from the front to the end of the letters by removing them and appending them.

def latinize(word):
    firstCon = []
    letters = list(word)
    for letter in letters:
        if letter in vowels:
            if letters.index(letter) == 0:
                return word
            else:
                break
        else:
            firstCon.append(letter)

    for letter in firstCon:
        letters.remove(letter)
        letters.append(letter)

In the next step away from the loop we add 'ay' to the letters list and create a string variable to hold the latinized word.

And now to completely model the word back together, we'll loop through each element in the letters list and add it to the latinized word string.

Finally, we return the word as a string and our function is done.

def latinize(word):
    firstCon = []
    letters = list(word)
    for letter in letters:
        if letter in vowels:
            if letters.index(letter) == 0:
                return word
            else:
                break
        else:
            firstCon.append(letter)

    for letter in firstCon:
        letters.remove(letter)
        letters.append(letter)

    letters.append('ay')
    latinized = ''
    for letter in letters:
        latinized += letter

    return latinized

At this point this seems like loads of work for a fun challenge but hang on
we just finished the main part. So, the good news is that you're almost done.

Follow for the next Part!

Test code:

print(latinize('Friday'))

full code:

HTML/CSS - Pig Latin Word.py Online Editor and JavaScript Compiler | Sololearn

Use our FREE Python online compiler to write, run and share your code. Works directly from your browser without any additional installation.

sololearn.com

Reversing a string

Kwith Code — Fri, 23 May 2025 19:07:49 +0000

How to create a reverse string function in python

In order to reverse a string in python and make our code reusable, first we need to define a function. In that function you'll have a parameter taking in a string,

def reverseStr(data:str)

two variables, one containing a split-word list and the other where we'll add a reversed string of letters
of the given string,

splitWord = list(data)
reversedWord = ''

a loop, in this loop we'll iterate by the value of the length of the split-word list and in each iteration
we'll add the index value of the length of the split-word list(len(splitWord)) minus the iteration number(i)
to the reversedWord making one reversed word.

for i in range(len(splitWord)):
    reversedWord += splitWord[(len(splitWord)-1)-i]

and finaly our work is done. Enjoy your day.

def reverseStr(data:str):
    splitWord = list(data)
    reversedWord = ''

    for i in range(len(splitWord)):
        reversedWord += splitWord[(len(splitWord)-1)-i]


    return reversedWord

let's test it:

def Run():
    word = 'Monopoly'
    print(reverseStr(word))

Run()

Heli9x / Codepens

A bunch of fun code to get u

Codepens

A bunch of fun code to get you on track or in line.

View on GitHub

Bubble Sort - Python

Kwith Code — Fri, 23 May 2025 12:31:07 +0000

How to make a sorting algorithm step by step

When creating an algorithm like a bubble sort algorithm, the position of data will be random. So in order to create an algorithm that will sort any list of data given with its elements in random positions, we'll need to access the data by the index of the list.

Bubble sort can be split into two loops at the very basic level. Where one loop iterates the phases and the other the replacement/swap of elements.

Yeah, I know, I also couldn't understand what this meant but hang on,

okay so check this out. You have a list of numbers
[2,4,3,5,6,7]

Our minds can easily sort this because we know which number is greater than the other. However the computer doesn't so we'll have to tell it how.

First thing you need to do is go through each element and compare if that element is greater than the one next to it sequentially.

So we'll take 2, compare it with 4 and if it is greater than 4 we'll swap the two numbers. In this case no so we leave it.
in the next case we'll take 4 compare it with 3, if it is greater, we'll swap the two numbers and now our list we'll be like this: [2,3,4,5,6,7]

data = [2,4,3,5,6,7]
for x in range(len(data)-1):
  if data[x] > data[x+1]:
     num = data[x]
     data[x] = data[x+1]
     data[x+1] = num

Now this is the main part which I referred to as the replacement/swap loop. in order to perfectly sort our list, we'll need to make a time for each element to be compared to all other elements. So that if we had in any case we had a list like [4,5,8,6,2,9,3] we wouldn't experience any issues.

And this is where the phase loop comes in. This part allows us to compare an element to other elements in its own phase. The number of iterations will be dependent on the length of the list. [1,7,8,5,6,4] will have six phases as len([1,7,8,5,6,4]) = 6

To put it all together now,

data = [1,7,8,5,6,4]
for i in range(len(data)-1):
    for x in range(len(data)-1):
        if data[x] > data[x+1]:
           num = data[x]
           data[x] = data[x+1]
           data[x+1] = num

print(data)

Test of the code:

C++ Playground - Sorting.py: Online Interpreter, Compiler & Editor | Sololearn

Use our FREE Python online compiler to write, run and share your code. Works directly from your browser without any additional installation.

sololearn.com