Normen voor pseudo-code?

Als de code is procedureel, normaal pseudo-code is waarschijnlijk gemakkelijk (Wikipedia heeft een aantal voorbeelden).

Objectgeoriënteerde pseudo-code zou kunnen worden bemoeilijkt. Overwegen:

• met behulp van UML class diagrammen aan de lessen af ​​te schilderen / inheritence
• middels UML diagrammen sequentie met de codereeks tonen

Ik stel voor dat je een kijkje nemen op de nemen Fortress Programming Language .

Dit is een werkelijke programmeertaal, en niet pseudocode, maar het werd ontworpen zo dicht mogelijk bij uitvoerbare pseudocode mogelijk te zijn. In het bijzonder voor het ontwerpen van de syntax, ze lezen en geanalyseerd honderden van CS en wiskunde papers, cursussen, boeken en tijdschriften tot wat gebruikelijk patronen voor pseudo-code en andere computationele / wiskundige notaties vinden.

U kunt al dat onderzoek benutten door alleen te kijken naar Fortress broncode en abstraheren van de dingen die je niet nodig hebt, omdat uw doelgroep is menselijk, terwijl Fortress is een compiler.

Hier is een werkelijk voorbeeld van het runnen van Fortress code van de NAS (NASA Uitgebreid Supercomputing) geconjugeerde gradiënten Parallel Benchmark . Voor een leuke ervaring, vergelijk de specificatie van de benchmark met de implementatie in Fortress en merk op hoe er is bijna een 1: 1 correspondentie. Vergelijk ook de uitvoering in een paar andere talen, zoals C of Fortran, en merk op hoe ze hebben absoluut niets te maken met de specificatie (en vaak ook een orde van grootte langer dan de spec).

Ik moet benadrukken: dit is niet pseudocode, dit is werkelijke arbeidstijd Fortress code! Fortress Code Voorbeeld http://ProjectFortress.Sun.Com/Projects/Community/raw-attachment/wiki/FortressQuestions/NAS-CG.png

Edit: bovenstaande code voorbeeld link is dood. Mogelijk soortgelijk voorbeeld kan hier worden gevonden: https://umbilicus.wordpress.com/2009/10/16/fortress-parallel-by-default/

Ik begrijp niet uw eis van "niet te dicht bij een aantal concrete programmeertaal".

Python wordt algemeen beschouwd als een goede kandidaat voor het schrijven van pseudo-code. Misschien een licht vereenvoudigde versie van python zou werken voor je.

Pascal is altijd al van oudsher de meest vergelijkbaar met pseudo geweest, als het gaat om de wiskundige en technisch gebied. Ik weet niet waarom, het was gewoon altijd zo.

Ik heb een aantal (oh, ik weet het niet, 10 misschien boeken op een plank, die concrete deze theorie).

Python zoals voorgesteld, kan aardig code zijn, maar het kan zo onleesbaar zijn zo goed, dat het een wonder op zich. Oudere talen zijn moeilijker te onleesbaar te maken - ze zijn "eenvoudiger" (neem met de nodige voorzichtigheid) dan die van vandaag. Ze zullen misschien moeilijker om te begrijpen wat er gaande is, maar gemakkelijker te lezen (minder syntax / taalfuncties is nodig om te begrijpen wat het programma doet).

Het beantwoorden van mijn eigen vraag, ik wilde alleen maar om de aandacht te vestigen op de volgende pagina over het zetten van pseudo-code in LaTeX: http://www.tex.ac.uk/cgi-bin/texfaq2html?label=algorithms . Ze beschrijven een aantal verschillende stijlen, lijst voor- en nadelen. Overigens, gebeuren er twee stylesheets bestaan voor het schrijven van pseudo-code op de wijze gebruikt in "Introductin tot Algorithms" door Cormen, zoals hierboven aanbevolen: newalg en clrscode. De laatste werd geschreven door Cormen zelf.

Dit bericht is oud, maar hopelijk zal dit anderen te helpen.

"Introduction to Algorithms" book (door Cormen, Leiserson en Rivest) is een goed boek om te lezen over algoritmen, maar de "pseudo-code" is verschrikkelijk. Dingen zoals Q [1 ... n] is onzin wanneer men moet begrijpen wat Q [1 ... n] is te veronderstellen betekenen. Die zullen moeten buiten de te worden opgemerkt "pseudo-code." Bovendien boeken als "Introduction to Algorithms" graag een wiskundige syntax, die het schenden van een doel van pseudo-code te gebruiken.

Pseudo-code moet twee dingen doen. Abstracte weg van syntax en zijn gemakkelijk te lezen. Indien de werkelijke code is meer beschrijvend dan de pseudo-code, en de werkelijke code is meer beschrijvend, dan is het niet pseudo-code.

Stel dat je aan het schrijven van een eenvoudig programma.

Screen design:

Welcome to the Consumer Discount Program!
Please enter the customers subtotal: 9999.99
The customer receives a 10 percent discount
The customer receives a 20 percent discount
The customer does not receive a discount
The customer's total is: 9999.99

Variable List:

TOTAL:         double
SUB_TOTAL:     double
DISCOUNT:      double

Pseudo-code:

DISCOUNT_PROGRAM

    Print "Welcome to the Consumer Discount Program!"
    Print "Please enter the customers subtotal:"
    Input SUB_TOTAL

    Select the case for SUB_TOTAL
        SUB_TOTAL > 10000 AND SUB_TOTAL <= 50000
            DISCOUNT = 0.1
            Print "The customer receives a 10 percent discount"
        SUB_TOTAL > 50000
            DISCOUNT = 0.2
            Print "The customer receives a 20 percent discount"
        Otherwise
            DISCOUNT = 0
            Print "The customer does not a receive a discount"

    TOTAL = SUB_TOTAL - (SUB_TOTAL * DISCOUNT)
    Print "The customer's total is:", TOTAL

Merk op dat dit is zeer gemakkelijk te lezen en geen syntax verwijzen. Dit ondersteunt alle drie van Bohm en Jacopini de controle structuren.

Volgorde:

Print "Some stuff"
VALUE = 2 + 1
SOME_FUNCTION(SOME_VARIABLE)

Selectie:

if condition
    Do one extra thing

if condition
    do one extra thing
else
    do one extra thing

if condition
    do one extra thing
else if condition
    do one extra thing
else
    do one extra thing

Select the case for SYSTEM_NAME
    condition 1
        statement 1
    condition 2
        statement 2
    condition 3
        statement 3
    otherwise
        statement 4

Herhaling:

while condition
    do stuff

for SOME_VALUE TO ANOTHER_VALUE
    do stuff

vergelijk dat deze N-Queens "pseudo-code" ( https://en.wikipedia.org/wiki/Eight_queens_puzzle ):

PlaceQueens(Q[1 .. n],r)

    if r = n + 1
        print Q
    else
        for j ← 1 to n
            legal ← True
            for i ← 1 to r − 1
                if (Q[i] = j) or (Q[i] = j + r − i) or (Q[i] = j − r + i)
                    legal ← False
        if legal
            Q[r] ← j
            PlaceQueens(Q[1 .. n],r + 1) 

Als je het niet zomaar kan verklaren, heb je het niet goed genoeg te begrijpen. - Albert Einstein