Beräkna värdet tills summan överstinger n (C)

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define ANTAL 100
#define radStart 0
#define radEnd 10
#define kolumnStart 0
#define kolumnEnd 10
#define randMax 901

void printMenu();
void mrndgen(int lista[ANTAL]);
void sort(int lista[ANTAL]);
void med(int lista[ANTAL]);
void graph(int lista[ANTAL]);
void binarsok(int lista[ANTAL]);

int main()
{
    int failsafe = 0;
    int lista[ANTAL];
    char choice = 0;
    while(choice != 5)
    {
    printMenu(); // här skriver vi ut menyn i en while-loop tills villkoret inte längre är uppfyllt.
    scanf(" %c", &choice);
        switch(choice)
        {
        case '1': mrndgen(lista); failsafe = 1; break;
        case '2': if(failsafe == 1){sort(lista); failsafe = 2;} else printf("Du måste ha en talfoljd."); break;
        case '3': if(failsafe == 2) med(lista); else printf("Du maste ha en sorterad talfoljd."); break;
        case '4': if(failsafe == 2) binarsok(lista); else printf("Du maste ha en sorterad talfoljd."); break;
        default: printf("Ogiltigt val.");
        }

    }
return 0;
}
void printMenu() // skapar en meny
{
printf("\n/==========================================================================/\n");
printf("/=================================MENU=====================================/\n");
printf("/==========================================================================/\n");
printf("1. Alstra en talfoljd med en slumpgenerator och skriv ut talen pa skarmen.\n");
printf("2. Sortera talfoljden med bubbelsortering. Efter sorteringen skall talfoljden skrivas ut pa skarmen.\n");
printf("3. Medelvarde, median, maxvarde och minvarde skall beraknas och skrivas ut pa skarmen.\n");
printf("4. Med binarsokning skall man kunna soka efter ett valfritt tal. Om talet finns i talfoljden meddelas, pa skarmen,\n pa vilken plats i tabellen (rad och kolumn) talet finns. Annars meddelas att talet inte finns i talfoljden.\n");
printf("/==========================================================================/\n");
printf("/==========================================================================/\n");
printf("/==========================================================================/\n");
printf(">>: \n");
}
void graph(int lista[ANTAL]) // skapar en 10*10 kolumn där int y är värdena vi ska lagra.
{
    int kolumner;
    int rader;
    int x = 0;

    for(rader  = radStart;  rader < radEnd; rader++)
    {
        for (kolumner = kolumnStart; kolumner<kolumnEnd; kolumner++){
        printf("%d \t", lista[x]);
        x++; // x börjar på 0 och går mot 100 då dessa tillsammans kommer köras 100 gånger.
        }
    printf("\n");
    }
}
void mrndgen(int lista[ANTAL]) // skapar en slumpartad talföljd i en array.
{
    srand(time(NULL));
    int tal = 0;

    for(int i=0; i<ANTAL; i++)
    {
      tal = rand() % randMax;
      lista[i] = tal;
    }
    graph(lista);
}
void sort(int lista[ANTAL]) // sorterar den slumpartade talföljden
{
    int temp = 0;

    for(int i = 0; i < ANTAL-1; i++)
    {
        for(int j = 0; j < ANTAL-1-i; j++)
        {
            if(lista[j] > lista[j+1])
            {
                temp = lista[j];
                lista[j] = lista[j+1];
                lista[j+1] = temp;
            }
        }
    }
    printf("Sorted list: \n");
    graph(lista);
}
void med(int lista[ANTAL]) // Beräknar medelvärde, median,, min och max.
{
int sum = 0, max = 0, tal = 0, mini = 1000;
float medel = 0, median = 0, median2 = 0, median1 = 0;

    for(int i=0; i<ANTAL; i++)
    {
        sum = sum + lista[i];
        medel = sum/ANTAL;
        tal = lista[i];
        if(tal < mini)
        mini = tal;
        if(tal > max)
        max = tal;
    }
    median2 = lista[50];
    median1 = lista[49];
    median = (median2+median1)/2;
    printf("The average is: %.2f, max is: %d min is: %d median is %.2f", medel, max, mini, median);
}

