TDDD44 Problemlösning och programmering

Lästips inför tentan

Allmänna lästips

Till att börja med är det bra att läsa igenom den information som finns på kurshemsidorna under "Tentor". Här finns mycket som svarar på frågorna du antagligen vill ställa.

Att läsa i boken och få grepp om saker är aldrig dumt. Det kan dock vara så att man tycker att man förstår sakerna utan att riktigt kunna tillämpa dem. Vad som ingår i kursen ser man genom att titta i kursinformationen. Exakt vilka sidor man skall läsa är oftast svårt att säga. Det är så mycket som hänger ihop.

Övning på uppgifter är det som ger absolut mest. Gamla tentauppgifter är bra, gamla laborationer också. Kanske man kan komma på egna uppgifter som man kan utföra. Detta ger ju också möjlighet att göra något som är roligt.

Att se på lösningar på uppgifter är inte dumt, MEN att titta på lösningar när man sitter och problemlöser gör ofta att man kommer vidare utan att egentligen lärt sig något. Ett tips är att ta t.ex. 10 gamla tentor och läsa igenom uppgifterna och bilda sig en uppfattning om hur man kanske skulle ha kunnat lösa dem. Därefter titta på lösningarna (observera att de lösningar som ligger på hemsidorna är några av många på varje uppgift). Efter detta tar man och löser ett antal uppgifter utan att titta på lösningsförslagen. Det kan ju vara så att ni kommer på en annan metod som är lika bra som den vi använt (det finns många sådana).

Ingår "alltid" i uppgifterna

Man kan säga att det finns saker som är så generella att de är svåra att undvika i uppgifterna. Även om man inte har dem med så är de i alla fall så nyttiga att det är dumt att inte ha förståelse för dessa. När man programmerar finns det två skilda saker bland dessa. Dels de saker som har med själva språket att göra och dels de saker som har med tankesättet att göra när man programmerar. Den senare av dessa är det svårt att "lära ut". Det är nog så att man måste "öva" på egen hand för att få till skickligheten i detta. Det innebär att det gäller att lösa många problem.

Om vi här begränsar oss till den del som har med själva språket att göra (och i denna kurs speciellt Ada) så har vi ett antal generella språkkomponenter. Här följer en "lista" av sådana.

