DEV Community: Nicolás Bost

Codewars - Pick peaks

Nicolás Bost — Fri, 10 Jan 2025 18:11:35 +0000

Salutations.

I'm posting Codewars challenges and my thought process in this series. I'm using JS and Node 18 whenever possible. Just for the sake of clarity, I'm making fair use of them.

I took a break, and now I'm back. Did some challenges without posting the solution here though. Let's approach an easy challenge.

Pick peaks is a fun one. You need to find local maxima according to its mathematical definition. From GFG:

Mathematically, f (a) ≥ f (a -h) and f (a) ≥ f (a + h) where h > 0, then a is called the Local maximum point.

In essence, we need to see which values are bigger than its closest neighbors. If a neighbor is missing we can't verify if it's a local maximum or not. So we won't check the borders of the array.

The following solution is not optimized. It should be one pass. Besides, I was taught to avoid using break and continue. But it does the job.

First we set the rules:

If the array is empty, return empty arrays. [] => {pos:[], peaks:[]}
If a value is less than or equal to the previous one, it's automatically discarded (plateaux will be treated in another rule). (array[i] <= array[i-1]) ? discard
If a value is NOT discarded by the previous rule, AND it's bigger than the next value, it's a maximum. (array[i] > array[i+1]) ? maximum
If a value is NOT discarded by the aforementioned rule, AND it's EQUAL TO the next value, it requires special treatment. We'll solve this later.

Second, it needs an specific return value: {pos:[], peaks:[]}
This challenge asks for position and value of the maxima.

Third, we need to set a loop for the array:
for (let i = 1 ; i < arr.length -1 ; i++)
We skip the first and last value because they'll never be maxima according to the definition.

Fourth, we implement the rules:

  for (let i = 1 ; i < arr.length -1 ; i++){
    if (arr[i] <= arr[i-1]){
      continue;
    }
    if (arr[i] > arr[i+1]){
      cache.pos.push(i);
      cache.peaks.push(arr[i]);
    }
    if (arr[i] == arr[i+1]){
      // TO DO
    }
  }

We'll need to refine that last part. That's the special treatment mentioned above while setting the rules. It is merely another loop that acts as a sub process:

    if (arr[i] == arr[i+1]){
      for (let j=i +1 ; j< arr.length - 1; j++){
        if (arr[j] == arr[j+1]){
          continue;
        }
        if (arr[j] < arr[j+1]){
          break;
        }
        if (arr[j] > arr[j+1]){
          cache.pos.push(i);
          cache.peaks.push(arr[i]);
        }
      }
    }

The sum of it all is this:

function pickPeaks(arr){
  let cache = {pos:[], peaks:[]};
  if (arr == false) {
    return cache;
  }

  for (let i = 1 ; i < arr.length -1 ; i++){
    if (arr[i] <= arr[i-1]){
      continue;
    }
    if (arr[i] > arr[i+1]){
      cache.pos.push(i);
      cache.peaks.push(arr[i]);
    }
    if (arr[i] == arr[i+1]){
      for (let j=i +1 ; j< arr.length - 1; j++){
        if (arr[j] == arr[j+1]){
          continue;
        }
        if (arr[j] < arr[j+1]){
          break;
        }
        if (arr[j] > arr[j+1]){
          cache.pos.push(i);
          cache.peaks.push(arr[i]);
        }
      }
    }
  }

  return cache;
}

And now let's test it... Yay! It passed! Let's submit and...

Oh no. What???

This particular test: pickPeaks([1,2,5,4,3,2,3,6,4,1,2,3,3,4,5,3,2,1,2,3,5,5,4,3])
This should return: {pos:[2,7,14,20], peaks:[5,6,5,5]}
It returns: {pos:[2,7,14,20,20], peaks:[5,6,5,5,5]}

But why? The logic is sound. And every loop is correctly... Uhmmm... Wait... It gets duplicated. Position 20, value 5. It's there twice. There's got be something wrong here:

    if (arr[i] == arr[i+1]){
      for (let j=i +1 ; j< arr.length - 1; j++){
        if (arr[j] == arr[j+1]){
          continue;
        }
        if (arr[j] < arr[j+1]){
          break;
        }
        if (arr[j] > arr[j+1]){
          cache.pos.push(i);
          cache.peaks.push(arr[i]);
        }
      }
    }

