3. @DrGreenthumb

@DrGreenthumb

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

    @DasPinsch: Die Absolution sei dir hiermit erteilt. 😃

    EDIT: hab ich doch tatsächlich "gegeben" statt "erteilt" geschrieben... uuuunglaublich 😃

    [ Dieser Beitrag wurde am 22.06.2003 um 20:46 Uhr von Mr. N editiert. ]

    0
  • ?

    .... du wolltest doch weiterschreiben.. oder immernoch am essen? 😃

    0
  • D

    Ja, wurde alles etwas länger, ist nun aber feddich 🙂

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

    0
Anmelden zum Antworten