Forem: atoms

nope

atoms — Sat, 19 Apr 2025 18:13:45 +0000

hacking but at what cost

atoms — Fri, 18 Apr 2025 01:40:29 +0000

I am a CS undergrad and i do what the uni tells me to do
cause academics

altho sometimes when they are shoving things down our throats i get mad

and so they gave us this online course platform to learn about AI
do they have structured classes ?
no
its more like bunch of random articles that we are supposed to read and click mark as done

so being the lazy guy i am i automated this redundant task
its an autoclicker

go right click click inspect, and paste this in console

targets=document.querySelector('.contentlist_sec').children

function complete(f=0){
elem=targets[f]
if(f >= targets.length){
    return
}
let pid=elem.id.split('_')[1]
getSubProduct(pid,'0','1','false')
setTimeout(()=>{
pre_mark_as_complete(pid,'false')
},1000)
setTimeout(()=>{
mark_as_complete_hub_product(parseInt(pid))
elem.classList.remove('allActiveProd')
},3000)
setTimeout(()=>{
    complete(f+1)
},7000)
}
complete()

wait some seconds and u have all your courses automatically clicked and done awesome right ?

well i should have stopped there
well i didn't

the ugly

little did i know i was getting myself into a grave grave mistake that would haunt me for an entire night
rise my adrenaline levels and almost threw me into a panic attack

i inspected the quizzes section and decided to see how i can bypass the quizz , i moved around the js files sent to the client and figured out a way to print the answers well the IDs of the answers
you'll have to inspect and click on them so its kinda hard

this wasnt enough i wanted to see if i can override the entire quizz cause i saw no live answers being posted to a server on checking requests all i saw was nothing

so the quizz was being validated on the client which itself is a stupid thing to do , hey atleast they put it inside an iframe to make it work so good for them
most peeps dont know this trick
you can access an <iframe></iframe> inside an html page from the console by

>> frames

this is an array of iframes so i can even call the methods inside the iframe script by just chaining them to the first iframe like an object's methods

>> frames[0].checkAnswers()

yup its that obvious client code isnt bundled no obscufication just straight up methods and their names
good for us
bad for them


frames[0].questions_data.map(v=>v.all_options.filter(s=>s.is_true==1)).forEach((val,i)=>{
let log=frames[0].document.getElementById(val[0].answer_id).children[0].children[0].innerHTML
console.log(`${i+1})  ${log}`)
})

i dont think they care tbh if they did they wouldnt have made a shitty site to begin with and most of all the courses are very shit

so i saw this method called publishResult() and thought this might directly publish my results and get me that quizz completed
so i went ahead and called it

grave mistake, if i had a timemachine i'd go back in time and smack old me before doing it,
this traumatic incident has given me a new insight

never call a function or any get routes that seems like they are
messing with data on the db
reason is simple get request's likely modify something on the server and its not gonna let u control that modification again , so once its done theres no over-riding it unless u find another post request that actually does something

well in this apps case its a get request so i started this shit around 2am as of time i am writign this its 6:30 am yes i didnt sleep
i couldnt sleep

cause the calling that publishResult() from the client did something and made my quizzy a self paced one meaning that i cant retake it anymore , too bad i havent even completed

so there i was stuck midway at a course 16% done , mandatory for the semester unable to move past this quizz , cause no matter how hard i try server will not serve the quizz link to me cause that route likely is doing some checking with some table inside the server and its saying that i have already completed so send me the results page

except the thing isn't marked as complete in the courses table (ig at this point i can only guess what they have named it as)
so i was cooked

deep fried 🥵
like burnt to ashes sorta cooked

there was 0 escape , i dug into the iframes nothing there
no new function calls no new ways to find the new routes
i even installed fucking gobuster in hopes of finding new routes
so that i can do a post request to
no way to continue this course without clearing that quizz , but quizz wont open cause the server thinks i did it already

i was almost at the verge of a panic attack i calmed down and started praying to the god

fr i was stressing over this cause no ordianry person would ever encounter this error and i had some serious explaining to do if i was caught

publishResult() was inside the iframe it wont be called unless the server decided its the right time to serve it to normies would never even call this let alone inspect the site, i cant even explain that to the helpline

anyways i decided to sleep and call helpline then due to the fear i refused to give up i wanted this shit done no matter how hard it was
if i got to this point i can fix it as well
i tried taking new courses and trying to attend quizzes again to see how the system did it

after hours of digging attending the same quizz over 10-11 times i finally found a promising url ,and i chaged the quizz id and then i did a get request to the server got 500 back

