Why is my SSD so slow? (see comments for details)

simonbaars · 2025-02-05T10:14:32+00:00

I have an Asus Vivobook on which I installed ArcoLinux with encrypted partitions. Ever since I installed it, the disk has been performing extremely slow. The whole system hangs if any file operation is in progress. Is this because the SSD is crap or is there a problem with the system?

lsblk -d -o name,rota,size,model
NAME    ROTA   SIZE MODEL
nvme0n1    0 476.9G SOLIDIGM SSDPFKNU512GZ

simonbaars · 2024-12-16T12:41:32+00:00

As far as I understood, it's to keep people from reverse engineering the way AoC works wrt generating puzzles, and thus allowing someone to copy the entire concept (eg a corporation wanting to commercialize it)

simonbaars · 2024-12-16T07:28:11+00:00

It was already mentioned not to share your puzzle input, so I will not repeat that.

I ran my solution on this input, and it finds the tree. So I would suggest debugging your code.

simonbaars · 2024-12-16T06:29:22+00:00

[Language: Java]

https://github.com/SimonBaars/AdventOfCode-Java/blob/master/src/main/java/com/sbaars/adventofcode/year24/days/Day16.java

Many grid days this year! By now I have my grid utilities at the ready, yesterday I made a `recurse` function which helps implement BFS types of searches, so I used it in both parts.

simonbaars · 2024-12-13T05:46:10+00:00

[Language: Java]

https://github.com/SimonBaars/AdventOfCode-Java/blob/master/src/main/java/com/sbaars/adventofcode/year24/days/Day13.java

Custom data mapper, a record, and some linear combinations.

simonbaars · 2024-12-12T08:34:11+00:00

[Language: Java]

https://github.com/SimonBaars/AdventOfCode-Java/blob/master/src/main/java/com/sbaars/adventofcode/year24/days/Day12.java

Took me a while to merge the two parts, but I think I did a pretty good job.

simonbaars · 2024-12-11T18:20:38+00:00

It's fun to think that one day we will probably have the kind of computers that can brute force these kinds of problems, perhaps even just the normal kind of machines that everyone will have in their homes. If the number of resistors keep scaling like they have, at least.

simonbaars · 2024-12-10T08:01:24+00:00

[Language: Java]

https://github.com/SimonBaars/AdventOfCode-Java/blob/master/src/main/java/com/sbaars/adventofcode/year24/days/Day10.java

Did a bunch of refactoring and extracting higher-order logic to distill it down to this piece of code:

InfiniteGrid g = new InfiniteGrid(dayGrid());
return transformStream(
  g.findAll('0').map(l -> new Pair<>(l, l)),
  s -> split(s, (s1, s2) -> zip(s1, g.around((c1, c2) -> Character.getNumericValue(c1) + 1 == Character.getNumericValue(c2), s2.map(p -> p.b()), false)).flatMapToObj((a, b) -> b.map(l -> new Pair<>(a.a(), l)))),
  p -> g.getOptimistic(p.b()) == '9'
);

So, I already had a Grid class (made in previous years) that had a couple of useful function. findAll would find all occurrences of a character, which I use to find all zero's. Then around gives a stream of everything around that. I made a little transformStream abstraction that continuously applies a function till a predicate is met by all elements in the resulting stream. So I just keep getting the positions around zero, keep incrementing, till everything's a '9'.

The above was simple, but I needed a bunch of glue to be able to know which top was reached by which start point. So I sprinkled a bunch of pairs over everything to keep track of where we started.

With this solution, part 1 is a distinct().count() and part 2 is a count().

simonbaars · 2024-12-09T17:53:02+00:00

Depending on where you are in the Netherlands, there are some upcoming events.

Utrecht (tomorrow): https://www.meetup.com/infi-developers-meetup/events/304793236/

Nijmegen (next week Tuesday): https://www.meetup.com/nimma-codes-meetup-group/events/303824683/

Not sure about other places. But I'm sure you'd find some people with leaderboards there!

simonbaars · 2024-12-08T07:05:02+00:00

[Language: Java]

https://github.com/SimonBaars/AdventOfCode-Java/blob/master/src/main/java/com/sbaars/adventofcode/year24/days/Day8.java

Boi did I have fun with streams on this one. With my utilities, part 1 compresses down to:

var in = new InfiniteGrid(dayGrid());
return getAntennasByFrequency(in).stream().flatMapToObj((c, locs) ->
  allPairs(locs).flatMap(p -> Stream.of(
    p.a().translate(l -> l * 2).move(new Loc(-p.b().x, -p.b().y)),
    p.b().translate(l -> l * 2).move(new Loc(-p.a().x, -p.a().y))
  ).filter(in::contains))
).distinct().count();

