C++11 standards

main.cpp: Działa troszkę bardziej

Laboratorium/20221109155432/euklides.cpp

@@ -0,0 +1,13 @@
+#include <iostream>
+#include <cmath>
+
+double odleglosc(double xa, double ya, double xb, double yb)
+{
+	return std::sqrt(std::pow(xa-xb, 2)+std::pow(ya-yb, 2));
+}
+int main(int argc, char *argv[])
+{
+	std::cout << odleglosc(1,1,2,1) << std::endl;
+	std::cout << odleglosc(1,1,2,2) << std::endl;
+	std::cout << odleglosc(1,1,-2,21) << std::endl;
+}

Laboratorium/20221109155432/gnirts.cpp

@@ -0,0 +1,14 @@
+#include <iostream>
+#include <string>
+std::string gnirts(std::string &wejscie){
+	int dlugosc = sizeof(&wejscie)/sizeof(int);
+	for (int i : dlugosc){
+		aaa
+	}
+	return gnirts;
+}
+
+int main(int argc, char *argv[])
+{
+	std::cout << gnirts("Hello, world!")<< std::endl;
+}

Laboratorium/20221109155432/miernikkrzyku.cpp

@@ -0,0 +1,16 @@
+#include <iostream>
+#include <string>
+int miernikkrzyku(std::string wejscie){
+	int counter = 0;
+	for (char znak : wejscie){
+		if (znak == 'a'){
+			counter++;
+		}
+	}
+	return counter;
+}
+
+int main(int argc, char *argv[])
+{
+	std::cout << miernikkrzyku("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") << std::endl;
+}

Laboratorium/20221109155432/ntapotega.cpp

@@ -0,0 +1,14 @@
+#include <iostream>
+
+double potega(int wykladnik, double podstawa){
+	double podstawa_old = 1;
+	for (int i = 0; i < wykladnik; i++) {
+		podstawa_old *= podstawa;
+	}
+	return podstawa_old;
+}
+
+int main()
+{
+	std::cout << potega(3, 21.5) << std::endl;
+}

Laboratorium/20221109155432/szescian.cpp

@@ -0,0 +1,11 @@
+#include <iostream>
+
+long long szescian(int podstawa)
+{
+	return podstawa*podstawa*podstawa;
+}
+
+int main(int argc, char *argv[])
+{
+ 	std::cout << szescian(2) << "\n" << szescian(3) << "\n" << szescian(42) << std::endl;
+}

Laboratorium/20221116155920/structs.cpp

@@ -0,0 +1,51 @@
+#include <iostream>
+#include <cmath>
+
+
+struct pointInSpace {
+	double xCoord;
+	double yCoord;
+};
+
+struct rectangle {
+	pointInSpace SW;
+	pointInSpace NE;
+};
+struct circle {
+	pointInSpace centre;
+	double radius;
+ };
+double distance(pointInSpace a, pointInSpace b){
+  return std::sqrt(std::pow(a.xCoord - b.xCoord, 2) + std::pow(a.yCoord - b.yCoord, 2));
+}
+double rectArea(rectangle caseInPoint){
+	return (caseInPoint.NE.xCoord-caseInPoint.SW.xCoord) * (caseInPoint.NE.yCoord-caseInPoint.SW.yCoord);
+}
+
+int biggerRect(rectangle a, rectangle b){
+	return (rectArea(a) > rectArea(b)) ? rectArea(a) : rectArea(b);
+}
+
+
+
+int main(int argc, char* argv[]){
+	pointInSpace dot = {3.141592, 42.0};
+	std::cout << dot.xCoord <<  std::endl << dot.yCoord << std::endl;
+
+	rectangle square = {0.0,0.0,20.0,20.0};
+	std::cout << square.SW.xCoord << std::endl << square.SW.yCoord <<  std::endl << square.NE.xCoord <<  std::endl << square.NE.yCoord << std::endl;
+
+	circle wheel = {1.0,1.0,1.0};
+	std::cout << wheel.centre.xCoord << std::endl << wheel.centre.yCoord << std::endl << wheel.radius << std::endl;
+
+	std::cout << distance({1.0,1.0},{3.0,1.0}) << std::endl;
+
+	std::cout << rectArea(square) << std::endl;
+
+	rectangle rect1 = {13.0,10.0,15.0,15.0};
+	std::cout << biggerRect(square,rect1) << std::endl;
+
+
+	return 0;
+
+}

Laboratorium/20221130155128/czytanie.cpp

@@ -0,0 +1,19 @@
+#include <iostream>
+#include <fstream>
+#include <string>
+
+using namespace std;
+int czytaj(char *nazwa){
+  ifstream plik(nazwa);
+	string linia;
+	while (getline(plik, linia)) {
+	  std::cout << linia << std::endl;
+	}
+  plik.close();
+	return 0;
+}
+int main (int argc, char *argv[])
+{
+	czytaj(argv[1]);
+	return 0;
+}

