Zadanie C++

[Roundstic 0]

Cześć mam zadanie z którym nie mogę sobie poradzić.

 

Zadanie brzmi następująco:

 

Napisz program w języku C++, który wczyta liczbę całkowitą 1<=N<=1000, a następnie n liczb całkowitych (typu int) i znajdzie wśród tych liczb minimum i maksimum zgodnie z algorytmem jednoczesnego znajdowania minimum i maksimum.

 

Algorytm jednoczesnego znajdowania minimum i maksimum wygląda jakoś tak

 

mamy np. liczby 1 5 7 2 3 8 2 4 3 2

 

Porównujemy je parami

 

1<5 7>2 3<8 2<4 3>2

 

U góry wypisujemy większe i wsród nich szukamy max

5 7 8 4 2

 

 

 

Na dole wypisujemy mniejsze i szukamy miniumum

 

1 2 3 2 2

 

 

Proszę o podpowiedzi z wykorzystaniem pętli oraz tablic bardzo proszę bez skomplikowanych funkcji

[Bono[UG] 1625]

Cześć mam zadanie z którym nie mogę sobie poradzić.

Napisz coś więcej z czym jest problem, bo to stwierdzenie jest zbyt ogólne i nie wiadomo czy problem tkwi w użyciu języka, czy z samym algorytmem, rozwiązaniem zadania.

[Roundstic 0]

Mam napisany taki kod do minimum:

#include <iostream>

 

using namespace std;

 

int main()

{

int T[100];

int n, i, m;

cin >> n;

for(i = 0; i < n; i++)

{

cin >> T;

}

 

m = T[0];

 

for(i = 1; i < n; i++)

{

if(m > T)

{

m = T;

}

}

 

cout << m << endl;

 

return 0;

}

 

I taki do maksimum

 

#include <iostream>

 

using namespace std;

 

int main()

{

int T[100];

int n, i, m;

cin >> n;

for(i = 0; i < n; i++)

{

cin >> T;

}

 

m = T;

 

for(i = 1; i < n; i++)

{

if(m <T)

{

m = T;

}

}

 

cout << m << endl;

 

return 0;

}

 

I nie wiem jak to połączyć

[Bono[UG] 1625]

Uwaga techniczna, jak wklejasz kod, to używaj tagów code (< > w menu).

 

Minimum

#include <iostream>

using namespace std;

int main()
{
   int T[100];
   int n, i, m;
   cin >> n;
   for(i = 0; i < n; i++)
   {
       cin >> T[i];
   }

   m = T[0];

   for(i = 1; i < n; i++)
   {
       if(m > T[i])
       {
           m = T[i];
       }
   }

   cout << m << endl;

   return 0;
}

 

Maksimum

#include <iostream>

using namespace std;

int main()
{
   int T[100];
   int n, i, m;
   cin >> n;
   for(i = 0; i < n; i++)
   {
       cin >> T[i];
   }

   m = T[i];

   for(i = 1; i < n; i++)
   {
       if(m <T[i])
       {
           m = T[i];
       }
   }

   cout << m << endl;

   return 0;
}

Prawda, że czytelniej?

 

 

Czy wiesz jak na papierze rozwiązać zadanie, jakie kroki trzeba zrobić?

Coś z programowania jarzysz, czy ciężko z tym? Rozumiesz jak działają zmienne, pętle, podane wyżej programy (w drugim jest błąd, widzisz go?)? Przydałoby się wiedzieć jakim językiem tłumaczyć.

 

Z połączenia tych dwóch programów nie do końca wyjdzie to co ma być w zadaniu, wynik będzie się zgadzał ale użyta metoda już nie. Ale na początek można zrobić taki wariant.

Żeby zrozumieć jak połączyć, to proponuję przyjrzeć się poszczególnym fragmentom i zobaczyć jaka jest część wspólna programów, a czym się różnią.

[Roundstic 0]

' date='14 Listopad 2019 - 15:01' timestamp='1573740072' post='15696906']

Uwaga techniczna, jak wklejasz kod, to używaj tagów code (< > w menu).

 

Minimum

#include <iostream>

using namespace std;

int main()
{
   int T[100];
   int n, i, m;
   cin >> n;
   for(i = 0; i < n; i++)
   {
       cin >> T[i];
   }

   m = T[0];

   for(i = 1; i < n; i++)
   {
       if(m > T[i])
       {
           m = T[i];
       }
   }

   cout << m << endl;

   return 0;
}

 

