3. @DrGreenthumb

@DrGreenthumb

  • D

    Ja moin, wollte mal fragen ob die forschleife in deiner sig von dir stammt!
    (for(int i=0,j=1407487463;i<125;++i,j=i<32?j:i<64?2477017384u:i<96?639716114:i<128?508059256:0,i%25?0:putchar(10))putchar(j&1<<i?64:32);)

    Wenn ja, wie hast das denn hingekriegt???

    0
  • M

    Cool, habs gerade ausgeführt ^^
    Ist so komüpliziert auch net, würd ich mir das länger anschauen würd ichs auch verstehen, ist doch net so schwer 🙂

    0
  • D

    Ja moin, wollte mal fragen ob die forschleife in deiner sig von dir stammt!

    Ja

    Wenn ja, wie hast das denn hingekriegt???

    1='@'
    0=' '

    Nicht so spektakulär 🙂

    Auch recht lustig: http://www.ioccc.org/

    0
  • D

    Original erstellt von DrGreenthumb:
    **
    [quote]Wenn ja, wie hast das denn hingekriegt???**

    **
    1='@'
    0=' '

    Nicht so spektakulär 🙂
    **[/QUOTE]

    naja, so meinte ich das nicht 😉 haste das buchstabe für buchstabe gemacht? oder zeile für zeile?

    0
  • D

    😕

    0
  • E

    Will auch mal ausführen, Compiler meckert aber. Welchen Header benötige ich für die Funktion putchar()?

    0
  • D

    Original erstellt von DrGreenthumb:
    😕

    ??

    0
  • D

    Der Smilie sollte ausdrücken, dass ich nicht weiß was du mit der Frage meinst.

    putchar() brauch stdio.h. Eigentlich wars eine C-Version mit main() drumrum, dass man's direkt compilieren kann. Aber das blöde Forum hat sich bei der 69-Zeichen langen Zeile beschwert, sie wäre über 80 Zeichen lang.

    0
  • D

    Original erstellt von DrGreenthumb:
    **Der Smilie sollte ausdrücken, dass ich nicht weiß was du mit der Frage meinst.
    **

    Jo, ich weiß/wusste aber nicht warum du die frage nicht verstehst 😉

    Also meine frage war wie du das gemacht hast^^ ne jetzt mal im ernst, also die schleife wird ja 125 mal durchlaufen (25*5). bei jedem durchgang wird entweder ein zeileumbruch, ein '@' oder ein leerzeichen ausgegeben. Nun zur Frage: wie hast du es hingekriegt, zu testen, an welcher position ein ' ' oder ein '@' muss (zeielnumbrüche sind ja leicht (%)). Hast du dafür bestimmte kriterien aufgestellt, die bei jeder "position" das richtige zeichen liefert? Wenn ja, wie?
    Hoffe ich habe mich jetzt ein wenig verständlich(er) ausgedrückt...

    0
  • ?

    Willst du das selbe wohl mit deinem Namen machen.

    0
  • D

    Und genau die Frage hatte ich ja in meinem ersten Post beantwortet 😉
    Zahlen werden im Computer mit 1 und 0 dargestellt. Jetzt überleg mal woher diese riesigen Zahlen kommen.

    0
  • D

    Original erstellt von DrGreenthumb:
    Und genau die Frage hatte ich ja in meinem ersten Post beantwortet 😉
    Zahlen werden im Computer mit 1 und 0 dargestellt. Jetzt überleg mal woher diese riesigen Zahlen kommen.

    Ahhhhhhh, ich habs geschnallt!

    *dummSei*

    0
  • W

    @DrGreenthumb: Also stehen die 4 großen Zahlen für die Buchstaben "D", "E", "N" und "S"?

    0
  • D

    Original erstellt von MaSTaH:
    @DrGreenthumb: Also stehen die 4 großen Zahlen für die Buchstaben "D", "E", "N" und "S"?

    Ne, du bist dumm ich wars !!! 😉 🙂 😃 🕶 also das ist natürlich zeile für zeile, die großen zahlen sind im binärformat und ergeben umgedreht und aneinader gereiht eine "kette" mit 0 und 1, wobei für jede 1 ein '@' und für jede '0' ein ' ' ausgegeben wird.

    0
  • D

    Ist, wenn man das Prinzip verstanden hat ja wirklich voll einfach 🙂

    for(int a=0,b=339494383;a<115;++a,b=a<32?b:a<64?289014306:a<96?1619559719u:a<128?253406:0)putchar((a+1)%23?b&1<<a?35:32:10);

    so, jetzt wisst ihr auch alle wie ich heiße!!

    0
  • ?

    Das ist wirklich interessant... ich hab das System auch schon halb verstanden. Aber kann jemand noch mal anhand des Wortes "TEST" erklären, was zu machen ist?

    Waere echt lieb von euch

    0
  • D

    Ok, also du holst dir am besten ein karriertes blatt und malst darauf den Text in Kästchen!

    xxxxx xxxx  xxx  xxxxx
  x   x    x       x
  x   xxx   xxx    x
  x   x        x   x 
  x   xxxx  xxx    x

    nun musst du wissen, dass ein int 32 bit hat, du also für jede 32 kästchen ein int brauchst. Nun musst du alle zeichen (ACHTUNG: an dem ende jeder zeile kommt ein leeres kästchen!!) aufschreiben und nach jeden 32 zeichen eine trennlinie machen! In diesem Fall wäre das also
    11111011110011100111110001000100 | 00100000001000001000111000111000 | 01000001000100000000100010000010 | 0011110011100001000

    sofern die letzte "zahl" keine 32 bit enthält müssen diese noch mit nullen aufgefüllt werden, also

    11111011110011100111110001000100 | 00100000001000001000111000111000 | 01000001000100000000100010000010 | 00111100111000010000000000000000

    so, da das programm die zahlen von hinten nach vorne liest (es geht auch andersherum, wäre aber länger) müssen die bist umgedreht werden, man erhält also

    00100010001111100111001111011111 | 00011100011100010000010000000100 |
    01000001000100000000100010000010 | 00000000000000001000011100111100

    diese binärzahlen müssen nun ins dezimale system umgewandelt werden.
    Man erhält (bei zahlen größer als 2^31 muss ein u für unsigned drangehängt werden) :

    574518239 | 477168644 | 1091569794u | 34620

    Nun zur For schleife:

    for(int a=0, b=574518239; ...

    es werden die zwei variablen initialisiert. b ist die erste zahl (für die ersten 32 zeichen) und a ist eine zählvariable. diese geht von 0 bis gesamtZeichen, in diesem Falle 23*5=115. Nun haben wir also auch die bedingung für die for schleife!

    for(int a=0, b=574518239; a<115; ...

    nun kommt ein etwas schwieriger teil: zuerst wird a um eins erhöht. Nun soll b für die ersten 32 zeichen zahl 1, für die nächsten 32 zeichen zahl 2, für die darauf folgenden zahl 3, etc sein. Es wird programmiertechnisch geguckt, ob a<32 wenn, dann ist b=zahl1 (bleibt zahl b), wenn nicht wird geguckt ob a<64. Wenn, dann ist b=zahl2, ansonsten wird geguckt ob a<96, etc.
    Das sieht also so aus:

    for(int a=0, b=574518239; a<115; ++a, b=a<32 ? b : a<64 ? 477168644 : a<96 ? 1091569794u : 34620) ...

    die schleife ist nun fertich. Jetzt wird die Funktion Putchar ausgeführt. Zuerst wird geguckt ob ein Zeilenumbruch notwendig ist. Dies ist der fall wenn a+1 durch 23 (anzahl zeichen in einer zeile) restlos teilbar, also 0 ist. Ist dies nicht der fall (also (a+1)%23 = true), wird geguckt ob das bit a (von hinten gesehen) der zahl b '1' ist. Hierzu wird die Zahl eins, die normal im binärformat so aussieht (nullen nur zur verdeutlichung!)

    00000000000000000000000000000001

    um a stellen nach links verschoben. wenn a z.B. 31 ist (ende der ersten zahl) sähe 1<<a so aus:

    10000000000000000000000000000000

    jetzt wird geguckt ob diese an dieser stelle von b auch eine 1 steht (& operator), also ob 1<<a & b. Jetzt wird das ergebnis ausgewertet: bei einem zeilenumbruch wird putchar eine 10, bei einer '1' ein bestimmtes zeichen, z.b. 35 und ansonsten 32 (leerzeichen, kann natürlich auch anderes zeichen sein) übergeben.
    es ergibt sich also:

    for(int a=0, b=574518239; a<115; ++a, b=a<32 ? b : a<64 ? 477168644 : a<96 ? 1091569794u : 34620) putchar((a+1)%23 ? 1<<a & b ? 35 : 32 : 10);

    Hoffe ich konnte dir(euch) helfen!

    MfG DasPinsch

    [ Dieser Beitrag wurde am 22.06.2003 um 20:58 Uhr von DasPinsch editiert. ]

    0
  • M

    Original erstellt von DasPinsch:
    bei zahlen größer als 2^16 muss ein u für unsigned drangehängt werden

    nee, nicht bei 2^16. bei 2^31 🙂 (oder so)

    0
  • W

    *patsch*, mann hatte ich ne lange Leitung... Ich mach auch mal eins wenn ich Zeit habe... NETTE IDEE!

    0
  • D

    Original erstellt von Mr. N:
    [quote]Original erstellt von DasPinsch:
    [qb]bei zahlen größer als 2^16 muss ein u für unsigned drangehängt werden

    nee, nicht bei 2^16. bei 2^31 🙂 (oder so)[/QB][/QUOTE]

    stimmt bin dumm, sorry, tut mir leid, wird nie wieder vorkommen, werds ändern!! 🙂

    0
Anmelden zum Antworten