Konwersja std::pair (C++)

Question

Witam piszę program, który ma w pewnej części pokazać najmniejszą i największą wartość.

Do tego kompilator zaproponował mi konwersję poprzez std::pair

int step_result = std::pair <int, int> std::minmax(steps); 

steps jest kilku krotnie podawane w pętli while{} (próbowałem też ....std::minmax(steps, steps);)

Comments

Czym jest `steps`?

---

w pewnej części pokazać najmniejszą i największą wartość

masz na mysli jakiś kontener? jeśli tak to minmax Ci nie pomoże, przyjmuje on albo dwie wartości albo liste inicjalizacyjną.

---

Yup. Natomiast std::minmax_element pomoże. Patrz na przykład na dole:

https://en.cppreference.com/w/cpp/algorithm/minmax_element

---

@adrian17,

steps to zmienna typu int.

---

Pojedyncza zmienna typu `int` nie ma "największej i największej wartości". Pokażesz, co konkretnie chcesz zrobić?

---

std::cout << "Podaj dystans do przejścia (k, aby zakończyć): ";
        while(std::cin >> target)
        {       
                std::cout << "Podaj długość kroku: ";
                if(!(std::cin >> d_steps))
                        break;
std::cout << "Ile razy próba ma zostać powtórzona: "; std::cin >> n_steps;
                for(int i = 0; i < n_steps; i++)
                {       
                        while(result.mag_value() < target)
                        {       
                                direction = rand() % 360;
                                step.reset(d_steps, direction, Vector::POL); 
                                std::cout << steps << ": (x,y) = " << result << std::endl;
                                result = result + step;
                                steps++;
                        }// #2 while
                        
                        std::cout << steps << ": (x,y) = " << result << std::endl;
                        //wynik
                        std::cout << "Po " << steps << " krokach delikwent osiągnął położenie:\n" << result << std::endl;
                        result.polar_mode();
                        std::cout << " czyli\n" << result << std::endl;
                        std::cout << "Średnia długość kroku pozornego = " << result.mag_value()/steps << std::endl;
                }//for
                
                //zestawienie danych o krokach
                std::cout << "Zestawienie informacji o wykonanych krokach\n";
                auto step_result = std::minmax_element();
                std::cout << "Minimalna ilość kroków: " << step_result.first << "\nMaksymalna ilość kroków: " << step_result.second << "\nŚrednia ilość kroków: " << steps/n_steps << std::endl;

                //zerowanie wartości
                steps = 0;
                result.reset(0.0, 0.0);
                std::cout << "Podaj dystans do przejścia (k, aby zakończyć): ";
        }// #1 while

Wielokrotnie powtórzy się 'steps' zzapoznałem się z dokumentacją i podejrzewałem, że to błąd.

---

Niestety wciąż słabo rozumiem, co tutaj chcesz zrobić. Widzę że liczysz kroki (steps++), ale nigdzie nie widzę, gdzie tutaj wchodzi w grę jakaś najwyższa/najniższa wartość.

---

Wcześniej podaję ile razy będą liczone kroki i długość. Przypuszczając, że będzie 5 prób w której będzie występowało np. (50, 52, 3, 4, 96) kroków to z tego ma wyznaczyć wartości najniższej i najwyższe.

---

No to musisz co próbę liczyć od zera liczbę kroków. Wtedy najprościej będzie zrobić coś w stylu

int min_tries = 9999; // lub std::numeric_limits<int>::max()
int max_tries = 0;
for (...proby...) {
    int tries = 0;
    // obliczenia
 
    if (tries > max_tries) max_tries = tries;
    if (tries < min_tries) min_tries = tries;
}
// masz teraz wartosc min i max

 

---

Dobra próba, jednak to nie pomogło. Nie wiem dlaczego ale ciągle wyświetla początkowe dane mimo dodania obu warunków.

---

A pokażesz nowy kod?

---

int max_steps = std::numeric_limits<int>::max();
        int min_steps = 0;

        std::cout << "Podaj dystans do przejścia (k, aby zakończyć): ";
        while(std::cin >> target)
        {
                std::cout << "Podaj długość kroku: ";
                if(!(std::cin >> d_steps))
                        break;

                std::cout << "Ile razy próba ma zostać powtórzona: "; std::cin >> n_steps;
                for(int i = 0; i < n_steps; i++)
                {
                        while(result.mag_value() < n_steps)
                        { 
                                direction = rand() % 360;
                                step.reset(d_steps, direction, Vector::POL);
                                std::cout << steps << ": (x,y) = " << result << std::endl;
                                result = result + step;
                                steps++;
                        }// #2 while                    
        
                        if(steps > max_steps) max_steps = steps; // maksymalna ilość kroków
                        if(steps < min_steps) min_steps = steps; // minimalna ilość kroków
                } // for        

                std::cout << steps << ": (x,y) = " << result << std::endl;
                //wynik
                std::cout << "Po " << steps << " krokach delikwent osiągnął położenie:\n" << result << std::endl;
                result.polar_mode();
                std::cout << " czyli\n" << result << std::endl;
                std::cout << "Średnia długość kroku pozornego = " << result.mag_value()/steps << std::endl;
        //      }//for

                //zestawienie danych o krokach
                std::cout << "Zestawienie informacji o wykonanych krokach\n";
                std::cout << "Minimalna ilość kroków: " << min_steps << "\nMaksymalna ilość kroków: " << max_steps << "\nŚrednia ilość kroków: " << steps/n_steps << std::endl;
//zerowanie wartości
                steps = 0;
                result.reset(0.0, 0.0);
                std::cout << "Podaj dystans do przejścia (k, aby zakończyć): ";
        }// #1 while

 