Maksimum

#include <iostream>

using namespace std;

int main()
{
   int T[100];
   int n, i, m;
   cin >> n;
   for(i = 0; i < n; i++)
   {
       cin >> T[i];
   }

   m = T[i];

   for(i = 1; i < n; i++)
   {
       if(m <T[i])
       {
           m = T[i];
       }
   }

   cout << m << endl;

   return 0;
}

Prawda, że czytelniej?

 

 

Czy wiesz jak na papierze rozwiązać zadanie, jakie kroki trzeba zrobić?

Coś z programowania jarzysz, czy ciężko z tym? Rozumiesz jak działają zmienne, pętle, podane wyżej programy (w drugim jest błąd, widzisz go?)? Przydałoby się wiedzieć jakim językiem tłumaczyć.

 

Z połączenia tych dwóch programów nie do końca wyjdzie to co ma być w zadaniu, wynik będzie się zgadzał ale użyta metoda już nie. Ale na początek można zrobić taki wariant.

Żeby zrozumieć jak połączyć, to proponuję przyjrzeć się poszczególnym fragmentom i zobaczyć jaka jest część wspólna programów, a czym się różnią.

 

Tak trochę słabo jarze, teorię znam, ale jak sam mam coś napisać sprawia mi to narazie ból. Błędu nie mogę znaleźć, jedynie może m=T[0]? Co do rozwiązania zadania z połączenia tych dwóch, to może stworzyć dwie funkcje jedną i potem je wywołać?

[Bono[UG] 1625]

Kolejna uwaga techniczna, nie cytuj poprzedzającej wypowiedzi.

 

Tak, przed pętlą szukającą maksimum, zamiast m=T powinno być m=T[0].

Tak jak było, to mogą wystąpić dwa błędy:

-odwołasz się do niezainicjowanego miejsca w tablicy lub co gorsza poza tablicę (tablica ma 100 elementów, przy podaniu 100 do wczytania, na koniec pętli i ma wartość 100, T[100] jest poza tablicą)

-pierwszy element tablicy nie jest uwzględniony w szukaniu (m ma inną wartość niż T[0], pętla startuje od i==1 czyli drugiego elementu tablicy)

 

 

Jak najbardziej można skorzystać z funkcji choć nie jest to konieczne, na pewno będzie eleganckie

 

To w ramach lepszego zrozumienia, trochę komentarzy

 

#include <iostream>

using namespace std;

int main()
{
   int T[100];
   int n, i, m;

//  << wczytywanie danych >>
   cin >> n;  //liczba elementów
   for(i = 0; i < n; i++)
   {
       cin >> T[i];  //kolejne elementy do tablicy
   }

// << szukanie minimum >>
   m = T[0];  //na początek za minimum przyjmujemy pierwszy element tablicy

   for(i = 1; i < n; i++)  //przeszukujemy w pętli całą tablicę
   {
       if(m > T[i])  //jeżeli minimum jest większe od i-tego elementu w tablicy, to ten element jest nowy minimum
                     //swoją drogą, to chyba łatwiej by się czytało kod, jeżeli porównanie wyglądałoby tak: T[i]<m, jak szukamy minimum, to sprawdzamy czy kolejny element nie jest mniejszy od obecnego minimum
                     //dla mnie taka kolejność jest bardziej naturalna
       {
           m = T[i];
       }
   }

// << wypisanie wyniku >>
   cout << m << endl;

   return 0;
}

 

Czyli mamy 3 główne bloki programu:

-wczytanie danych

-wyszukanie minimum

-zwrócenie wyniku

 

Po połączeniu będzie to wyglądało np. tak:

-wczytanie danych

-wyszukanie minimum

-wyszukanie maksimum

-zwrócenie wyniku

 

Jednym słowem wystarczy przepisać kawałek kodu od przeszukiwania, pamiętając, żeby użyć innej zmiennej do minimum i maksimum.

Warto komentować swój kod, bo zostaje ślad "co autor miał ne myśli". Przy większych projektach można się pogubić we własnym kodzie napisanym pół roku wcześniej. Przy nauce chyba też widać wtedy czy się rozumie co się pisze, jak nie wiadomo jak opisać kod, to znaczy, że nie wie co się robi

