crille/Datastrukturer_Algoritmer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Startpunkten

Browse Source
This commit is contained in:
Christian Ohlsson
2026-03-05 13:39:39 +01:00
commit c4d164d8c3
20 changed files with 3598 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
Simulering/lab1.cpp Normal file
View File

@@ -0,0 +1,144 @@
/* *********************************************************************** */
/* lab1.cpp 980910 */
/* Innehåller köhantering */
/* *********************************************************************** */
/* Daniel Westerberg */
/* Christian Ohlsson */
/* Anna-Maria Haglund */
/* Ingela Johansson */
/* Charlotta Lagerkvist */
/* *********************************************************************** */
#include "lab1.hpp"
/* *********************************************************************** */
/* constructorn */
/* Nollställer variabler */
/* INPUT: inget */
/* OUTPUT: inget */
/* *********************************************************************** */
queue::queue()
{
first = NULL;
last = NULL;
cur = NULL;
r = 0;
}
/* *********************************************************************** */
/* destructorn */
/* Tömmer listan */
/* INPUT: inget */
/* OUTPUT: inget */
/* *********************************************************************** */
queue::~queue()
{
cur = first;
while (cur)
{
first = cur;
cur = cur->next;
delete first;
}
first = NULL;
last = NULL;
cur = NULL;
r = 0;
}
/* *********************************************************************** */
/* enqueue() */
/* ställer en person med ett antal varor i kön */
/* INPUT: antal varor */
/* OUTPUT: bool */
/* *********************************************************************** */
bool queue::enqueue(int v)
{
if (cur = new kund)
{
cur->next=NULL;
cur->varor = v;
if (first == NULL)
first = cur;
else
last->next = cur;
last = cur;
return TRUE;
}
return FALSE;
}
/* *********************************************************************** */
/* dequeue() */
/* tar bort en person ur kön */
/* INPUT: inget */
/* OUTPUT: bool */
/* *********************************************************************** */
bool queue::dequeue()
{
if (cur = first)
{
if ((first = first->next) == NULL)
last=NULL;
delete cur;
return TRUE;
}
return FALSE;
}
/* *********************************************************************** */
/* warez() */
/* kollar hur lång varje kö är, tidsmässigt! */
/* INPUT: inget */
/* OUTPUT: tiden för varje kund baserad på antal varor */
/* *********************************************************************** */
int queue::warez()
{
int x=0;
cur = first;
while (cur)
{
x += cur->varor*R + B; // räknar ut tiden för varje kund + 'x'
cur = cur->next;
}
return x;
}
/* *********************************************************************** */
/* pay() */
/* betalningsfunktion, returnerar antalet varor kvar att betala */
/* INPUT: antal varor att läggas till */
/* OUTPUT: antal varor för första kunden i kön */
/* *********************************************************************** */
int queue::pay(int v)
{
if (first)
return (first->varor += v); // lägger till 'v' och returnerar
else
return 0;
}
/* *********************************************************************** */
/* queueSize() */
/* returnerar antalet kunder i kön */
/* INPUT: inget */
/* OUTPUT: Antal kunder i kön */
/* *********************************************************************** */
int queue::queueSize()
{
int x=0;
cur = first;
while (cur)
{
cur = cur->next;
x++;
}
return x;
}
/* *********************************************************************** */
/* isEmpty() */
/* kollar om en kö är tom */
/* INPUT: inget */
/* OUTPUT: TRUE om listan är tom */
/* *********************************************************************** */
bool queue::isEmpty() { return (first == NULL) ; }

57
Simulering/lab1.hpp Normal file
View File