i was dead 500 error code ,luckly error was some
for some reason the thing worked and i had overridden the quizz
and got the course marked as completed

override quizzes

here is that magic overriding link

https://www.<the sitename.in>/LX/vcourses/declare_course_complete_self_pace?c_id=<quiz-id>&enb_id=<your_enbId>&content_player=true&dashboard_mark_as_complete=&new_ui_flag=true&quiz_single_node=true

idk what enb id is (cause god knows what they thought of while making this api) i figured it'd be different for diff users so if u wanna know yours just inspect some of those iframe ajax requests or just inspect the iframe itself prolly youll find it there

and it overrides quizzes , i want to see how to override a whole course like the entire thing but that will prolly be too noticeable to be disregarded as a glitch ig
so basically if u wanna override a quizz without doing it just call this ig

i didnt wanna expose that company so i placed sitename.in replace that with the sites name if yk yk

should u do this

absolutely frikin no !!
defo dont do this if u are doing this , then you are either running out of time or just wanna like do it for the sake of doing this

btw the autoclicker thingy perfectly safe to use , but ethically i think its better to go through each article and try to learn something dont chase comfort like i did , i lost sleep over it
well now i am scared to even open that website
😩 anyways that was my terrible experience with this mooc courses platform

(i should make another article criticizing how retarded most indian companies are when it comes to making websites its like we never escaped the php and jquery era { i am speaking as if i could make these big sites 😵})

algorithms: intro to sorting algorithms 5 {counting sort and radix sort}

atoms — Fri, 21 Mar 2025 18:12:30 +0000

Hey reader. lets wrap this up shall we we will be learning non comparitive sorting algorithms today

lets throw in our route map again

1) insertion sort [x]
2) selection sort [x]

3) merge sort [x]
5) quick sort [x]

6) bubble sort [x]
7) cocktail shaker sort [x]

8) heap sort [x]
9) priority ques [x]

10) counting sort <
11) radix sort<

counting sort

this is a non comparative sorting algorithm that works in a different way to all the other sorting algorithms we have seen so far
because instead of sorting by comparing this seems to work differently

of course we need more space for this but its worth it let me break down the counting sort algorithm


[5,6,1,2,0,2]
 0 1 2 3 4 5 - indexing

[1,1,2,0,0,1,1] - frequency array
 0 1 2 3 4 5 6 - indexing corresponds to value of number we are counting

[1,2,4,4,4,5,6] - cumulative frequency array this (add up elements of            
 0 1 2 3 4 5 6    frequency array as we traverse)


-------

now we work backwards to make the sorted list ,our cumulative array stores the position of elements , the key is indexing 
we traverse the main array from left to right 

2 is valued as 4 in cummulative array so we place it at 4-1 = 3 index (indexing starts from 0)

[_, _, _, 2, _, _]

decrement the cumulative count of 2 to 3 since one is done 

now 0 is at position 1 , which is 1-1 =0 th index

[0, _, _, 2, _, _]

decrement cumulative count to 0 

now 2 again since we have modified our cumulative array to have 3 in 2nd index from the first step we place 2 at 3-1=2th index

[0, _, 2, 2, _, _]

we continue as 1 we find it pos 2 (2-1=1) and then 6 at 5th index 5 at 4th index
[0,1,2,2,5,6] sorted array

algortithm itself is peak dont u think we can just overwrite the frequency array to store the cumulative array instead of making a new array which saves space

implementation

 countingSort(array) {
    int min = Array.min(array)
    int max = Array.max(array)
    counting = Array(max - min + 1).fill(0)

    for (i in 0...array.length) { // building frequency array
        counting[array[i] - min] += 1  // this shift is because indexing of counting is smaller than array so we shift it by min 
    }

    for (i in 1...counting.length) {
        counting[i] += counting[i - 1]
    }

    let sorted = Array(array.length)

    for (i in array.length...0) { // reverse traversal of main array
        num = array[i]
        sorted[counting[num - min] - 1] = num
        counting[num - min] -= 1 
    }

    return sorted
}

features

1) very fast for small datasets
2) stable algorithm (duplicates order preserved)
3) O(n+k ) linear time complexity

disadvantages
1) insanely bad for large datasets k>>n
2) space complexity of O(1)
3) only works for integers
4) not suitable for linkedlists

Radix sort

this is also a non comparative sorting algorithm eeks ;)
its built on top of counting sort ( u could change this if u want )

basically it works by finding the msd of largest number and then sorting the array based on the units place , 10th place etc.. till it reaches the msd's place

