Programmeringsmetodik: Övningar

Det här är ett antal övningsuppgifter till kursen Programmeringsmetodik. Det finns också övningsuppgifter i läroboken.

Uppgifterna som är markerade med en och två stjärnor görs i mån av tid. Men försök hinna med dem!

Snabblänkar: Datorövning 1 2 3 4 5 6

Datorövning 1

Datorövning 1 handlar främst om modularisering och abstraktion, bland annat med hjälp av separatkompilering.

Man kan göra datorövning 1 på det första övningstillfället, men räkna med att det kan krävas både förberedelsetid och ytterligare hemarbete om man ska hinna göra uppgifterna.

[Lösningsförslag till datorövning 1]

Datorövning 1 A

Kör igång Microsoft Visual Studio, och skapa ett tomt C++-projekt av typen Win 32 Console Application, med namnet Strangtest.

Ja, det skulle kunna heta Strängtest, men erfarenheten lär oss att även om det ska funka med ÅÄÖ i olika namn på datorer, så är det tyvärr inte alltid det verkligen gör det. Plötsligt får man något konstigt fel som efter flera timmars letande visar sig bero på att man hade ett svenskt tecken i ett filnamn. Så det kan vara en god idé att undvika svenska tecken, åtminstone i namn som slutanvändarna inte ser. (Och allra helst borde det kanske vara på engelska?) Samma sak gäller mellanslag.

På kursens hemsida (eller direkt här) finns en instruktion om hur man startar Visual Studio 2010. och sen skapar och provkör ett enkelt C-program. Om man arbetar på en egen dator är det inte förbjudet att använda till exempel GCC under Linux. Här förutsätter vi dock Visual Studio 2010.

När du skapar projektet, bläddra då och skapa en ny katalog M:\PCSA\Metod. Ditt projekt hamnar nu i katalogen M:\PCSA\Metod\Strangtest\. Ta fram Solution Explorer med View och addera den nya filen Strang.c till projektets Source Files. I denna fil ska du skriva funktionen strlangd, som tar en sträng som parameter och returnerar strängens aktuella längd. Använd inte den färdiga funktionen strlen! Spara filen och kompilera filen separat genom att i Solution Explorer markera filen Strang.c och med höger musknapp välja Compile. Addera sedan en ny fil Strangtest.c till Source Files och skriv där ett huvudprogram, som läser in en sträng på max 30 tecken och skriver ut strängens längd genom att anropa funktionen strlangd. Kompilera separat och tänk på att deklarationen (huvudet) för funktionen strlangd måste skrivas in före main. Länka ihop projektet med Project | Build och kör det med Debug | Start.

Datorövning 1 B

Döp om filerna från Strang.c och Strangtest.c till Strang.cpp och Strangtest.cpp. Då kommer de att kompileras som C++ i stället för C. Det fungerar nästan likadant som C, men med en modernare C-dialekt än Visual Studio egentligen klarar av. Verifiera att det fungerar. Är det något som behöver ändras i C-koden?

Datorövning 1 C

Välj File | Open Project och öppna projektet Strangtest. Utöka filen Strang.cpp med en ny funktion strkopia, som tar två strängar som parametrar och kopierar den andra strängen tecken för tecken till den första. Använd inte den färdiga funktionen strcpy! Kompilera filen separat. Komplettera huvudprogrammet med ett anrop av strkopia samt skriv ut den kopierade strängen. Istället för att skriva funktionernas deklarationer direkt i samma fil som huvudprogrammet, skriver du in dessa i en headerfil Strang.h, som du sedan inkluderar i huvudprogrammet. Filen skapar du genom att addera en headerfil till projektet. Länka och kör.

Datorövning 1 D

Skapa ett projekt Medlemstest som förutom huvudprogrammet Medlemstest.cpp, som läser in och skriver ut data för en medlem, innehåller den (ganska) abstrakta datatypen Medlem i filerna Medlem.cpp och Medlem.h, där headerfilen ska innehålla specifikationen:
#define MAX_NAMN 30
#define MAX_TELEFON 20

struct Medlem {
    int medlemsnummer;
    char namn[MAX_NAMN + 1];
    char telefon[MAX_TELEFON + 1];
};

typedef struct Medlem Medlem;

void las_medlem(Medlem *mp);
void skriv_medlem(Medlem *mp);
Koden i las_medlem bör kontrollera att medlemmens namn och telefonnummer verkligen får plats i fälten i posten. (Vad kan hända annars?)

Datorövning 1 E (*)

