mendinskis

void IeskotiSkaiciu(string e)
{
string sk("0123456789");
string s(" /?.,()"); // skyrikliai
int zpr = 0, zpb = 0; //zpr - zodzio pradzia, zpb - zodzio pabaiga,
string zodis("");
int SK = 0;
zpr = e.find_first_not_of(s, zpb);
while (zpr != -1)
{
zpb = e.find_first_of(s, zpr);
zodis = e.substr(zpr, zpb - zpr);
SK = zodis.find_first_not_of(sk, 0); // jei zodyje nera raidziu, vadinasi jis yra skaicius
if (SK == -1)
{
cout << " Skaicius rastas - " << zodis;
}
zpr = e.find_first_not_of(s, zpb);
}
}
 
Manau, esme supratai ;)

Yra du protingi variantai:

Prieš įrašydamas elementą į masyvą pasižiūri, ar jau jame yra elementas su tokiu pavadinimu. Jei yra ir jei naujo elemento kaina didesnė, tai įrašai naująją kainą. Jei nėra, įterpi naują elementą.
Surašai visus elementus į masyvą. Tada masyvą surikiuoji. Elementai su vienodais pavadinimais bus vienas šalia kito. Tada pereini per visą masyvą tikrindamas du gretimus narius ir pasižymėdamas didžiausią kainą. Tiesa, kad masyvas būtų be pasikartojimų, reikės kiekvieną pavadinimą su jo didžiausia kaina perkopijuoti į naują masyvą.

Jei čia norėjai priskirti vieną elementą kitam, tai neteisingai – čia priskiri tik vieno pavadinimą kitam. Reiktų K = K[j].
 
Aišku, tai nepašalina visiškai, nes dabar tiesiog turėsi du vienodus. :) Šalinimas yra toks:

n - elementų kiekis, s - šalinamas elementas a) kai tvarka nesvarbi: K[s] = K[n]; n-- (paskutinį perkeli į šalinamo vietą, vienu elementu sumažėja) b) kai tvarka svarbi: for (int i = s; i < n-1; i++) { K[i] = K[i+1] }; n--; (visus elementus, pradedant nuo šalinamo, perrašo elementais, esančiais viena pozicija toliau, vienu elementu sumažėja)

Sveiki, kas galetu paaiskint JK trigeri ir jo veikima?

Pažiūrėk į mano redaguotą pranešimą.

Jauti skirtuma tarp "Failo pavadinimas" ir "Failo pavadinimas.txt". Normaliai failo varda apsirasai ir viskas veikia.

Tikrai toks. Cia ir buvo mano pirmas zingsnis kai pamaciau sia klaida.

http://rosettacode.org/wiki/Sorting_algorithms/Insertion_sort#C
http://stackoverflow.com/questions/14171195/insertion-sort-c-implementation

p[i].setPamoka(new_value);
 
Setterius pačiam susikodinti reikia. :-)
 
Pvz.:

type Klasė::nustatytiPamoka(const type &newVal) // type pasikeiti į savo kintamojo tipą. &newVal reiškia, kad kintamąjį paduodi kaip reference – „nuorodą“ į kintamąjį, nes tai nebloga praktika – jeigu ateityje duosi objektus, tai jų nekopijuos, kaip kad „by value“ būdu. { this.someVariable = newVal; }
 
RED:
Tavo atveju:

void Pamoka::nustatytiPamoka(std::string &naujaPamoka) // Čia reikia kabliataškio? { this.pamoka = naujaPamoka; }
 
Ir naudoji

p[i].nustatytiPamoka("Kažkas");
 
 
Sėkmės.

Krc sukeisk 100 ir 101 eilutes vietom ir viskas bus gerai ;)

Bandei į viršų pascrollint? Žinok ne visada visas tekstas telpa :rolleyes:

visi tie 'Imti' metodai gražina reikšmę, o ne ją paima <_<

int n = 0; string klase, diena, pamoka; int nr; while(!fd.eof()){ fd >> klase >> diena; while(fd.peek() != '\n' && !fd.eof()) { fd >> nr >> pamoka; p[n++].Deti(klase, diena, nr, pamoka); } }