radixSort(array){
int max=Array.max(array)
int digits=1

while(Math.floor(max/digits) >0){
countingSortByDigit(array,digits)
digits=digits*10
}

return array
}

countingSortByDigit(array, digit) {
     output =  Array(array.length).fill(0); // Temporary output array
     counting = new Array(10).fill(0); // We need only 10 slots (digits 0-9)

    // Build frequency array
    for (i in 0...array.length) {
        let digit = Math.floor(array[i] / digitPlace) % 10;
        counting[digit]++; 
    }

    //  Compute cumulative frequency
    for (i in 1...10) {
        counting[i] += counting[i - 1];
    }

    for (i in array.length - 1...0) {
        let num = array[i];
        let digit = Math.floor(num / digitPlace) % 10;
        output[counting[digit] - 1] = num; 
        counting[digit]-=1
    }
    for (i in 0...array.length) {
        array[i] = output[i];
    }
}

we modify the counting sort to keep the last digit or the places digits to its indexing and then when accessing them we do the same

O(n+10) complexity per a digits place

hence O(d(n+k))

since k=10 (0-9)
O(d*n) neglecting k
max=10^d
log 10 max=d
hence O(n log 10 (max)) is also a form of writing this

features

stable sorting algorithm
o(n+k) due to coutning sort
if d is large not that good
works in fixed length data

so what we have learnt is the LSD radix sort its great for fixed length data but there is one more radix sort MSD radix sort it works better for diffrent length data and floats

it is very similiar but instead of going from lsd to msd it goes for a recursive top down approach where it goes from msd to lsd

we wont be covering this but ill leave the code here if u wanna check it out (i ai'd it )

function msdRadixSort(array, left = 0, right = array.length - 1, digitPlace = null) {
    if (left >= right) return; // Base case: Only one element or empty

    if (digitPlace === null) {
        let maxNumber = Math.max(...array);
        digitPlace = Math.pow(10, Math.floor(Math.log10(maxNumber))); // Start from highest power of 10
    }

    let buckets = Array.from({ length: 10 }, () => []); // Create 10 buckets for digits 0-9

    // Step 1: Distribute numbers into buckets based on the MSD
    for (let i = left; i <= right; i++) {
        let digit = Math.floor(array[i] / digitPlace) % 10;
        buckets[digit].push(array[i]);
    }

    // Step 2: Recursively sort each bucket and overwrite the original array
    let index = left;
    for (let i = 0; i < 10; i++) {
        if (buckets[i].length > 0) {
            for (let num of buckets[i]) {
                array[index++] = num; // Place back sorted numbers
            }
            msdRadixSort(array, index - buckets[i].length, index - 1, digitPlace / 10); // Recursive call for the next digit place
        }
    }
}

thats it guys and gals we are wrapping up our intro to sorting algorithms series there are a couple of promises i werent able to keep but ill do fullfil them later on

like priority ques were harder than expected for me then theres bucket sort and the other things which i have left out btw if u havent noticed msd radix uses bucketsort

basically putting things into buckets and then sorting them using a basic sorting algo ig like insertion or selection sort

this is not the end ill be back to serve my empty ghost audience of webscrapping bots
next i plan on doing a intro to searching algorithms series

and before that i might do an article on trees ,linkedlist or ques god knows anyways thanks

algorithms : intro to sorting algorithms 4 { heap sort }

atoms — Thu, 20 Mar 2025 23:35:07 +0000

Hey reader. finally we have done it we have overcame the challenges of many sorting algorithms and has arrived at heap sort

lets throw in our route map again

1) insertion sort [x]
2) selection sort [x]

3) merge sort [x]
5) quick sort [x]

6) bubble sort [x]
7) cocktail shaker sort [x]

8) heap sort <
9) priority ques <

10) counting sort
11) radix sort

heap sort is radically different from previous sorting algorithms as they rely on a new data structure which you may or may not be familiar with , a max-heap
think of it as a heap where the largest things stays on top sorta like billionaires in our society lol

its basically a tree data structure which follows heap min and max operations or satisfies their conditions

now what we do basically is make these max heap from the array that we wanna sort lets use a function buildHeap() for that
and then since heap is already sorted we are done .right ?

NO , its never that easy
max heap just shows you that the one on top is the largest it necessarily doesnt follow a sorted order

when we build the heap once we get the first largest element now that we know the largest element lets put it to the end of the array
by swapping the last element to this largest element (root of the heap)
also remove this largest element from the heap , so in next iteration we find the second largest

now rebuild the heap , heapifydown() which is a function that will like go through the heap again and get the largest at the root again which will result in the second largest element being found now replace the second last index with this and so on