After some debugging with Dev Tools, I found it. Here's the problem:

        if (arr[j] > arr[j+1]){
          cache.pos.push(i);
          cache.peaks.push(arr[i]);
        }

It's missing a break statement. [...3,5,5,4,3] duplicates the second value because it only breaks out of the inner loop when it finds a sequence where this exit condition occurs:

        if (arr[j] < arr[j+1]){
          break;
        }

Otherwise it keeps going. Turns out it should exit when it finds a maximum too:

        if (arr[j] > arr[j+1]){
          cache.pos.push(i);
          cache.peaks.push(arr[i]);
          break; // <------------ EXTREMELY IMPORTANT
        }

FIXED:

function pickPeaks(arr){
  let cache = {pos:[], peaks:[]};
  if (arr == false) {
    return cache;
  }

  for (let i = 1 ; i < arr.length -1 ; i++){
    if (arr[i] <= arr[i-1]){
      continue;
    }
    if (arr[i] > arr[i+1]){
      cache.pos.push(i);
      cache.peaks.push(arr[i]);
    }
    if (arr[i] == arr[i+1]){
      for (let j=i +1 ; j< arr.length - 1; j++){
        if (arr[j] == arr[j+1]){
          continue;
        }
        if (arr[j] < arr[j+1]){
          break;
        }
        if (arr[j] > arr[j+1]){
          cache.pos.push(i);
          cache.peaks.push(arr[i]);
          break;  // if you don't break, situations like this: 3,5,5,4,3
                  // can duplicate a value..
        }
      }
    }
  }

  return cache;
}

Inefficient, but effective.

Take care. Drink water 💧💧💧.

Dealing with internet addiction

Nicolás Bost — Wed, 08 Jan 2025 20:47:48 +0000

Guten Morgen.

Wish I could know who drew the cover image. It's very well done. Would suggest you to check out their work, but sadly not even I know.

Moving on, I wanted to write about what I'm going through. This is by no means an exhaustive research made alongside a mental health professional, and I'm not looking for anything that will be written here to be of any utility to anybody. It doesn't pretend to be that. It's merely a blog post of someone who wishes to start 2025 in good spirits, avoiding the pitfalls, so that it becomes the professional it seeks to be.

I'm going through what the title describes. Internet addiction. Research has been picking up since I've looked up for any information about this disease back in 2015. Some screenshots of search results for "internet addiction":

The world has advanced quite a bit since 2015. And in all that time, research on this must have grown exponentially. But the most comprehensive briefing of it is this paper. And it goes up until pre-COVID-19. One could only assume internet addiction developed even more. It's not surprising to spend 6 hours or more a day on the phone for an average person. We addicts might have 16 or more hours per day. And it's not even coding.

Being an aspiring dev, this is a hindrance. You are supposed to chase after your passion. But what if your passion is not as strong as your compulsion?

As far as research goes, this type of disease seems to be behavioral. Rewards are triggered for the wrong reasons. So what can you do to fight back? Cut down the rewards for the compulsory behaviors, and increase the rewards for your passion.

Oh, if only it was that easy...

So, the guy above went with the nuclear option. Destroy the screen. Keep that for a period of time and that will definitely help you touch more grass. Somewhere, someone wrote that habits stick permanently after 90 days, but destroying PCs and phones and go back to writing letters so that your friends know you exist doesn't seem to be that easy nowadays. So is there an alternative?

Yeah. Write something. Drink hot water. Stay 10 minutes in the library. Do 1 pushup. Talk to one person about anything that crosses your mind. Sleep if you feel tired. Repeat.

Do easy, achievable tasks. Something completely different than the screen you are used to. Allow yourself to feel bored.

Code something easy and unrelated when you are in front of the screen. Games can elevate you. And it's important to know how to go back down. Every plane needs to land eventually.

So, I think that's it. You will find your peace. Talk to you soon. Hope to see you better in the future

Codewars - Find the missing letter

Nicolás Bost — Tue, 07 Jan 2025 13:27:48 +0000

Salutations.

I'm posting Codewars challenges and my thought process in this series. I'm using JS and Node 18 whenever possible. Just for the sake of clarity, I'm making fair use of them.

For this next exercise we have an ordered, ascending array of letters, but somewhere in the middle one letter is missing:
['a','b','c','d','f']
['O','Q','R','S']

