ALGORITHMEN UND ANDERES ZEUG - Teil XIII

  • Abt. Magische Quadrate brute force suchen ??
    =============================
    Magische Quadrate mit der Methode "Alle Zahlen durchprobieren" suchen ist gelinde gesagt:
    §%&)!#blöd! Beweis anbei...
    Gruss

    Quellcode

    1. var k&=9
    2. WindowTitle "Auf der Jagd nach Magischen Quadraten 3x3 bis Z_max="+str$(k&)
    3. WindowStyle 24:Window 0,0-%maxx,%maxy:showmax:font 2:
    4. declare n&,x1&,x2&,x3&,x4&,x5&,x6&,x7&,x8&,x9&,s!
    5. s!=1:whileloop k&,2,-1:s!=s!*k&:endwhile:set("decimals",0)
    6. print s!;" Kombinationen testen":s!=0
    7. whileloop 1,k&:x1&=&Loop
    8. whileloop 1,k&:x2&=&Loop
    9. case x2&=x1&:continue
    10. whileloop 1,k&:x3&=&Loop
    11. case x3&=x1&:continue
    12. case x3&=x2&:continue
    13. s!=x1&+x2&+x3&
    14. ::print "*";
    15. whileloop 1,k&:x4&=&Loop
    16. case x4&=x1&:continue
    17. case x4&=x2&:continue
    18. case x4&=x3&:continue
    19. whileloop 1,k&:x5&=&Loop
    20. case x5&=x1&:continue
    21. case x5&=x2&:continue
    22. case x5&=x3&:continue
    23. case x5&=x4&:continue
    24. whileloop 1,k&:x6&=&Loop
    25. case x6&=x1&:continue
    26. case x6&=x2&:continue
    27. case x6&=x3&:continue
    28. case x6&=x4&:continue
    29. case x6&=x5&:continue
    30. whileloop 1,k&:x7&=&Loop
    31. case x7&=x1&:continue
    32. case x7&=x2&:continue
    33. case x7&=x3&:continue
    34. case x7&=x4&:continue
    35. case x7&=x5&:continue
    36. case x7&=x6&:continue
    37. whileloop 1,k&:x8&=&Loop
    38. case x8&=x1&:continue
    39. case x8&=x2&:continue
    40. case x8&=x3&:continue
    41. case x8&=x4&:continue
    42. case x8&=x5&:continue
    43. case x8&=x6&:continue
    44. case x8&=x7&:continue
    45. whileloop 1,k&:x9&=&Loop
    46. case x9&=x1&:continue
    47. case x9&=x2&:continue
    48. case x9&=x3&:continue
    49. case x9&=x4&:continue
    50. case x9&=x5&:continue
    51. case x9&=x6&:continue
    52. case x9&=x7&:continue
    53. case x9&=x8&:continue
    54. if s!=(x4&+x5&+x6&)
    55. if s!=(x7&+x8&+x9&)
    56. if s!=(x1&+x4&+x7&)
    57. if s!=(x2&+x5&+x8&)
    58. if s!=(x3&+x6&+x9&)
    59. if s!=(x1&+x5&+x9&)
    60. if s!=(x7&+x5&+x3&)
    61. print:inc n&
    62. font 2:print n&;"(";int(s!);")":font 0
    63. print x1&,x2&,x3&
    64. print x4&,x5&,x6&
    65. print x7&,x8&,x9&
    66. beep
    67. endif
    68. endif
    69. endif
    70. endif
    71. endif
    72. endif
    73. endif
    74. endwhile
    75. endwhile
    76. endwhile
    77. endwhile
    78. endwhile
    79. endwhile
    80. endwhile
    81. endwhile
    82. endwhile
    83. print "\n----Ende-----"
    84. sound 1000,160
    85. waitinput
    86. end
    Alles anzeigen
  • Lösung zu Neue Rätselecke Nr. 10 "Diogenes-Rätsel"
    Spoiler anzeigen
    Diogenes stellt Archimedes eine offenbar zuerst undefinierte Aufgabe: Obwohl Archimedes die genaue Olivenzahl kennt, bleiben dabei zwei Möglichkeiten mit Produkt 2450: Dies ist bei der Olivenzahl 64 der Fall: 5 * 10 * 49 = 2450 und 7 * 7 * 50 = 2450. Der älteste Besucher ist also 49 oder aber 50 Jahre alt.

    Diogenes will Archimedes mit seinem Hinweis auf Platon nun helfen: Der Besucher war jünger als Platon da gerade ist. Das hilft Archimedes aber nur, wenn Platon da gerade 50 ist, sonst gäbe es durch den Hinweis noch immer keine Entscheidung.

    Also war der älteste Besucher 49, und Platon (geb 427 v.Chr.) war 50 Jahre alt.
    Wir schreiben also 427-50=377 v.Chr., da ist Aristoteles übrigens gerade 8.
    Nette Geschichte, oder?
  • Nachtrag zu Rätsel Nr. 7: Logik-Ableitungsgang
    ------------------------------------------------
    Spoiler anzeigen
    Das Rätsel lautete:
    ---------------------
    'Alle Athener klug (1) A(x)==>K(x)
    'Alle Spartaner heldenmütig (2) S(x)==>H(x)
    'Keine Doppelbürger (3) S(x) wurde hier als ~A(x) kodiert: Spartaner sind Nicht-Athener
    'Jeder aus einer der beiden Städte (4) ~A(x) OR A(x)
    'Wenn Platon Spartaner: Diogenes nicht Held (5) ~A(p)==>~H(d)
    'Wenn Euklid Spartaner: Diogenes Memme (6) S(e)==>~H(d)
    'Wenn Diogenes Athener: Euklid nicht Held (7) A(d)==> ~H(e)
    'Wenn Platon Athener: Euklid nicht klug (8) A(p)==> ~K(e)

    Oder in Kurzform (x kann e,d oder p sein):
    1. Ax:Kx
    2. ~Ax:Hx
    3. ~(Ax & ~Ax)
    4. Ax or ~Ax
    5. ~Ap:~Hd
    6. ~Ae:~Hd
    7. Ad:~He
    8. Ap:~Ke
    -------------
    '9. Ap {Annahme}
    ' Ap AND 8. Ap:~Ke
    '10. ~Ke
    ' ~Ke AND 1. Ae:Ke
    '11. ~Ae
    ' ~Ae AND 4. Ae or ~Ae
    '12. ~Ae
    ' ~Ae AND 6. ~Ae:~Hd
    '13. ~Hd
    ' ~Hd AND 2. ~Ad:Hd
    '14. Ad
    ' Ad AND 7. Ad:~He
    '15. ~He
    ' ~He AND 2. ~Ae:He
    '16. Ae
    ' Ae AND 12. ~Ae
    '[] leere Klausel
    'Somit ist Annahme (9.) zum Widerspruch geführt.
    'Sie ist mitsamt den aus ihr abgeleiteten Klauseln (10) bis (16) zu verwerfen.
    'Wir erhalten stattdessen:
    ...............................................................................
    20. ~Ap // also p = Spartaner


    'Nehmen wir nun an, Diogenes sei Spartaner, und wenden wir weiterhin das Resolutionsprinzip an:
    '21. ~Ad {Annahme}
    ' ~Ad AND 2. ~Ad:Hd
    '22. Hd
    ' Hd AND 5. ~Ap:~Hd
    '23. Ap
    ' Ap AND 20. ~Ap
    '24. Leere Klausel
    'Somit ist die Annahme (21) widerlegt und mitsamt den aus ihr abgeleiteten
    'Klauseln (22) – (24) zu verwerfen. Wir erhalten stattdessen:
    .......................................................................
    26. Ad

    'Nehmen wir an, Euklid sei Spartaner. Wir erhalten:
    '27. ~Ae
    ' ~Ae AND 2. ~Ae:He
    '28. He
    ' He AND 7. Ad:~He
    '29. ~Ad
    ' ~Ad AND 26. Ad
    '30. Leere Klausel
    'Also ist (27.) falsch und alles bis (30.) zu verwerfen.
    'Wir erhalten stattdessen:
    ..........................................................................
    31. Ae
    ---------------------------------------------------------------------------------
    Daher: Platon ist Spartaner (20). Diogenes ist Athener (26), ebenso Euklid (31).
    ---------------------------------------------------------------------------------
    q.e.d.
  • Abt. Permutationsverfahren im Benchmark
    ===============================
    Im Vergleich:
    1. Selektiionsverfahren mit OR-Kaskade,
    2. Beschleunigung mit Mehrfach-Continue,
    3. Starke Beschleunigung mittels Knuth-Shufflealgorithmus
    Gruss

    Brainfuck-Quellcode

    1. Windowtitle "Benchmark für Acht-Elemente Permutationsverfahren":Cls:font 2
    2. declare tm&,Name1&,Name2&,Name3&,Name4&,Name5&,Name6&,Name7&,Name8&
    3. tm&=&gettickcount
    4. whileloop 1,8:Print ".";
    5. Name1&=&Loop
    6. whileloop 1,8
    7. case &Loop=Name1&:continue
    8. Name2&=&Loop
    9. whileloop 1,8
    10. case (&Loop=Name1&) OR (&Loop=Name2&):continue
    11. Name3&=&Loop
    12. whileloop 1,8
    13. case (&Loop=Name1&) OR (&Loop=Name2&) OR (&Loop=Name3&):continue
    14. Name4&=&Loop
    15. whileloop 1,8
    16. case (&Loop=Name1&) OR (&Loop=Name2&) OR (&Loop=Name3&) OR (&Loop=Name4&):continue
    17. Name5&=&Loop
    18. whileloop 1,8
    19. case (&Loop=Name1&) OR (&Loop=Name2&) OR (&Loop=Name3&) \
    20. OR (&Loop=Name4&) OR (&Loop=Name5&):continue
    21. Name6&=&Loop
    22. whileloop 1,8
    23. case (&Loop=Name1&) OR (&Loop=Name2&) OR (&Loop=Name3&) \
    24. OR (&Loop=Name4&) OR (&Loop=Name5&) OR (&Loop=Name6&):continue
    25. Name7&=&Loop
    26. whileloop 1,8
    27. case (&Loop=Name1&) OR (&Loop=Name2&) OR (&Loop=Name3&) \
    28. OR (&Loop=Name4&) OR (&Loop=Name5&) OR (&Loop=Name6&) OR (&Loop=Name7&):continue
    29. Name8&=&Loop
    30. 'print Name1&,Name2&,Name3&,Name4&,Name5&
    31. endwhile
    32. endwhile
    33. endwhile
    34. endwhile
    35. endwhile
    36. endwhile
    37. endwhile
    38. endwhile
    39. tm&=&gettickcount-tm&:print "\n OR: ";tm&,"ms\n"
    40. tm&=&gettickcount
    41. whileloop 1,8:Print ".";
    42. Name1&=&Loop
    43. whileloop 1,8
    44. case &Loop=Name1&:continue
    45. Name2&=&Loop
    46. whileloop 1,8
    47. case &Loop=Name1&:continue
    48. case &Loop=Name2&:continue
    49. Name3&=&Loop
    50. whileloop 1,8
    51. case &Loop=Name1&:continue
    52. case &Loop=Name2&:continue
    53. case &Loop=Name3&:continue
    54. Name4&=&Loop
    55. whileloop 1,8
    56. case &Loop=Name1&:continue
    57. case &Loop=Name2&:continue
    58. case &Loop=Name3&:continue
    59. case &Loop=Name4&:continue
    60. Name5&=&Loop
    61. whileloop 1,8
    62. case &Loop=Name1&:continue
    63. case &Loop=Name2&:continue
    64. case &Loop=Name3&:continue
    65. case &Loop=Name4&:continue
    66. case &Loop=Name5&:continue
    67. Name6&=&Loop
    68. 'print Name1&,Name2&,Name3&,Name4&,Name5&
    69. whileloop 1,8
    70. case &Loop=Name1&:continue
    71. case &Loop=Name2&:continue
    72. case &Loop=Name3&:continue
    73. case &Loop=Name4&:continue
    74. case &Loop=Name5&:continue
    75. case &Loop=Name6&:continue
    76. Name7&=&Loop
    77. whileloop 1,8
    78. case &Loop=Name1&:continue
    79. case &Loop=Name2&:continue
    80. case &Loop=Name3&:continue
    81. case &Loop=Name4&:continue
    82. case &Loop=Name5&:continue
    83. case &Loop=Name6&:continue
    84. case &Loop=Name7&:continue
    85. Name8&=&Loop
    86. 'print Name1&,Name2&,Name3&,Name4&,Name5&,Name6&,Name7&,Name8&
    87. endwhile
    88. endwhile
    89. endwhile
    90. endwhile
    91. endwhile
    92. endwhile
    93. endwhile
    94. endwhile
    95. tm&=&gettickcount-tm&
    96. print "\n CASE: ";tm&,"ms"
    97. hupf:
    98. Declare t$,t$[],n&,k&,j&,u&,v&,e%,z&,q$
    99. e%=1:z&=0:q$=" "
    100. t$="1 2 3 4 5 6 7 8"
    101. t$=trim$(t$):t$=translate$(t$," "," "):case instr("|",t$):q$="|"
    102. t$=translate$(t$," ","|"):t$[]=explode(t$,"|"):n&=SizeOf(t$[])
    103. tm&=&gettickcount
    104. While e%:inc z&':casenot q$="|":print " ";
    105. 'WhileLoop n&:print t$[&Loop-1];:case &Loop=n&:continue:print q$;:EndWhile:print
    106. if n&<2:e%=0:break:endif
    107. k&=n&-2:While t$[k&]>=t$[k&+1]:Dec k&:case k&<0:break:EndWhile
    108. if k&<0:e%=0:break:endif
    109. j&=n&-1:While t$[j&]<=t$[k&]:dec j&:EndWhile
    110. t$=t$[k&]:t$[k&]=t$[j&]:t$[j&]=t$:u&=k&+1:v&=n&-1
    111. :While u&<v&:t$=t$[u&]:t$[u&]=t$[v&]:t$[v&]=t$:inc u&:dec v&:EndWhile
    112. EndWhile'print "-------------- Ausgegebene Zeilen:",z&,"-----------------"
    113. tm&=&gettickcount-tm&
    114. print "\n KNUTH: ";tm&,"ms"
    115. waitinput
    116. End
    Alles anzeigen
  • Abt. Rechendauer nach Anzahl zu permutierender Elemente
    ============================================
    Der Knuth-Shufflealgorithmus für Permutationen schafft in reinem XProfan (ohne Assembler) ca. 12000 Shuffles pro Sekunde. Die 40.320 Permutationen von 8 Elementen brauchen bei mir daher 3.33 Sekunden. Das geht ja noch, - aber wie sieht es bei mehr als 8 Elementen aus? Die 16 Felder eines Magischen 4x4-Quadrates brauchen so ca. 55 Jahre - Voll die Explosion, wie beiliegendes Machwerk zeigt. Gesetzt den Fall, Assembler liefe 1000 mal schneller, wären das immer noch 3 Wochen. All-zu-viel wäre somit noch nicht gewonnen! Das Ganze schreit einfach nach intelligenteren Verfahren als bloß "Systematisch alles ausprobieren"...
    Gruss

    P.S.: Irgendwann gibt es für solche Probleme den 512-qbit Home-Quantencomputer in Schuhschachtelgröße. Ob wir das noch erleben?

    Quellcode

    1. WindowTitle "Rechenzeit nach Anzahl Permutationen"
    2. WindowStyle 24
    3. Window 0,0-%maxx,%maxy
    4. set("decimals",0)
    5. declare j!,mo!,wo!,d!,h!,m!,s!
    6. j!=365.2425*24*60*60
    7. mo!=j!/12
    8. d!=24*60*60
    9. wo!=7*d!
    10. h!=60*60
    11. m!=60
    12. declare i&,n&,p!
    13. WHILELOOP 0,169:n&=&Loop:p!=1
    14. whileloop n&,2,-1:i&=&loop
    15. p!=p!*i&
    16. endwhile
    17. font 0
    18. print n&;"!=";
    19. if n&<=32
    20. print p!,
    21. else
    22. print format$("%g",p!),
    23. endif
    24. font 2
    25. s!=p!/12000
    26. if n&<40
    27. print "Zeit: ";
    28. print format$("%g",s!);" s =";
    29. print s!/j!;" J =";
    30. print s!/wo!;" Wo =";
    31. print s!/h!;" h"
    32. else
    33. print
    34. endif
    35. if %csrlin>53:waitinput:cls:endif
    36. endwhile
    37. waitinput
    Alles anzeigen

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von p. specht ()

  • zu Nr 7 (#124):

    Donaldos Diogenes ist entweder Athener oder Spartaner
    . Wenn dieser Platon Athener ist, dann ist Herr Euklid ein Spartaner

    Pedros Platon ist entweder Athener oder Spartaner
    . wenn Euklid Spartaner ist, dann ist Diogenes Athener
    . wenn Diogenes allerdings Athener ist, dann ist Euklid ein Athener ????? (Gegenteil des ersten, oder nicht)

    Ernesto Euklid ist entweder Athener oder Spartaner
    . Wenn Platon Spartaner ist, dann ist Diogenes Athener

    -----

    Wie erklärt sich Platons Aussage, wenn alle die Wahrheit sagen:

    Zitat:
    Herr Platon behauptete: „Diogenes ist eine Memme, wenn der Euklid Spartaner ist; ...“ (6)
    "wenn Herr Diogenes allerdings Athener ist, dann ist Euklid ein Waschlappen!" (7)


    Die ersten 3 Bedingungen sind ja: Athener == klug, Spartaner == heldenmütig, Athener <> Spartaner

    Das ergibt dann umgewandelt:
    . Diogenes ist eine Memme (~heldenmütig=Athener), wenn der Euklid Spartaner ist; ...“ (6)
    "wenn Herr Diogenes allerdings Athener ist, dann ist Euklid ein Waschlappen([i]~heldenmütig=Athener)" (7)[/i]
    Programmieren, das spannendste Detektivspiel der Welt.
  • @ Michael W: Das hat mich auch lange ratlos gelassen. Im Original herrscht offenbar eine andere "Lesart": Diogenes wäre dann eine Memme, wenn der Euklid (also wer aderer!) Spartaner (also Nicht-Athener) ist: ~A(e)==>~H(d) bzw. A(e)==>H(d). Der zweite Satz (Wenn aber A(d)==>~H(e)) ist dann noch kein Widerspruch.

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von p. specht ()

  • Korrektur zu oben: ~A(e)==>~H(d) entspricht natürlich H(d)==>A(e). Sorry!
    Ausserdem: == (Äquivalenz) ist nicht gleich ==> (Implikation)
    Daraus kann man nur folgern: Boole´sche Logik ist was für Masochisten!

    Abt. Magische Quadrate mit ungerader Seitenlänge
    ================================
    Im Jahr 1691 publizierte der Französische Gesandte Simon de la Loubére ein aus Siam (heute Thailand) mitgebrachtes Verfahren zur Erstellung beliebig großer Magischer Quadrate ungerader Seitenlänge. Allerdings stammt dieses verblüffend einfache Verfahren wahrscheinlich aus Surat (in Indien), von wo es ein Franzose namens M. Vincent dann nach Siam brachte. Alter und Zuschreibung von EDV-Verfahren scheinen also ziemlich willkürlich. Na Hauptsache, es klappt!
    Gruss

    Quellcode

    1. WindowTitle "Simon de la Loubére (Siamesische Methode) für Magische Quadrate ungerader Seitenlänge"
    2. '(D) Demo 2017-09 by P.Specht, Vienna/Austria. Alles ohne Gewähr! 'Q: Wikipedia
    3. var N&=7 '<<< Gewünschte ungerade Seitenlänge hier eingeben!
    4. '====================================================================================
    5. 'Die erste Zahl (1) kommt oben in die Mitte.
    6. 'Wenn die zuletzt geschriebene Zahl i kein Vielfaches von n ist (i mod n <> 0),
    7. 'dann trage die nächste Zahl i+1 in das Feld oben rechts vom zuletzt ausgefüllten Feld.
    8. 'Hierbei wird das magische Quadrat als periodisch wiederholt angesehen, d. h.,
    9. 'wenn man über den oberen Rand hinausgeht (das passiert schon beim ersten Schritt),
    10. 'kommt man von unten wieder hinein, und wenn man rechts hinausgeht, dann kommt man
    11. 'von links wieder hinein.
    12. '
    13. 'Ist die zuletzt geschriebene Zahl i ein Vielfaches von n (i Mod n = 0),
    14. 'dann trage die nächste Zahl in das Feld *unter* der zuletzt geschriebenen Zahl.
    15. '
    16. 'Verlässt man nach diesen Regeln das Quadrat nach oben (x,-1), so schreibe die nächste Zahl
    17. 'ganz unten in die Spalte, die rechts der Spalte liegt, in die die letzte Zahl geschrieben wurde.
    18. 'Wird das Quadrat nach rechts verlassen, schreibe die nächste Zahl ganz links in die Zeile,
    19. 'die über der Zeile der zuletzt geschriebenen Zahl liegt.
    20. '
    21. 'Hier ein nach dieser Regel konstruiertes 7×7-Quadrat
    22. '
    23. '30 39 48 1 10 19 28
    24. '38 47 7 9 18 27 29
    25. '46 6 8 17 26 35 37
    26. ' 5 14 16 25 34 36 45
    27. '13 15 24 33 42 44 4
    28. '21 23 32 41 43 3 12
    29. '22 31 40 49 2 11 20
    30. WindowStyle 24:if n&<16:cls:else:Window 0,0-%maxx,%maxy:showmax:endif:font 2
    31. if n&>25:print "\n Darstellung am Schirm nicht mehr möglich!":goto "exit":endif
    32. if n& mod 2
    33. declare F&[n&,n&],m&,x&,y&,z&,i&,j&,lx&,ly&
    34. proc show
    35. locate 2,2
    36. Whileloop 1,n&:j&=&Loop:whileloop 1,n&:i&=&Loop
    37. print tab(5*i&);if(F&[i&,j&],F&[i&,j&],"_");
    38. endwhile:print:print:endwhile
    39. endproc
    40. prep:
    41. m&=n&*n&
    42. x&=(n&+1)/2:y&=1
    43. z&=1:F&[x&,y&]=z&:Show
    44. While 1
    45. x&=x&+1:case x&>n&:x&=x&-n&
    46. y&=y&-1:case y&< 1:y&=y&+n&
    47. if F&[x&,y&]=0
    48. inc z&:case z&>m&:goto "exit"
    49. F&[x&,y&]=z&
    50. else
    51. y&=y&+3
    52. x&=x&-2
    53. case y&=n&+2:goto "exit"
    54. case x&<1:x&=x&+n&
    55. case y&>n&:y&=y&-n&
    56. endif
    57. case n&<14:Show ':waitinput
    58. Endwhile
    59. else
    60. Print "\n Dieser Algorithmus gilt nur für ungerade Seitenlängen!"
    61. endif
    62. exit:
    63. case (n&>14) and (n&<26):show
    64. print "\n Reihensumme des Magischen ";n&;"x";n&;"-Quadrates: ";int((n&^3+n&)/2);
    65. beep:waitinput 30000
    66. End
    Alles anzeigen

    Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von p. specht ()

  • Abt. Hardware-Sicherheit
    ================
    Dass PC-Prozessoren hardwaremäßig RISC-Prozessoren sind, die ein CISC-System mit 80 bis 120 GHz on Chip emulieren, ist seit langem bekannt. Daß Sicherheitsmodi für Tests des RISC-Teils selbst bei der Fertigung existieren müssen, ist daher logisch.

    Seit 29.12.2015 ist Insidern klar, daß es auf x86-Prozessoren hardwareunterstützte Ring ´-1´ (Hypervisor) und Ring ´-2´ (System Management Mode) gibt, und dass für den Zugriff inzwischen Exploits existieren. Seit ich das vor kurzem erfahren habe ist mir endgültig klar geworden, was das Wort "Sicherheit" in der EDV bedeutet: Sicherheit$ = ""
    Gruss

    P.S.: Quelle und Details:(Nur per PM)

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von p. specht ()

  • Abt. Inhalt dieses Teils XIII
    =================
    Hier am Ende üblich, hier noch ein chronologisches INHALTSVERZEICHNIS zu diesem TEIL XIII.
    Gruss
    Spoiler anzeigen
    13_001 ALGORITHMEN UND ANDERES ZEUG - TEIL XIII
    13_002 Die Collatz-Vermutung doch unbewiesen?
    13_003 XProfan unterstützt ab Version X4 nun JSON
    13_004 Quaternions, Teil I
    13_005 Selbstreplikative Sequenzen
    13_006 Replikativsequenz als Turtlegraphik
    13_007 Profangerechte Liste der x86-FPU-Befehle
    13_008 Wie Intel-Befehle zusammengesetzt sind Teil 1
    13_009 Wie Intel-Befehle zusammengesetzt sind Teil 2
    13_011 Intel-Befehle REX.W und dergleichen
    13_012 The Stinker (statt Rodins ´Der Denker´)
    13_013 ASCII, ANSI, UTF-8 und Co.
    13_014 Intel x86 OpCode Chart (Fraunhofer-Institut)
    13_015 Intel x86 Flag Register
    13_017 Intel x86 Stack und FPU Flag Register
    13_018 Ziffern-Selfies natürlicher Zahlen
    13_020 Intel Befehle: Aufbau und Regeln
    13_021 Ungeordnete Partitionen natürlicher Zahlen Teil 1
    13_022 Partitionen und Partitionszahlen Teil 2
    13_023 Zwischenstand: XProfan-X4 und FPU-Befehle, mit Merkblatt XASM FPU-Befehle
    13_024 Bedingte Ausführung mit RGH-XASM oder anderen Mitteln
    13_025 Volkmar: In der letzten X4-Version liefert $ProfVer schon die korrekte Version
    13_026 Schnell UND genau: DoublePrecision 64bit-Floats für RGH-XASM
    13_027 DoublePrecision-Werte in XASM reinbekommen
    13_029 FPU - ganz simpel (.chm Help wiedergefunden)
    13_030 RGH-Kommentar zum Übergabemechanismus an XASM
    13_031 Merkblätter Merkblatt_XASM.pdf XASM_FPU-Befehle.pdf Bedingungen&Schleifen.pdf X4-JSON.pdf
    13_034 Beladen von XProfan-Variablen aus XASM heraus klappt jetzt
    13_035 Variable noch immer direkt beschickbar: FLD QWORD PTR [eax] bzw. FST QWORD PTR [ebx]
    13_036 Aviso Mondfinsternisse 2018
    13_037 Quaternions Teil 2
    13_038 Rationale Trigonometrie nach Wildberger
    13_039 Psychologie: Phasen der Automatisierung und Künstliche Intelligenz KI
    13_040 Standardmodell der Hochenergie-Tellchenphysik inkl. Graviton
    13_041 Link: Künstliche Evolution, GPU-Computing, KI (insb. "Deep Learning") und Genetische Algorithmen
    13_042 Folgen und Reihen mit Summenformeln; Rechengesetze für Reihen
    13_043 Teilungen und Schnitte, Steiner-Formel
    13_044 Programmierprojekte Programmieraufwand und Ablaufplan
    13_045 Euler Produktreihen Formel
    13_046 Polynominversion
    13_047 Youtube-Link: Prof. Gunter Dueck: Gegenwartsforschung
    13_048 Kommt das Internet of Things IoT mit JSON?
    13_049 Berühmte mathematische Formel- und Tabellensammlung der Chemical Rubber Coproration CRC
    13_050 Explizite Faulhaber-Formeln für Exponentialreihen, mit Bernoullizahlen
    13_051 Höhere Programmierparadigmen, Business rules, Use cases
    13_052 Bernoulli-Zahlen berechnen
    13_053 Zukunftsfeste Aus- und Weiterbildung
    13_054 Link: Gültigkeit von JSON-Datenstrukturen
    13_055 Zukunftsforschung: Internet-Trends Prognose 2017-
    13_056 Nichtganzzahlige Ableitungen: Neuer Zweig der Mathematik - Fractional calculus
    13_057 Youtube-Link: Fernsteuerbaren LED-Leuchte ins Internet of Things IoT integrieren
    13_058 Wahrscheinlichkeit, in einem Haus mit ungeradzahliger Hausnummer zu wohnen
    13_059 Wunderzahlen
    13_060 Anzahl der Partitionen per Formel ermitteln
    13_061 Zellulärautomaten
    13_062 Zellulärautomat ´Automaton Nr.30´
    13_063 EDV-Programmierparadigmen Wasserfall-Modell, Agile Programmierung, Extreme Programming, SCRUM
    13_064 Aldi Maginon Wildkamera WK I Passwort vergessen? Abhilfe
    13_065 Schwarmdummheit: Kriech zum Nachbarn-Regel
    13_066 Gurus der Zukunftsforschung, Jeremy Rifkin
    13_067 Bester Solarzellenwirkungsgrad
    13_068 Programm: Sichtbare Bildbreite eines 16:9-Fernsehers
    13_069 Zwischenstand Solid State Drives SSD
    13_070 Prinzip einer einfachen Nervenzelle ("Perzeptron")
    13_073 Programm Röntgentisch, Weisslicht-Schirm
    13_074 Volkmar: Weisslichtschirm für Diabetrachtung nützlich
    13_075 Keyboard-Scancodes, IsKey()-Befehl
    13_076 Keyboard-Scancodes Teil 2
    13_077 Volkmar kommt Unterscheidung der Shift-Tasten auf die Spur
    13_080 Unterscheidung der ALT-Tasten
    13_082 Buchstabenhäufigkeiten Deutsch
    13_083 KeyCode Scancode noch kompakter
    13_084 GetKeyName-Funktion für große deutsche Keyboards
    13_085 WaitScan-Studie
    13_086 Dateinamen aus Linux-Verzeichnissen auslesen
    13_087 Jac de Lad: Dateinamen aus Verzeichnis lesen
    13_089 Arraylisten umkehren
    13_091 Profan steht in der Zeittafel der Programmiersprachen
    13_092 Einsteins Rätsel
    13_093 USA-Wahlen 2018
    13_094 Erweiterter MUSIC-Befehl: Midi Spieldose
    13_095 Regierung 4.0, Japanisches Ringrätsel nach 10 Jahren gelöst
    13_096 Zahlen-Rätsel: Welche Zahl wird verdoppelt wenn man Einerstelle an 1. Stelle zieht?
    13_097 Das wirklich allererste Elektronik-Spiel
    13_098 Hamster-Rätsel
    13_099 SINNERFASSENDES LESEN 15% Schulabgänger Analphabeten
    13_100 Jac de Lad: Schlage Emojis vor!
    13_101 RGH: Kommentar zu "Sinnerfassendes Lesen"
    13_102 Michael Wodrich: Kommentar
    13_103 Jac de Lad: Kommentar
    13_104 P.Specht: Meinung
    13_105 Im Grenzbereich von genauen Zahlendarstellungen
    13_106 Chemische Oszillatoren: Brüsselator simulieren
    13_107 Selbsterkenntnis: Prof. Duecks drei Charaktertypen
    13_112 Umwandlungsmöglichkeiten von WAV nach MIDI
    13_115 Teileranzahl-Funktion "Tau": Ganzzahlige Teiler einer Integer-Zahl
    13_116 Neue Rätselecke Nr.1: Wie viele Reiskörner fehlen?
    13_117 Antwort zu Neue Rätselecke Nr. 1
    13_118 Neue Rätselecke Nr.2: Falsch herausgegeben!
    13_119 Neue Rätselecke Nr. 3: Raser-Risiko
    13_120 Neue Rätselecke Nr. 4: Das Alter des Diophant
    13_121 Neue Rätselecke Nr. 5: Operator-Mix
    13_122 Neue Rätselecke Nr.6: Die Fähren
    13_123 Abläufe und Tätigkeiten bei der Schaltlogik-Entwicklung
    13_124 Neue Rätselecke Nr.7: Logik-Rätsel (Athener Spartaner)
    13_125 Zweiwertige Logik nach George Boole, Logische Grundgesetze
    13_126 Merkblatt LOGIK.pdf zum Download
    13_127 Michel Wodrich: Antwort zu Logik-Rätsel
    13_128 Matching und Kettenbildung: Problem Zirkelschluss
    13_129 Boole´sche Logik: Weitere Zusammenhänge
    13_130 Neue Rätselecke Nr. 8: Deutsch schwer sein!
    13_131 Lösung zu Neue Nr. 8
    13_132 Merkblatt "BOOLE´SCHE LOGIK" (PDF) upgedatet
    13_133 Denkfiguren: Die 7 essentiellen Syllogismen des Aristoteles
    13_134 BEWEISTECHNIKEN Deduktion, Induktion
    13_135 Fallen der Logik
    13_136 Gültige Schlüsse ziehen
    13_137 Falsche Argumentation erkennen
    13_138 Wie rettet man sich vor der Wahrheitstafelexplosion? Natürliches Schliessen
    13_139 Vereinfachung von Beweisketten
    13_140 Jac de Lad: Hinweis auf Android-Spiel Tiger or Lady
    13_141 Das 290-Theorem, Fields Medaille
    13_142 Hinreichende Bedingungen, Notwendige Bedingungen, Äquivalente Bedgg., INUS-Bedgg.
    13_143 Michael Wodrich: Hinweis Turbo-Prolog
    13_145 Aus Fehlern lernen, Widerspruch Begrifflich, Konträr, Kontradiktorisch
    13_146 KLAUSELN, Horn clauses, Kanonische Form, "Or folgt aus and operator <=="
    13_147 Anwendung von Klauseln
    13_148 Cloud-Ersatz
    13_149 Neue Rätselecke Nr. 9: Da ist was überflüssig!
    13_150 Logik-Grundlagen: Warum ist ein Ding ein Ding? Aristoteles vs Kant
    13_151 Lösung zum neuen Rätsel 9
    13_152 0,1-WhileLoop-Test
    13_153 Lösung zu Neue Rätselecke Nr. 7 (Athener Spartaner)
    13_154 Kompaktierter 30-stelliger aufsteigender Von/Bis-Enumerator
    13_155 Michael Wodrich: Hinweis für schnellere Permutation
    13_157 Neue Rätselecke Nr. 10: Diogenes-Rätsel
    13_158 Lösungshilfe zu Nr. 10 Diogenes-Rätsel
    13_159 XProfan AND-Ausdrücke immer vor OR-Ausdrücken ausgewertet
    13_160 Magisches Quadrat aus Kubikzahlen
    13_161 Magische Quadrate brute force suchen ??
    13_162 Lösung zu Neue Rätselecke Nr. 10 Diogenes-Rätsel
    13_163 Nachtrag zu Rätsel Nr. 7: Logik-Ableitungsgang
    13_164 Permutationsverfahren im Benchmark, Knuth-Shuffle
    13_165 Rechendauer nach Anzahl zu permutierender Elemente
    13_166 M.Wodrich: Klärung zu Nr. 7 (ad 13_124)
    13_167 P.Specht: Andere Lesart?
    13_168 De la Loubere Siam-Verfahren: Magische Quadrate beliebiger ungerader Seitenlänge
    13_169 Hardware-Sicherheit? Ring -1, -2 - Exploit!
    13_170 Chronologisches Inhaltsverzeichnis zu ALGORITHMEN XIII

    P.S.: NEUE BEITRÄGE BITTE IN ALGORITHMEN - TEIL XIV POSTEN!