and in time youll have the entire array sorted
building heap takes O(n) and heapify takes O(log n)
overall this process is time complexity of O(n log n) over all cases

and it is inplace sorting so O(1) space complexity very good damm
and it doesnt rely on recursion that much lol

its used in priority ques task scheduling etc very useful

now to get to the heart of heap sort its pretty difficult yk i cant just memorize an code and call it a day lets ask why it works

important things to be aware of

fancy guys might not tell u this but an array can be used as a heap , oop programmers would have already made a class heapnode by now

why does an array work as a heap and how

  6
 / \
4    5
/ \   \
2  1   3

lets make this into an array from 
let heap =[6,4,5,2,1,3]

this makes things easier for us we could just make an array and call it a heap without having to define classes etc

you might be saying but how does this beat a regular class or struct based definition


struct HeapNode{
     int data;
     struct HeapNode * right,left,parent;

}

which gives u ability to access the right and left node of any node using the members right and left and parent node by using .parent

very cool but u can do litterally do all the same with just maths and array

 0 1 2 3 4 5
[6,4,5,2,1,3]

let see some patterns look how the right children of any element are odd numbers and left ones are even indices

that makes to get the index of right child of nth element just find nth odd number , 2*n +1

and to find left child of nth element just do 2*n + 2 (since index starts with 0 we have to account for that by adding 2 )

notice how the parent is just i-1 for right nodes and i-2 for left
left node are given by i=2p+2 then p (parent index) by rearranging is
p=(i-2)/2
right nodes are given by i=2p+1
p=(i-1)/2

we take floor of the formula for p to find the p since parent index cant be decimal
Math.floor((i-1)/2)gives parent index of any node with index i

so voila you just made a heap using just array and a bit of maths

now what we have created is just a heap its not a min heap or max heap for that we need to write logic for the largest element to be on top of the heap (heapifydown)

we start at each node and check if its children are larger than it if it is we swap the node with the child
and continue untill all nodes satisfies this heap property (for max heap)

heapifyDown(array,size,startIndex=0){
left=2*startIndex+ 2
right=2*startIndex + 1
whattoswap=startIndex

if(right < n){ //checking if right exists"
     if(array[right] > array[startIndex]){
        whattoswap=right
     }
}

if(left < n){ //checking if right exists"
     if(array[left] > array[startIndex]){
        whattoswap=left
     }
}

if(whattoswap!==startIndex){
    temp=array[whattoswap]
    array[whattoswap]=array[startIndex]
    array[startIndex]=temp

     //recursively call it 
     heapifyDown(array,size,whattoswap)
}



}

heapifyDown(a,10)

heapify down is an important function as this forms the basis for converting an array into a max heap
to do so we start from the bottom up implying we start from the end of the array and build the heap by using heapify to modify the array in such a way that parents are larger than childrenn

from about half of the length of array you have leaf nodes so u should start from there and work towards 0

buildHeap(array){

for(i=array.len/2 ; i>=0 ;i--){
    heapifyDown(array,array.len,i)
}

}

}

when adding elements to a heap you might encounter heapifyUp which works its way up from the bottom and swaps elements that dont fit
with its parents this is also useful but not useful here
anyways ill drop a quick algorithm of how they work

heapifyUp(array,index){
    if index==0 return 
    parent=floor(index-1/2)
    if array[index] > array[parent] then
        // swap them too lazy to write 
        heapifyUp(array,parent)

}

now we are ready to tackle heap sort algorithm
which will first build a max heap then use iteratively gets the

heapsort(array){
    buildHeap(array)
    for(i=n-1; i >0; i--){
        root=array[0]
        array[0]=array[i]
        array[i]=root
        heapifyDown(array,i,0)
    }


}

well there u have it heap sort what a wonderful sorting algorithm which has so many low level applications now like i said before lets discuss priority scheduling which is an application of heapsort

priority scheduling

in Os processes has to be scheduled and for scheduling process we often use heaps for priority based scheduling , since heaps can help us keep track of the task with most priority

it is used in both preemptive and non premptive priority scheduling ( preemptive just means inturupts are allowed during process runs )

also used in shortest job next algorithms (min heaps prolly)

its for another article since this is already too long

algorithms : intro to sorting algorithms 3 { bubble sort and cocktail shaker sort }

atoms — Thu, 20 Mar 2025 09:27:32 +0000

Hey reader , welcome back so lets brush up what we learnt last article so we've discussed about insertion sort and selection sort , one works by shifting and inserting other by finding smallest and swapping , merge sort works by divide and conquor and merging and quicksort works by sorting around a pivot
etc etc and so on check on the older article if u haven't read that already

