Úkol: Zpracování záznamu žáků ze souboru a jejich prospěchu – C / C++ – Fórum – Programujte.com

Ahoj,

Ve škole jsme dostali zadání, se kterým bych potřeboval pomoc. Ačkoliv nejsem žádný hlupák a na střední mám vyznamenání, programátorství nejspíše nebude odvětví pro mě. Znám nějaké ty základní funkce, cykly a podobně, ale s tímto si nejspíše sám neporadím. Rád bych tedy Vás, jako zkušené programátory, ke kterým mám respekt a obdiv, poprosil o pomoc. Pokud by se zde našel někdo, kdo by byl ochoten pro mne zadání vypracovat ve formě, kterou bych z většiny chápal (a s komentáři), svůj velký vděk bych mu mohl vyjádřit prostřednictvím paypalu.

Myslím, že již není co dál dodat, snad jen doufat, že mě někdo z téhle svízelné situace dostane... :)

Zadání:

Vždy v létě probíhá na univerzitě ve Stanfordu v Kalifornii ve Spojených státech týdenní
intenzivní kurz jazyka C++ [4]. Jedna z úloh, kterou účastníci kurzu řešili, je
obdobou tohoto příkladu (úprava zadání spočívá pouze v jiném systému hodnocení studentů

v ČR).

ZADÁNÍ ÚLOHY:
V textovém souboru jsou vedle jména studenta zapsány jeho známky z daného předmětu.
Jsou tam známky získané zkoušením během vyučování ale i známky ze samostatných projektů.
Běžné známky následují hned za jménem a jsou navzájem odděleny mezerou, známky
z projektů jsou uvedeny za oddělovačem '|' a jsou také navzájem odděleny mezerou:

Adamová Eva 1 2 3 4 5 | 3 2 1
Dvořák Jan 4 2 | 4 3
Horák Petr 3 3 4 4 3 2 3 5 | 4
Novák Milan 2 | 3 2 4
Pevný Antonín 3 5 1 3 | 2 3 1
Rada Karel 3 2 | 5
Syrová Marie 1 2 1 2 | 1 2 2
Tyl František |
Zelená Lucie 3 3 | 4 3 3

Počet běžných známek jednotlivých studentů se může lišit. Za hodnocené období má však
student povinnost odevzdat 3 samostatné projekty. Pokud student neodevzdá všechny projekty,
je hodnocen jako "neprospěl", pokud projekty odevzdal ale nemá alespoň tři běžné
známky, je hodnocen jako "neklasifikován".
Běžné známky mají při hodnocení váhu 1, známky za projekty mají váhu 2. Váhou známky se
rozumí celé číslo, které říká, jakou důležitost známka má (čím vyšší váha, tím důležitější
známka).
Vytvořte program, který vypíše jméno, příjmení a vážený průměr známek studenta resp.
slovo "neprospěl" nebo "neklasifikován". Vážený průměr známek např. Evy Adamové se vypočítá
následovně:
(1x1 + 1x2 + 1x3 + 1x4 + 1x5 + 2x3 + 2x2 + 2x1) : (1+1+1+1+1+2+2+2) = 27:11 = 2,45
Přičemž v první závorce jsou součiny vah a známek, v druhé je součet vah všech známek.

VÝSTUP PROGRAMU:

PŘÍJMENÍ JMÉNO HODNOCENÍ
======================================
Adamová Eva 2.45
Dvořák Jan neprospěl/a
Horák Petr neprospěl/a
Novák Milan neklasifikován/a
Pevný Antonín 2.40
Rada Karel neprospěl/a
Syrová Marie 1.60
Tyl František neprospěl/a
Zelená Lucie neklasifikován/a

Myslím, že tu něco podobného bylo před pár týdny. Zkus nejdřív přečíst řádek souboru. Při parsování máš tak trochu výhodu - známka je jednociferné číslo a má tedy jeden znak. V podstatě je to jméno - mezera - příjmení - mezera - známka - mezera - známka - .....atd. Znamená to načtený řádek procházet a vyhledávat oddělovače - mezery. Druhá možnost je číst po znacích ze souboru a současně testovat, zda je to oddělovač. V každém případě jméno a příjmení rovnou vypíšeš, známky budeš podle předepsaného vzorce násobit a sčítat (průběžně - každou přečtenou známku vynásobíš koeficientem a přičteš k součtu známek). Současně budeš do druhé proměnné tvořit součet koeficientů. Na začátku nastavíš koeficient na 1, až narazíš na | změníš koeficient na 2. Když narazíš na konec řádku, jsou přečteny všechny známky. Provedeš dělení součtu známek součtem koeficientů a vedle jména a příjmení vypíšeš výsledek. Tak postupuješ pro každý řádek v souboru až po konec souboru. Pokud u položek budeš kontrolovat, zda je číslo, můžeš se i vypořádat s více jmény např. Vladimír Vasiljevič Putin (pro udavače KGB: je to jméno fiktivní osoby).