Warto też nazywać zmienne po imieniu. Wiem, że to upierdliwe i zabiera czas wpisanie minimum czy maksimum zamiast m ale jest czytelniejsze i tak samo przy większym programie łatwiej się połapać, która zmienna jest od czego. Wiadomo, że na ogół w pętlach i, j, k to liczniki i nie ma potrzeby z długimi nazwami.

[Roundstic 0]

#include <iostream>
using namespace std;
int main()
{
   int T[100];
   int n, max, min, i, j, g;
   //n - liczba elementow
   //max- maksimum
   //min- minimum
   //i- licznik pętli dla maksimum
   //j- licznik pętli dla minimum

   cin>>n; //wczytuje dane

   for(g=0; g<n; g++)
   {
       cin>>T[g];//kolejne elementy do tablicy
   }
//szukanie maksimum
   max=T[0];
   for(i=1; i<n; i++)
   {
       if(max<T[i])
       {
           max=T[i];
       }

   }
   //*****************************************************


   //szukanie minimum
   min=T[0];

   for(j=1; j<n; j++)
   {
       if(min>T[j])
       {
           min=T[j];
       }
   }
  //Wypisanie wyniku

   cout<<"Maksimum to: "<<max<<endl;
   cout<<"Minimum to: "<<min<<endl;


}

 

Bardzo dziękuję za wyjaśnienie. Czy tak może być?

[Bono[UG] 1625]

Może, tylko pamiętaj, że to nie jest rozwiązanie zadania.

 

Komentarze do zmiennych zwykle robi się tak

int T[100];  //tablica elementow
int n;      //liczba elementow
int max;    //szukane maksimum
int min;    //szukane minimum
int i, j, g; //liczniki petli (tu już mi się nie chciało rozbijać na poszczególne  )

Jak nie masz zagnieżdżonych pętli, to nie potrzeba do każdej deklarować innej zmiennej (chyba że licznik pętli chcesz wykorzystać poza nią). Przy większych programach zabraknie literek

 

 

Teraz trzeba dorobić część od jednoczesnego znajdowania minimum i maksimum. Nie wiem jaką macie definicję tego algorytmu ale znalazłem dwa warianty:

-dzieli zbiór na połowy min/max względem porównania kolejnych par, w zbiorze min wyszukuje się minimum, w max maksimum

-prawie to samo ale w jednej pętli, bez dzielenia zbioru i ponownego przeszukania podzielonych

 

Pierwszy wariant wydaje się prostszy, drugi powinien być ciut szybszy i oszczędniejszy na pamięci ale trochę bardziej skomplikowany.

Edytowane 16 Listopada 2019 przez Bono[UG]

[Roundstic 0]

Dzięki, to mam teraz kolejne pytanie chyba związane nadal z tym tematem, dlatego nie będę tworzył nowego.

 

Zadanie brzmi:

 

Napisz funkcję znajdzMinimum(...), która wśród elementów tablicy (wczytanych uprzednio od użytkownika) znajdzie element minimalny.

 

Wersja I:

 

Program ma wypisywać znaleziony element minimalny.

 

Wersja II:

 

Program ma wypisywać indeks w tablicy odpowiadający znalezionemu minimum oraz element minimalny.

 

 

 

 

Czy mogę zrobić to zadanie modyfikując to:

 

#include <iostream>

using namespace std;

int main()
{
   int T[100];
   int n, i, m;
   cin >> n;
   for(i = 0; i < n; i++)
   {
       cin >> T[i];
   }

   m = T[0];

   for(i = 1; i < n; i++)
   {
       if(m > T[i])
       {
           m = T[i];
       }
   }

   cout << m << endl;

   return 0;
}

[Roundstic 0]

Mam takie coś

 

 

#include <iostream>
using namespace std;

int ZnajdzMinimum(int T[], int n)// nagłówek funkcji
{

int i;// licznik pętli
int min; // minmum

min=T[0];// przyjmuje, że minumum równa się pierwszemu elementowi w tablicy



for(i=1; i<n; i++)//szukanie minumum
{
   if(min>T[i])
   {
       min=T[i];
   }
}

       return min; //zwrócenie wartości

}