Vi vill kunna läsa och skriva textfiler med medlemmar. Komplettera därför datatypen Medlem med funktionerna las_medlem_fil och skriv_medlem_fil, med följande deklarationer:
int las_medlem_fil(FILE *tsin, Medlem *mp);
void skriv_medlem_fil(FILE *tsut, Medlem *mp);
las_medlem returnerar ett heltal för att man ska se om läsningen nått slutet på filen. Returvärdet 1 betyder att det gick bra att läsa en medlem från filen, och returvärdet 0 betyder att det inte gick.

Koden i las_medlem_fil ska kontrollera att medlemmens namn och telefonnummer verkligen får plats i fälten i posten.

En medlem ska lagras som tre rader i filen, med medlemsnummer, namn och telefonnummer:

3
Viola-Christina Henriksson
0159-135914
Filen 10-medlemmar.txt innehåller data om 10 medlemmar. Ändra huvudprogrammet Medlemstest.cpp så att det läser från den filen, mellanlagrar alla medlemmarna i en array, och till sist skriver en ny fil med alla medlemmar utom de som bor i riktnummerområde 0158.

(Tips: Man kan använda funktionen strncmp för att jämföra med början av en sträng.)

Datorövning 1 F (**)

Ändra programmet i projektet Medlemstest så att man kan välja vilken fil det läser från. Provkör med några olika filer. Rita en enkel graf över hur körtiden beror på antalet medlemmar i indatafilen.

Programmet skapa-medlemsfil.cpp kan användas för att skapa filer med olika antal medlemmar.

[Lösningsförslag till datorövning 1]


Inlämningsuppgift 1

Övningsuppgifterna till datorövning 1 handlar mycket om modularisering och abstraktion. Även inlämningsuppgift 1 handlar om modularisering och abstraktion, och det är lämpligt att göra den efter uppgifterna i övning 1.


Datorövning 2

Datorövning 2 handlar om pekare, och om listor och andra sätt att lagra flera likadana data.

Man kan göra datorövning 2 på det andra övningstillfället (tredje kursveckan), men räkna med att det kan krävas både förberedelsetid och ytterligare hemarbete om man ska hinna göra uppgifterna.

Under den tredje veckan av kursen bör man också försöka hinna med inlämningsuppgift 1.

[Lösningsförslag till datorövning 2]

Datorövning 2 A

Skriv ett program som läser in ett heltal i en variabel, placerar adressen till detta heltal i en pekarvariabel, och till sist skriver ut heltalet med hjälp av den pekarvariabeln.

Datorövning 2 B

Skriv funktionen medel_och_spridning, som beräknar både medelvärdet och spridningen (största - minsta) för en vektor av flyttal, och som anropas från ett huvudprogram enligt:
#include <stdio.h>

int main()
{
    double medel;
    double spridning;
    double talarray[] = {2.3, 1.2, 3.4, 5.6, 4.5};

    medel_och_spridning(talarray, 5, &medel, &spridning);
    printf("Medel = %.2f\n", medel);
    printf("Spridning = %.2f\n", spridning);
    return 0;
}

Datorövning 2 C

Skriv ett program som dynamiskt allokerar minne för ett flyttal, läser in ett värde till detta tal, och till sist skriver ut talet multiplicerat med 3.

Datorövning 2 D

Skriv ett program som dynamiskt allokerar minne för två strängar på maximalt 30 tecken vardera, läser in ditt förnamn till den första och ditt efternamn till den andra. Byt sedan pekare, så att den första pekaren kommer att peka på efternamnet och den andra på förnamnet. Testa genom att skriva ut. Använd en temporär pekare, så att du inte tappar bort något namn.

Datorövning 2 E

Skriv ett program som dynamiskt skapar mätposter av typen:
struct Measure {
    int nr;
    double x;
    struct Measure *next;
};
och som läser in mätvärdesnummer (nr) och mätvärde (x) till dessa, samt länkar ihop dessa till en länkad lista med hjälp av next-pekarna. Inläsningen ska upprepas så länge det inlästa nr-värdet inte är 0. Då inläsningen avslutats, ska alla x-värdena skrivas ut, följt av deras medelvärde.

Städa upp den länkade listan innan programmet avslutas, genom att gå igenom listan och avallokera (med free) varje malloc-allokerad post.

Datorövning 2 F (*)