Laboratorium/20221130155128/generowanie.cpp

@@ -0,0 +1,17 @@
+#include <iostream>
+#include <fstream>
+
+using namespace std;
+int generator(int n, char *nazwa){
+  ofstream plik(nazwa);
+	for (int i = 1; i <= n; i++) {
+	  plik << i << endl;
+  }
+  plik.close();
+	return 0;
+}
+int main (int argc, char *argv[])
+{
+	generator(atoi(argv[1]), argv[2]);
+	return 0;
+}

Laboratorium/20221221155543/wskazniki.cpp

@@ -0,0 +1,81 @@
+#include <iostream>
+struct Punkt
+{
+    double x;  // Współrzędna x punktu
+    double y;  // Współrzędna y punktu
+};
+
+void my_swap_1(int* a, int* b)
+{
+    // Zamiana wartości zmiennych wskazywanych przez a i b
+    int tmp = *a;
+    *a = *b;
+    *b = tmp;
+}
+void movex(Punkt* a, double x)
+{
+    a->x += x;  // Przesunięcie punktu wzdłuż osi x o zadaną wartość
+}
+void fill_random(double* arr, int rozmiar, double a, double b)
+{
+    // Inicjalizacja generatora liczb losowych
+    std::srand(time(nullptr));
+
+    // Wypełnienie tablicy losowymi wartościami z przedziału od A do B
+    for (double* p = arr; p < arr + rozmiar; ++p)
+        *p = a + (b - a) * std::rand() / RAND_MAX;
+}
+int main()
+{
+    // Definicja zmiennej typu int
+    int x = 5;
+
+    // Definicja zmiennej wskaźnikowej typu int*
+    int* px = &x;
+
+    // Definicja zmiennej referencyjnej typu int&
+    int& rx = x;
+
+    // Modyfikacja wartości zmiennej x bezpośrednio
+    x = 10;
+
+    // Wypisanie wartości zmiennej x
+    std::cout << "x = " << x << std::endl;
+
+    // Modyfikacja wartości zmiennej x za pomocą wskaźnika
+    *px = 15;
+
+    // Wypisanie wartości zmiennej x
+    std::cout << "x = " << x << std::endl;
+
+    // Modyfikacja wartości zmiennej x za pomocą referencji
+    rx = 20;
+
+    // Wypisanie wartości zmiennej x
+    std::cout << "x = " << x << std::endl;
+
+    // Przykładowe użycie funkcji my_swap_1
+    int a = 10;
+    int b = 20;
+    std::cout << "a = " << a << ", b = " << b << std::endl;
+    my_swap_1(&a, &b);
+    std::cout << "a = " << a << ", b = " << b << std::endl;
+
+    Punkt p{3.0, 4.0};  // Inicjalizacja obiektu typu Punkt
+
+
+    std::cout << "Przed przesunięciem: p.x = " << p.x << ", p.y = " << p.y << std::endl;
+    movex(&p, 5.0);  // Przesunięcie punktu wzdłuż osi x o 5.0
+    std::cout << "Po przesunięciu: p.x = " << p.x << ", p.y = " << p.y << std::endl;
+    int rozmiar = 10;
+    double tab[rozmiar];  // Utworzenie tablicy o rozmiarze 10
+
+    // Wypełnienie tablicy losowymi wartościami z przedziału od 0.0 do 1.0
+    fill_random(tab, rozmiar, 0.0, 1.0);
+
+    // Wypisanie zawartości tablicy
+    for (double* p = tab; p < tab + rozmiar; ++p)
+        std::cout << *p << ' ';
+    std::cout << std::endl;
+    return 0;
+}

Laboratorium/20230111160622/mapa.cpp

@@ -0,0 +1,28 @@
+#include <map>
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <sstream>
+using namespace std;
+
+int main (int argc, char *argv[])
+{
+	std::map<std::string, int> pantadeusz;
+  int nr_linii = 1 ;
+	ifstream plik("pantadeusz.txt");
+	string linia;
+	while (getline(plik, linia)) {
+	          std::stringstream slinia;
+            std::string slowo;
+            slinia << linia;
+            while (slinia >> slowo)
+                 pantadeusz[slowo]++;
+            nr_linii++;
+	}
+  plik.close();
+  for (const auto& el : pantadeusz)
+	{
+	std::cout << el.first << ": " << el.second << '\n';
+	}
+	return 0;
+}

Projekt/Makefile

