215
The best love letters are written in C (apologies to the Rust fans) (fedia.io)
submitted 1 week ago by LostXOR@fedia.io to c/programmer_humor@programming.dev
17 comments fedilink hide all child comments
top 17 comments
sorted by: hot top controversial new old
[-] LostXOR@fedia.io 65 points 1 week ago

If anyone wants to actually run this, here ya go:

          #include              <stdio.h>
      short i=0;long          b[]={1712,6400
    ,3668,14961,00116,      13172,10368,41600,
  12764,9443,112,12544,15092,11219,116,8576,8832
,12764,9461,99,10823,17,15092,11219,99,6103,14915,
69,1721,10190,12771,10065,16462,13172,10368,11776,
14545,10460,10063,99,12544,14434,16401,16000,8654,
12764,13680,10848,9204,113,10441,14306,9344,12404,
  32869,42996,12288,141129,12672,11234,87,10086,
    12655,99,22487,14434,79,10083,12750,10368,
      10086,14929,79,10868,14464,12357};long
        n=9147811012615426336;long main(){
          if(i<0230)printf("%c",(char)((
            0100&b[i++>>1]>>(i--&0x1)*
              007)+((n>>(b[i>>001]>>
                7*(0b1&01-i++)))&1
                  *main(111))));
                    return 69-
                      0b0110
                        ;}

Bonus points if you can deobfuscate it!

[-] 1stTime4MeInMCU@mander.xyz 43 points 1 week ago* (last edited 1 week ago)

If your love letter isn't given in the form of highly obfuscated C, is it really a love letter? I don't know, but what I do know is that I love you! <3

[-] Redkey@programming.dev 8 points 1 week ago* (last edited 1 week ago)

I don't know if this will work or even compile, but I feel like I'm pretty close.

long main () {
    char output;
    unsigned char shift;
    long temp;
    
    if (i < 152) {
        shift = (i & 1) * 7;
        temp = b[i >> 1] >> shift;
        i++;
        output = (char)(64 & temp);
        output += (char)((n >> (temp & 63)) & main());
        printf("%c", output);
    }

    return 63;
}
[-] ulterno@lemmy.kde.social 9 points 1 week ago

Here's it with some amount of de-obfuscation:

#include <stdio.h>
short i = 0;
const long b[]
	= { 0xd60,  0x3200,  0x1ca8, 0x74e2, 0x9c,   0x66e8, 0x5100,  0x14500,
		0x63b8, 0x49c6,  0xe0,   0x6200, 0x75e8, 0x57a6, 0xe8,    0x4300,
		0x4500, 0x63b8,  0x49ea, 0xc6,   0x548e, 0x22,   0x75e8,  0x57a6,
		0xc6,   0x2fae,  0x7486, 0x8a,   0xd72,  0x4f9c, 0x63c6,  0x4ea2,
		0x809c, 0x66e8,  0x5100, 0x5c00, 0x71a2, 0x51b8, 0x4e9e,  0xc6,
		0x6200, 0x70c4,  0x8022, 0x7d00, 0x439c, 0x63b8, 0x6ae0,  0x54c0,
		0x47e8, 0xe2,    0x5192, 0x6fc4, 0x4900, 0x60e8, 0x100ca, 0x14fe8,
		0x6000, 0x44e92, 0x6300, 0x57c4, 0xae,   0x4ecc, 0x62de,  0xc6,
		0xafae, 0x70c4,  0x9e,   0x4ec6, 0x639c, 0x5100, 0x4ecc,  0x74a2,
		0x9e,   0x54e8,  0x7100, 0x608a };
const long n = 9147811012615426336;
long
main ()
{
	if (i < 152)
	{
		char shifter;
		if (i % 2 == 0)
		{
			shifter = 8;
		}
		else
		{
			shifter = 1;
		}
		char adder1 = (b[i >> 1] >> shifter) & 64;

		char adder2 = (n >> (b[i >> 1] >> shifter)) & 63;

		char to_print = (char)adder1 + adder2;
		i++;
		main ();
		printf ("%c", to_print);
	}
	return 63;
}