Pas tave buvo taip:

void Pamoka::Deti(string klase, string diena, int nr, string pamoka){ klase=klase; diena=diena; nr=nr; pamoka=pamoka; }
 
This pointeris nurodo pačios klasės kintamąjį. Kadangi tavo metode parametrų vardai nesiskiria nuo klasėje aprašytų vardų, kompiliatorius galvoja, kad tu dirbi su metodo parametrais, o ne klasės kintamaisiais.

Transponuoji matricą, tada vietoj x statai transponuotą C išraišką ir viskas. Tik prie laisvo lario nepamiršk prirašyti vienetinės matricos.

Tavo pamokų pavadinimai yra du žodžiai, o "failas >> x" berods skaito iki tarpo ar kitokio whitespace... Pilnai gali lūžti dėl to – viskas „nusivažiuoja“ per kokią vietą ir bando dėti ne į tą kintamąjį, kur reikia (pvz. stringą į int).
 
Vietoj to, skaityk pamoką iki eilutės galo. (Apskritai, pasimokyk C++ I/O savarankiškai)
 
Na o dar labiau sutaupytum viską sumetęs į vieną eilutę :D Kodo eilutės – ne pinigai, taupyt nereikia. IMO kaip žmogui geriau ir įskaitomiau, taip ir daro. Jei kada prireiktų ant to paties elemento daryt du veiksmus (p.Deti(), p.DarKazkas()), tai vėl nebetiktų i++ skliaustuose... :)

Na man su tavo failu ir tokiu kodu

#include <iostream> #include <fstream> using namespace std; int main() { ifstream in("duom.txt"); string klase, diena, pamoka; int nr; while (!in.eof()) { in >> klase >> diena >> nr >> pamoka; cout << klase << " " << diena << " " << nr << " " << pamoka << endl; } }
 
Nelūžta. Vadinasi, ne skaityme bėda. Apskritai, duok visą informaciją, jei nori, kad padėtume. Koks klasės kodas? (problema gali būti būtent joje, nes šiaip skaitymas yra OK). Kurioj eilutėj išvis lūžta? (pasipraktikuok debuggerio skillus :)).
 
Neturėdami pilno, veikiančio tavo programos kodo, o tik tą vietą (kurioje greičiausiai nėra klaidos), niekaip nepadėsim.

Menkos mano C++ žinios, bet būtų panašu, kad Pamoka::Deti() bando užsettinti kintamuosius ant klasės (kaip statinius?), o ne ant instancijos (this)... Kodėl?! :blink: :blink: :blink:
 

#include <iostream> #include <fstream> using namespace std; class Pamoka { private: string klase; string diena; int nr; string pamoka; public: void Deti(string klase, string diena, int nr, string pamoka); string ImtiKlase(){return klase;} string ImtiDiena(){return diena;} int ImtiNr(){return nr;} string ImtiPamoka(){return pamoka;} }; void Pamoka::Deti(string klase, string diena, int nr, string pamoka){ this->klase = klase; this->diena = diena; this->nr = nr; this->pamoka = pamoka; } int main() { ifstream in("duom.txt"); string klase, diena, pamoka; int nr; Pamoka pamokos[123]; int i = 0; while (!in.eof()) { in >> klase >> diena >> nr >> pamoka; pamokos[i].Deti(klase, diena, nr, pamoka); i++; } cout << pamokos[0].ImtiPamoka() << endl; }
 
Puikiai veikia.
 
Tiesa, kodėl naudoji pvz "diena2" ir "diena3" atskirose klasėse? Juk vardai pilnai gali kartotis atskirose klasėse, funkcijose, etc. :)
 
Žodžiu, trūksta C++ OOP pagrindų.

Skaitai pamokas, bet iš Klases.txt?

const char AB[] = "Klases.txt"; // duom ... Pamokos(AB, p, i);
 
Pasidaryk protingesnius, prasmingesnius konstantų vardus ir nesusimaišysi taip. Ir dar – su debuggeriu klaidų ieškoti yra paprasta ir efektyvu, priešingai, nei tiesiog spėliojant :)
 