Gör om programmet från E-uppgiften ovan så att det istället för att läsa in värden från tangentbordet läser från textfilen xindata.txt, som du själv skrivit rader med nr- och x-värden i. Programmet ska sedan fortsätta med att fråga efter ett nr-värde och med en sökfunktion söka efter motsvarande x i listan. Låt sökfunktionen ha nummer och lista som parameter och returnera mätvärdet x. Skriv ut mätvärdet.

Datorövning 2 G (*)

Gör ett program som kan generera en stor xindata.txt, för att provköra programmet i F-uppgiften.

Datorövning 2 H (**)

Gör om programmet från F-uppgiften ovan så att det istället för en länkad lista lagrar mätposterna i en array, som växer dynamiskt med hjälp av realloc.

Datorövning 2 I (***)

Ett anrop till realloc kan ibland vara ganska dyrt, dvs ta lång tid, i förhållande till andra operationer i primärminnet. Gör om programmet från H-uppgiften ovan så att den dynamiskt växande arrayen inte växer med bara ett tal i taget, utan i större steg.

Hur bör man provköra för att se om det blir någon skillnad i hastighet?

Blir det någon skillnad i hastighet? Om det inte blev det - vad skulle det kunna bero på?

[Lösningsförslag till datorövning 2]


Datorövning 3

Datorövning 3 handlar om C++ och generella datastrukturer, särskilt den generiska listan std::list från C++:s standardbibliotek.

Man kan göra datorövning 3 på det tredje övningstillfället (fjärde kursveckan), men räkna med att det kan krävas både förberedelsetid och ytterligare hemarbete om man ska hinna göra uppgifterna.

Under den fjärde veckan av kursen bör man också försöka hinna med inlämningsuppgift 2. Det är en teoriuppgift som inte behöver lösas vid datorn.

[Lösningsförslag till datorövning 3]

Datorövning 3 A

Gör om den abstrakta datatypen Medlem från övning 1 D till en C++-klass.

Det ska fortfarande finnas en deklarationsfil Medlem.h och en definitionsfil Medlem.cpp, men nu ska det vara en class i stället för en struct, med medlemsnummer, namn och telefon som privata medlemsvariabler, och funktionerna las_medlem och skriv_medlem som publika medlemsfunktioner.

(En riktig C++-programmerare skulle fnysa åt våra char-arrayer, vår användning av stdio-paketet, med mera, och föreslå att vi ändrade till mer C++-mässiga lösningar, som klassen std::string. Men i den här övningen behöver vi bara ändra så mycket som behövs för att göra en klass.)

Ändra huvudprogrammet Medlemstest.cpp så att det fungerar som förut, men med den nya medlemstypen.

(Om du gjort övning 1 E eller övning 1 F, där programmet läser från en fil, kan du utgå från det programmet i stället.)

Datorövning 3 B

Skriv ett C++-program som använder sig av den färdiga generella list-typen std::list från C++:s standardbibliotek. Programmet ska skapa tre olika listor: en lista av heltal (int), en lista av flyttal (double), och en lista av medlemmar (Medlem från uppgiften ovan). Använd sen funktionerna push_front och push_back för att stoppa in några element i var och en av de tre listorna.

(Tips: För att stoppa in heltal och flyttal i listorna kan man skicka med värden direkt till push_front och push_back, som i push_front(17.7). Med medlemmar behöver du först göra en variabel av typen Medlem och läsa in data till den med las-funktionen, och därefter kan du stoppa in den i listan.)

Skriv sen ut längden på listorna (fås med funktionen size). Använd lämpliga kombinationer av funktionerna pop_front, pop_back och clear för att tömma de tre listorna på element. Skriv sen ut längden på listorna igen, för att kontrollera att de verkligen är tomma.

Prova också vad som händer om man försöker ta bort för många element ur en lista!

Det finns en del inbyggd hjälp i Visual Studio, till exempel med IntelliSense, men man kan också använda den här referenssidan: http://www.cplusplus.com/reference/stl/list/.

Datorövning 3 C (*)

Även vanliga C-structar kan lagras i en std::list. Det behöver inte vara C++-klasser, så bara för att använda std::list är det inte nödvändigt att göra om sina vanliga C-structar till C++-klasser.

Gör ett C++-program som lagrar vanliga C-structar i en std::list.

Datorövning 3 D

Iteratorer är ett sätt att gå igenom en lista eller array.

Skapa en lista av typen std::list, lägg in lite data, och skriv ut dem genom att gå igenom listan med en iterator. Använd std::list:s egen iteratortyp.

Datorövning 3 E

Skriv ett C++-program som läser in heltal, och lagrar dem i en std::list, ända tills man ger ett negativt tal.