void binarsok(int lista[ANTAL]){ // Binärsökning.
    int v=0, h=ANTAL, mitten, sok; // v = startvärdet i arrayen upp till 100. Mitten blir alltså 100+0/2 = 50. Nästa mitt om > 50 = 100+50/2 = 75 osvosv.
    printf("\nAnge soktal: ");
    scanf("%d",&sok);
    while((h-v) > 1)
    {
        mitten=(v+h)/2;
        if(sok>=lista[mitten]) // ifall t.ex 20 >= mitten så är v (dvs 0) mitten. Och den letar då mellan 0-50 som steg 2.
            v=mitten;
        else
            h=mitten; // här blir 100 mitten så då letar den mellan 50-100 som steg 2.
    }
    if(sok==lista[v])
        printf("Talet finns pa plats: %d\nRad: %d\nKolumn: %d\n",v+1, v/10+1, v%10+1); // Eftersom arrayen börjar på 0 och kolumnen på 1 så behöver man ta +1 för att få fram rätt.
    else
        printf("Talet finns inte i talfoljden\n");
}

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define ANTAL 100
#define radStart 0
#define radEnd 10
#define kolumnStart 0
#define kolumnEnd 10
#define randMax 901

void printMenu();
void mrndgen(int lista[ANTAL]);
void sort(int lista[ANTAL]);
void med(int lista[ANTAL]);
void graph(int lista[ANTAL]);
void binarsok(int lista[ANTAL]);

int main()
{
    int failsafe = 0;
    int lista[ANTAL];
    char choice = 0;
    while(choice != 5)
    {
    printMenu(); // här skriver vi ut menyn i en while-loop tills villkoret inte längre är uppfyllt.
    scanf(" %c", &choice);
        switch(choice)
        {
        case '1': mrndgen(lista); failsafe = 1; break;
        case '2': if(failsafe == 1){sort(lista); failsafe = 2;} else printf("Du måste ha en talfoljd."); break;
        case '3': if(failsafe == 2) med(lista); else printf("Du maste ha en sorterad talfoljd."); break;
        case '4': if(failsafe == 2) binarsok(lista); else printf("Du maste ha en sorterad talfoljd."); break;
        default: printf("Ogiltigt val.");
        }

    }
return 0;
}
void printMenu() // skapar en meny
{
printf("\n/==========================================================================/\n");
printf("/=================================MENU=====================================/\n");
printf("/==========================================================================/\n");
printf("1. Alstra en talfoljd med en slumpgenerator och skriv ut talen pa skarmen.\n");
printf("2. Sortera talfoljden med bubbelsortering. Efter sorteringen skall talfoljden skrivas ut pa skarmen.\n");
printf("3. Medelvarde, median, maxvarde och minvarde skall beraknas och skrivas ut pa skarmen.\n");
printf("4. Med binarsokning skall man kunna soka efter ett valfritt tal. Om talet finns i talfoljden meddelas, pa skarmen,\n pa vilken plats i tabellen (rad och kolumn) talet finns. Annars meddelas att talet inte finns i talfoljden.\n");
printf("/==========================================================================/\n");
printf("/==========================================================================/\n");
printf("/==========================================================================/\n");
printf(">>: \n");
}
void graph(int lista[ANTAL]) // skapar en 10*10 kolumn där int y är värdena vi ska lagra.
{
    int x = 0;
   for(int rader  = radStart;  rader < radEnd; rader++)
    {
        for (int kolumner = kolumnStart; kolumner<kolumnEnd; kolumner++){
        printf("%d \t", lista[x]);
        x++; // x börjar på 0 och går mot 100 då dessa tillsammans kommer köras 100 gånger.
        }
    printf("\n");
    }
}
void mrndgen(int lista[ANTAL]) // skapar en slumpartad talföljd i en array.
{
    srand(time(NULL));
    int tal = 0;

    for(int i=0; i<ANTAL; i++)
    {
      tal = rand() % randMax;
      lista[i] = tal;
    }
    printf("***********************\n");
    printf("***  Slumpad lista: ***\n");
    printf("***********************\n");
    graph(lista);
}
void sort(int lista[ANTAL]) // sorterar den slumpartade talföljden
{
    int temp = 0;

    for(int i = 0; i < ANTAL-1; i++)
    {
        for(int j = 0; j < ANTAL-1-i; j++)
        {
            if(lista[j] > lista[j+1])
            {
                temp = lista[j];
                lista[j] = lista[j+1];
                lista[j+1] = temp;
            }
        }
    }
    printf("***********************\n");
    printf("*** Sorterad lista: ***\n");
    printf("***********************\n");
    graph(lista);
}
void med(int lista[ANTAL]) // Beräknar medelvärde, median,, min och max.
{
int max = 0, tal = 0, mini = 1000;
float medel = 0, median = 0, median2 = 0, median1 = 0, sum = 0;

    for(int i=0; i<ANTAL; i++)
    {
        sum = sum + lista[i];
        tal = lista[i];
        if(tal < mini)
        mini = tal;
        if(tal > max)
        max = tal;
    }
    median2 = lista[ANTAL/2];
    median1 = lista[ANTAL/2-1];
    median = (median2+median1)/2;
    medel = sum/ANTAL;
    printf("*** The average is: %.2f, max is: %d min is: %d median is %.2f ***", medel, max, mini, median);
}