Needless to say, the return value doesn't matter any more. So you can change it to 0 or 69 depending upon your preferences.

[-] ulterno@lemmy.kde.social 5 points 1 week ago

And more de-obf:

#include <stdio.h>

const char addarr1[]
	= { 0x40, 0x40, 0x0,  0x40, 0x40, 0x40, 0x40, 0x0,  0x40, 0x40, 0x40, 0x40,
		0x0,  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x0,  0x40, 0x40, 0x40, 0x0,
		0x40, 0x0,  0x40, 0x40, 0x40, 0x40, 0x40, 0x0,  0x40, 0x40, 0x0,  0x40,
		0x40, 0x40, 0x0,  0x40, 0x40, 0x40, 0x40, 0x0,  0x40, 0x40, 0x0,  0x40,
		0x40, 0x40, 0x40, 0x40, 0x40, 0x0,  0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
		0x40, 0x40, 0x40, 0x40, 0x0,  0x40, 0x0,  0x0,  0x40, 0x40, 0x0,  0x40,
		0x40, 0x0,  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x0,  0x40, 0x0,  0x40,
		0x40, 0x40, 0x40, 0x0,  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x0,  0x0,
		0x40, 0x0,  0x40, 0x40, 0x40, 0x0,  0x40, 0x0,  0x40, 0x40, 0x40, 0x40,
		0x0,  0x0,  0x40, 0x40, 0x40, 0x0,  0x40, 0x40, 0x40, 0x40, 0x0,  0x40,
		0x0,  0x40, 0x40, 0x0,  0x40, 0x40, 0x40, 0x40, 0x0,  0x40, 0x40, 0x0,
		0x40, 0x40, 0x40, 0x40, 0x0,  0x40, 0x0,  0x40, 0x40, 0x40, 0x40, 0x0,
		0x40, 0x40, 0x40, 0x0,  0x0,  0x0,  0x0,  0x0 };

const char addarr2[]
	= { 0x9,  0x26, 0x20, 0x39, 0x2f, 0x35, 0x32, 0x20, 0x2c, 0x2f, 0x36, 0x25,
		0x20, 0x2c, 0x25, 0x34, 0x34, 0x25, 0x32, 0x20, 0x29, 0x33, 0x2e, 0x27,
		0x34, 0x20, 0x27, 0x29, 0x36, 0x25, 0x2e, 0x20, 0x29, 0x2e, 0x20, 0x34,
		0x28, 0x25, 0x20, 0x26, 0x2f, 0x32, 0x2d, 0x20, 0x2f, 0x26, 0x20, 0x28,
		0x29, 0x27, 0x28, 0x2c, 0x39, 0x20, 0x2f, 0x22, 0x26, 0x35, 0x33, 0x23,
		0x21, 0x34, 0x25, 0x24, 0x20, 0x3,  0x2c, 0x20, 0x29, 0x33, 0x20, 0x29,
		0x34, 0x20, 0x32, 0x25, 0x21, 0x2c, 0x2c, 0x39, 0x20, 0x21, 0x20, 0x2c,
		0x2f, 0x36, 0x25, 0x20, 0x2c, 0x25, 0x34, 0x34, 0x25, 0x32, 0x3f, 0xa,
		0x9,  0x20, 0x24, 0x2f, 0x2e, 0x27, 0x34, 0x20, 0x2b, 0x2e, 0x2f, 0x37,
		0x2c, 0x20, 0x22, 0x35, 0x34, 0x20, 0x37, 0x28, 0x21, 0x34, 0x20, 0x9,
		0x20, 0x24, 0x2f, 0x20, 0x2b, 0x2e, 0x2f, 0x37, 0x20, 0x29, 0x33, 0x20,
		0x34, 0x28, 0x21, 0x34, 0x20, 0x9,  0x20, 0x2c, 0x2f, 0x36, 0x25, 0x20,
		0x39, 0x2f, 0x35, 0x21, 0x20, 0x3c, 0x33, 0xa };