+ SpausdintiPamokas dar viena klaida – tu juk neskaitai iš failo, tai kam tas ifstream? Kai neskaitai iš jo, tai niekada nebus fd1.eof(), taip peržengi rėžius su begaliniu ciklu ir dėl to crashinasi. (čia jau pataisius failo vardą)
 
Tiesiog eik per mąsyvą su for ciklu (aišku, limituok pamokų skaičių iki tiek, kiek perskaitei – kažkur išsisaugok tą skaičių)

http://funny-voice.en.softonic.com/ :)

Prašau:

for(; !fin.eof(); ) { doSomething(); }

naudok if-else-if konstrukciją:

if(condition) { doSomething(); } else if(other_condition) { doSomethingElse(); } else if(other_other_condition) { ... } ...
 
Jeigu bus tenkinama pirma sąlyga, į kitą jau nežiūrės, jei tenkinama antra - nežiūrės į trečią. Ko gero tai yra tai, ko tau reikia.

Gali būti kas tik nori. Kaip masyvo indeksą gali naudoti ir konstantą kode, ir kintamąjį. "A" nėra stebuklingas sakinys

int i = 1; int sausainis = 4; A[0] = 10; A[i] = 20; A[sausainis] = 30;
Visi jie teisingi.

Kaip tu įsivaizduoji masyvą? Įprastai masyvas suprantamas kaip tam tikri objektai sudėti į eilę. Ta eilė ir būtų masyvas. Penktas daiktas eilėje būtų masyvo penktas masyvo elementas.
 
Šiuo atveju mąstom šiek tiek kitaip. Vietoj objektų į masyvą dedam grupeles. Grupelę apibūdinam skaičiumi, kuris reiškia objektų skaičių toje grupelėje.
 
Tarkim, objektus grupuojame pagal jų dydį. Tada kai varžto dydis 8, jį dedame į 8 grupelę.
 

2 4 2 7 2
 
Perskaitę tokią eilutę gausime 3 vnt. anroje grupelėje, po vieną vnt. ketvirtoje ir septintoje, t. y.

A[2] = 2; A[4] = 1; A[7] = 1;
 
Visos kitos grupelės yra tuščios (tuščia = 0), todėl:

A[] = {0, 0, 2, 0, 1, 0, 0, 1, 0, 0, ...}
 
Taigi kaip pridedi aštunto dydžio varžtą į grupelę? A[8]++
 
Kiek pastebėjau, mąstai per daug konkrečiai. O programavimas yra sulipdytas ant abstraktumo, tai vienas iš pagrindinių įvairių ideologijų principų. Turėtum mažiau galvoti apie konkrečius skaičius ir daugiau apie kintamuosius. Kitaip po to sudetingesnės užduotys taps nesuvokiamos. Čia tos kur dabar sprendi tik gėlytės.

Berods, kai mokykloj darėm šitą, naudojom „netikrą rikiavimą“. T.y. pirmiausiai nusinulini veržlių/varžtų masyvus (21 vietos, tuoj suprasi kodėl), tada vietoj masyvo indekso naudojam nusiskaitytus veržlių/varžtų numerius. T.y. sutikę pirmą varžtą nededam varztai[0] = 8, o varztai[8] += 1. Nusiskaitę turim tokį masyvą, kur varztai parodo, kiek yra dydžio i varžtų (analogiškai su veržlėmis).
 
Tada, kaip wi_lius sakė, belieka iš kiekvieno veržlių skaičiaus atimti varžtų ir žiūrėti, ar skiriasi (ir į kurią pusę)

Šis metodas ir yra protingiausias šio uždavinio atžvilgiu. Pasidarai masyvą A[21] (20 – maksimalus dydis). Tik galima skaitant veržles pliusuoti (A[k]++), o skaitant varžtus minusuoti (A[k]--). Tada jei skaičius teigiamas — trūksta tiek varžtų, jei neigiamas — trūksta tiek vežlių.
 
Kur kas įdomiau, jei varžtų dydžiai galėtų būti daug didesni. Tada tektų susirikiuoti abu masyvus ir lygiagrečiai per juo iteruoti ieškant vienodų narių.