void binarsok(int lista[ANTAL]){ // Binärsökning.
    int v=0, h=ANTAL, mitten, sok; // v = startvärdet i arrayen upp till 100. Mitten blir alltså 100+0/2 = 50. Nästa mitt om > 50 = 100+50/2 = 75 osvosv.
    printf("\nAnge soktal: ");
    scanf("%d",&sok);
    while((h-v) > 1)
    {
        mitten=(v+h)/2;
        if(sok>=lista[mitten]) // ifall t.ex 20 >= mitten så är v (dvs 0) mitten. Och den letar då mellan 0-50 som steg 2.
            v=mitten;
        else
            h=mitten; // här blir 100 mitten så då letar den mellan 50-100 som steg 2.
    }
    if(sok==lista[v])
        printf("Talet finns pa plats: %d\nRad: %d\nKolumn: %d\n",v+1, v/10+1, v%10+1); // Eftersom arrayen börjar på 0 och kolumnen på 1 så behöver man ta +1 för att få fram rätt.
    else
        printf("Talet finns inte i talfoljden\n");
}

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define ANTAL 100
#define radStart 0
#define radEnd 10
#define kolumnStart 0
#define kolumnEnd 10
#define randMax 901

void printMenu();
void mrndgen(int *lista);
void sort(int *lista);
void med(int *lista);
void graph(int *lista);
void binarsok(int *lista);