Sen ska programmet fråga efter ett ytterligare ett tal, och tala om hur många gånger det förekommer i listan. Använd en iterator när du går igenom listan och letar efter förekomster.

Datorövning 3 F (*)

Skriv ett C++-program som läser in två sekvenser av heltal, som vi kan kalla allihop och förbjudna. Därefter ska vi först ta bort de förbjudna talen från listan allihop, sen sortera listan allihop i stigande ordning, och till sist skriva ut resultatet.

Exempel: Om allihop är 1, 7, 9, 3, 9, 3, 2, 8 och förbjudna är 3, 1, 1, 1, så ska resultatet bli 2, 7, 8, 9, 9.

Tips: Det finns flera färdiga funktioner i std::list som kan underlätta!

Kom ihåg att det finns en del inbyggd hjälp i Visual Studio, till exempel med IntelliSense, men man kan också använda den här referenssidan: http://www.cplusplus.com/reference/stl/list/.

Datorövning 3 G (*)

När man arbetar i C kan man inte använda C++-listan std::list. Gör tillämpliga övningar ovan (3 C, 3 D, 3 E och 3 F) i C, med hjälp av en generisk listtyp i C.

Det finns några olika att välja på i föreläsningsanteckningarna, och här är en till av void*-varianten, generic_list, och en av typedef-varianten, twolist.

Du kan också göra en egen (se uppgiften nedan).

Datorövning 3 H (**)

Gör en egen generisk listtyp i C, och använd den i uppgift 3 G ovan. Det är bra om den är bättre än lärarens olika förslag.

Datorövning 3 I (**)

Gör ett eget list-template i C++, och använd det i uppgift 3 G ovan. Det är bra om det är bättre än lärarens förslag.

[Lösningsförslag till datorövning 3]


Inlämningsuppgift 2

Inlämningsuppgift 2 är en teoriuppgift om komplexitetsteori. Man kan göra den när man vill, även innan man gjort uppgifterna i övning 3.


Datorövning 4

Stackar och köer.

Datorövning 4 A

Skriv ett program som läser in ett antal reella tal från tangentbordet (avsluta med 0) och lägger dem på en stack. Därefter ska programmet hämta talen från stacken och skriva ut dem, så att talen kommer i omvänd ordning.

Använd modulen StackOfDoubles från föreläsning 7 (filer: StackOfDoubles.h, StackOfDoubles.cpp) för att hantera stacken.

Datorövning 4 B

Skriv ett program som läser in ett antal reella tal från tangentbordet (avsluta med 0) och placerar dem i en kö, samtidigt som medelvärdet beräknas. Därefter ska programmet hämta talen från kön och skriva ut de av talen som avviker med mer än 10% från medelvärdet, så att talen kommer i samma ordning som de matades in.

Använd std::queue för att hantera kön.

Det finns en del inbyggd hjälp i Visual Studio, till exempel med IntelliSense, men man kan också använda den här referenssidan: http://www.cplusplus.com/reference/stl/queue/.

Datorövning 4 C (*)

Vi ska öppna en ny McDonald's-restaurang, och vi vill veta om det räcker med fyra kassor, eller om köerna kommer att bli för långa. Vi vet att det i genomsnitt anländer en person var 25:e sekund, och att det tar i genomsnitt 100 sekunder att betjäna en kund, så det borde räcka precis med fyra kassor, men vi vill prova det med en simulering.

Det anländer i genomsnitt en person var 25:e sekund, och det tar i genomsnitt 100 sekunder att betjäna en kund.

Kunderna numreras efter den ordning de anländer, och varje kund representeras av detta heltal. Simulera köerna med fyra stycken std::queue. Varje sekund händer följande:

Simulera en timme, och skriv ut den längsta kölängd som förekommit under den timmen. Från början är alla köerna tomma.

[Lösningsförslag: mcdonalds.cpp]

Restaurangen har öppet 07-23 (16 timmar). Hur blir det om man simulerar hela dagen? Varierar det mellan olika körningar av programmet?

Datorövning 4 D (*)

Det finns miniräknare där man matar in tal och operationer "baklänges", med talen först och den operation som ska utföras sist. I stället för till exempel 2 + 3 skriver man 2 3 +. Det kallas postfixnotation eller omvänd polsk notation.

En RPN-miniräknare

Miniräknaren använder en stack. Principen är att om man matar in ett tal, så placeras det på stacken, och om det kommer en operation (som +) så hämtas två tal från stacken, operationen utförs på dessa, och resultatet läggs tillbaka på stacken. Läs mer här.