@@ -0,0 +1,6 @@
+build:
+	g++ -g -Iinclude main.cpp
+
+clean:
+	rm -f a.out
+	rm -rf Dokumentacja

Projekt/include/types.hpp

@@ -0,0 +1,2 @@
+using namespace std;
+typedef std::map<std::string, std::map<std::string, double>> mapa;

Projekt/main.cpp

@@ -0,0 +1,154 @@
+
+/***
+ * 13. Kurier ma za zadanie zawieść towar do klientów w różnych lokalizacjach i powrócić do miejsca, z którego wyjechał. Kurier musi odwiedzić każdego klienta raz i tylko raz. Należy
+znaleźć zamkniętą najkrótszą drogę, która umożliwia odwiedzenie wszystkich klientów.
+W pliku wejściowym zapisane są długości dróg pomiędzy miastami. Drogi zapisane
+są w następujący sposób:
+(<klient A> - <klient B> : <odległość>).
+Niektóre drogi nie są symetryczne, tzn. jest pewna różnica między drogą tam a z powrotem.
+Zapis (<klient C> -> <klient D> : <odległość CD>), oznacza długość drogi jednokierunkowej
+od klienta C do klienta D. Poszczególne drogi są rozdzielone przecinkami. Nie jest podana
+liczba dróg. Jeżeli nie jest możliwe wyznaczenie drogi, program zgłasza odpowiedni
+komunikat. Przykładowy plik wejściowy:
+(1 - 2 : 4.5), (4 -> 3 : 4.5), (4 - 2 : 0.4)
+W pliku wynikowym należy zapisać drogę kuriera (kolejność odwiedzania klientów i długość
+drogi).
+Program uruchamiany jest z linii poleceń z potrzebnymi przełącznikami, natomiast
+uruchomienie programu bez parametrów powoduje wypisanie krótkiej instrukcji
+
+   1   2   3   4
+1     4.5
+
+2 4.5         0.4
+
+3             4.5
+
+4     0.4
+
+**/
+
+#include <iostream>
+#include <iomanip>
+#include <string>
+#include "include/cxxopts.hpp"
+#include "include/types.hpp"
+#include <algorithm>
+#include <limits.h>
+#include <queue>
+#include <fstream>
+#include <sstream>
+
+double nieskończoność=std::numeric_limits<double>::max();
+
+using namespace std;
+
+cxxopts::Options options("Kurier", "Program rozwiązujący problem kuriera");
+
+/*
+ *
+ * Parsujemy A, B, rodzaj korelacji <bool>, dystans
+ *
+ *
+ */
+typedef std::map<std::string, std::map<std::string, double>> mapa;
+mapa mapaOdległości;
+/*
+ * @brief Funkcja czyszcząca stringi z niepotrzebnych znaków
+ */
+void czyscStringa( string &str, char* znakiDoCzyszczenia ) {
+   for ( unsigned int i = 0; i < strlen(znakiDoCzyszczenia); ++i ) {
+      str.erase( remove(str.begin(), str.end(), znakiDoCzyszczenia[i]), str.end() );
+   }
+}
+
+
+void dijkstruj(mapa doPrzetworzenia){
+    for (auto const &i : doPrzetworzenia){
+      for (auto const &ii : i.second){
+          std::cout << i.first << ':' << ii.first << ':'<< ii.second << std::endl;
+      }}
+}
+
+void dumpOutput(string outputFile, string preparedString)
+{
+ofstream file(outputFile);
+file << preparedString;
+    
+}
+
+
+/**
+ * @brief		Funkcja parsująca dane wejściowe.
+ *
+ * @details	Funkcja pobiera dane wejściowe z przekazanej ścieżki do pliku. Plik zawiera długości dróg pomiędzy poszczególnymi miastami w formacie (<klient A> - <klient B> : <odległość>).
+ *
+ * @param		inputFile Ścieżka do pliku wejściowego
+ *
+ * @return	iterator pliku
+ */
+void parseInput(string inputFile) {
+    ifstream file(inputFile);
+    std::string token,miastoA,miastoB,dystans,rodzajRelacji;
+    while(std::getline(file, token, ',')) {
+        czyscStringa(token, "(:)");
+        istringstream tokenstream(token);
+        tokenstream >> miastoA >> rodzajRelacji >> miastoB >> dystans;
+        if (rodzajRelacji.compare("-")==0) {
+            // Jeśli drugie miasto zaczyna się od znaku '-', to znaczy, że jest to droga dwukierunkowa.
+            // Dodajemy odległość do mapy dla obu kierunków.
+            mapaOdległości[miastoA][miastoB] = stod(dystans);
+            mapaOdległości[miastoB][miastoA] = stod(dystans);
+        } else if (rodzajRelacji.compare("->")==0) {
+            // Jeśli drugie miasto zaczyna się od znaku '>', to znaczy, że jest to droga jednokierunkowa.
+            // Dodajemy odległość tylko w jednym kierunku.
+            mapaOdległości[miastoA][miastoB] = stod(dystans);
+            mapaOdległości[miastoB][miastoA] = nieskończoność;
+        }
+    }
+}
+/**
+ * @brief Główna funkcja.
+ *
+ */
+int main (int argc, char *argv[])
+{
+
+    options.add_options()
+    ("d,debug", "Włącza tryb debugowania") // a bool parameter
+    ("h,help", "Pokazuje pomoc") // a bool parameter
+    ("i,input", "Nazwa pliku wejściowego", cxxopts::value<string>())
+    ("o,output", "Nazwa pliku wyjściowego", cxxopts::value<string>())
+    ("v,verbose", "Pokazuje tok działania programu", cxxopts::value<bool>()->default_value("false"));
+
+    auto result = options.parse(argc, argv);
+
+    // Jeżeli przełącznik -h jest ustawiony albo nie podano argumetów, wyświetla pomoc.
+    if (result.count("help") || argc == 1) {
+        std::cout << options.help() << std::endl;
+        exit(0);
+    }
+    bool debug = result["debug"].as<bool>();
+    string plikWejsciowy;
+    string plikWyjsciowy;
+    if (result.count("input") && result.count("output")) {
+        plikWejsciowy = result["input"].as<string>();
+        parseInput(plikWejsciowy);
+        dijkstruj(mapaOdległości);
+        plikWyjsciowy = result["output"].as<string>();
+        
+    } else {
+        std::cout << std::endl <<  "Błąd - nie podano wymaganych parametrów" << std::endl << std::endl << std::endl << options.help() << std::endl;
+        exit(3);
+    }
+    if (debug == true) {
+        for (int i = 0; i < argc; i++) {
+            std::cout << argv[i] << std::endl;
+        }
+    }
+
+
+
+
+
+    exit(0);
+}

