C++11 standards

main.cpp: Działa troszkę bardziej

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)