First, we need to know that letters have a corresponding numerical value in Unicode. Therefore, we need functions capable of transforming letters to numbers and vice versa.

Let's try some JS functions to see what they do:

function findMissingLetter(array)
{
  return [array[3].charCodeAt(),array[4].charCodeAt()];
}

// the array is ['a','b','c','d','f']
// it expects 'e'
// this function returns [ 100, 102 ]

We have our first important piece of the puzzle. Now we need to create a solution around it. To do so, we could use something to traverse the array, looking for the anomaly:

let counter = 0;
  while (array[counter].charCodeAt() + 1 == array[counter + 1].charCodeAt()
        && counter < array.length)
  {
    counter++;
  }

Then, we need to find the actual missing letter:

let letter = String.fromCharCode(array[counter].charCodeAt() + 1)

Assemble everything:

function findMissingLetter(array)
{
  let counter = 0;
  while (array[counter].charCodeAt() + 1 == array[counter + 1].charCodeAt()
        && counter < array.length)
  {
    counter++;
  }
  let letter = String.fromCharCode(array[counter].charCodeAt() + 1)
  return letter;
}

Surprisingly readable. I think it's fine. There has to be a way to optimize it, but I can't see how yet.

Take care. Drink water 💧💧💧.

Codewars - Build a pile of Cubes

Nicolás Bost — Mon, 06 Jan 2025 22:44:43 +0000

Salutations.

I'm posting Codewars challenges and my thought process in this series. I'm using JS and Node 18 whenever possible. Just for the sake of clarity, I'm making fair use of them.

The next one is tricky for us, people who struggle with math. It's a nice challenge though. Essentially, it boils down to figuring out the sum of "n" cubes. Then there's some black magic (a.k.a: algebra) et voilà! Solved.

Sum of cubes explained with proof.

Full solution:

function findNb(m) {

  // sum of n cubes = ( n^2 * (n+1)^2 ) / 4

  let number = m * 4;
  number = number ** (1/2);
  let numberAux = number ** (1/2);
  let floor = Math.floor(numberAux);
  let ceiling = (Number.isInteger(numberAux)) ? floor + 1 : Math.ceil(numberAux);
  if ( floor * ceiling == number ){
    return floor;
  }
  return (-1);
}

Why do we compute floor and ceiling? Because if the argument m does indeed represent a sum of "n" cubes, then numberAux is PARTLY the number we are looking for. We just need the integer part. Which is "n". And it's also floor.

If 'm' does not represent a sum of cubes, then the function returns -1. No big deal.

It works. I don't know if me-in-6-months will understand anything though.

Take care. Drink water 💧💧💧.

Codewars - Delete occurrences of an element if it occurs more than n times

Nicolás Bost — Mon, 06 Jan 2025 01:23:52 +0000

Salutations.

I'm posting Codewars challenges and my thought process in this series. I'm using JS and Node 18 whenever possible. Just for the sake of clarity, I'm making fair use of them.

"Delete occurrences of an element if it occurs more than n times". In essence, trim parts in the middle of the array, without altering the order.

function deleteNth(arr,n){
  let counter = {"top": n , "undef": 0};

  for (let i = 0 ; i < arr.length ; i++ ){
    (counter[arr[i]]) ? null : counter[arr[i]] = 0;
    if (counter[arr[i]] < n){
      counter[arr[i]]++;
    } 
    else {
      arr[i] = undefined;
      counter.undef++;
    }
  }

  arr.sort((a,b) => 0);

  for (let i = 0 ; i < counter.undef ; i++){
    arr.pop();
  }

  return arr;
}

It... works. Needs refactoring since it clearly doesn't follow any good practices, but I'm gonna move on to the next challenge.

Take care. Drink water 💧💧💧.

Codewars - Two to One

Nicolás Bost — Sun, 05 Jan 2025 23:05:43 +0000

Salutations.

I'm posting Codewars challenges and my thought process in this series. I'm using JS and Node 18 whenever possible. Just for the sake of clarity, I'm making fair use of them.

Ok, this was juicy. In essence, you have to remove duplicates in a string, order what's left and join two strings. Not exactly in that order. Actually, I did it in the exact opposite way. And I also built an utility function for a very specific step (removing duplicates).

First, concatenate two strings. Easy:

let longest = s1 + s2;

Second, split up the letters:

let array = new Array(s1.length + s2.length);
for (let i = 0 ; i < s1.length + s2.length ; i++ ){
    array[i] = longest[i];
  }

Third, sort the letters:

array = array.sort((a, b) => a.localeCompare(b));
// (a, b) => a.localeCompare(b)  THIS IS REDUNDANT, but I leave it as a reminder

Fourth, remove duplicates:

function keepFirstLetter(array){
  let arrayFixed = new Array(array.length);
  let counter = 0;
  arrayFixed[0] = array[0];


  for (let i = 0 ; i < array.length ; i++ ){
    if (arrayFixed[counter] != array[i]){
      counter++;
      arrayFixed[counter] = array[i];
    }
  }

  return arrayFixed;
}

Fifth, clean up:

array = array.join("");

Last, place every piece of the puzzle together:

function longest(s1, s2) {
  let array = new Array(s1.length + s2.length);

  let longest = s1 + s2;

  for (let i = 0 ; i < s1.length + s2.length ; i++ ){
    array[i] = longest[i];
  }

  array = array.sort((a, b) => a.localeCompare(b));

  array = keepFirstLetter(array);

  array = array.join("")

  return array;
}

function keepFirstLetter(array){
  let arrayFixed = new Array(array.length);
  let counter = 0;
  arrayFixed[0] = array[0];

  for (let i = 0 ; i < array.length ; i++ ){
    if (arrayFixed[counter] != array[i]){
      counter++;
      arrayFixed[counter] = array[i];
    }
  }

  return arrayFixed;
}

It's definitely NOT performant. I don't like that second loop. And it's not so clean either. Someday I'll need to revisit this one.

Be well. Drink water 💧💧💧.

Codewars - Find The Parity Outlier

Nicolás Bost — Sat, 04 Jan 2025 15:58:28 +0000

Salutations.

I'm posting Codewars challenges and my thought process in this series. I'm using JS and Node 18 whenever possible. Just for the sake of clarity, I'm making fair use of them.

The problem says we need to find either of these: the odd number in an array full of even numbers, or the even number in an array full of odd numbers. That is to say:
[ 0, 2, 4, 6, 8, 97, 14, 14, -2 ] -> 97
[ 1, 3, 2, -3, -7, 227, -183 ] -> 2

First, I'll check what kind of outlier is by looking at the first 3 elements of the array:

3 even elements => $2)=0\sum_{\substack{0\leq i\leq 2}} ( x_{i}\mod 2 ) = 0$
1 odd element => $2)=1\sum_{\substack{0\leq i\leq 2}} ( x_{i}\mod 2 ) = 1$
2 odd elements => $2)=2\sum_{\substack{0\leq i\leq 2}} ( x_{i}\mod 2 ) = 2$
3 odd elements => $2)=3\sum_{\substack{0\leq i\leq 2}} ( x_{i}\mod 2 ) = 3$

All we need to do afterwards is traverse the array until we hit the one number whose modulo-2 is different. Two variations of said algorithm are applied accordingly:

// odd number in even array
while (number % 2 == 0 && counter < integers.length){
      number = integers[counter];
      counter++;
    }
// even number in odd array
while (number % 2 == 1 && counter < integers.length){
      number = integers[counter];
      counter++;
    }

Assembling the parts together we end up with:


function findOutlier(integers){
  let counter = 0;
  let number = 0;

  let a = integers[0] % 2;
  let b = integers[1] % 2;
  let c = integers[2] % 2;


  if (a + b + c <= 1){
    number = integers[0];
    while (number % 2 == 0 && counter < integers.length){
      number = integers[counter];
      counter++;
    }
  }
  else {
    number = integers[0];
    while (number % 2 == 1 && counter < integers.length){
      number = integers[counter];
      counter++;
    }
  }
  return number;
}

And this is exactly how I felt when it didn't pass the tests:

Second, I had to google what happened. Turns out I didn't consider negative numbers could appear. And so I had to read how JS deals with negative modulos

For the third step, use Math.abs():

function findOutlier(integers){
  let counter = 0;
  let number = 0;

  let a = Math.abs(integers[0] % 2);
  let b = Math.abs(integers[1] % 2);
  let c = Math.abs(integers[2] % 2);


  if (a + b + c <= 1){
    number = integers[0];
    while (Math.abs(number) % 2 == 0 && counter < integers.length){
      number = integers[counter];
      counter++;
    }
  }
  else {
    number = integers[0];
    while (Math.abs(number) % 2 == 1 && counter < integers.length){
      number = integers[counter];
      counter++;
    }
  }
  return number;
}