Projekt/testfile

@@ -0,0 +1 @@
+(1 - 2 : 4.5), (4 -> 3 : 4.5), (4 - 2 : 0.4), (1 - 3 : 2.1), (2 - 4 : 3.2), (3 -> 1 : 1.5), (2 - 5 : 5.5), (5 - 4 : 2.3), (3 - 6 : 4.1), (6 - 5 : 3.2), (1 - 7 : 6.5), (7 - 6 : 2.7), (2 - 8 : 7.1), (8 - 7 : 3.8), (3 - 9 : 5.2), (9 - 8 : 4.1), (4 - 10 : 6.3), (10 - 9 : 2.5), (5 - 11 : 5.1), (11 - 10 : 3.6), (6 - 12 : 4.7), (12 - 11 : 2.9), (7 - 13 : 3.4), (13 - 12 : 2.5), (8 - 14 : 4.1), (14 - 13 : 3.3), (9 - 15 : 5.8), (15 - 14 : 2.7), (10 - 16 : 4.2), (16 - 15 : 3.1), (11 - 17 : 5.5), (17 - 16 : 2.8), (12 - 18 : 4.9), (18 - 17 : 3.2), (13 - 19 : 6.1), (19 - 18 : 2.5), (14 - 20 : 5.2), (20 - 19 : 3.6), (15 - 21 : 4.7), (21 - 20 : 2.9), (16 -> 22 : 5.1), (22 -> 21 : 3.6), (17 -> 23 : 4.2), (23 - 22 : 2.8), (18 - 24 : 3.9), (24 - 23 : 2.5), (19 - 25 : 5.8), (25 - 24 : 3.3), (20 - 26 : 4.2), (26 - 25 : 2.7), (21 - 27 : 5.5), (27 - 26 : 3.2), (22 - 28 : 4.9), (28 - 27 : 2.8), (23 - 29 : 6.1), (29 - 28 : 2.5), (24 - 30 : 5.2), (30 - 29 : 3.6), (25 - 31 : 4.7), (31 - 30 : 2.9), (26 - 32 : 5.1), (32 - 31 : 3.6), (27 - 33 : 4.2), (33 -> 32 : 2.8), (28 - 34 : 3.9), (34 - 33 : 2.5), (29 -> 35 : 5.8), (35 - 34 : 3.3), (30 - 36 : 4.2), (36 - 35 : 2.7), (31 - 37 : 5.5), (37 - 36 : 3.2), (32 - 38 : 4.9), (38 - 37 : 2.8), (33 - 39 : 6.1), (39 - 38 : 2.5), (34 - 40 : 5.2), (40 - 39 : 3.6), (35 - 41 : 4.7), (41 -> 40 : 2.9)