int main()
{
   int m; //liczba elementow
   int T[100];

   cin>>m; //wczytanie danych

   for(int i=0; i<m; i++)//kolejne dane do tablicy
   {
       cin>>T[i];
   }

   cout<<"Minimum to: "<<ZnajdzMinimum(T, m);

   return 0;
}

Edytowane 17 Listopada 2019 przez Roundstic

[Bono[UG] 1625]

Tak. Trzeba fragment wyszukujący minimum zamknąć w funkcji.

W zależności od wersji, będzie trzeba dostosować argumenty funkcji oraz to co zwraca. Przydadzą się pojęcia przekazywania argumentów przez wartość i przez referencję.

 

Edit:

Masz złe warunki w pętlach, za dużo razy pętla przechodzi.

Edytowane 17 Listopada 2019 przez Bono[UG]

[MitycznyJeż 476]

Uwaga jakościowa. Zmienne powinno się inicjalizować wartościami zawsze gdy to tylko możliwe. To znaczy zamiast

int i;// licznik pętli
int min; // minmum

min=T[0];// przyjmuje, że minumum równa się pierwszemu elementowi w tablicy

for(i=1; i<n; i++)//szukanie minumum

Lepiej napisać tak:

int min=T[0]; // minmum - przyjmuje, że minumum równa się pierwszemu elementowi w tablicy

for(int i=1; i<n; i++)//szukanie minumum

 

Ponadto - enigmatyczne i jednoliterowe nazwy zmiennych i funkcji to (poza pewnymi wyjątkami) bardzo zła praktyka. Po co zaciemniać kod i doklejać do każdej deklaracji/definicji komentarz, jeżeli można po prostu dobrze rzeczy nazywać?

Komentowanie wszystkiego co popadnie również jest złą praktyką. Ktokolwiek kto miał styczność z cin będzie wiedzieć, że cin >> m; wczytuje. Komentarz zbędny. Tak samo - ktokolwiek, kto pisał funkcje doskonale wie, jak wygląda jej sygnatura/nagłówek - taki komentarz również nic nie wnosi, a jest tylko szumem informacyjnym.

Komentarze się przydają, gdy sam czytelny kod nie wystarcza do przekazania idei. Ale generalnie im ich mniej tym lepiej.

[Roundstic 0]

Dziękuję za odpowiedzi, komentarze są narazie dla mnie, bo w ten sposób lepiej zapamiętuje( uczę się c++ dopiero od miesiąca dlatego przepraszam za tak banale pytania/ błędy)

[Auberon 240]

on ma tam małą optymalizacje

min=T[0];

wiec w 1 kroku pętli było by porównanie T[0] > T[0] co zawsze jest fałszywe

 

fragment

int T[100];

może a nawet powinien wygadać

const int N = 100;
int T[N];

a puryści jeżykowi mogą się już domagać

constexpr int N = 100;

 

cin>>m; //wczytanie danych

nigdzie nie sprawdzasz czy ilość danych mieści się w 100 element-owej tablicy int ...

co już jest buffer overflow'em zaliczanym do błędów bezpieczeństwa (witamy w C++ )

no i kompletnie nie sprawdzasz poprawności wczytania danych ze strumienia cin

[wprowadź literę zamiast cyfry to się przekonasz]

słowem obsługa błędów nie istnieje

 

jednoliterowe nazwy i, j, k iteratorów pętli stały się już nie pisanym standardem

ale "m" dla liczby "wczytanych danych" jest złym pomysłem (ratuje tylko komentarz)

standardem samych komentarzy niby ma być język Szekspira ...

 

wartości nie zainicjowanych zmiennych (nie elementów tablic) de-facto zalezą od implementacji kompilatora dla profilu "debug" będą rożne od "release"

no i oczywiście wartości na różnych kompilatorach mogą być różne ponieważ standard C++ nie ich definicje (a chodżą słuchy że ma zacząć)

z tego powodu hard-koduje się wartości początkowe w ramach internalizacji zmiennych

 

te funkcje są tak krótkie i nigdzie indziej nie wykorzystywane że jest to głównie ćwiczenie

[Bono[UG] 1625]

Zluzuj, po jaką cholerę męczyć się ze sprawdzaniem poprawności wczytywanych danych do tak prostego programu, gdzie podstawową trudnością jest sam algorytm.

Definiowanie stałej określającej rozmiar tablicy, gdzie będzie wykorzystana raz też lekki przerost formy nad treścią.