hu

Děkuji za odpověď.
Myslel jsem, že by také bylo možné uložit známky před "|" do jednoho vectoru, zbytek pak do druhého. Problém je, že nevím, jak docílit právě oddělení v momentu, kdy přijde onen oddělovač. Také si nejsem jistý jak přistupovat k prvkům vectoru, potažmo, jak s nimi provádět operace.. to bych snad ale dokázal někde okoukat. Jak už jsem psal, programování není moje silná stránka a doma se k tomu jen zřídkakdy dostanu kvůli mým vlastním 3D projektům a editacím, ze kterých je i nějaký zisk. Proto jsem vděčný za každou pomoc.

#2 hlucheucho
Špatně jsi to četl, on nepotřebuje poradit jako to má udělat...

On jenom nesouhlasí s tím, že někdo určil, že součástí vzdělání na jeho škole je i znalost programování a zdá se mu morálně přijatelné vyřešit to tak, že si to nechá vyrobit od někoho, koho to naopak baví. Aby uspěl, musí se ovšem tvářit tak, že to udělal sám, takže o té cizí práci zřejmě bude muset něco říct, proto to musí být srozumitelně popsané v komentářích.

#4 JoDiK
Většinou jsem to právě já, kdo ostatním radí, proto když někdy potřebuju pomoc já, nikoho, jak už to tak bývá, ve třídě nenajdu. Proti výuce programování na naší škole nic nemám, je to jeden z mnoha odoborných přemětů. Bohužel ale také jediný, ve kterém si nejsem moc jistý. Z hlediska morálnosti by bylo nemorální, kdybych za službu nenabídl protislužbu.

Skládání známek do vektorů je sice taky možné, ale není nutné. Jinak s vektorem se dá pracovat jako s polem a k prvkům přistupovat pomocí indexů (operátor [ ]). Rozsah platných indexů je od 0 do velikost - 1. Velikost (= počet prvků ve vektoru) získáš po přečtení vlastnosti size. Druhá možnost je použití iterátoru. Doporučuji si přečíst dokumentaci (google najde). Že jsi načetl nějaký konkrétní znak zjistíš běžnou podmínkou - prostě porovnáš načtený znak s konstantou = požadovaným znakem. Podmínka pak bude vypadat takto:

Je načtený znak '|' ?
- ano: jedná se o oddělovač skupin známek, změním koeficient na 2
- ne: předpokládám načtení další známky (možná by se měla provést kontrola, zda je to číslo), provedu převod znak -> číslo, přičtu do součtu známek a přičtu koeficient do součtu koeficientů

V programovacích jazycích tomu odpovídá  if ... else. Pokud bych měl rozlišovat více znaků, použil bych switch.

Při programování je důležité sestavení algoritmu, znalost programovacího jazyka je až druhou složkou - syntaxe a jména funkcí se dá většinou najít dost rychle v dokumentaci. Při komplexnosti současných programovacích jazyků snad neexistuje nikdo, kdo by alespoň některý z nich znal v plné šíři. ,

hu

#4 JoDiK
Zkouším, jestli překoná tu psychickou bariéru.....

hu

Teď jste mi vnukl nápad, vyzkouším až příjdu domu. Co se týče toho vektoru, ve škole jsme data vždy načítali do vectoru nebo listu... a protože s vectorem se mi dělalo o něco líp, nejspíše nebudu měnit pravidlo.

podmínka by pak vypadala nějak takto (?)

string oddelovac = "|";

if(i==oddelovac){
    //zmena vectoru
}
else{
    //pokracovani v nacitani
    i++;
}

#8 Michael
jestli v i máš načtený znak, tak asi jo, to bys pak ale v pokračování načítání nedělal i++, takže asi ne.

Já bych spíš začal tak, že bych v načteném řetězci osahujícím celý řádek vyhledal ten oddělující znak | a podle pozice rozdělil načtený řetězec na dva a ty pak zpracovával samostatně - čímž se ti podstatně zjednoduší ten problém se dvěma vektory...

#9 JoDiK
Asi nějak takhle:

vstup=radek ze souboru
r=poziceznaku "|" ve vstupu
r1=kopie vstupu od pozice 1 po r-1
r2=kopie vstupu od pozice r+1 po delku vstupu

m=pozice mezery v r1
jmeno=kopie r1 od pozice 1 po m-1
r1=kopie r1 od m+1 po delku r1

m=pozice mezery v r1
prijmeni=kopie r1 od pozice 1 po m-1
r1=kopie r1 od m+1 po delku r1

znamky1[]=rozdeleny r1 podle mezer
znamky2[]=rozdeleny r2 podle mezer

zpracovani znamek...
a to furt dokola dokud je v souboru co cist...

#9 JoDiK
rozdělit na dva řetězce např. pomocí metody find by taky šlo. Tento přístup mne nenapadl.

hu

použít vektor na známky opravdu není nutný: 

suma_znamek = 0;
suma_koef = 0;
koef = 1;

//v cyklu provedu zpracovani prvni skupiny znameknačtu znamku;
suma_znamek = suma_znamek + koef * znamka;
suma_koef =  suma_koef + koef;

//po zpracovani prvni skupiny znamek
koef = 2;

//opakuji cyklus pro druhou skupinu znamek
načtu znamku;
suma_znamek = suma_znamek + koef * znamka;
suma_koef =  suma_koef + koef;

//po zpracovani druhe skupiny znamek je potřeba provest FLOAT deleni
prumer = suma_znamek / suma_koef;

"pseudokód", dostatečně naznačující řešení.

hu

Jména a známky můžeš načítat z řetězce taky pomocí find, oddělovačem je mezera. Ukázku jak na to najdeš třeba na http://www.cplusplus.com/reference/string/string/find/

Měj na paměti, že získáš podřetězce a ne čísla, takže "načtu známku" skrývá vyseknout podřetězec a konvertovat ho na číslo.

Ještě jsme tu neprobrali "neprospěl" a "neklasifikován". K tomu potřebuješ počitadla známek, pro každou skupinu známek jedno. Při načtení známky přičteš jedničku do příslušného počitadla. Pak stačí stav počitadla porovnat s předepsanou hodnotou a vypsat buď hlášku nebo průměr.

Edit: počitadla by mohla nahrazovat proměnnou suma_koef takto (násobení jedničkou je napsáno pro názornost):

prumer = suma_znamek / (počitadlo1 * 1 + počitadlo2 * 2)

hu

 Takhle by to mělo chodit. :D

Předem upozorňuji, nějaké posměváčky, že jsem začal před měsícem. Takže je skoro jisté, že tam budou nějaké hloupé věci. :D :D

#include <iostream>
#include <string>
#include <fstream>
#include <stdlib.h>


using namespace std;
int konec_jm;
int znamky=0;
int poc_zn=0;
int projekty=0;
int poc_pr=0;
int oddelovac;
int main()
{   cout<<"Hodnoceni Studentu:"<<endl;
    fstream vstup("/home/steve/Desktop/zaci.txt");
    string line;
    while(getline(vstup,line)){//nacte se  novy radek
    int pocet_mez=0;
    int delka=line.size();
    // Urci kde konci jmeno
    for(int i=0;i<delka;i++){

        if(line[i]==' '){pocet_mez++;}

        if(pocet_mez==2){ konec_jm=i-1;}
    }
    // Vytiskne jmeno
    cout<<line.substr(0,konec_jm);


    //nacitani znamek
    for(int i=konec_jm+1;i<delka;i++){

        if(line[i]==' '){continue;}

        if(line[i]=='|'){oddelovac=i;break;}
        else {znamky+=int(line[i])-48;
              poc_zn++;}

    }

    //nacitani projektu
    for(int i=oddelovac+1;i<delka;i++){

        if(line[i]==' '){continue;}

        else {projekty+=int(line[i])-48;
              poc_pr++;}
    }


    //rozhodnuti zda uspel/neuspel
    if(poc_pr<3){cout<<"  neprospel/a"<<endl;}
    else{
        if(poc_zn<3){cout<<"  neklasifikovan/a"<<endl;}
        else{
         double prumer=(znamky+projekty*2.0)/(poc_zn+poc_pr*2.0);
         cout<<"  "<<prumer<<endl;
        }
    }
poc_zn=0;
znamky=0;
projekty=0;
poc_pr=0;

    }


    return 0;
}

O něco modernější řešení než od kolegy hodiks.

Constants.h

#ifndef CONSTANTS_H_DEFINED
#define CONSTANTS_H_DEFINED