Decent performance, not so readable though. It has ample room for improvement.

Take care. Drink water 💧💧💧.

Codewars - Counting Duplicates

Nicolás Bost — Sat, 04 Jan 2025 00:10:34 +0000

Salutations.

I'm posting Codewars challenges and my thought process in this series. I'm using JS and Node 18 whenever possible. Just for the sake of clarity, I'm making fair use of them.

For the "Counting duplicates" challenge, I'll start with this:

function duplicateCount(text){
  text = text.toString();
  let countTotal = {"max":0};
  let letter = '';
  for (let i=0 ; i < text.length ; i++){
    letter = text.at(i).toLowerCase();
    if (letter){
      countTotal[letter] = countTotal[letter] ? countTotal[letter]++ : 1;
      if (countTotal[letter] > countTotal["max"]){
        countTotal["max"] = countTotal[letter];
      }
    }
  }
  return countTotal["max"];
}

Seems... wordy. Wonder if this many words are actually aiming in the right direction. I'll give you a bit of time if you'd like to think for yourself.

3...

2...

1...

1/2...

1/4...

Ok, I think that's enough. No. Slang from the Bay Area made its way onto the web, so if I may: It's hella wrong.

The thing is, I was trying to find how many duplicates of the most duplicated letter are there. Turns out we need to answer how many duplicate types are there. Case insensitive.

AbC -> 0 -> no letter repeats
AbCC -> 1 -> "C" repeats, we don't care how many times
AbBCC -> 2 -> "b" and "c" repeat, we don't care how many times or the casing

We can take advantage of object literals in JS to create a counter for each letter. Then, one property could be "repetitions", which would be a counter that goes up ONLY whenever a letter shows up two times.

if (countTotal[letter]==2){
        countTotal.repetitions++;
      }

Full solution:

function duplicateCount(text){
  text = text.toString();
  let countTotal = {"repetitions": 0};
  let letter = '';
  for (let i=0 ; i < text.length ; i++){
    letter = text.at(i).toLowerCase();
    if (letter){
      (countTotal[letter] === undefined) ? countTotal[letter] = 0 : null;
      countTotal[letter]++;
      if (countTotal[letter]==2){
        countTotal.repetitions++;
      }
    }
  }
  return countTotal["repetitions"];
}

Took a while, it can be improved.

Take care. Drink water 💧💧💧.

Codewars - Beginner Series #3 Sum of Numbers

Nicolás Bost — Fri, 03 Jan 2025 02:46:27 +0000

Salutations.

I'm posting Codewars challenges and my thought process in this series. I'm using JS and Node 18 whenever possible. Just for the sake of clarity, I'm making fair use of them.

So, next in this series is Sum of Numbers. In this specific problem, it's more math than coding. See, you need to calculate an area. In this graph, for example, we show all values between -5 and 4:

You can use integration if you so desired, but there's a simpler route. Since we're dealing with linear functions, we can search for the median and multiply for the range:

s u m = m e d ian * r an g e

\frac{b-a}{2} * (b - a + 1)

\frac{b^2 - a^2 + b + a}{2}

So we just need to insert that equation in the code. It starts like this:

function getSum(a, b)
{
   //Good luck!
}

function getSum(a, b)
{
   let sum = (b ** 2 - a ** 2 + b + a ) / 2 ;
   return sum;
}

We test it and:

But why? I know the equation is correctly simplified, so... Oh. This is the problem:

getSum(a, b)

(a,b) in exactly that order. It works if the input is (-5,4), but not if it's (4,-5). Fix? You could code an "if" statement for both situations. I won't do it like that though. I'll do this:

if (a > b){
    let c = a;
    a = b;
    b = c;
  }

And so, we put together everything:

function getSum(a, b)
{
  if (a > b){
    let c = a;
    a = b;
    b = c;
  }
  let sum = (b ** 2 - a ** 2 + b + a ) / 2 ;
  return sum;
}

Somewhat decent, easy for the reading.

Cya. Drink water 💧💧💧.

Codewars - Friend or Foe?

Nicolás Bost — Thu, 02 Jan 2025 15:44:19 +0000

Salutations.