---

No, zapewne dlatego że nie zerujesz liczby kroków między kolejnymi próbami.

---

To jest wyjście programu (poniżej wypiszę błędy).

Podaj dystans do przejścia (k, aby zakończyć): 50
Podaj długość kroku: 20
Ile razy próba ma zostać powtórzona: 2
0: (x,y) = (x, y) = (0, 0)
1: (x,y) = (x, y) = (-17.1433, -10.3008)
2: (x,y) = (x, y) = (-5.10705, -26.2735)
3: (x,y) = (x, y) = (12.3853, -16.5773)
4: (x,y) = (x, y) = (19.8775, 1.9664)
5: (x,y) = (x, y) = (16.7488, -17.7874)
6: (x,y) = (x, y) = (36.4449, -21.2603)
7: (x,y) = (x, y) = (26.1442, -38.4037)
0: (x,y) = (x, y) = (42.3245, -26.648)
Po 0 krokach delikwent osiągnął położenie:
(x, y) = (42.3245, -26.648)
 czyli
(mag, ang) = (50.0148, -32.195)
Średnia długość kroku pozornego = inf
Zestawienie informacji o wykonanych krokach
Minimalna ilość kroków: 0
Maksymalna ilość kroków: 2147483647
Średnia ilość kroków: 0
Podaj dystans do przejścia (k, aby zakończyć):

Gdy dodałem zerowanie kroków wynik po dotarciu do celu wynosi 0 zamiast 7.

W dodatku nie wiem (próbowałem wielu warunków) w jaki sposób sprawić, żeby n_steps wpłynęło na wewnętrzną pętle while i żeby ponawiała próbę.

---

A, odwróciłeś liczby.

int max_steps = std::numeric_limits<int>::max();

jeśli z góry ustawiłeś `max_steps` na maksymalną liczbę, to nic większego się nie znajdzie ;) Miało być 0.

---

Dobra to wiele zmieniło . Dziękuję.

Jednak w wciąż próbuje zmienić działanie 'prób'. Ponieważ  pętla #2 while ( wewnętrzna) zawsze wykonuję się tylko i wyłącznie jeden raz. W momencie gdy z niej całkowicie zrezygnowałem pojawił się kolejny problem z końcowym wynikiem kroków, który wynosił 0 (ponieważ 'steps' było resetowane na początku pętli).

---

Już mocno na ślepo... jedyny mój strzał jest taki, że jakiejś zmiennej nie resetujesz między próbami.

---

W jakiś sposób ją znajdę, w każdym razie dziekuję za twój czas i pomoc.

---

@adrian17,

while(std::cin >> target)
        {
                std::cout << "Podaj długość kroku: ";
                if(!(std::cin >> d_steps))
                        break;
                
                std::cout << "Ile razy próba ma zostać powtórzona: "; std::cin >> n_steps;
                for(int i = 0; i < n_steps; i++){
                        while(result.mag_value() < target)
                        {
                                direction = rand() % 360; 
                                step.reset(d_steps, direction, Vector::POL);
                                std::cout << steps << ": (x,y) = " << result << std::endl;
                                result = result + step;
                                steps++;        
                        } // #2 while
                
                        if(steps > max_steps) max_steps = steps; // maksymalna ilość kroków
                        if(steps < min_steps) min_steps = steps; // minimalna ilość kroków

                        std::cout << steps << ": (x,y) = " << result << std::endl;
                        //wynik
                        std::cout << "Po " << steps << " krokach delikwent osiągnął położenie:\n" << result << std::endl;
                        result.polar_mode();
                        std::cout << " czyli\n" << result << std::endl;
                        std::cout << "Średnia długość kroku pozornego = " << result.mag_value()/steps << std::endl << std::endl;
                        steps = 0;
                } // petla (wyznaczająca ilość prób !

                //zestawienie danych o krokach
                std::cout << "Zestawienie informacji o wykonanych krokach\n";
                std::cout << "Minimalna ilość kroków: " << min_steps << "\nMaksymalna ilość kroków: " << max_steps << "\nŚrednia ilość kroków: " << steps/n_steps << std::endl;

                //zerowanie wartości
                steps = 0;
                result.reset(0.0, 0.0);
                std::cout << "Podaj dystans do przejścia (k, aby zakończyć): ";
        }// #1 while

Niestety moje próby nie dały pełnego sukcesu. Problem jest z pętla 'while', która nie wykonuje ponownie obliczeń (w kolejnych podejściach pętla ją pomija, lecz wykonuje całą resztę).

W przypadku usunięcia pętli zamysł  wytycznych jej poprawny:

- wykonywać n razy (n podaje użytkownik),

- zliczać kroki z każdej próby, wyznaczyć min i max,

- 'target' i 'd_steps' mają być takie same dla wykonywanych prób.

Jednak przez usunięcie 'while' pojawia się błąd w obliczeniach i zlicza tylko do 1 kroków.