int main()
{
    int failsafe = 0;
    int lista[ANTAL];
    char choice = 0;
    while(choice != 5)
    {
    printMenu(); // här skriver vi ut menyn i en while-loop tills villkoret inte längre är uppfyllt.
    scanf(" %c", &choice);
        switch(choice)
        {
        case '1': mrndgen(lista); failsafe = 1; break;
        case '2': if(failsafe == 1){sort(lista); failsafe = 2;} else printf("Du måste ha en talfoljd."); break;
        case '3': if(failsafe == 2) med(lista); else printf("Du maste ha en sorterad talfoljd."); break;
        case '4': if(failsafe == 2) binarsok(lista); else printf("Du maste ha en sorterad talfoljd."); break;
        default: printf("Ogiltigt val.");
        }

    }
return 0;
}
void printMenu() // skapar en meny
{
printf("\n/==========================================================================/\n");
printf("/=================================MENU=====================================/\n");
printf("/==========================================================================/\n");
printf("1. Alstra en talfoljd med en slumpgenerator och skriv ut talen pa skarmen.\n");
printf("2. Sortera talfoljden med bubbelsortering. Efter sorteringen skall talfoljden skrivas ut pa skarmen.\n");
printf("3. Medelvarde, median, maxvarde och minvarde skall beraknas och skrivas ut pa skarmen.\n");
printf("4. Med binarsokning skall man kunna soka efter ett valfritt tal. Om talet finns i talfoljden meddelas, pa skarmen,\n pa vilken plats i tabellen (rad och kolumn) talet finns. Annars meddelas att talet inte finns i talfoljden.\n");
printf("/==========================================================================/\n");
printf("/==========================================================================/\n");
printf("/==========================================================================/\n");
printf(">>: \n");
}
void graph(int *lista) // skapar en 10*10 kolumn där int y är värdena vi ska lagra.
{
    int x = 0;
    for(int rader  = radStart;  rader < radEnd; rader++)
    {
        for (int kolumner = kolumnStart; kolumner<kolumnEnd; kolumner++){
        printf("%d \t", lista[x]);
        x++; // x börjar på 0 och går mot 100 då dessa tillsammans kommer köras 100 gånger.
        }
    printf("\n");
    }
}
void mrndgen(int *lista) // skapar en slumpartad talföljd i en array.
{
    srand(time(NULL));

    for(int i=0; i<ANTAL; i++)
    {
     int tal = rand() % randMax;
      lista[i] = tal;
    }
    printf("***********************\n");
    printf("***  Slumpad lista: ***\n");
    printf("***********************\n");
    graph(lista);
}
void sort(int *lista) // sorterar den slumpartade talföljden
{
    for(int i = 0; i < ANTAL-1; i++)
    {
        for(int j = 0; j < ANTAL-1-i; j++)
        {
            if(lista[j] > lista[j+1])
            {
               int temp = lista[j];
                lista[j] = lista[j+1];
                lista[j+1] = temp;
            }
        }
    }
    printf("***********************\n");
    printf("*** Sorterad lista: ***\n");
    printf("***********************\n");
    graph(lista);
}
void med(int *lista) // Beräknar medelvärde, median,, min och max.
{
int max = 0, mini = 1000;
float sum = 0;

    for(int i=0; i<ANTAL; i++)
    {
        sum = sum + lista[i];
        int tal = lista[i];
        if(tal < mini)
        mini = tal;
        if(tal > max)
        max = tal;
    }
    float median2 = lista[ANTAL/2];
    float median1 = lista[ANTAL/2-1];
    float median = (median2+median1)/2;
    float medel = sum/ANTAL;
    printf("*** The average is: %.2f, max is: %d min is: %d median is %.2f ***", medel, max, mini, median);
}

void binarsok(int *lista){ // Binärsökning.
    int v=0, h=ANTAL, mitten, sok; // v = startvärdet i arrayen upp till 100. Mitten blir alltså 100+0/2 = 50. Nästa mitt om > 50 = 100+50/2 = 75 osvosv.
    printf("\nAnge soktal: ");
    scanf("%d",&sok);
    while((h-v) > 1)
    {
        mitten=(v+h)/2;
        if(sok>=lista[mitten]){// ifall t.ex 20 >= mitten så är v (dvs 0) mitten. Och den letar då mellan 0-50 som steg 2.
            v=mitten;
        }else{
            h=mitten; // här blir 100 mitten så då letar den mellan 50-100 som steg 2.
    }
    }if(sok==lista[v]){
        printf("Talet finns pa plats: %d\nRad: %d\nKolumn: %d\n",v+1, v/10+1, v%10+1); // Eftersom arrayen börjar på 0 och kolumnen på 1 så behöver man ta +1 för att få fram rätt.
    }else{
        printf("Talet finns inte i talfoljden\n");
    }
}

