Vaporeon :vaporeon:

Y'all are surprising me with your programming opinions

Then again, JavaScript or whatever apparently has a Math.max function, while C doesn't

1
sherclod holmes

@vaporeon_ software eggineering poisons your brain

1
Vaporeon :vaporeon:

@wallhackio Are you referring to yourself or to me or to us all?

1
sherclod holmes

@vaporeon_ I'm referring to anyone who writes code for money instead of writing code for fun

1
sherclod holmes

@vaporeon_ this is not a slight on Holly. i hope that is clear. she does code golf so you know she actually likes coding for the hell of it

1+
mixed berry social anxiety disorder 🍓

@wallhackio @vaporeon_ oh yeah all this goes out the window when you're golfing. sometimes it's fun to let loose and write some horseshit

1
sherclod holmes

@monorail @vaporeon_ my worst code practices occur when i hack a solution to a challenging data structures/algorithms problem

1
Vaporeon :vaporeon:

@wallhackio How can you have bad code practices when there's no such thing as good Java code, it's all terrible

1
sherclod holmes

@vaporeon_ I've done DS&A problems in JavaScript and written some nightmarish oneliners doing that

1+
Vaporeon :vaporeon:

@wallhackio Need to see :blobcatreach:

1
sherclod holmes
Follow

@vaporeon_ I know how this is gonna go. I will show it to you and then you'll be like, wait this is cool I like it :)

· · 2 · 1 · 2
sherclod holmes

@vaporeon_ okay here's a bad one. i implemented a non-recursive quicksort using the variables gorp, norp, and sorp:

const partition = (arr, start, end, strategy) => {
  const q = [[start, end]];
  while (q.length > 0) {
    const [left, right] = q.pop();

    const p = strategy(arr, left, right);
    const pVal = arr[p];
    swap(arr, p, right);

    let gorp = 0;
    let norp = 0;
    let sorp = 0;

    const L = right - left + 1;

    for (let i = 0; i < L - 1; ++i) {
      const curr = left + gorp + sorp;
      if (arr[curr] === pVal) {
        swap(arr, left + sorp, curr);
        ++sorp;
      } else if (arr[curr] > pVal) {
        swap(arr, curr, right - norp - 1);
        ++norp;
      } else {
        ++gorp;
      }
    }

    for (let j = 0; j < gorp; ++j) {
      swap(arr, left + j, left + sorp + j);
    }
    swap(arr, left + gorp + sorp, right);

    if (gorp > 1) q.push([left, left + gorp - 1]);
    if (norp > 1) q.push([left + gorp + sorp + 1, right]);
  }
};
1+
Vaporeon :vaporeon:

@wallhackio I love how my Mastodon posting has made you use gorp, norp, and sorp in actual code

0
æʃliŋ, purrepurrocessor

@wallhackio @vaporeon_ is that single member array of arrays not a typo lol

1+
sherclod holmes

@aescling @vaporeon_ nope :)

0
sherclod holmes

@aescling @vaporeon_ if you are wondering this is using the Dutch National Flag partition, which is the actual real name for it, and I simulated recursion using a stack (a JavaScript array has methods on it that allow it to easily resemble a stack)

I used the ninther strategy for the pivot selection but that was not present in this snippet

1+
sherclod holmes

@aescling @vaporeon_ oh this was an inefficient implementation of Dutch National Flag too, lol

0
aschmitz

@wallhackio @aescling @vaporeon_ It's funny how "a JavaScript start has methods on it that allow it to easily resemble a stack" should immediately set off all kinds of red flags for anyone with basic algorithms knowledge, *and yet* because developers regularly use them like that, most JavaScript engines have developed to make those operations fast and otherwise efficient.

1
sherclod holmes

@aschmitz @aescling @vaporeon_ I once used a JavaScript array as a queue, using the shift method to pluck elements from the start of the array. Of course, this means iterating over an entire "queue" should be slow, since every call to shift causes every element in the array to be reassigned and reduces the size of the array by 1. I benchmarked my algorithm and it was slower than I hoped, so I immediately worked on the queue as I thought it was a throttle for the algorithm.

I made an object that effectively had a JavaScript array as a private variable and created a method for "removing" the first element from the array. In reality, there was pointer being tracked by the object that simply shifted to the right by 1, simulating the behavior of a queue with an ordinary array. Obviously iterating over this structure should be O(n).

To my surprise, when I benchmarked the algorithm again, it was slower. Evidently, with my first approach, the JIT engine realized I was using an array as a queue and secretly optimized it for me. Without realizing, I tried to outsmart the JIT engine, and lost.

0
sherclod holmes

@vaporeon_ here is another hack with a "beautiful" one liner:

Problem Statement
You are given a 0-indexed array of integers nums of length n. You are initially positioned at nums[0].

Each element nums[i] represents the maximum length of a forward jump from index i. In other words, if you are at nums[i], you can jump to any nums[i + j] where:

  • 0 <= j <= nums[i] and
  • i + j < n

Return the minimum number of jumps to reach nums[n - 1]. The test cases are generated such that you can reach nums[n - 1].

Example

  • Input: nums = [2,3,1,1,4]
  • Output: 2
  • Explanation: The minimum number of jumps to reach the last index is 2. Jump 1 step from index 0 to 1, then 3 steps to the last index.

Code

const jump = (nums, i = 0, gorp = {}) => {
    if (i === nums.length - 1) return 0;
    if (i > nums.length - 1 || nums[i] === 0) return Infinity;
    if (gorp[i] !== undefined) return gorp[i];

    let min = Infinity;
    for (let j = 1, res; j <= nums[i]; ++j) res = 1 + jump(nums, i + j, gorp), min = res < min ? res : min;

    return gorp[i] = min;
};
1+
æʃliŋ, purrepurrocessor

@wallhackio @vaporeon_ i think you omitted a closing parenthesis?

1
sherclod holmes

@aescling @vaporeon_ I just ran it and what is here is correct

1
æʃliŋ, purrepurrocessor

@wallhackio @vaporeon_ oh i can't read, nvm

0
sherclod holmes

@vaporeon_ oooooh I could have done for (var min = Infinity, j = 1, res; j <= nums[i]; ++j) res = 1 + jump(nums, i + j, gorp), min = res < min ? res : min;

javascript variables declared with var and not block scoped, so min is available outside of the for loop teehee

1
æʃliŋ, purrepurrocessor

@wallhackio @vaporeon_ that's awful i love it lol

1
sherclod holmes

@aescling @vaporeon_ ....it runs faster with this change

1
æʃliŋ, purrepurrocessor

@wallhackio @vaporeon_ if you look into the semantic diffurences between for with let and var scoped variables, this is not surpurrising; the furmer is surpurrisingly complicated. const allows fur some optimizations over let though iirc

1
sherclod holmes

@aescling @vaporeon_ with let the algo ran the test cases ~700ms and with var it shaved ~100ms

0
Sign in to participate in the conversation
📟🐱 GlitchCat

A small, community‐oriented Mastodon‐compatible Fediverse (GlitchSoc) instance managed as a joint venture between the cat and KIBI families.

Trending now

Resources

Developers

What is Mastodon?

cat.family

More…

v3.5.3+kibicat · Privacy Policy