lets throw in our route map again

1) insertion sort [x]
2) selection sort [x]

3) merge sort [x]
5) quick sort [x]

6) bubble sort <
7) cocktail shaker sort <

8) heap sort
9) priority ques

10) counting sort
11) radix sort

now we will be learning bubble sort and cocktail shaker sort

bubble sort

bubble sort works by constantly swapping adjacent elements , it has a time complexity of O(n^2) almost all the time except when the array is sorted already and its O(n)
it performs a lot of swaps making it very innefficient but despite all this bubble sort is easy to implement so it is widely used to teach kids sorting

function  bubbleSort(arr) {
    let swaped;
    for(let i=0;i<arr.length;i++){
        swaped=false 
        for(let j=0; j< n-i-1 ; j++){
            if(arr[j]>arr[j+1]){
                temp=arr[j+1]
                arr[j+1]=arr[j]
                arr[j]=temp
                swaped=true
            }
        }
        if(!swaped) break
    }

}

# cocktail shaker sort

this is bubble sort but 2x it does forward and backwards traversal and then it swaps , but this reduces the number of swaps needed somehow

function  cockSort(arr) {
    let swaped;
    do{
        swaped=false

    for(let j=0;j<arr.length;j++){
            if(arr[j]>arr[j+1]){
                temp=arr[j+1]
                arr[j+1]=arr[j]
                arr[j]=temp
                swaped=true
     }


    if(!swaped) break
    swaped=false


        for(let j=arr.length-1; j>=0 ; j--){
            if(arr[j]>arr[j+1]){
                temp=arr[j+1]
                arr[j+1]=arr[j]
                arr[j]=temp
                swaped=true
     }



    }

    }while(swaped)

}

tad bit better than bubble sort still is impractical for normal use cases when large data arises
since it still has a worst case time complexity of O(n^2)
and best case if sorted O(n)

algorithms : intro to sorting algorithms 2 {merge sort and quick sort }

atoms — Tue, 18 Mar 2025 22:47:35 +0000

Hey reader , back again ? so lets brush up what we learnt last article so we've discussed about insertion sort and selection sort , one works by shifting and inserting other by finding smallest and swapping ,etc etc and so on check on the older article if u haven't read that already

lets throw in our route map again

1) insertion sort [x]
2) selection sort [x]

3) merge sort <
5) quick sort <

6) bubble sort
7) cocktail shaker sort

8) heap sort
9) priority ques

10) counting sort
11) radix sort

we have reached merge sort and quick sort
now these guys are used everywhere in programming as they scale well for big datasets they are the best we got

both of them works by the principle of divide and conqueror ,which works very well and can even topple the largest of largest empires to its knees (rip india)
same goes for data when u break it down to smaller chunks and sort them portion by portion eventually you'll have the entire data sorted

merge sort

merge sorts works by repeatedly halfing the array till it becomes sigular and addding them together while sorting them along the way

our implementation is pretty damm cool

function merge(left,right){
        let sortedArry=[]
        let i=0;
        let j=0;

        while(i< left.length && j<right.length){
                if(left[i]<right[i]){
                    sortedArry.push(left[i])
                    i++
                }else{
                    sortedArry.push(right[i])
                    j++
                }
        }
        return [...sortedArray,...left.slice(i),right.slice(j)]

}

function mergeSort(arry){
         if(arry.length<=1) {
            return arry
         }
         let mid=Math.floor(arr.length/2)
         let left=mergeSort(arry.slice(0,mid))
         let right =maergeSort(arry.slice(mid))



        return merge(left,right)
}

but its rather confusing when u think about the call stack so lets break the call stack down

<  initailly lets consider an array of 6 elems

mergeSort is called 
it finds half 3
right half is set to mergesort of half 3 -> 
                    |- mergesort called of arry element 3 
                            |- finds half as 1 
                            | - mergesort called again on 1 
                                        |- array returned 1 
                            |- mergesort called again on 2 
                                        |- array split and mergesort called again on 1 and 1 
                            |- merges(2 1)
                            | returns sorted right half 
                     |- mergesort called of arry element 3 
                            |- finds half as 1 
                            | - mergesort called again on 1 
                                        |- array returned 1 
                            |- mergesort called again on 2 
                                        |- array split and mergesort called again on 1 and 1 
                            |- merges(2 1)
                            | returns sorted left half 
                    | merges them together to get final sorted array

merge sort always shows the time complexity of O(nlog n) and space complexity of O(n)
since it doesnt varies the average case worst case and the best case are all the same and it is O(n log n)

