Bescheuertste Möglichkeit "Hello World" auszugeben?



  • Titel ist Programm.



  • @Swordfish system("echo hello world")



  • ja, ne, unkreativ.



  • Lass „Hallo Welt“ von Google übersetzen.



  • #include <stdio.h>
    #include <stdint.h>
    struct s
    {
    int64_t i[9];
    }S;
    #define N 11
    int main()
    {
        int s=sizeof(S),i=s,j=N;
        int x[N]={i,i+=29,i+=7,i,i+=3,2*N+10,s+=15,i,i+=3,i-=6,i-=8};
        while(j--)
        {
            putchar(x[N-1-j]);
        }
        return 0;
    }
    

    powered by google



  • @Zhavok Ja ne, klauen ist unsportlich.



  • #include <stdio.h>
    #include <math.h>
    
    
    int main()
    {
            double i;
            double no;
    
            for(i = 0; i < 12; i++)
            {
                    no      = -6607.0 * i * i * i * i * i * i * i * i * i * i * i / 9979200.0
                            +  6089.0 * i * i * i * i * i * i * i * i * i * i / 151200.0
                            - 386969.0 * i * i * i * i * i * i * i * i * i / 362880.0
                            + 162557.0 * i * i * i * i * i * i * i * i / 10080.0
                            - 122829.0 * i * i * i * i * i * i * i / 800.0
                            + 6885167.0 * i * i * i * i * i * i / 7200.0
                            - 1422324013.0 * i * i * i * i * i / 362880.0
                            + 313100189.0 * i * i * i * i / 30240.0
                            - 7573714751.0 * i * i * i / 453600.0
                            + 30752857.0 * i * i / 2100.0
                            - 10300853.0 * i / 1980.0
                            + 72.0;
    
                    no = round(no);
    
                    printf("%c\n",  (char) no);
            }
    
            printf("\n");
    
            return 0;
    }
    
    

    aber ist das nicht auch unsportlich?



  • @Wade1234 sagte in Bescheuertste Möglichkeit "Hello World" auszugeben?:

    aber ist das nicht auch unsportlich?

    ne, das sind nur viele ihhhs.



  • ja ich hab das zuerst mit long long int probiert und wollte pow() nicht verwenden, aber da sind die ungenauigkeiten dann noch größer bzw. das ergebnis kommt dann nicht mal in die nähe von "HELLO WORLD!". aber eigentlich müsste das mit pow auch gehen. edit: wobei das dann ja nicht mehr sooo bescheuert wäre.........



  • This post is deleted!


  • @Wade1234 sagte in Bescheuertste Möglichkeit "Hello World" auszugeben?:

    edit: wobei das dann ja nicht mehr sooo bescheuert wäre.........

    je bescheuert desto gut. je höher desto platsch.



  • Gilt es auch, wenn ich das Ergebnis noch nicht finden konnte? Habe es über zufällige Bytes probiert, welche mit einem MD5 Hash von "Hello World" verglichen werden, damit der String nicht selbst im Code auftaucht.

    Nachdem ich vier Terminals eine Stunde hab laufen lassen, habe ich es jedoch erst einmal beendet.

    #include <stdlib.h>
    #include <stdio.h>
    #include <stdint.h>
    #include <time.h>
    #include <string.h>
    /*
     **********************************************************************
     ** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved. **
     **                                                                  **
     ** License to copy and use this software is granted provided that   **
     ** it is identified as the "RSA Data Security, Inc. MD5 Message     **
     ** Digest Algorithm" in all material mentioning or referencing this **
     ** software or this function.                                       **
     **                                                                  **
     ** License is also granted to make and use derivative works         **
     ** provided that such works are identified as "derived from the RSA **
     ** Data Security, Inc. MD5 Message Digest Algorithm" in all         **
     ** material mentioning or referencing the derived work.             **
     **                                                                  **
     ** RSA Data Security, Inc. makes no representations concerning      **
     ** either the merchantability of this software or the suitability   **
     ** of this software for any particular purpose.  It is provided "as **
     ** is" without express or implied warranty of any kind.             **
     **                                                                  **
     ** These notices must be retained in any copies of any part of this **
     ** documentation and/or software.                                   **
     **********************************************************************
     */
    
    /* typedef a 32 bit type */
    typedef unsigned long int UINT4;
    
    /* Data structure for MD5 (Message Digest) computation */
    typedef struct {
      UINT4 i[2];                   /* number of _bits_ handled mod 2^64 */
      UINT4 buf[4];                                    /* scratch buffer */
      unsigned char in[64];                              /* input buffer */
      unsigned char digest[16];     /* actual digest after MD5Final call */
    } MD5_CTX;
    
    /* forward declaration */
    void MD5Init ();
    void MD5Update ();
    void MD5Final ();
    static void Transform ();
    
    static unsigned char PADDING[64] = {
      0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    };
    
    /* F, G and H are basic MD5 functions: selection, majority, parity */
    #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
    #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
    #define H(x, y, z) ((x) ^ (y) ^ (z))
    #define I(x, y, z) ((y) ^ ((x) | (~z)))
    
    /* ROTATE_LEFT rotates x left n bits */
    #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
    
    /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4 */
    /* Rotation is separate from addition to prevent recomputation */
    #define FF(a, b, c, d, x, s, ac) \
      {(a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
       (a) = ROTATE_LEFT ((a), (s)); \
       (a) += (b); \
      }
    #define GG(a, b, c, d, x, s, ac) \
      {(a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
       (a) = ROTATE_LEFT ((a), (s)); \
       (a) += (b); \
      }
    #define HH(a, b, c, d, x, s, ac) \
      {(a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
       (a) = ROTATE_LEFT ((a), (s)); \
       (a) += (b); \
      }
    #define II(a, b, c, d, x, s, ac) \
      {(a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
       (a) = ROTATE_LEFT ((a), (s)); \
       (a) += (b); \
      }
    
    void MD5Init( MD5_CTX *mdContext )
    {
      mdContext->i[0] = mdContext->i[1] = (UINT4)0;
    
      /* Load magic initialization constants.
       */
      mdContext->buf[0] = (UINT4)0x67452301;
      mdContext->buf[1] = (UINT4)0xefcdab89;
      mdContext->buf[2] = (UINT4)0x98badcfe;
      mdContext->buf[3] = (UINT4)0x10325476;
    }
    
    void MD5Update( MD5_CTX *mdContext, unsigned char *inBuf, unsigned int inLen)
    {
      UINT4 in[16];
      int mdi;
      unsigned int i, ii;
    
      /* compute number of bytes mod 64 */
      mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
    
      /* update number of bits */
      if ((mdContext->i[0] + ((UINT4)inLen << 3)) < mdContext->i[0])
        mdContext->i[1]++;
      mdContext->i[0] += ((UINT4)inLen << 3);
      mdContext->i[1] += ((UINT4)inLen >> 29);
    
      while (inLen--) {
        /* add new character to buffer, increment mdi */
        mdContext->in[mdi++] = *inBuf++;
    
        /* transform if necessary */
        if (mdi == 0x40) {
          for (i = 0, ii = 0; i < 16; i++, ii += 4)
            in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
                    (((UINT4)mdContext->in[ii+2]) << 16) |
                    (((UINT4)mdContext->in[ii+1]) << 8) |
                    ((UINT4)mdContext->in[ii]);
          Transform (mdContext->buf, in);
          mdi = 0;
        }
      }
    }
    
    void MD5Final( MD5_CTX * mdContext )
    {
      UINT4 in[16];
      int mdi;
      unsigned int i, ii;
      unsigned int padLen;
    
      /* save number of bits */
      in[14] = mdContext->i[0];
      in[15] = mdContext->i[1];
    
      /* compute number of bytes mod 64 */
      mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
    
      /* pad out to 56 mod 64 */
      padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi);
      MD5Update (mdContext, PADDING, padLen);
    
      /* append length in bits and transform */
      for (i = 0, ii = 0; i < 14; i++, ii += 4)
        in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
                (((UINT4)mdContext->in[ii+2]) << 16) |
                (((UINT4)mdContext->in[ii+1]) << 8) |
                ((UINT4)mdContext->in[ii]);
      Transform (mdContext->buf, in);
    
      /* store buffer in digest */
      for (i = 0, ii = 0; i < 4; i++, ii += 4) {
        mdContext->digest[ii] = (unsigned char)(mdContext->buf[i] & 0xFF);
        mdContext->digest[ii+1] =
          (unsigned char)((mdContext->buf[i] >> 8) & 0xFF);
        mdContext->digest[ii+2] =
          (unsigned char)((mdContext->buf[i] >> 16) & 0xFF);
        mdContext->digest[ii+3] =
          (unsigned char)((mdContext->buf[i] >> 24) & 0xFF);
      }
    }
    
    /* Basic MD5 step. Transform buf based on in.
     */
    static void Transform( UINT4 *buf, UINT4 *in)
    {
      UINT4 a = buf[0], b = buf[1], c = buf[2], d = buf[3];
    
      /* Round 1 */
    #define S11 7
    #define S12 12
    #define S13 17
    #define S14 22
      FF ( a, b, c, d, in[ 0], S11, 3614090360); /* 1 */
      FF ( d, a, b, c, in[ 1], S12, 3905402710); /* 2 */
      FF ( c, d, a, b, in[ 2], S13,  606105819); /* 3 */
      FF ( b, c, d, a, in[ 3], S14, 3250441966); /* 4 */
      FF ( a, b, c, d, in[ 4], S11, 4118548399); /* 5 */
      FF ( d, a, b, c, in[ 5], S12, 1200080426); /* 6 */
      FF ( c, d, a, b, in[ 6], S13, 2821735955); /* 7 */
      FF ( b, c, d, a, in[ 7], S14, 4249261313); /* 8 */
      FF ( a, b, c, d, in[ 8], S11, 1770035416); /* 9 */
      FF ( d, a, b, c, in[ 9], S12, 2336552879); /* 10 */
      FF ( c, d, a, b, in[10], S13, 4294925233); /* 11 */
      FF ( b, c, d, a, in[11], S14, 2304563134); /* 12 */
      FF ( a, b, c, d, in[12], S11, 1804603682); /* 13 */
      FF ( d, a, b, c, in[13], S12, 4254626195); /* 14 */
      FF ( c, d, a, b, in[14], S13, 2792965006); /* 15 */
      FF ( b, c, d, a, in[15], S14, 1236535329); /* 16 */
    
      /* Round 2 */
    #define S21 5
    #define S22 9
    #define S23 14
    #define S24 20
      GG ( a, b, c, d, in[ 1], S21, 4129170786); /* 17 */
      GG ( d, a, b, c, in[ 6], S22, 3225465664); /* 18 */
      GG ( c, d, a, b, in[11], S23,  643717713); /* 19 */
      GG ( b, c, d, a, in[ 0], S24, 3921069994); /* 20 */
      GG ( a, b, c, d, in[ 5], S21, 3593408605); /* 21 */
      GG ( d, a, b, c, in[10], S22,   38016083); /* 22 */
      GG ( c, d, a, b, in[15], S23, 3634488961); /* 23 */
      GG ( b, c, d, a, in[ 4], S24, 3889429448); /* 24 */
      GG ( a, b, c, d, in[ 9], S21,  568446438); /* 25 */
      GG ( d, a, b, c, in[14], S22, 3275163606); /* 26 */
      GG ( c, d, a, b, in[ 3], S23, 4107603335); /* 27 */
      GG ( b, c, d, a, in[ 8], S24, 1163531501); /* 28 */
      GG ( a, b, c, d, in[13], S21, 2850285829); /* 29 */
      GG ( d, a, b, c, in[ 2], S22, 4243563512); /* 30 */
      GG ( c, d, a, b, in[ 7], S23, 1735328473); /* 31 */
      GG ( b, c, d, a, in[12], S24, 2368359562); /* 32 */
    
      /* Round 3 */
    #define S31 4
    #define S32 11
    #define S33 16
    #define S34 23
      HH ( a, b, c, d, in[ 5], S31, 4294588738); /* 33 */
      HH ( d, a, b, c, in[ 8], S32, 2272392833); /* 34 */
      HH ( c, d, a, b, in[11], S33, 1839030562); /* 35 */
      HH ( b, c, d, a, in[14], S34, 4259657740); /* 36 */
      HH ( a, b, c, d, in[ 1], S31, 2763975236); /* 37 */
      HH ( d, a, b, c, in[ 4], S32, 1272893353); /* 38 */
      HH ( c, d, a, b, in[ 7], S33, 4139469664); /* 39 */
      HH ( b, c, d, a, in[10], S34, 3200236656); /* 40 */
      HH ( a, b, c, d, in[13], S31,  681279174); /* 41 */
      HH ( d, a, b, c, in[ 0], S32, 3936430074); /* 42 */
      HH ( c, d, a, b, in[ 3], S33, 3572445317); /* 43 */
      HH ( b, c, d, a, in[ 6], S34,   76029189); /* 44 */
      HH ( a, b, c, d, in[ 9], S31, 3654602809); /* 45 */
      HH ( d, a, b, c, in[12], S32, 3873151461); /* 46 */
      HH ( c, d, a, b, in[15], S33,  530742520); /* 47 */
      HH ( b, c, d, a, in[ 2], S34, 3299628645); /* 48 */
    
      /* Round 4 */
    #define S41 6
    #define S42 10
    #define S43 15
    #define S44 21
      II ( a, b, c, d, in[ 0], S41, 4096336452); /* 49 */
      II ( d, a, b, c, in[ 7], S42, 1126891415); /* 50 */
      II ( c, d, a, b, in[14], S43, 2878612391); /* 51 */
      II ( b, c, d, a, in[ 5], S44, 4237533241); /* 52 */
      II ( a, b, c, d, in[12], S41, 1700485571); /* 53 */
      II ( d, a, b, c, in[ 3], S42, 2399980690); /* 54 */
      II ( c, d, a, b, in[10], S43, 4293915773); /* 55 */
      II ( b, c, d, a, in[ 1], S44, 2240044497); /* 56 */
      II ( a, b, c, d, in[ 8], S41, 1873313359); /* 57 */
      II ( d, a, b, c, in[15], S42, 4264355552); /* 58 */
      II ( c, d, a, b, in[ 6], S43, 2734768916); /* 59 */
      II ( b, c, d, a, in[13], S44, 1309151649); /* 60 */
      II ( a, b, c, d, in[ 4], S41, 4149444226); /* 61 */
      II ( d, a, b, c, in[11], S42, 3174756917); /* 62 */
      II ( c, d, a, b, in[ 2], S43,  718787259); /* 63 */
      II ( b, c, d, a, in[ 9], S44, 3951481745); /* 64 */
    
      buf[0] += a;
      buf[1] += b;
      buf[2] += c;
      buf[3] += d;
    }
    
    void fill_buffer_random( unsigned char buffer[11] )
    {
    	int i;
    	for( i = 0; i < 11; i++ )
    	{
    		buffer[i] = (rand()/((RAND_MAX + 1u)/91)) + 31;
    	}
    }
    
    int main( int argc, char *argv[argc] )
    {
    	unsigned char target[16] = { 6,221,220,177,19,144,
    					129,92,147,6,118,61,31,184,116,74 };
    	srand( time( (void *)0 ) );
    	unsigned char buffer[12] = { 0 };
    	int found = 0;
    	while( !found )
    	{
    		/* Fill a 11 Byte Buffer with random Bytes between \x1F and \x7A */
    		fill_buffer_random( buffer );
    		MD5_CTX mdContext;
    		MD5Init( &mdContext );
    		MD5Update( &mdContext, buffer, 12 );
    		MD5Final( &mdContext );
    		if( memcmp( mdContext.digest, target, 16 ) == 0 )
    		{
    			found = 1;
    		}
    	}
    	printf( (char *)buffer );
        return 0;
    }
    
    


  • Wie wäre es mit einer Ausgabe zur Compiletime:

    template <typename...> struct HelloWorld;
    class Something {};
    
    int main() {
        HelloWorld<Something>{};
    }
    


  • int main()
    {
       int j = 10;
       double i = 1700;
       while(j--)
       {
          putchar(68.+std::fmod(78676.14+17558.925564*i+45147.710171081*i*i,20.));
          i+=66;
       }
       return 0;
    }
    


  • Bist du dir sicher? Laut Ideone-Code kommt da "HELLVWORLQ" raus...



  • @Swordfish Geht's jetzt darum das Ausgeben besonders bescheuert zu machen oder darum den String bzw. die einzelnen Characters möglichst bescheuert zu erzeugen/berechnen? Oder beides?



  • @Th69 sagte in Bescheuertste Möglichkeit "Hello World" auszugeben?:

    Bist du dir sicher? Laut Ideone-Code kommt da "HELLVWORLQ" raus...

    Na dann weiss ich wenigstens, das es jemand mal ausgefuehrt hat. 😉



  • #include <iostream>
    #include <cmath>
    
    
    double f(double x)
    {
        return 29492.0-838263.116*x+9685440.585*pow(x, 2)-60885051.639*pow(x, 3)+233703681.362*pow(x, 4)-577997182.418*pow(x, 5)+940045047.453*pow(x, 6)-999105986.690*pow(x, 7)+667689319.621*pow(x, 8)-254511133.480*pow(x, 9)+42184744.322*pow(x, 10);
    }
    
    double f2(double x)
    {
        return 14368966466.85*cos(x)-45932195791.30*cos(2*x)+70807159188.54*cos(3*x)-73411022613.29*cos(4*x)+56310865464.60*cos(5*x)-32962326822.50*cos(6*x)+14737490620.50*cos(7*x)-4921864176.42*cos(8*x)+1166029347.91*cos(9*x)-175859946.28*cos(10*x)+12758321.53*cos(11*x);
    }
    
    
    int main(int argc, char** argv)
    {
        const std::string s = "Hello World";
    
        // Idee: Bestimme eine Funktion f(x) = a0 + a1*x + a2*x^2 + ... a10*x^10, s.d.
        // f(0.1) = 'H', f(0.2) = 'e', usw. ist. Wir wollen also den String durch ein
        // Polynom des Grads 10 interpolieren.
    
        // Schritt 1: Ausgabe des Strings in numerische Werte.
        for (const auto& c : s)
        {
            printf("%i ", c);
        }
    
        // Zur Bestimmung der Koeffizienten nutze ich die Programmiersprache R
    
        // Schritt 2 (R): Ich bringe das Interpolationsproblem in die Form Mx=b.
    
        // In b stehen die numerischen Werte von "Hello World", in x die gesuchten Koeffizienten und
        // in M die Terme:
        // (x0^0, x0^1, x0^2,...,x0^9,x0^10)
        // (x1^0, x1^1, x1^2,...,x1^9,x1^10)
        // ...
        // (x9^0, x9^1, x9^2,...,x9^9,x9^10)
    
        // x=seq(0, 10)
        // y = c(0.1**x, 0.2**x, 0.3**x, 0.4**x, 0.5**x, 0.6**x, 0.7**x, 0.8**x, 0.9**x, 1**x, 1.1**x)
        // M = t(matrix(y, nrow=11, ncol=11))
        // -> In M steht nun die Vandermonde-Matrix, deren Konditionierung mieß ist.
    
        // b=c(72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100)
    
        // Schritt 3 (R): Gleichungssystem lösen lassen
    
        // solve(M, b)
    
        printf("\n");
        for (double c = 0.1; c < 1.1; c += 0.1)
        {
            //printf("%.3f ", f(c));
            printf("%c", static_cast<char>(round(f(c))));
        }
        printf("\n");
    
        // Die Interpolationsfunktion gefällt mir aber nicht. Deswegen interpoliere ich den String mittels einer
        // Fourier-Reihe der Form: f(x) = a0*cos(x) + a1*cos(2x) + a2*cos(3x) + ... a10*cos(10x). Dies funkioniert
        // genauso wie oben beschrieben.
    
        for (double c = 0.1; c < 1.1; c += 0.1)
        {
            //printf("%.3f ", f2(c));
            printf("%c", static_cast<char>(round(f2(c))));
        }
        printf("\n");
    
        return 0;
    }
    


  • Man könnte auch einen Brainfuck-Interpreter schreiben und dann ein Brainfuck-Programm das Hello-World ausgibt interpretieren.

    Ich fände aber fast interessanter was die bescheuertste aber realistische Möglichkeit ist "Hello, World!" auszugeben.



  • int f(int i){return i&4?f(--i)+f(2+i/3):i&2;}
    char g(int i){return 100+i+f(i);}
    
    int main()
    {
    	std::mt19937 mt_rand(240204768);
    	for (int i=0;i<10;++i)
    		std::cout << g(mt_rand()>>29);
    
    	return 0;
    }
    

    @hustbaer
    Nicht erzählen, sondern machen!


Log in to reply