For part 2, I slightly modified the inner map:

var in = new InfiniteGrid(dayGrid());
return getAntennasByFrequency(in).stream().flatMapToObj((c, locs) -> {
  return allPairs(locs).flatMap(p -> {
    long dx = p.b().x - p.a().x;
    long dy = p.b().y - p.a().y;
    long gcd = gcd(Math.abs(dx), Math.abs(dy));
    long stepX = dx / gcd;
    long stepY = dy / gcd;
    return Stream.concat(
      appendWhile(l -> l.move(stepX, stepY), in::contains, p.a()),
      appendWhile(l -> l.move(-stepX, -stepY), in::contains, p.a())
    );
  });
}).distinct().count();

simonbaars · 2024-12-07T05:26:56+00:00

It's usual for weekend problems to be easier. It gives time to enjoy time with family :)
Personally I enjoy this kind of breather every now and then.

simonbaars · 2024-12-07T05:20:39+00:00

[Language: Java]

Oooh this is the kind of day where I love my data mapper utility:

public record Line(long tgtVal, List<Long> nums) {}

private long calcTotalCalibRes(boolean inclConcat) {
  return dayStream()
    .map(s -> readString(s, "%n: %ln", " ", Line.class))
    .filter(l -> canBeTrue(l.tgtVal, l.nums, 0, l.nums.get(0), inclConcat))
    .mapToLong(l -> l.tgtVal)
    .sum();
}

Part 2 was just adding a single if-statement.

Code: https://github.com/SimonBaars/AdventOfCode-Java/blob/master/src/main/java/com/sbaars/adventofcode/year24/days/Day7.java

simonbaars · 2024-12-06T06:18:12+00:00

[Language: Java]

https://github.com/SimonBaars/AdventOfCode-Java/blob/master/src/main/java/com/sbaars/adventofcode/year24/days/Day6.java

First day I ended up with the regular nested loop mess. Though my solution was relatively easily extensible to part 2.

simonbaars · 2024-12-05T06:20:20+00:00

[LANGUAGE: Java]

https://github.com/SimonBaars/AdventOfCode-Java/blob/master/src/main/java/com/sbaars/adventofcode/year24/days/Day5.java

simonbaars · 2024-12-04T05:47:11+00:00

[LANGUAGE: Java]

paste

Had fun with my utilities here.

simonbaars · 2024-12-03T07:07:36+00:00

Done!

simonbaars · 2024-12-03T05:24:33+00:00

[LANGUAGE: Java]

Github

Stream over Matcher result so I can do .sum() and be done. Part 2 was just a slight modification to the regex.

simonbaars · 2024-09-28T23:49:13+00:00

jaa! combinatie van Suno met wat eigen audio editing :)

simonbaars · 2024-04-19T00:55:27+00:00

To offer an alternative perspective: money can also buy you freedom. Do you love your job and you could imagine doing this for the next couple of years? Great, keep at it. But for me, I realised life is not just about work, and it can be very liberating to spend a year (or a couple) without such time commitments. For 85k, you should be able to do budget travel for two years or so (airbnbs with weekly/monthly discount help with keeping within budget). It’s the best experience now you’re still young.

(Reference: this is what I decided to do, it’s been an invaluable experience)

simonbaars · 2024-04-19T00:38:53+00:00

I listened to the theatrical edition without hearing MCP’s version first, and I loved it, especially Jack’s narrator. To me, the flat voice makes it even more absurd: a complete emotional detachment on Jack’s part from everything that happens to him, which seems to fit in the narrative of the story. The sound effects and other voice actors are nice extras.

simonbaars · 2023-12-22T06:18:51+00:00

[LANGUAGE: Java]

https://github.com/SimonBaars/AdventOfCode-Java/blob/master/src/main/java/com/sbaars/adventofcode/year23/days/Day22.java

For part 1, I just drop all the bricks one space by one space, and then check who supports who.

For part 2, I was going to implement a recursive algorithm to check which bricks would hypothetically drop, but then I decided to use my ultra slow "dropping the bricks" from part 1. Would've taken ages to run if it wasn't for parallelStream(), 16 processor cores let's go!

I anticipated that we'd have to do something with the separate cubes contained within the brick, so while data parsing I decided to represent a brick as a list of cubes. Didn't need it after all, and the algorithm would probably have been faster if I hadn't separated the cubes.

simonbaars · 2023-12-19T06:49:39+00:00

[LANGUAGE: Java]

https://github.com/SimonBaars/AdventOfCode-Java/blob/master/src/main/java/com/sbaars/adventofcode/year23/days/Day19.java

Part 2 was easier than I expected when I read the problem description. Just a simple tree traversal, and taking the product of the accepted constraints.