#define MIN_REQUIRED_REGULAR_MARKS 3
#define MIN_REQUIRED_PROJECT_MARKS 3

#define PROJECT_MARK_WEIGHT 2

#define NOT_QUALIFIED_STR "neprospel/a"
#define NOT_CLASSIFIED_STR "neklasifikovan/a"

#define INPUT_FILE "./student_marks.txt"
#define REGULAR_PROJECT_MARKS_DELIMITER '|'

#endif

Student.h

#ifndef STUDENT_H_DEFINED
#define STUDENT_H_DEFINED

#include "Constants.h";

#include <vector>
#include <string>

class Student
{
private:
	std::string firstName;
	std::string lastName;
	std::vector<int> regularMarks;
	std::vector<int> projectMarks;
public:
	Student(
		const std::string& firstName,
		const std::string& lastName,
		const std::vector<int>& regularMarks,
		const std::vector<int>& projectMarks
	) : firstName(firstName), lastName(lastName), regularMarks(regularMarks), projectMarks(projectMarks)
	{
		
	}

	std::string evaluate() const
	{
		auto fullName(firstName + " " + lastName + ": ");

		if (projectMarks.size() < MIN_REQUIRED_PROJECT_MARKS)
		{
			return std::string(fullName + NOT_QUALIFIED_STR);
		}

		if (regularMarks.size() < MIN_REQUIRED_REGULAR_MARKS)
		{
			return std::string(fullName + NOT_CLASSIFIED_STR);
		}

		auto count = 0;
		auto sum = 0;
		for (auto &i : regularMarks)
		{
			sum += i;
			++count;
		}

		for (auto &i : projectMarks)
		{
			sum += (PROJECT_MARK_WEIGHT * i);
			count += PROJECT_MARK_WEIGHT;
		}

		auto avg = static_cast<double>(sum) / count;
		return std::string(fullName + std::to_string(avg));
	}
};

#endif

main.cpp

#include "Constants.h"
#include "Student.h"

#include <vector>
#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include <cctype>
#include <algorithm>

inline std::vector<std::string> splitString(const std::string& s, char delimiter);
inline std::string trim(const std::string &s);

int main(int agrc, char* argv[])
{
	std::vector<Student> students;

	std::ifstream file(INPUT_FILE);
	std::string line;	
	while (std::getline(file, line))
	{
		auto leftRightParts = splitString(line, REGULAR_PROJECT_MARKS_DELIMITER);
		std::string left;
		std::string right;

		auto index = 0;
		for (auto& part : leftRightParts)
		{
			switch (index)
			{
			case 0:
				left = trim(part);
				break;
			case 1:
				right = trim(part);
				break;
			}

			++index;
		}

		std::string firstName;
		std::string lastName;
		std::vector<int> regularMarks;
		std::vector<int> projectMarks;

		auto wordsLeft = splitString(left, ' ');
		auto end = leftRightParts.end();
		auto wordsRight = splitString(right, ' ');

		index = 0;
		for (auto& word : wordsLeft)
		{
			switch (index)
			{
			case 0:
				firstName = word;
				break;
			case 1:
				lastName = word;
				break;
			default:
				regularMarks.push_back(std::stoi(word));
				break;
			}

			++index;
		}

		for (auto&word : wordsRight)
		{
			projectMarks.push_back(std::stoi(word));
		}

		students.push_back(Student(firstName, lastName, regularMarks, projectMarks));
	}

	for (auto& student : students)
	{
		std::cout << student.evaluate() << std::endl;
	}

	return 0;
}

inline std::vector<std::string> splitString(const std::string& stringToSplit, char delimiter)
{
	std::vector<std::string> parts;

	std::stringstream ss(stringToSplit);
	std::string tmp;
	while (std::getline(ss, tmp, delimiter))
	{
		parts.push_back(tmp);
	}

	return parts;
}

inline std::string trim(const std::string &s)
{
	auto wsfront = std::find_if_not(s.begin(), s.end(), [](int c){return std::isspace(c); });
	auto wsback = std::find_if_not(s.rbegin(), s.rend(), [](int c){return std::isspace(c); }).base();
	return (wsback <= wsfront ? std::string() : std::string(wsfront, wsback));
}

#15 ondrej39
A kde jsou komentáře?

:-)

#16 JoDiK
nejsou, ale i tak pan učitel pozná, že to opsal :)

hu

#16 JoDiK
K čemu komenáře? Zbytečné komentáře se přece dělat nemají :)