I'm posting Codewars challenges and my thought process in this series. I'm using JS and Node 18 whenever possible. Just for the sake of clarity, I'm making fair use of them.

"Friend or Foe?" can be simply done like this:

function friend(friends){
  let trueFriends = friends.filter((dude) => dude.length==4 );
  return trueFriends;
}

Generally performant, and a simple solution. Does the job.

Regards. Drink water 💧💧💧.

Codewars - You're a square!

Nicolás Bost — Thu, 02 Jan 2025 14:13:22 +0000

Salutations.

I'm posting Codewars challenges and my thought process in this series. I'm using JS and Node 18 whenever possible. Just for the sake of clarity, I'm making fair use of them.

Next one in this series is "You're a Square!". See, your LEGO addiction got a little out of hand, and you're now coding as a replacement drug.

Nah, you're fine 😎. And your next task involves squares. So the problem seeks to answer "Is this number a square?". So, how do we tackle this? However we desire. As with any coding problem.

First, solve it. Then, solve it correctly. Then, solve it correctly and fast.

Step 1: Make mistakes

My first hunch led me to this:

var isSquare = function(n){
  let nIsSquare = false;
  if (n>=0) {
      nIsSquare = ( n ** 2 ) == 2 * ( (n - 1) ** 2 ) - ( (n-2) ** 2 ) + 2;
  }
  return nIsSquare;
}

This is wrong. I went with $n^2 = 2(n − 1)^2 − (n − 2)^2 + 2$
Thanks Wikipedia. But this is a formula to verify n^2. I need a formula to verify n.

Step 2: ~~Do it right~~MAKE MORE MISTAKES

On another wikipedia article there was a neat, short way to calculate square roots: Exponential identity.

So we fix our previous code:

var isSquare = function(n){

  let nIsSquare = false;
  if (n>=0) {
     let sqrt = Math.E ** ( Math.log(n) / 2 );
     nIsSquare = Number.isInteger(sqrt);
  }

  return nIsSquare;
}

Annnnnnnnnnnnd:

Oh, come on. Why does it fail? Oh. JavaScript does weird things with floating-point numbers. So, it's not the code's fault. Right? Guess we'll never know. Even so, I love you JS. You quirky bastard.

Step 3: Do it right and fast

Just use Math.sqrt():

var isSquare = function(n){
  let nIsSquare = false;
  if (n>=0) {
     nIsSquare = Number.isInteger(Math.sqrt(n));
  }
  return nIsSquare;
}

Not the best, but the simplest solution. Does the job.

Bye bye. Drink water 💧💧💧.

Codewars - Descending Order

Nicolás Bost — Tue, 31 Dec 2024 20:05:33 +0000

Salutations.

I'm posting Codewars challenges and my thought process in this series. I'm using JS and Node 18 whenever possible. Just for the sake of clarity, I'm making fair use of them.

Onto the next challenge from Codewars. In this one, we are tasked with developing a function that takes any integer as input. We have to order the digits from highest to lowest.

I start with this thought:

"Ok, I'll need to split the digits somehow. Maybe I should turn the integer to string first. Then split digits. Then order, then concatenate all, then revert to integer"

And so, it starts with a template:

function descendingOrder(n){

 // stringify
  number = n.toString();

 // split digits
  array = new Array(number.length);
  // code that fills array with digits {}

 //sort
  array.sort()

 // concatenate digits
  reverse = array.join('');

 // back to integer
  n = Number.parseInt(reverse);

  return n;
}

Much letters, such bore. And still not functional. So, what else do we need? Well, a loop that places the digits in the array for starters:

 // split digits
  array = new Array(number.length);
  for(i=0 ; i<number.length ; i++){
    array[i] = number.at(i);
  }

That should do it. Right?

Nope. One tiny little detail. The devil is in the details. And so are bugs. The sort function orders in ascending fashion by default. We need to "revert polarity". In essence, we need this. The default behavior is like this:

(a, b) => a - b

And we need:

(a, b) => b - a

All the ingredients combined:

function descendingOrder(n){
  number = n.toString();
  array = new Array(number.length);
  for(i=0;i<number.length;i++){
    array[i] = number.at(i);
  }
  array.sort((a,b)=>b-a)
  reverse = array.join('');
  n = Number.parseInt(reverse);
  return n;
}

Not the best, nor the simplest solution. But it does the job.

Cya. Drink water 💧💧💧.