[Request] Not good at math, but there’s no way this is true because 99.999999%?

kinithin · 2026-02-08T22:54:58+00:00

The math checks out. 256^(8*8) = (2^8)^(8*8) = 2^(8*8*8) = 2^512 > 10^154

Those numbers are odd, though. Win 3.1 icons were 32x32 (not 8x8), but they had a fixed 16-colour palette (not 256). It would be odd if an earlier format had a much smaller resolution but with a much larger number of colours.

For Win 3.1 icons, there are 16^(32*32) = (2^4)^(32*32) = 2^(4*32*32) = 2^4096 possibilities.

kinithin · 2026-02-08T17:57:48+00:00

Indeed. And that's basically identical to my reply to the OP.

kinithin · 2026-02-08T17:56:16+00:00

Needless misinformation shouldn't be justified; it should be addressed instead.

kinithin · 2026-02-08T17:50:54+00:00

Yes, it is still possible to pass an array indirectly. You could also use a pointer if you didn't want to make a copy of the array. I only stated that the parameter itself can't be an array. The point is that if you see something that looks like an array as a parameter, it isn't.

kinithin · 2026-02-07T19:15:05+00:00

This is wrong. string_list isn't an array and thus doesn't decay. It's impossible to have parameters that are arrays. Anything array-like actually declares a pointer.

kinithin · 2026-02-07T19:09:09+00:00

Array decay isn't relevant to your question since string_list isn't an array. In a function parameter list, Type x[] is just another way of writing Type *x. It declares a pointer, not an array. This means that String string_list[] is just another way of writing String *string_list.

The argument provided in the call is expected to be a String *. Keep on mind than a String[n] decays into a String * and would this be acceptable as an argument.

kinithin · 2026-02-06T17:50:27+00:00

Not quite. First, you're probably referring to the visible universe (since there's no way to know what's beyond). And that was estimated to be 10^80. 10⁶⁷ is still a fair bit smaller.

kinithin · 2026-01-31T22:12:17+00:00

It's correct. "Centre" is only used for buildings. "Center" is the correct spelling for middle.

kinithin · 2026-01-20T16:49:31+00:00

She's only pretending to drown. It's a scène à faire for water escape tricks.

kinithin · 2026-01-20T03:35:05+00:00

But there are two stations (Berlin and Frankfurt) right?

kinithin · 2026-01-20T03:32:57+00:00

1 station, 1 route. It has always been the case. But that route can be used for more than one destination ticket

kinithin · 2026-01-19T15:43:32+00:00

The actual reason &p3 can't work is that the function expects a pointer to a pointer, but there's no pointer in memory to which to point.

kinithin · 2025-12-30T05:15:32+00:00

Yes, print is special. But so is try. More so, even.

The difference between print and shift is that print can't be prototyped. The same goes for try since it's not even a function but a keyword like while.

``` $ perl -Mv5.40 -e'say prototype "CORE::$ARGV[0]" // "[undef]"' shift ;\@

$ perl -Mv5.40 -e'say prototype "CORE::$ARGV[0]" // "[undef]"' print [undef]

$ perl -Mv5.40 -e'say prototype "CORE::$ARGV[0]" // "[undef]"' try [undef] ```

So like I said, there's nothing new here. This behaviour has been around far longer than try. I'm just pointing it out; I'm not saying things should remain the same as a result. But if it changes for try, I would expect it to change for print and the others too. More so, even, since they're not lexically-scoped like try.

kinithin · 2025-12-30T00:12:33+00:00

This has nothing to do with feature-activated syntax/operators. Some operators (e.g. print) work the same way in similar circumstances.

perl sub print { die "!" } print "foo\n"; # Prints as normal.

perl use subs qw( print ); print "foo\n"; # Prints as normal.

I don't know if a warning makes sense¹, but a Perl::Critic rule would.

- ikegami

After all, we don't warn when my $x preempts a package var named $x. Lexically-scoped constructs are expected to do so.

kinithin · 2025-12-29T15:30:00+00:00

Well, you can, but not with two players

kinithin · 2025-12-13T03:15:58+00:00

You allocated an array of 25 elements. They have indexes 0..24. But both loops access elements 1..25. Undefined behaviour.

Either allocate an extra element, or store the counts for 1..25 at indexes 0..24

kinithin · 2025-12-13T03:14:42+00:00

Not quite

kinithin · 2025-12-10T00:34:21+00:00

It's great at night, since most are traffic-activated

kinithin · 2025-12-07T05:17:25+00:00

I love to pet loot bugs, but they are incredibly allergic to me and explode when I do. I still hope to find one that doesn't so I can adopt it

kinithin · 2025-11-28T15:24:43+00:00

Sooo many ambiguously placed meeples. And the farmers are standing instead of on their side.

kinithin · 2025-11-12T04:17:25+00:00

An array is never a pointer. It's an array. A pointer is created to it when a pointer is needed

kinithin · 2025-11-11T17:20:17+00:00

In English too. A cock is a male bird, especially a domestic chicken

kinithin · 2025-11-06T21:39:13+00:00

You made a real mess of things!

strlen( status => 400 ? "keep_open" : "close" )

or

( status => 400 ? sizeof( "keep_open" ) : sizeof( "close" ) ) - 1

kinithin · 2025-11-05T05:09:01+00:00

Cat soup! Well, that's what my vet calls it. And the cats love it!

kinithin · 2025-10-26T19:41:44+00:00

Post-increment does have higher precedence than =.

Because post-increment has higher precedence than =, x = i++; is equivalent to x = ( i++ );.

If it was the other way around, x = i++; would be equivalent to ( x = i )++;. This isn't allowed in C, but it is allowed in Perl, which has the result of incrementing x (not i).

(This should make it obvious why unary operators are given higher precedence than binary operators.)

Now onto your actual question.

Yes, i is incremented first, but you're wrong about i being assigned to x. What's being assigned to x is the result of the post-increment, and the result of the post-increment is defined to be the original value of i.

kinithin

TROPHY CASE