int main ()
{
	for (int i = 0; i < 152; i++)
	{
		char adder1 = addarr1[i];

		char adder2 = addarr2[i];

		char to_print = (char)adder1 + adder2;

		printf ("%c", to_print);
	}
	return 63;
}

I guess I should have kept the recursion and straightened it out in the next step, but now that it's done...

The next step will just have an array of the characters that would be printed, so I'll leave it here.

[-] ulterno@lemmy.kde.social 1 points 1 week ago

Some kind of Caesar cipher you made?

fIy uo rolevl teet rsi'n tigev nnit ehf ro mfoh gilh yboufcstadeC ,sii terlayla l vo eelttre ? Iod'n tnkwo ,ub thwtaI d onkwoi shttaI l vo eoy!u< 3%

[-] Redkey@programming.dev 3 points 1 week ago* (last edited 1 week ago)

Whoops! When I looked at the second time that the shift value is calculated, I wondered if it would be inverted from the first time, but for some reason I decided that it wouldn't be. But looking at it again it's clear now that (1 - i) = (-i + 1) = ((~i + 1) + 1), making bit 0 the inverse. Then I wondered why there wasn't more corruption and realized that the author's compiler must perform postfix increments and decrements immediately after the variable is used, so the initial shift is also inverted. That's why the character pairs are flipped, but they still decode correctly otherwise. I hope this version works better:

long main () {
    char output;
    unsigned char shift;
    long temp;
    
    if (i < 152) {
        shift = (~i & 1) * 7;
        temp = b[i >> 1] >> shift;
        i++;
        output = (char)(64 & temp);
        output += (char)((n >> (temp & 63)) & main());
        printf("%c", output);
    }

    return 63;
}

EDIT: I just got a chance to compile it and it does work.

[-] palordrolap@fedia.io 33 points 1 week ago

If there was ever a time to replace this Drake format with the Geordi LaForge alternative, this was it.

[-] TheImpressiveX@lemmy.ml 69 points 1 week ago

On it.

[-] Klear@lemmy.world 21 points 1 week ago* (last edited 1 week ago)

return 69
; }

[-] Black616Angel@discuss.tchncs.de 15 points 1 week ago

As a rust fan I can say:

Don't be sorry, cause the code is in C!
Be sorry for what you did in C!

[-] CanadaPlus@lemmy.sdf.org 0 points 1 week ago* (last edited 1 week ago)

I mean, of course it wouldn't be fair to expect everyone to be migrated over yet, but at some point it's going to be an obsolete language. Memory unsafety is a pretty nasty quirk; just one that was previously unavoidable, as far as I know.

[-] 0x0@programming.dev 6 points 1 week ago

at some point it’s going to be an obsolete language.

Yeah, COBOL went the way of the dodo too.

[-] CanadaPlus@lemmy.sdf.org 1 points 1 week ago* (last edited 1 week ago)

Exactly. COBOL still gets used in legacy stuff, but at this point you'd have to be either insane or a historical re-enactor to build something new in it.

I've used C more than anything else, for reference.

[-] 0x0@programming.dev 1 points 6 days ago

COBOL is on my to-learn list...

[-] CanadaPlus@lemmy.sdf.org 1 points 6 days ago

I really want to build and learn to use a medieval-style pole lathe.

[-] pmarcilus@discuss.tchncs.de 7 points 1 week ago

The code is even wink at u

this post was submitted on 07 Sep 2024
215 points (97.8% liked)

Programmer Humor

19166 readers
670 users here now

Welcome to Programmer Humor!

This is a place where you can post jokes, memes, humor, etc. related to programming!

For sharing awful code theres also Programming Horror.

Rules

founded 1 year ago
MODERATORS
Feyter@programming.dev
anzo@programming.dev
BurningTurtle@programming.dev