merge sort is a stable sorting algorithm meaning that order of the elements with equal values are presevrved when comparing to the original as they appear first

it is very useful to sort linkedlists
as linkedlist does not support indexing and random acess halfing them with slow and fast pointers work best making it suitable
no need of extra space as pointers can be swapped directly
consistant time complexity O(n log n)

disadvantage : memory usage and recursive overhead

quick sort

i always thought quick sort hard but turns out it easy as well
so basically we divide array based on a piviot element and then put elements bigger than pivot to its right and lesser to its left
then we recursively do it with left part and right part

and at the end we will have a sorted array

pivot choice is very important as it decides the performance of the algorithm
here we went for the easist where we use the last element as the pivot

function quickSort(arr){
    if(arr.length==1){
        return arr
    }

    let pivot=arr[arr.length-1]
    let right =arr.filter(e=> e > pivot)
    let left =arr.filter(e=>e< pivot)

    return [...quickSort(left),pivot,quickSort(right)]

}

using first element or last element as pivots work best for random data but fails for sorted or reverse sorted data and drops to O(n^2) time complexity

other pivots we can use are

random pivot

function quickSort(arr) {
    if (arr.length <= 1) return arr;

    let pivotIndex = Math.floor(Math.random() * arr.length);
    let pivot = arr[pivotIndex];

    let left = arr.filter((x, i) => x < pivot && i !== pivotIndex);
    let right = arr.filter((x, i) => x >= pivot && i !== pivotIndex);

    return [...quickSort(left), pivot, ...quickSort(right)];
}

works best for large datasets, avoids worst case scenario

median of three pivot

function median(arr){
    let first=arr[0]
    let last=arr[arr.length-1]
    let mid =Math.floor(arr.length/2)

    return [first,last,mid].sort()[1] //sort and get the central element 

}

prevents worst case scenario and stable
slight overhead in calculating median each time

median of median pivot bit more complex but it gurantees O (n log n ) complexity but overhead of some compute slower than others

useful to find kth smallest element or smthn

splits array into group of 5 then find median of those groups then recursively finds median of those medians and then so on till it finds a pivot

quick sort is not stable sorting
quick sort works in place so its used in general pourpose codes

conclusion

ik this chapter feels a bit rushed and not to the point , well its cause its 4 in the morning and my back hurts and all i had for dinner was a frickin orange and i am writing this just so that i am dedicated to learning these

algorithms : intro to sorting algorithms 1 { insertion sort and selection sort }

atoms — Tue, 18 Mar 2025 22:37:17 +0000

Hey reader , you have stumbled across a series of posts where I'll be speed running through algorithms for sorting arrays ,linked-lists , heaps etc

this series will deeply go into the algorithms and try to understand them ,when I was starting I felt like algorithms are something you have to come up on your own like independently discover then after long hours and wasting a lot of time I realized I am not the tourist lol.
my IQ is barely enough to do Javascript so i shouldn't waste my time trying to race to the moon using an aircraft that barely flies

well this course is for you as a dumb dumb I explain these things as dumb dumbs would understand

sorting algorithms came from the need to sort things cause humans are fundamentally data organizing machines , so its only natural that we love sorted data

so when we had stored items in memory as arrays trees etc we also wanted to sort them in ascending or descending order
and we developed many algorithms for it each algorithm has a tradeoff and some advantages

so we will look into that exactly

sorting algorithms

1) insertion sort <
2) selection sort <

3) merge sort
4) quick sort

5) bubble sort
6) cocktail shaker sort

7) heap sort
8) intro to priority ques

9) counting sort
10) radix sort

we will go over each and identify their time complexity ( time efficiency ) space complexity (space efficiency) their algorithm and implementation

this article is meant to be small and readable so i decided ill be going at 2 algorithms per article , in this one we will be covering insertion sort and selection sort

insertion sort

insertion sort kinda feels like putting things to its actual place , like while going through the things to sort when we something we put it at its correct place

this is how humans naturally sort things like suppose we have a bunch of screws we have to sort them such that the rustiest screw comes first and shiniest screw at last , so when going over the screw we will put the rusty ones at the start and arrange them one by one

this algorithm happens a lot by shifting things , it starts by comparing element at second position (index: 1) to the one at index: 0 if it is lesser then it shifts it to the right and the loop continues till the second element gets into the right position and outer loop continues this and make this happens till all the elements
are in the right position

note that the comparison happens to elements before the selected element so the time complexity is incremental and its O(n^2)
in worst case and O(n) in best case already sorted array