int failsafe = 0;
    int lista[ANTAL];
    char choice = 0;
    while(choice != 5)
    {
    printMenu(); // här skriver vi ut menyn i en while-loop tills villkoret inte längre är uppfyllt.
    scanf(" %s", &choice);
        switch(choice)
        {
        case '1': mrndgen(lista); failsafe = 1; break;
        case '2': if(failsafe == 1){sort(lista); failsafe = 2;} else printf("Du måste ha en talfoljd."); break;
        case '3': if(failsafe == 2) med(lista); else printf("Du maste ha en sorterad talfoljd."); break;
        case '4': if(failsafe == 2) binarsok(lista); else printf("Du maste ha en sorterad talfoljd."); break;
        default: printf("Ogiltigt val.");
        }

#include "definitions.h"

/*char inputSingleChar(int length)
{
	char safeInput[100] = {'0'};
	scanf("%s", safeInput[0]);
	while(strlen(safeInput)>length)
	{
		printf("Too long input.");
		scanf("%s", safeInput[0]);
		if(strlen(safeInput==1))
			return safeInput[0];
	}
	return safeInput[0];
}*/

void qCarType(vehicle car[], int i) // Gör en valbar meny för typer av fordon.
{
	char input;
	printf("Which car type do you have?\n");
	printf("1: Petrol\n");
	printf("2: Diesel\n");
	printf("3: Hybrid\n");
	printf("4: Electric\n");
	scanf(" %c", &input);
	switch(input)
	{
		case '1': strcpy(car[i].type, "Petrol"); break;
		case '2': strcpy(car[i].type, "Diesel"); break;
		case '3': strcpy(car[i].type, "Hybrid"); break;
		case '4': strcpy(car[i].type, "Electric"); break;
		default: printf("Please input a number between 1-4");
	}
}

int countCars(vehicle car[]) // Räknar antalet fordon när vi startar programmet.
{
	int key = car[0].key, i = 0;

	while(key == 1 && i < REGISTER_SIZE)
	{
		key = car[i].key;
		if(key != 1){return i;}	
		i++;
		// printf("Key: %d i: %d\n", key, i); --> DEBUG

		if(i >= REGISTER_SIZE){printf("Register is full!\n"); return i; }

	}
}

int addVehicle(vehicle car[], int *count) // Lägger till Fordon.
{
	
	int i = 0;
	if(*count >= REGISTER_SIZE){printf("Register is full!\n"); return 0; }

	i = *count;

	printf("What is the car brand?\n>>:");				//Frågar efter värden för "vehicle"
	scanf("%s", car[i].brand);
	printf("What is the car type?\n>>");
	qCarType(car, i);
	printf("Selection: %s\n", car[i].type);

	printf("What is the registration number?\n>>");
	scanf("%s", car[i].reg);

	printf("What is your Firstname?\n>>:");				//Frågar efter värden för "user"
	scanf("%s", car[i].user.firstName);
	printf("What is your Surname?\n>>:");
	scanf("%s", car[i].user.lastName);
	printf("How old are you?\n>>:");
	scanf("%d", &car[i].user.Age);
												
	car[i].key = 1;
	*count = *count + 1;
	printf("Car successfully added to registry.\n");

	return 0;
}

int deleteVehicle(vehicle car[], int *count) // Tar bort fordon.
{
	int input;

	printf("Which user do you want to remove?: \n");
	scanf("%d", &input);
	input--;

	if(input > *count){printf("This vechicle does not exist.\n"); return 0;}
	// car[input-1].key = 0;
	for(input; input<*count; input++)
	{
		memcpy(&car[input], &car[input+1], sizeof(vehicle));
	}
	printf("Car #%d successfully deleted.", *count);
	*count = *count - 1; 
	// printf("COUNTER == %d\n", *count); --> DEBUG
	return 0;

}

int sortVehicle(vehicle car[], int *count) // Sorterar fordon efter märke.
{
	vehicle temp[REGISTER_SIZE];

	if (*count < 2)
	{
		printf("To few vehicles in the registry, you must have atleast 2.\n");
		return 0;
	}

	for(int i=0; i<*count-1; i++)
	{
		for(int j=0; j<*count-i; j++)
		{
			if((strcmp(car[j].brand,car[j+1].brand) >0) && (car[j+1].key == 1))
			{
				memcpy(&temp, &car[j], sizeof(vehicle));
            	memcpy(&car[j], &car[j+1], sizeof(vehicle));
            	memcpy(&car[j+1], &temp, sizeof(vehicle));
			}
		}
	}
	return 0;
}

int printVehicle(vehicle car[], int *count) // Skriver ut fordonet som användaren väljer.
{

	// printf("COUNTER == %d\n", *count); --> DEBUG

	int i;
	printf("Which vehicle do you want to see? \n>>:");
	scanf("%d", &i);
	if(i > *count){printf("This car does not exist. Try with another.\n"); return 0;}
	printf("vehicle number %d: \n", i);
	printf("A %s %s with reg: %s\n", car[i-1].brand, car[i-1].type, car[i-1].reg);
	printf("The owner is: %s %s, %d years old.\n", car[i-1].user.firstName, car[i-1].user.lastName, car[i-1].user.Age);
	return 0;
}

int printAllVehicle(vehicle car[], int *count) // Skriver ut alla fordon i registret.
{
	int i = 0;

	// printf("COUNTER == %d\n", *count); --> DEBUG

	if(*count == 0){printf("No cars in registry. Please add with menu option 1 first.\n"); return 0;}

	printf("user details: \n");
	for(i=0;i<REGISTER_SIZE;i++)
	{

		if(car[i].key == 1)
		{
			printf("vehicle number %d: \n", i+1);
			printf("--> A %s %s with reg: %s\n", car[i].brand, car[i].type, car[i].reg);
			printf("--> The owner is: %s %s, %d years old.\n", car[i].user.firstName, car[i].user.lastName, car[i].user.Age);
		}
	}

	return 0;
}

void printMenu() // Skriver ut menyn.
{
	printf("\n1.Add vehicle:\n");
	printf("2.Remove vehicle:\n");
	printf("3.Sort vehicle by brand:\n");
	printf("4.Print vehicle information:\n");
	printf("5.Print entire vehicle registry:\n");
	printf("6.Save and Quit. \n");
	printf(">>: \n");
}

int main() // Huvudprogram.
{	

	vehicle car[REGISTER_SIZE];

	int counter = 0; //DEKLARERING AV COUNTER

	readFile(car); // Här kallar vi på Readfile där vi läser in structen.

	counter = countCars(car); // Här räknar vi antalet fordon som fanns i structen.

	char choice[100] = {'0'};
	int i = 0;
	printf("** MENU ** \n");
	while(i == 0)
	{
		printMenu();
		scanf(" %s", &choice[0]);
		switch(choice[0])
		{
			case '1': addVehicle(car, &counter); break;
			case '2': deleteVehicle(car, &counter); break;
			case '3': sortVehicle(car, &counter); break;
			case '4': printVehicle(car, &counter); break;
			case '5': printAllVehicle(car, &counter); break;
			case '6': writeFile(car, &counter); break;
			default: printf("Faulty input, please try again!");
		}
	}
	return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#define REGISTER_SIZE 10
#define USER_NAME_LEN 50

typedef struct
{
	char firstName[USER_NAME_LEN];
	char lastName[USER_NAME_LEN];
	int Age;
}owner;

typedef struct
{
	owner user;
	char brand[USER_NAME_LEN];
	char type[USER_NAME_LEN];
	int key;
	char reg[6];
	

}vehicle;

int readFile();
int writeFile();

int countCars(vehicle car[]);

#include "definitions.h"

int readFile(vehicle car[])
{

	FILE *file;
	file = fopen("records.txt", "r"); // öppnar en read-only version av records.txt
	if (!file) // ifall filen inte kan öppnas
	{
    	printf("File could not be opened\n**Creating New File**\a\a");
    	file = fopen("records.txt", "w+");

    	for (int i = 0; i < REGISTER_SIZE; i++)
    	{
    		car[i].key = 0;
    	}

    	fwrite(car, sizeof(vehicle), REGISTER_SIZE, file);

  	}

  	fread(car, sizeof(vehicle), REGISTER_SIZE, file);

  	fclose(file);

  	return 0;

}

int writeFile(vehicle car[], int *count)
{

	FILE *file;
	file = fopen("records.txt", "w+"); // "a" innebär att man ska påbörja där man sist avslutade i textfilen.
	if (!file) // ifall filen inte kan öppnas
	{
    	printf("File could not be opened\n\a\a");
    	return -1;
  	}

  	fwrite(car, sizeof(vehicle), *count, file); // ny testkod
  	printf("\nData is stored succesfully!\n"); // ny testkod

	
	fclose(file);
	exit(0);

}