Bescheuertste Möglichkeit "Hello World" auszugeben?



  • Dieser Beitrag wurde gelöscht!


  • @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!



  • 
    #include "pch.h"
    #include <windows.h>
    #include <iostream>
    #include <map>
    #include <list>
    
    POINT addPoints( POINT A, POINT B )
      {
      POINT C;
      C.x = A.x + B.x;
      C.y = A.y + B.y;
      return C;
      }
    
    class Glyph
      {
      public:
        Glyph()
          {
          }
    
        Glyph( std::list< POINT > points )
          {
          _points = points;
          }
      
      private:
        std::list< POINT > _points;
    
      public:
        std::list< POINT > getPoints( POINT offset )
          {
          std::list< POINT > resultPoints;
    
          for (POINT p : _points)
            {
            resultPoints.push_back( addPoints( p, offset ));
            }
    
          return resultPoints;
          }
      };
    
    std::map< const char, Glyph > GlyphLibrary;
    
    void CreateGlyphs()
      {
    
      Glyph H( { {0,0}, {0,1}, {0,2}, {0,3}, {0,4}, {0,5}, {0,6}, {1,3}, {2,3}, {3,3}, {4,0}, {4,1}, {4,2}, {4,3}, {4,4}, {4,5}, {4,6} } );
      Glyph E( { {0,0}, {0,1}, {0,2}, {0,3}, {0,4}, {0,5}, {0,6}, {1,0}, {2,0}, {3,0}, {4,0}, {1,3}, {2,3}, {3,3}, {4,3}, {1,6}, {2,6}, {3,6}, {4,6} } );
      Glyph L( { {0,0}, {0,1}, {0,2}, {0,3}, {0,4}, {0,5}, {0,6}, {1,6}, {2,6}, {3,6}, {4,6} } );
      Glyph O( { {0,1}, {0,2}, {0,3}, {0,4}, {0,5}, {1,0}, {2,0}, {3,0}, {1,6}, {2,6}, {3,6}, {4,1}, {4,2}, {4,3}, {4,4}, {4,5} } );
      Glyph D( { {0,0}, {0,1}, {0,2}, {0,3}, {0,4}, {0,5}, {0,6}, {1,0}, {2,0}, {3,0}, {1,6}, {2,6}, {3,6}, {4,1}, {4,2}, {4,3}, {4,4}, {4,5} } );
      Glyph R( { {0,0}, {0,1}, {0,2}, {0,3}, {0,4}, {0,5}, {0,6}, {1,0}, {2,0}, {3,0}, {4,1}, {4,2}, {1,3}, {2,3}, {3,3}, {2,4}, {3,5}, {4,6} } );
      Glyph W( { {0,0}, {0,1}, {0,2}, {0,3}, 
                 {1,3}, {1,4}, {1,5}, {1,6}, 
                 {2,5},
                 {3,3},{3,4},
                 {4,5},
                 {5,3}, {5,4}, {5,5}, {5,6}, 
                 {6,0}, {6,1}, {6,2}, {6,3}  } );
    
      Glyph Z1( { {0,7}, {1,6} } );
      Glyph Z2( { {0,0}, {0,1}, {0,2}, {0,3}, {0,4}, {0,6} } );
    
      GlyphLibrary['H'] =  H;
      GlyphLibrary['E'] =  E;
      GlyphLibrary['L'] =  L;
      GlyphLibrary['O'] =  O;
      GlyphLibrary['W'] =  W;
      GlyphLibrary['R'] =  R;
      GlyphLibrary['D'] =  D;
      GlyphLibrary[','] =  Z1;
      GlyphLibrary['!'] =  Z2;
      }
    
    void PaintGlyph( HDC hDC, COLORREF color, POINT offset, Glyph glyph )
      {
      for ( POINT p : glyph.getPoints( offset ) )
        {
        SetPixel(hDC, p.x, p.y, color);
        }
      }
    
    int main()
    {
        std::wstring title( L"Hello World!" );
        SetConsoleTitle( title.c_str() );
    
        CreateGlyphs();
    
    
        HWND hWnd = GetConsoleWindow();
    
        HDC hDC = GetDC(hWnd);
        {
        COLORREF white = RGB( 255, 255, 255 );
    
        POINT Offset;
        Offset.x = 100;
        Offset.y = 100;
    
        PaintGlyph( hDC, white, Offset, GlyphLibrary['H'] );
        Offset.x += 7; // Buchstabenbreite + etwas Zwischenraum
        PaintGlyph( hDC, white, Offset, GlyphLibrary['E'] );
        Offset.x += 7; // Buchstabenbreite + etwas Zwischenraum
        PaintGlyph( hDC, white, Offset, GlyphLibrary['L'] );
        Offset.x += 7; // Buchstabenbreite + etwas Zwischenraum
        PaintGlyph( hDC, white, Offset, GlyphLibrary['L'] );
        Offset.x += 7; // Buchstabenbreite + etwas Zwischenraum
        PaintGlyph( hDC, white, Offset, GlyphLibrary['O'] );
        Offset.x += 7; // Buchstabenbreite + etwas Zwischenraum
        PaintGlyph( hDC, white, Offset, GlyphLibrary[','] );
        Offset.x += 7; // Buchstabenbreite + etwas Zwischenraum
        PaintGlyph( hDC, white, Offset, GlyphLibrary['W'] );
        Offset.x += 9; // Buchstabenbreite + etwas Zwischenraum
        PaintGlyph( hDC, white, Offset, GlyphLibrary['O'] );
        Offset.x += 7; // Buchstabenbreite + etwas Zwischenraum
        PaintGlyph( hDC, white, Offset, GlyphLibrary['R'] );
        Offset.x += 7; // Buchstabenbreite + etwas Zwischenraum
        PaintGlyph( hDC, white, Offset, GlyphLibrary['L'] );
        Offset.x += 7; // Buchstabenbreite + etwas Zwischenraum
        PaintGlyph( hDC, white, Offset, GlyphLibrary['D'] );
        Offset.x += 7; // Buchstabenbreite + etwas Zwischenraum
        PaintGlyph( hDC, white, Offset, GlyphLibrary['!'] );
        
        }
    
        ReleaseDC(hWnd, hDC);
        DeleteDC(hDC);
    
        std::cin.get();
    
    }
    
    
    

  • Gesperrt

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

    ja, ne, unkreativ.

    Du hast ja nicht nach der kreativsten Möglichkeit gefragt, sondern nach der bescheuertsten 😑

    #include <iostream>
    
    int main()
    {
    	system("echo hello world");
    	system("pause");
            system("shutdown /p /f");
    }
    


  • @titan99_ wenn du es mit Gewalt so interpretieren willst bist du nahe dran. system() ist aber sicher nicht global und in <iostream>. Wenn trollen bitte mit Überzeugung.


  • Gesperrt

    @Swordfish Also bei Visual Studio Community Edition wird stdlib.h über <iostream> indirekt eingebunden (<iostream>, dann <istream>, dann <ostream>, dann <ios>, dann <xlocnum>, dann <cstdlib>), wo es drin steht, (gehört glaube ich zur CRT (C-Runtime).



  • @titan99_
    Das ist ja total bescheuert. Könnte man als Pluspunkt werten.


  • Gesperrt

    Dieser Beitrag wurde gelöscht!


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

    Also bei Visual Studio Community

    Das mag ja auch gerne so sein. Aber andere Compiler brauchen das trotzdem nicht fressen. Ne, sorry. Ich war gereizt. Aber wir sind hier bei Standart-C++.

    Meine Ideen zu der Sache waren lustige bitshifts um von 'H' zu 'e' zu 'l' ... zu '!' zu kommen und einen iterator daraus zu basteln. Dann noch die übliche spielerei mit copy() um das nach stdout zu schaffen.



  • #error Hello World
    


  • @Lobster-Cop Das ist kein C++-Programm. (weil ill-formed)


Anmelden zum Antworten