we are only using a single storage space and it is constant , that is to store the element which we are selecting for the iteration making space complexity just O(1) and in-place swapping so its independent of no of elements

we will be using typescript

initial implementation ( this is not o(1) as we arent using any extra space at all )

let a=[1,2,5,3,6]

for(let i=1; i < a.length ;i++){
     let j=i-1 //setting j to the previous index of i 
     while(a[i]<a[j] && j >=0){ //condition  
           a[j+1]=a[j] //shifting to the right 
           j-=1
       }
     a[j+1]=a[i]
}

some doubts i had initially

1) where does the array shift into , wont this overwrite one of the elements yes while shifting we are essentially using up the space of the selected element we will overwrite the selected element so its important to store the element before we begin shifting making the space complexity O(1) again

2) another doubt i had was why j+1 and not j while setting the last bit
but that is also cleared up as the loop ends it subtracts a j again from the actual j where we have to enter the item so it is one less , to get the actual index to insert our key we get the a[j+1]

3)one more doubt i had was what lies there in a[j+1] wont that be overwritten , since we shifted the last element we shifted is present as a duplicate on a[j+1] so we can overwrite that with no worries
4) j is greater than 0 condition is given to stop our loop at 0 even if the condition hasn't been satisfied yet

so that gives rise to our final implementation

let a=[1,2,5,3,6]

for(let i=1; i < a.length ;i++){
     let j=i-1 //setting j to the previous index of i 
     let key = a[i] //storing the selected element 
     while(a[j]>key && j >=0){ //condition  
           a[j+1]=a[j] //shifting to the right 
           j-=1
       }
     a[j+1]=key 
}

more info

insertion sort has space complexity O(1) and time complexity that varies from O(n) - O(n^2) , O(n) for already sorted array and o(n^2) for reversely sorted array
can be used in small datasets where the data is nearly sorted as performance would be close to O(n)
it is a stable sorting algorithm implying that for equal elements the order of the elements will be preserved based on their appearance in the original unsorted array

Selection sort

this sorting algorithm is where we choose the smallest element from unsorted part and swap it to the first element of the unsorted part

the algorithm itself is quite easy
Given an array arr of size n:
Loop from i = 0 to n-2.
Find the index of the smallest element in the remaining unsorted array.
Swap it with arr[i].
Continue until all elements are sorted.

my initial implementation was like this

let a=[1,3,2,6,4]

for(let i=0 ; i <a.length ; i++){
   let smallestAt=i
  for(let j=i ; j< a.length ;j++){
        if(a[j] < a[smallestAt]){
            smallestAt=j
          }          
   }
   //swapping
   let temp=a[i]
   a[i]=a[smallestAt]
   a[smallestAt] =temp
}

i stored the index of the smallest element as it is needed for swapping in the end

with some critical evaluation i realized i only need to swap if a smaller element than the element at i was found and also i only need to compare it to the elements after i , so i+1
why should i compare it to itself

let a=[1,3,2,6,4]

for(let i=0 ; i <a.length ; i++){
   let smallestAt=i
  for(let j=i+1 ; j< a.length ;j++){
        if(a[j] < a[smallestAt]){
            smallestAt=j
          }          
   }
   //swapping
   if(smallestAt!= i){
   let temp=a[i]
   a[i]=a[smallestAt]
   a[smallestAt] =temp
}
}

selection sort is intutive when u think of it , its like picking the smallest one of the unsorted part comparing it with we have already sorted and swapping them

but this shit is not efficient like look at this blud we are comparing and constantly looking for smallest element making the time complexity of this O(n^2) no matter how the array is sorted

worst case , average case , best case it is all time complexity is O(n^2) and
it sorts in-place so no extra memory is needed hence O(1) space complexity

also its not stable and for equal elements your order might not be preserved

seems like a downgrade from insertion sort at first but this is a simple algorithm that can be used in small datasets where the need for stability is not there and minimizing the number of swaps

selection sort only performs n-1 swaps for an array of n elements while sorting it while insertion sort performs lots of swaps (for shifting etc O(n^2) swaps in worst case)

this nature of selection sort makes it a good choice for large chunks of data where swaps are expensive
told ya each algorithm is special in its own way and don't discriminate lol

tysm for your time hope u find it useful

The Journey to my Fullstack Scaffold: create smota-app

atoms — Sun, 16 Mar 2025 09:02:00 +0000

As a fullstack developer,I found myself spending more time bootstrapping projects than actually building them. A self-hosted app typically requires an OAuth system, a database and its adapters, UI components, and a multitude of configurations before I could even begin the core development process. This realization sparked the creation of a small CLI tool that could streamline the project scaffolding process. Thus, create smota-app@latest was born.