Vanliga satser: Tilldelning (:=), villkor (if, case), repetitioner (loop, while, for), specialsatser (null, exit, return).
Definitioner av underprogram: Det gäller för er del att kunna skapa underprogram (procedurer, funktioner och operatorer) då detta är en del av tankesättet i programmering. Underprogram ökar ofta läsbarheten i programmet (vilket ger lättare felsökning) och delar upp problemet i mindre delar (vilket gör att ni lättare finner en lösningsmetod. Obervera att definitionerna av underprogram också inkluderar parameterlistor med typer och moder ("in", "out" och "in out") samt returvärden för funktioner och operatorer.
Anrop av underprogram: Procedurer, funktioner och operatorer. Det gäller att det finns både fördefinerade sådana i själva språket (eventuellt i paket) och sådana som ni själva definierar.
De grundläggande datatyperna: "Integer", "Float", "Character", "Boolean" och "String". Dessa måste man förstå och kunna hantera för att ha en chans.
Några grundläggande attribut: Det finns många attribut som är grundläggande och vi tar upp ett antal exempel här:
```
    Integer'Last
    Character'First
    Character'Pos('A')
    String'Length
    
```
Vanliga operatorer: Aritmetiska (+, -, *, /, mod, **), logiska (and, or, and then, or else, xor, not), sammaslagning av strängar (&). Vilken prioritetsordning de olika operatorerna har är väsentligt att veta också. Vill man ändra prioritetsordningen får man sätta in parenteser (precis som i matematiken).
Uttryck: Dessa används på många ställen (t.ex. i villkor och tilldelningar).

Typomvandlingar: Det finns i Ada flera sätt som används för att typomvandla och det skiljer sig från fall till fall. Här är tre exempel:

    I := Integer(F);        ("Casting", det som brukar kallas typomvandling)
    I := Integer'Value(S);  (Attribut med parameter)
    I := To_Integer(Date);  (Anrop av funktion)

Standardenheter: Det finns i Ada en mängd standardbibliotek och -rutiner. De vi tagit upp i kursen är:

    Ada.Text_IO                        (paket)
    Ada.Float_Text_IO                  (paket)
    Ada.Integer_Text_IO                (paket)
    Ada.Numerics                       (paket)
    Ada.Numerics.Elementary_Functions  (paket)
    Ada.Numerics.Descrete_Random       (generiskt paket)
    Ada.Strings                        (paket)
    Ada.Strings.Fixed                  (paket)
    Ada.Strings.Unbounded              (paket)
    Ada.Sequential_IO                  (generiskt paket)
    Ada.Unchecked_Deallocation         (generisk procedur)

Under kursens gång har vi tryckt på att ni skall följa vissa regler vad det gäller programmeringen. Detta för att underlätta för er och för att se till att ni skriver "vettiga" program. Några regler som gäller på tentan som ni bör tänka på är:

Fullständig uppräkning: Att räkna upp alla varianter på villkor som finns i en lång "if"-sats (eller "case"-sats) istället för att utföra samma sak med t.ex. upprepning (en "for"-sats eller liknande med en enkel "if"-sats inuti). Detta skapar oftast oläsbar kod och skapar dessutom en massa onödig läsning för den som skall ta över efter er. Detta ger automatiskt komplettering på tentan om man lätt borde se att det skall lösas med t.ex. en "for"-sats.
Globala variabler: Det vi menar med detta är egentligen något som kallas "sidoeffekter". Att använda en globalt definierad variabel i ett underprogram kan ge efterverkningar i andra delar av programmet och detta vill man inte ha. Det man skall göra är istället att skicka med data in till (eller ut ur) ett underprogram via parametrar eller som returvärden. En "global variabel" behöver inte nödvändigtvis vara definierad i huvudprogrammet. Det kan lika gärna vara en variabel som är definierad i en funktion som i sin tur har underprogram som utnyttjar funktionens variabel utan att den skickats via en parameterlista. Detta ger automatiskt komplettering på tentan.

Speciella saker just i Ada

Det kan ju vara bra att ha koll på några specialfall i det språk man hanterar. I Ada finns det några saker som vi kanske inte har tagit upp, men som kan vara bra att få reda på så här inför tentan.

Talbashantering: Den vanliga "Get" för heltal som finns i Ada klarar av att läsa in tal i olika talbaser. För att läsa in tal i basen tio behöver vi inte göra något speciellt. Det har ni gjort under hela kursen. Vill man däremot kunna mata in t.ex. det binära talet "10101" (som motsvarar 21 i basen 10) skriver man in talet på följande format BAS#TALET#. Vårt exempel skulle alltså skrivas (på tangentbordet):
```
    2#10101#
    
```
"Put" kan skriva ut tal på samma format som ovan. Det finns nämligen en parameter till "Put" som heter "Base".
Citationstecken i en sträng: Då citationstecknet (") används som strängmarkering i Ada måste detta tecken specialbehandlas om man vill stoppa in det i en sträng. Det man gör är att man skriver två stycken i rad inuti strängen så motsvarar det ett. Antag att man vill ha de tre tecknen A"B i en sträng. Då får man skriva "A""B" i sin programkod.
Apostrof som tecken: På samma sätt som citationstecknet (") är ett specialfall för strängar är apostrofen för tecken. Detta behandlas på samma sätt. Två apostrofer i rad i en teckenkonstant anses vara en apostrof. Vill man t.ex. skriva ut en apostrof på skärmen kan man skriva:
```
    Put('''');
    
```
Ersättningstecken: Tidigare fanns det inte så många tecken på alla tangentbord som vi har nu. Detta ledde till att man i Ada bestämt sig för att vissa tecken har så kallade ersättningstecken. Vi tar här upp några av dessa så att ni inte råkar illa ut i något sammanhang.
```
    Tecknet # kan istället skrivas med : (kolon).
    Tecknet | kan istället skrivas med ! (utropstecken).
    Tecknet " kan istället skrivas med % (procent).
    
```

Ingår i uppgifterna förutom det generella

I kursen tar vi upp en hel del moment som inte behövs för att lösa alla problem. Det är dock så att dessa moment är väsentliga för att man skall kunna skriva program i stort. De uppgifter som inte bara baserar sig på det generella kan dessutom innehålla ett eller flera av nedanstående moment.

In- och utmatning (tangentbord): Hur fungerar de olika "Get" och "Put"?
Undantag: Fördefinierade och egendefinierade (eng. "exception").
Fält: Endimensionella samt flerdimensionella fält (eng. "array"). Ett specialfall är strängar. Det går att definiera fälttyper som inte är begränsade redan i typdefinitionen utan måste specificeras vid deklarationen av variabeln.
Poster: (eng. "record").
Filhantering: Textfiler och binära filer.
Paket: Fördefinierade och egendefinierade (eng. "package"). Uppdelning på filer ("ads" och "adb"). På en tenta kan man ge er ett paket som ni aldrig sett och ni skall kunna utläsa hur man använder detta eller kanske skall ni kunna modifiera eller lägga till saker i ett givet paket.
Underprogram: Speciellt att ha dem på separata filer ("ads" och "adb"). Underprogram i underprogram. Synlighet (vilka delar i koden kan man nå från andra delar).
Generiska enheter: Kan vara paket, procedurer eller funktioner. Det är viktigt att förstå hur de generiska enheterna används och hur man kan skapa sådana. Speciellt är den generiska "parameterlistan" ("generic"-delen) viktig att kunna tyda.
Attribut: Det finns en massa fördefinierade attribut. Se med om dessa i boken. Attribut motsvarar "egenskaper" hos datatyper och variabler.
Pekare: Används ofta till att skapa datastrukturer som länkade listor, träd m.m. Man måste se till att man inte får minnesläckor (på tentorna kan det vara så att vi inte bryr oss om minnesläckor i vissa uppgifter, kolla dock med examinator om du är tveksam).
Rekursion: Underprogram som anropar sig själva för att lösa problemet. Tänk på att det måste finnas ett slutvillkor som gör att det tar slut någon gång.
Matematiska saker: Ofta används datorer till att beräkna saker. Detta skall man ju givetvis kunna klara av som programmerare. Till er hjälp finns det matematiska bibliotek. T.ex. finns det paket med matematiska funktioner:
```
    Ada.Numerics.Elementary_Functions  (paket)
    
```
Serieutvecklingar m.m. är ju inga konstiga saker. Det har ni hållit på med sen tidigare och det är ofta enkelt att överföra t.ex. en serie till en upprepning. Rekursion är ibland trevligt att använda här.
Slump eller sannolikheter: I Ada finns flera olika paket för att hantera "slumptal". Man kan tänka sig "slumptal" som är diskreta (t.ex. heltal, tecken, veckodagar m.m.) eller analoga (t.ex. flyttal). De två paket ni har att tillgå för detta är:
```
    Ada.Numerics.Discrete_Random  (generiskt paket)
    Ada.Numerics.Float_Random     (paket)
    
```
Problemlösning: Detta krävs det övning för att få in tekniken. Generellt kan man dock säga att det är "bra" att dela upp problem och skjuta saker framför sig och att tänka på hur man skall lagra de data man har all "leka" med i uppgiften. Det är alltid bra att rita figurer!
Problemområden eller teman: Oavsett vad problemet är skall du försöka se igenom problemställningen och försöka se vad det är för något man kan säga att man är ute efter. Det kan vara att lösningen har med fält, poster, filer, pekare, underprogram eller något annat av ovanstående att göra.
Det viktiga är inte vilket tema själva uppgiften har. Temat kan ju vara mekanik, ekonomi, biologi, matematik eller vad som helst och samma lösningsförfarande kan appliceras. Det kan t.ex. röra sig om att man skall skriva ut en tabell med tre kolumner av data oavsett vilket av ovanstående områden det gäller.

Sidansvarig: Torbjörn Jonsson
Senast uppdaterad: 2011-02-03

IDA - Institutionen för datavetenskap