Skriv en postfix-kalkylator, med hjälp av en stack som lagras i en std::stack. Användaren matar in rader, som antingen kan innehålla ett reellt tal eller en operator (+, -, * eller /). Efter varje utförd operation ska programmet skriva ut det värde som nu ligger överst på stacken. Om man försöker utföra en operation när det inte finns minst två tal på stacken, ska man få ett varningsmeddelande, och operationen ska inte utföras.

Det finns en del inbyggd hjälp i Visual Studio, till exempel med IntelliSense, men man kan också använda den här referenssidan: http://www.cplusplus.com/reference/stl/stack/.

Datorövning 4 E (**)

En debugger brukar innehålla sätt att spåra exekveringen av ett program, så man kan se precis hur funktionerna anropar varandra. Ett alternativt sätt är att stoppa in anrop till funktioner i ett särskilt spårbibliotek.

Ta till exempel följande program:

void h() {

}

void g() {
    h();
}

void f() {
    g();
    h();
}

int main(void)
{
    f();
    g();

    return 0;
}

main startas, anropar f, som sen i sin tur anropar g, som anropar h, och så vidare. Om vi har ett spårbibliotek trace, kan vi inkludera filen trace.h, och lägga in anrop till enter och leave i alla funktioner:

#include "trace.h"

void h() {
    enter("h");
    leave();
}

void g() {
    enter("g");
    h();
    leave();
}

void f() {
    enter("f");
    g();
    h();
    leave();
}

int main(void)
{
    enter("main");
    f();
    g();

    leave();
    return 0;
} // main

Spårutskrifterna från en körning av programmet skulle kunna se ut så här:

Entering main
  Entering f
    Entering g
      Entering h
      Leaving h
    Leaving g
    Entering h
    Leaving h
  Leaving f
  Entering g
    Entering h
    Leaving h
  Leaving g
Leaving main

Implementera spårbiblioteket trace genom att skriva filerna trace.h och trace.h. Ledtråd: Det behövs en stack, så att leave vet vad det är för funktion som lämnas. Glöm inte att indentera spårutskrifterna, så man ser hur djupt anropen har nästlats.

[Lösningsförslag: trace.h, trace.cpp]


Inlämningsuppgift 3

Inlämningsuppgift 3 är en lite större programmeringsuppgift med listor. Räkna inte med att den går att hinna med på den bokade och handledda labbtiden.


Datorövning 5

Från Valmyndigheten (www.val.se) kan man ladda ner valresultatet 2010, bland annat en fil med alla handskrivna partibeteckningar (handskrivna.skv):

VALTYP;LAN;NAMN_LAN;KOM;NAMN_KOM;KRETS;NAMN_KRETS;DISTRIKT;NAMN_DISTRIKT;PARTIBETECKNING;ANTAL
K;03;Uppsala län;05;Håbo;00;Håbo kommun;0101;Håbo  1;Toppzi;1
K;03;Uppsala län;05;Håbo;00;Håbo kommun;0102;Håbo  2;HARRY POTTER;1
K;03;Uppsala län;05;Håbo;00;Håbo kommun;0102;Håbo  2;Piratpartiet;2
R;03;Uppsala län;05;Håbo;00;Håbo kommun;0102;Håbo  2;HARRY POTTER;1
(och så vidare)

På filen handskrivna.txt finns de handskrivna rösterna till riksdagsvalet, men lite enklare formaterat och utan informationen om vilken valkrets rösterna kommer från. (Följande är inte den riktiga filen, utan ett exempel för att visa dataformatet.)

1       HARRY POTTER
2       Stoppa E4 väst
1       Harry Potter
1       Harry Potter
1       All makt åt kungen
1       Fartguppsförbjudarpartiet
2       All makt åt kungen
1       ETT GOTT PARTI
Talet i början av raden anger hur många röster med den partibeteckningen som avgavs i den valkretsen.

Vi antar att för rösterna ska räknas till samma parti så måste namnen vara exakt likadana (dvs strcmp ska tycka att de är lika), så till exempel räknas HARRY POTTER och Harry Potter som två olika partier. Med dessa exempeldata har partiet All makt åt kungen fått 3 röster, och vinner alltså valet bland de handskrivna rösterna.

Datorövning 5 A

Skriv ett program som läser filen handskrivna.txt, och sedan talar om vilket parti som fått flest röster och hur många röster det fick.