Dovolil jsem si tedy do vašeho projektu přidat komentáře své, snad odpovídají tomu, co jednotlivé řádky skutečně dělají. Jinak děkuju za pomoc. 

//IMPORT KNIHOVEN
#include <iostream>
#include <string>
#include <fstream>
#include <stdlib.h>

using namespace std;

int main(){

	//ZALOZENI PROMENNYCH
	int konec_jm;
	int znamky=0;
	int poc_zn=0;
	int projekty=0;
	int poc_pr=0;
	int oddelovac;
    int pocet_mez=0;

	//VYPIS NA KONZOLU
	cout<< "PROSPECH:"<< endl;
	cout << "==========================================" << endl;
	cout << "JMENO" << '\t' << '\t' << "  HODNOCENI" << endl;
	cout << "==========================================" << endl;

    fstream vstup("data.txt"); //urceni odkud se data budou do proudu cerpat
    string radek; //zalozeni promenne radek

    while(getline(vstup,radek)){ //nacitani jednotlivych radku
 
		int delka=radek.size(); //nastaveni promenne delka na hodnotu poctu znaku na radku

		// cyklus urcuje, kdy konci jmeno, pracuje dokud neni na konci radku
		for(int i=0;i<delka;i++){

			if(radek[i]==' '){ //pokud najde znak mezery, promenna pocet_mez
				pocet_mez++;   //se zvysi o 1
			}
			if(pocet_mez==2){ //pokud je pocet mezer roven dvema, konci jmeno
			konec_jm=i-1;	  //a zacinaji znamky
			}
		}
		cout << radek.substr(0,konec_jm) << '\t' ; //na konzolu se vypise jmeno a prijmeni

    	//dalsi cyklus nacita znamky
		for(int i=konec_jm+1;i<delka;i++){ //zacina tam, kde skoncil predchozi cyklus 
										   //(za koncem jmena)a pokracuje do konce radku

			if(radek[i]==' '){
				continue;     //pokud narazi na mezeru mezi znamkami, pokracuje
			} 

			if(radek[i]=='|'){
				oddelovac=i; //pokud ale narazi na oddelovac ("|"), nastavi promenne oddelovac
				break;		 //konecnou pozici a dale uz nepokracuje
			}
			else{
				znamky+=int(radek[i])-48;
				poc_zn++;
			}
		}

		//nasledujici cyklus nacita znamky z projektu

		for(int i=oddelovac+1;i<delka;i++){ //opet zacina tam, kde skoncil predchozi cyklus
											//tzn. za oddelovacem

			if(radek[i]==' '){
				continue;	//pokud narazi na mezeru mezi znamkami, pokracuje
			}

			else{
				projekty+=int(radek[i])-48;
				poc_pr++;}
		}

		//dale program rozhodne, zda zak uspel 
		if(poc_pr<3){
			cout<<"  neprospel/a"<<endl; //pokud ma zak mene nec 3 projekty, potom neprospel
		}
		else{
			if(poc_zn<3){ //pokud ma zak mene nez 3 bezne znamky, potom je neklasifikovan
				cout<<"  neklasifikovan/a"<<endl;
			}
			else{
				double prumer=(znamky+projekty*2.0)/(poc_zn+poc_pr*2.0); //pokud uspel v obojim,
				cout << "  " << prumer << endl;	//muze se vypocitat prumer a vypsat se
			}
		}
	//nastaveni promennych na deafultni hodnoty (0), pro pouziti v dalsim radku
	poc_zn=0;
	znamky=0;
	projekty=0;
	poc_pr=0;
	}

cout << "==========================================" << endl;
system("PAUSE");
}

potřeboval bych ale vysvětlit toto: 

			else{
				znamky+=int(radek[i])-48;
				poc_zn++;
			}

#19 Michael
prevadi ascii znak  '1' az '5'  na ciselnou podobu, jen to zamaskoval magickou konstantou 48... trosku citelnejsi by asi bylo:   radek[i] - '0' 

Udela to to same. Jen to chce aspon kontrolovat, jesli to opravdu je znak 1-5

Mohl bys přidat argumenty do funkce main a v ladícím programu zadat argument cesta/soubor.

 V praxi sotva budeš programovat tak, abys název souboru měl zkompilovaný přímo v programu. Spíš budeš chtít otevřít konkrétní soubor a třeba jiný soubor již zkompilovaným souborem. To je dost nepohodlné.

Taky bych psal všude std::cout pro větší přehlednost. Až budeš mít více tříd a více namespaců budeš tak vědět která funkce patří které třídě.