Bescheuertste Möglichkeit "Hello World" auszugeben?



  • 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)



  • Ich möchte diesen Thread nutzen, um für die Verwendung moderner Enterprise-Softwareentwicklungstechniken zu werben, die die Wiederverwendbarkeit und Modularität des Quellcodes sicherstellen und optimieren. So kann auch bei kurzfristigen Performanceabstrichen langfristige Wartbarkeit gesichert werden, was Kosten minimiert und auf lange Sicht durch die Vermeidung von "Verfilzungen" auch ein gutes Laufzeitverhalten garantiert.

    Im Folgenden findet sich eine Hello-World-Implementation mit angemessener Abstraktion.

    #include <iostream>
    #include <memory>
    #include <string>
    
    template<typename Character>
    class AbstractSink {
    public:
            virtual ~AbstractSink();
            virtual void sinkCharacter(Character c) = 0;
    };
    
    template<typename Character>
    AbstractSink<Character>::~AbstractSink() {
    }
    
    template<typename Character>
    class AbstractSinkFactory {
    public:
            virtual ~AbstractSinkFactory();
            virtual AbstractSink<Character> *create(void *context) = 0;
    };
    
    template<typename Character>
    AbstractSinkFactory<Character>::~AbstractSinkFactory() {
    }
    
    template<typename Character>
    class AbstractPrinter {
    public:
            virtual ~AbstractPrinter();
            virtual void printToSink(AbstractSink<Character> &sink) = 0;
    };
    
    template<typename Character>
    AbstractPrinter<Character>::~AbstractPrinter() {
    }
    
    template<typename Character>
    class AbstractPrinterFactory {
    public:
            virtual ~AbstractPrinterFactory();
            virtual AbstractPrinter<Character> *create() = 0;
    };
    
    template<typename Character>
    AbstractPrinterFactory<Character>::~AbstractPrinterFactory() {
    }
    
    template<typename Character>
    class BasicOstreamSink : public AbstractSink<Character> {
    public:
            BasicOstreamSink(std::basic_ostream<Character> &out);
            virtual void sinkCharacter(Character c);
    
    private:
            std::basic_ostream<Character> &m_sOut;
    };
    
    template<typename Character>
    BasicOstreamSink<Character>::BasicOstreamSink(std::basic_ostream<Character> &out)
            : m_sOut(out)
    {
    }
    
    template<typename Character>
    void BasicOstreamSink<Character>::sinkCharacter(Character c) {
            m_sOut.put(c);
    }
    
    template<typename Character>
    class BasicOStreamSinkFactory : public AbstractSinkFactory<Character> {
    public:
            virtual BasicOstreamSink<Character> *create(void *context);
    };
    
    template<typename Character>
    BasicOstreamSink<Character> *BasicOStreamSinkFactory<Character>::create(void *context) {
            return new BasicOstreamSink<Character>(*static_cast<std::basic_ostream<Character>*>(context));
    }
    
    template<typename Character>
    class MessagePrinter : public AbstractPrinter<Character> {
    public:
            MessagePrinter(std::basic_string<Character> const &message);
            virtual void printToSink(AbstractSink<Character> &sink);
    
    private:
            std::basic_string<Character> m_strMessage;
    };
    
    template<typename Character>
    MessagePrinter<Character>::MessagePrinter(std::basic_string<Character> const &message)
            : m_strMessage(message)
    {
    }
    
    template<typename Character>
    void MessagePrinter<Character>::printToSink(AbstractSink<Character> &sink) {
            for(typename std::basic_string<Character>::const_iterator it = m_strMessage.begin(); it != m_strMessage.end(); ++it) {
                    sink.sinkCharacter(*it);
            }
    }
    
    class AnsiHelloPrinter : public MessagePrinter<char> {
    public:
            AnsiHelloPrinter();
    };
    
    AnsiHelloPrinter::AnsiHelloPrinter()
            : MessagePrinter<char>("Hello, World!\n")
    {
    }
    
    class AnsiHelloPrinterFactory : public AbstractPrinterFactory<char> {
    public:
            virtual AnsiHelloPrinter *create();
    };
    
    AnsiHelloPrinter *AnsiHelloPrinterFactory::create() {
            return new AnsiHelloPrinter();
    }
    
    int main() {
            // Use std::auto_ptr for compatibility with legacy build system
            // TODO: Update to use std::shared_ptr when/if C++11 becomes widespread
            //       in enterprise software development. Until then, compile wih
            //       -Wno-deprecated
            std::auto_ptr<AbstractSinkFactory<char> > sinkFactory(new BasicOStreamSinkFactory<char>());
            std::auto_ptr<AbstractPrinterFactory<char> > printerFactory(new AnsiHelloPrinterFactory());
            std::auto_ptr<AbstractSink<char> > sink(sinkFactory->create(&std::cout));
            std::auto_ptr<AbstractPrinter<char> > printer(printerFactory->create());
    
            printer->printToSink(*sink);
    }
    




  • @enterprise 👍, vor allem das TODO 🙂
    Fehlt nur noch ein Dependency Injection Container.


Anmelden zum Antworten