@@ -0,0 +1,57 @@
/* *********************************************************************** */
/* lab1.hpp 980910 */
/* Headerfil för lab1 */
/* *********************************************************************** */
/* Daniel Westerberg */
/* Christian Ohlsson */
/* Anna-Maria Haglund */
/* Ingela Johansson */
/* Charlotta Lagerkvist */
/* *********************************************************************** */
#include <dos.h>
#include <conio.h>
#include <stdlib.h>
#include <iostream.h>
typedef int bool;
const bool TRUE=-1, FALSE=0;
const int K=6; //Konstant för antal kassor
const int R=8; //Konstant för antal sekunder per vara
const int B=20; //Konstant för betalning
const int T=100; //Konstant för hur mycket snabbare än real-time det går
const int MS=1000; //Konstant för antal ms på en sekund
const int SPM=60; //Antal sekunder per minut
const int STARTTID=9*SPM*SPM+SPM; //Gör att programmet startar 9.01
const int MOVEX=5; //Antal steg att flytta i X-led
const int CENT=100; //Ger 100% att starta med
const int FALL1=10; //Ger 10% chans
const int FALL2=40; //Ger 30% chans
const int FALL3=90; //Ger 50% chans
const int MAV=40; //Ger slumptal mellan 1 - 40
class queue
{
private:
typedef struct kund
{
struct kund *next;
int varor;
} kund;
kund *first;
kund *last;
kund *cur;
public:
char r;
queue();
~queue();
bool enqueue(int);
bool dequeue();
int warez();
int pay(int);
int queueSize();
bool isEmpty();
};

123
Simulering/main.cpp Normal file
View File

@@ -0,0 +1,123 @@
/* *********************************************************************** */
/* main.cpp 980910 */
/* Innehåller huvudprogram för köhantering */
/* *********************************************************************** */
/* Daniel Westerberg */
/* Christian Ohlsson */
/* Anna-Maria Haglund */
/* Ingela Johansson */
/* Charlotta Lagerkvist */
/* *********************************************************************** */
#include "lab1.hpp"
/* *********************************************************************** */
/* Klassarray */
/* *********************************************************************** */
class queue q[K];
/* *********************************************************************** */
/* funktionsprototyper som denna fil innehåller */
/* *********************************************************************** */
void betala(int);
void print(long);
void addkund(void);
/* *********************************************************************** */
/* main med huvud-loop och delay */
/* *********************************************************************** */
void main()
{
long clock=STARTTID;
int kund=0;
while(!kbhit())
{
print(clock++);
if (++kund == SPM)
{
addkund();
kund=0;
}
for(int x=0; x<K; x++)
betala(x);
delay(MS/T);
}
}
/* *********************************************************************** */
/* print() */
/* skriver ut allting på skärmen */
/* INPUT: klockan */
/* OUTPUT: Tiden på skärmen */
/* *********************************************************************** */
void print(long cl)
{
for(int x=0; x<K; x++)
{
gotoxy(2,x+MOVEX);
cout << "Kassa nr " << (x+1) << "; Varor: " << q[x].pay(0) << ' ';
gotoxy(23,x+MOVEX);
cout << ", Kunder: " << q[x].queueSize() << ' ';
}
gotoxy(1,1);
cout<<"Tid: "<<(cl/(SPM*SPM))<<':'<<((cl/SPM)%SPM)<<':'<<(cl%SPM)<<" ";
}
/* *********************************************************************** */
/* betala() */
/* beräknar tiden för varorna och tar bort varor och kunder */
/* INPUT: position i klassarray */
/* OUTPUT: inget */
/* *********************************************************************** */
void betala(int pos)
{
if(q[pos].isEmpty()==0)
if(q[pos].pay(0))
{
q[pos].r++;
if(q[pos].r==R)
if(q[pos].pay(-1)==0)
q[pos].r=B;
else
q[pos].r=0;
}
else
if(q[pos].r>0)
q[pos].r--;
else
q[pos].dequeue();
}
/* *********************************************************************** */
/* addkund() */
/* lägger till en kund med ett slumpmässigt antal varor i den minsta kön */
/* INPUT: inget */
/* OUTPUT: inget */
/* *********************************************************************** */
void addkund()
{
int in, x, min, pos=0;
unsigned int slumptal;
srand((unsigned) time(NULL));
slumptal = rand()%CENT;
if (slumptal < FALL1)
in=0;
else if (slumptal < FALL2)
in=1;
else if (slumptal < FALL3)
in=2;
else
in=3;
while(in)
{
min=q[0].warez();
for(x=1; x<K; x++)
if (min>q[x].warez())
{
min=q[x].warez();
pos=x;
}
q[pos].enqueue(rand()%MAV+1);
in--;
}
}