The Hackathon Wake-Up Call

I first tested my tool during a hackathon. However, I quickly encountered significant friction when dealing with the API. React Server Actions (RSA) required extensive integration with the client side, along with cumbersome hooks and Zod schemas for form validation. This complexity drained my motivation to handle the backend, leading me to showcase only the frontend during the event.

This experience lit a fire within me to create the perfect fullstack setup, one that could handle API development efficiently while maintaining type safety and flexibility.

Building the Perfect Stack

Over the years, I explored nearly every frontend and backend framework. After extensive experimentation, I settled on Next.js and Server Actions. However, I soon realized the tight coupling of Server Actions with Vercel made it nearly impossible to migrate the backend to a separate repository or host it elsewhere. Additionally, since RSA isn't an API, building native apps that rely on the same backend would require extensive refactoring.

Discovering tRPC

I discovered tRPC through the T3 stack and was instantly captivated. tRPC provided the type safety of RSA while offering the flexibility to work with any backend solution. It enabled seamless app organization within a monorepo. However, I disliked the T3 stack’s naming conventions and its use of an older version of tRPC with React Query. So, I integrated tRPC with the latest Tanstack Query, following my own conventions and custom helpers.

Choosing Drizzle and NeonDB for the Database

For the database, I chose Drizzle ORM due to its speed and simplicity compared to Prisma. The migration process is less bloated, and Drizzle Studio is a cherry on top. While my stack is opinionated towards NeonDB, I plan to add options for PostgreSQL or SQLite in the future.

Seamless Authentication with Auth.js

Auth.js stood out as the best authentication system due to the control it offers over solutions like Clerk. I prefer building custom sign-in and sign-up pages, but I’ve included a small sign-in snippet for when I’m feeling lazy.

Elevating the UI with Tailwind CSS and Shadcn

Tailwind CSS 4, with its new theming capabilities, allows for rapid and flexible styling. Combined with Shadcn Canary, which provides pre-built UI components, the stack ensures a smooth and aesthetically pleasing user experience. The integration of these tools significantly reduces development time while maintaining a high level of customization.

Effortless Hosting on Vercel

Given the seamless integration with Next.js, Vercel remains the go-to platform for hosting this stack.

The Final Stack

Next.js 15
Tailwind CSS 4 (with new themes)
Shadcn Canary for UI components
TypeScript
tRPC with Tanstack Query
Drizzle ORM with NeonDB
Auth.js

How to Build a Project

To create a new project using this stack, simply run the following command:

pnpm create smota-app@latest

Wrapping It Up

create smota-app@latest is the result of my relentless pursuit of efficiency in fullstack development. It’s fast, flexible, and perfectly suited for building scalable, type-safe applications. With the power of this stack, I can now focus on building features rather than wrangling configurations.

ILUS a css framework for madlads

atoms — Sat, 26 Feb 2022 20:05:50 +0000

most of us would love a simple framework with some features but some madlads love things when they have every feature imaginable

ilus css is one of those css framework which tries to do multiple things at once
ofcource its not the best at everything it does but it does a solid job of making your website look funky

here is a login page made with ilus

another site made with ilus

ilus has a lot of things

some of the inputs in ilus

complex components(no js)
colors
built in animations
responsive grid system
utility classes

one of my favourites is the navigation menu which is very easy to build and also fully responsive

advantages

unique it gives websites a unique look go for it if you like the looks
animations has basic animations built in and can easily be used
utility classes you can do most of the css using utility classes
lightweight ilus is extremely lightweight and quick to import only 22 kb
responsive grid and media queries everyone wants responsive sites and ilus has responsive sites

disadvantages

terrible naming convention sometimes the class names makes you think this framework was made by a depressed 14year old
not for everyone :ilus's looks are highly stylized and may not be for everyone
terrible documentation there are no tutorials or proper documentation for ilus it doesnt even have a proper domain

some hard truths

so here's the part where i drop my persona and accept the truth

i made ilus

yes this whole thing was made by me a year ago while i was 15 or maybe 14
i wandered through source codes of many other css frameworks learning how they function and finally i made ilus (no palagrism)

its got no real life users tho except maybe me and i dont even code nowdays cause i gotta learn for exams

btw check it out on github if you want and use it if you liked it👍

learn more about ilus

view on github

the biggest fault of this framework is that its built by a guy who is an amateur who has stopped coding now

pls dont send pull requests idk how to push them using github😂🥺