Indicerade variabler
•
•
•
•
•
•
•
Declaration och användning av array
Array och for-loop
Slumptal
Arrayer i två dimensioner
sizeof
bool i c99
Sortering
int a[3];
a[0]=2;
a[1]=7;
a[2]=9;
printf("Test: %d, %d, %d",a[0],a[1],a[2]);
Resultat:
Test: 2, 7, 9
a[0]
a
2
a[1]
7
a[2]
9
#include <stdio.h>
#define LANGD 5
int main(void)
{
int a[LANGD];
Pa plats: 0 har vi 1
int i;
Pa plats: 1 har vi 2
for(i=0;i<LANGD;i++)
Pa plats: 2 har vi 3
{
Pa plats: 3 har vi 4
a[i]=i+1;
Pa plats: 4 har vi 5
}
for(i=0;i<LANGD;i++)
{
printf("Pa plats: %d har vi %d\n",i,a[i]);
}
return 0;
}
#include <stdio.h>
#define LANGD 5
int main(void)
{
int a[LANGD];
int i;
for(i=0;i<LANGD;i++)
{
scanf("%d",&a[i]);
}
int sum=0;
for(i=0;i<LANGD;i++)
{
sum = sum+a[i];
}
printf("Summan blir: %d \n",sum);
return 0;
}
• En dator kan inte generera slumptal då den är helt deterministisk, däremot kan den
generera pseudo-slumptal som kan fås att upplevas som slumptal:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(void)
{
srand(time(NULL)); //Anropas EN gång för att sätta frö
int tarning1 = rand()%6+1; //blir slumptal 1-6
int tarning2 = rand()%6+1;
printf("du fick %d och %d",tarning1, tarning2);
return 0;
}
• rand() beräknar nästa slumptal i serien. Resultatet blir mellan 0 och RAND_MAX
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
Antal 2: 318. Andel: 3.18%
Antal 3: 505. Andel: 5.05%
Antal 4: 854. Andel: 8.54%
Antal 5: 1129. Andel: 11.29%
Antal 6: 1395. Andel: 13.95%
Antal 7: 1704. Andel: 17.04%
Antal 8: 1365. Andel: 13.65%
Antal 9: 1112. Andel: 11.12%
Antal 10: 823. Andel: 8.23%
Antal 11: 516. Andel: 5.16%
Antal 12: 279. Andel: 2.79%
int main(void)
{
int s[13],kast,k;
srand(time(0));
for(k=2;k<=12;k++)
s[k]=0;
for(k=1;k<=10000;k++)
{
kast=rand()%6+rand()%6+2;
s[kast]++;
}
for(k=2;k<=12;k++)
printf("Antal %2d: %d. Andel: %.2f%%\n",k,s[k],100*s[k]/10000.);
return 0;
}
1, 2, 3, 4
int rad=3,kolumn=4;
5, 6, 7, 8
int a[rad][kolumn];
9,10,11,12
int i,j;
int plats=1;
for(i=0;i<rad;i++)
{
for(j=0;j<kolumn;j++)
{
a[i][j]=plats;
plats++;
}
}
Observera att det går att ha arrayer med ännu fler dimensioner!
• sizeof-operatorn svarar på hur många bytes (1 byte är 8 bitar,
en bit är 1 eller 0) en typ eller variabel är
sizeof(char); //ger alltid 1
sizeof(int);//kan variera på 32-bitars dator oftast 4
int j;
sizeof(j);//går också bra
• Vad ska man ha detta till? Tex:
int i,a[5];
for(i=0;i<sizeof(a)/sizeof(a[0]);i++)
a[i]=1;
• C saknaren speciell typ för att representera sant och falskt (de flesta språk har det) och
använder istället 1 och 0. I C99 har man lagt till en header som delvis fixar detta. Boken
använder detta så därför går vi igenom det nu:
#include <stdio.h>
#include <stdbool.h>
int main(void)
{
bool flag;
flag = true;//eller false
if(flag)
{
printf("Sant!");
}
return 0;
}
• flag är egentligen en int men kan bara anta värdet 0 och 1. flag=5 ger flag värdet 1
Även om datorer idag används till väldigt mycket olika saker är
fortfarande två av de viktigaste funktionerna att lagra data
och att tillhandahålla valda delar av dessa data.
Mycket forskning har gjorts i hur detta skall göras på
bästa/effektivast sätt.
Målet är att man så fort som möjligt ska kunna få tag på valda
delar av lagrade data.
För att hitta rätt data behöver man söka igenom tillgänglig data.
Detta kan effektiviseras med bra sökalgoritmer och genom
sortering av data i förväg.
(Allra effektivast blir det om man använder nycklar och tabeller
för att organisera data – relations-databaser)
Vi ska börja med att titta på hur man kan sortera data. I
exemplet tittar vi på hur man sorterar heltal men metoden
fungerar lika bra på alla sorters data som kan ordnas i en
bestämd sekvens, t.ex decimaltal, bokstäver, ord.
Algoritmen vi ska titta på kallas bubbelsortering eftersom de
större talen tillåts bubbla upp (till höger).Ex:
12
8
14
9
2
Jämför talen två och två från vänster till höger. Om talet till vänster är
större byter man plats. Jämför tal 0 och 1:
12
8
14
Talet till vänster är större så vi byter plats!
9
2
8
12
14
9
2
Nu jämför vi tal 1 och 2:
8
12
14
9
2
Talet till vänster är mindre så ingen åtgärd. Nu jämför vi tal 2 och 3:
8
12
14
Talet till vänster är större så vi byter plats:
8
12
9
Nu jämför vi tal 3 och 4:
8
12
9
Talet till vänster är större så vi byter plats:
8
12
9
9
2
14
2
14
2
2
14
Vad har vi då åstadkommit?
Jo vi kan vara säkra på att det största talet befinner sig längst till
höger. Detta gäller oberoende hur det såg ut från början.
Övertyga gärna dig själv om detta!
Vad gör vi nu? Jo samma sak med fältet utom den sista platsen.
Jämför tal 0 och 1:
8
12
9
Ingen åtgärd. Nu jämför vi tal 1 och 2:
8
12
9
Talet till vänster är större så vi byter plats:
8
9
12
Nu jämför Vi tal 2 och 3:
2
14
2
14
2
14
8
9
12
Talet till vänster är större så vi byter plats:
2
14
8
9
2
12
14
Vi kan nu vara säkra på att det näst sista talet är det näst högsta. Nu
behöver vi bara upprepa algoritmen två gånger till för att vara säkra
på att alla tal kommer i nummerordning.
Steg 3: Jämför tal 0 och 1:
8
9
2
Ingen åtgärd. Nu jämför vi tal 1 och 2:
8
9
2
Talet till vänster är större så vi byter plats:
8
2
9
Steg 4: Jämför tal 0 och 1:
8
2
9
Talet till vänster är större så vi byter plats:
12
14
12
14
12
14
12
14
2
8
9
12
14
Vi kan nu vara säkra på att alla tal är i nummerordning!
Sortera fält f med antal element n:
För i från 0 till n – 2:
För varje varv bubblar
ett nytt tal upp.
För j från 0 till n – 2 – i:
Den inre loopen
Om f[j]>f[j+1] byt plats
bubblar upp ett tal.
Varför fungerar inte:
tal[j]=tal[j+1]
tal[j+1]=tal[j]
for(i=0;i<antal-1;i++)
{
for(j=0;j<antal-1-i;j++)
{
if(tal[j]>tal[j+1])
{
tmp=tal[j];
tal[j]=tal[j+1];
tal[j+1]=tmp;
}
}
}
int main()
{
int antal=10;
int tal[antal];
srand(1);
int i;
for(i=0;i<antal;i++)
{
tal[i]=rand()%20;
}
for(i=0;i<antal;i++) printf("%d,",x[i]);
printf("\n");
int j,tmp;
for(i=0;i<antal-1;i++)
{
for(j=0;j<antal-1-i;j++)
{
if(tal[j]>tal[j+1])
{
tmp=tal[j];
tal[j]=tal[j+1];
tal[j+1]=tmp;
}
}
}
for(i=0;i<antal;i++) printf("%d,",x[i]);
printf("\n");
}
• Skriv ett program som läser in 10 siffror från användaren till en array och som
sedan kontrollerar hur många åttor arrayen innehåller och skriver ut detta
• Skriv ett program som lagrar 2 slumptal i en array och sedan sorterar dessa
• Försök att förstå sorteringsalgoritmen och ändra sedan koden så att den
sorterar med störst först
• Läs 7.6 och Boolean Values in C99 sid 85 i 5.2
• Läs 8.1, observera att vi inte gått igenom initialisering alls men det ingår absolut
• Gör K8 P1, P2, P3
Börja med att sätta dig in i programmet!
Vad gör n%10? 234%10 ger 4
Vad gör n/=10? 234/=10 ger 23
• Läs 8.2 och 8.3 (8.3 har vi inte heller gått igenom!)
• Gör K8 P7
• Gör P9 om du hinner
E-excercises, P-programming projects