Använd en länkad lista för att lagra partierna. Använd inte någon färdig listtyp som std::list eller liknande, utan bygg själv upp den länkade listan med hjälp av poster ("structar") och pekare. Men dela gärna upp programmet så att listan hanteras som en abstrakt datatyp, eller i alla fall med särskilda funktioner.

Tips: Läs filen rad för rad. För varje rad, sök i den länkade listan efter det partiet. Om partiet redan fanns i listan, lägg till det antal röster som stod på raden. Om det inte redan fanns i listan, stoppa in en ny post i listan, med den partibeteckningen och det antal röster som stod på raden. När filen är slut, gå igenom hela listan för att hitta det parti som har flest röster. Skriv ut det partiet.

[Lösningsförslag: val-lista.cpp]

Datorövning 5 B

Skriv ett program som läser in ett heltal n, och sedan skriver ut talen enligt nedan genom att anropa en rekursiv utskriftsfunktion, med n som parameter:
1
2
.....
n
Kör programmet i Debuggern och studera hur n varierar.

Datorövning 5 C

Fibonacci-funktionen f(n) för heltal definieras rekursivt enligt: Skriv ett program som innehåller en rekursiv funktion för beräkning av det n:te fibonaccitalet. Testa funktionen genom att läsa in ett tal och skriva ut motsvarande fibonaccital.

Datorövning 5 D (*)

Sammanställ valresultatet på samma sätt som i uppgift 5 A ovan, men använd nu ett binärt sökträd för att lagra partierna, i stället för en länkad lista.

Använd inte någon färdig trädtyp, utan bygg själv upp trädet med hjälp av poster ("structar") och pekare.

Datorövning 5 E (*)

Sammanställ valresultatet på samma sätt som i uppgift 5 A ovan, men använd nu en hashtabell för att lagra partierna, i stället för en länkad lista.

Använd inte någon färdig hashtabelltyp, utan bygg själv upp hashtabellen med hjälp av poster ("structar"), pekare och en array.

[Lösningsförslag: val-hashtabell.cpp]

Datorövning 5 F (**)

Leta på nätet efter en färdig generisk hashtabelltyp, eller en färdig generisk sökträdstyp, och använd den i ännu en version av programmet för att sammanställa valresultatet på samma sätt som i uppgift 5 A.

Datorövning 6

Datorövning 6 handlar om mer maskinnära programmering, bland annat med bitoperationer.

[Lösningsförslag till datorövning 6]

Datorövning 6 A

Skriv ett program som läser in ett heltal och med en funktion udda testar om heltalet är udda. Låt funktionen testa bit nummer 0 i heltalet med hjälp av någon lämplig bitoperator.

Datorövning 6 B

Skriv ett program som läser in ett tecken, skriver ut tecknets teckenkod i binär form på skärmen, och till sist räknar och skriver ut antalet satta bitar i koden. Skapa två funktioner utskrift och antal.

Datorövning 6 C (*)

När man sänder 7-bitarstecken brukar man använda den 8:e biten som en kontrollbit eller paritetsbit. Skriv ett program som läser in ett tecken, räknar antalet satta bitar i teckenkoden och sätter rätt paritetsbit om udda paritet ska gälla, dvs antalet satta bitar i det sända tecknet ska vara udda.

Datorövning 6 D (*)

Att multiplicera ett tal med 2 är detsamma som att skifta bitarna i talet ett steg till vänster. Skriv ett program som läser in ett tal och det antal gånger som talet ska multipliceras med 2, samt skriver ut resultatet. Använd en funktion som tar tal och antal som parametrar och returnerar resultatet.

Datorövning 6 E (**)

Antag att du i en byte vill hålla reda på dag (1 - 7) och månad (1 - 12). Skriv ett program som läser in dag och månad som heltal och skapar en motsvarande byte. Låt sedan programmet fortsätta med att från byten hämta dag och månad och skriva ut dessa. Använd funktioner för omvandlingarna.

Datorövning 6 F (**)

Använd ett bitfält på 1 byte för att hantera punkter i ett koordinatsystem. Använd de 4 minst signifikanta bitarna till punktens x-koordinat (0-15) och de resterande bitarna till y-koordinaten (0-15). Slumpa sedan två punkter samt beräkna avståndet mellan dem. Använd funktioner för att skapa en punkt samt beräkna avståndet mellan två punkter i koordinatsystemet.

[Lösningsförslag till datorövning 6]


Thomas Padron-McCarthy (thomas.padron-mccarthy@oru.se), 22 september 2011