Programme pour trouver le plus grand et le plus petit parmi 5 nombres sans utiliser de tableau
Hier, je suis allé pour une entrevue où on m'a demandé de créer un programme pour trouver le plus grand et le plus petit des 5 nombres sans utiliser de tableau.
Je sais comment créer le programme en utilisant array.
int largestNumber;
int smallestNumber;
int numbers[n];
largestNumber=numbers[0];
smallestNumber=numbers[0];
for (i=0 ; i<n; i++)
{
if (numbers[i] > largestNumber)
{
largest = numbers[i];
}
if (numbers[i] < smallestNumber)
{
smallestNumber= numbers[i];
}
}
Mais comment le créer sans utiliser de tableau. De l'aide??
#include <algorithm>
#include <iostream>
template <typename T>
inline const T&
max_of(const T& a, const T& b) {
return std::max(a, b);
}
template <typename T, typename ...Args>
inline const T&
max_of(const T& a, const T& b, const Args& ...args) {
return max_of(std::max(a, b), args...);
}
int main() {
std::cout << max_of(1, 2, 3, 4, 5) << std::endl;
// Or just use the std library:
std::cout << std::max({1, 2, 3, 4, 5}) << std::endl;
return 0;
}
Fonctionne pour n’importe quel nombre de nombres issus de l’entrée standard:
#include <algorithm>
#include <iterator>
#include <iostream>
int main()
{
std::istream_iterator<int> it_begin(std::cin), it_end;
auto p = std::minmax_element(it_begin, it_end);
if (p.first != it_end)
std::cout << "min: " << *p.first << " max: " << *p.second;
}
Avertissement:
Techniquement, cela n’est pas nécessaire pour fonctionner avec la norme C++. La catégorie d'itérateur minimale requise pour minmax_element est ForwardIterator, ce que les itérateurs de flux ne sont pas. Une fois qu'un itérateur d'entrée est déréférencé ou incrémenté, il n'est plus garanti que ses copies soient déréférencables ou comparables aux autres itérateurs. Ça marche sur ma machineTM. :)
Vous pouvez faire quelque chose comme ça:
int min_num = INT_MAX; // 2^31-1
int max_num = INT_MIN; // -2^31
int input;
while (!std::cin.eof()) {
std::cin >> input;
min_num = min(input, min_num);
max_num = max(input, max_num);
}
cout << "min: " << min_num;
cout << "max: " << max_num;
Ceci lit les nombres de l'entrée standard jusqu'à la fin (peu importe combien vous avez - 5 ou 1 000 000).
Par exemple 5 numéros consécutifs
int largestNumber;
int smallestNumber;
int number;
std::cin>>number;
largestNumber = number;
smallestNumber = number;
for (i=0 ; i<5; i++)
{
std::cin>>number;
if (number > largestNumber)
{
largest = number;
}
if (numbers < smallestNumber)
{
smallestNumber= number;
}
}
Voici ma mise en œuvre: simple et court
#include <iostream>
#include <cstdio>
using namespace std;
int max_of_five(int a, int b, int c, int d,int e){
int large= max(max(a, b), max(c,d));
return max(large,e);
}
int min_of_five(int a,int b,int c, int d,int e){
int small=min(min(a,b),min(c,d));
return min(small,e);
}
int main() {
int a, b, c, d,e;
scanf("%d %d %d %d %d", &a, &b, &c, &d,&e);
int ans = max_of_five(a, b, c, d, e);
int ans1=min_of_five(a,b,c,d,e);
printf("Max:\t%d\n", ans);
printf("Min:\t%d", ans1);
return 0;
}
int findMin(int t1, int t2, int t3, int t4, int t5)
{
int min;
min = t1;
if (t2 < min)
min = t2;
if (t3 < min)
min = t3;
if (t4 < min)
min = t4;
if (t5 < min)
min = t5;
return min;
}
int findMax(int t1, int t2, int t3, int t4, int t5)
{
int max;
max = t1;
if (t2 > max)
max = t2;
if (t3 > max)
max = t3;
if (t4 > max)
max = t4;
if (t5 > max)
max = t5;
return max;
}
Utilisez un réseau de tri!
#include <iostream>
#include <utility>
int main()
{
int a, b, c, d, e;
std::cin >> a >> b >> c >> d >> e;
if (a < b) std::swap(a, b);
if (d < e) std::swap(d, e);
if (c < e) std::swap(c, e);
if (c < d) std::swap(c, d);
if (b < e) std::swap(b, e);
if (a < d) std::swap(a, d);
if (a < c) std::swap(a, c);
if (b < d) std::swap(b, d);
if (b < c) std::swap(b, c);
std::cout << "largest = " << a << '\n';
std::cout << "smallest = " << e << '\n';
}
Si vous aimez garder les choses simples, voici ma solution.
Cela fonctionne pour n'importe quel nombre d'entiers pris de l'entrée standard. Cela fonctionne aussi pour les entiers négatifs. Entrez end lorsque vous avez terminé.
#include <iostream>
int main()
{
int max,min,input;
std::cout<<"Enter the number: ";
std::cin>>input;
min=max=input;
while(std::cin>>input){
if(input>max) max=input;
if(input<min) min=input;
std::cout<<"Enter the number: ";
}
std::cout<<"\nMax: "<<max<<"\nMin: "<<min;
}
Ce n'est pas une réponse efficace mais cela fonctionne toujours
int a,b,c,d,e,largest;
if ((a>b) and (a>c) and (a>d) and (a>e))
{
largest=a;
}
else if ((b>a) and (b>c) and (b>d) and (b>e))
{
largest=b;
}
else if ((c>a) and (c>a) and (c>d) and (c>e))
{
largest=c;
}
else if ((d>a) and (d>c) and (d>a) and (d>e))
{
largest=d;
}
else
{
largest=e;
}
vous pouvez utiliser une logique similaire pour respecter la plus petite valeur
Let max tiendra le maximum de 5 nombres. Attribuer le premier numéro à max. Prenez le deuxième nombre et comparez-le avec max si le deuxième nombre est supérieur à max, puis affectez-le à max sinon ne faites rien. Ensuite, prenez le troisième nombre et comparez-le avec max. Si le troisième nombre est supérieur à max, affectez-le à max sinon ne faites rien. Faites la même chose pour les 4ème et 5ème numéros. Enfin, max tiendra le nombre maximum de 5.
void main()
{
int a,b,c,d,e,max;
max=a;
if(b/max)
max=b;
if(c/max)
max=c;
if(d/max)
max=d;
if(e/max)
max=e;
cout<<"Maximum is"<<max;
}
Les > et < sont des propriétés transitives, donc si a > b et b > c, alors a > c. Afin que vous puissiez
int a=10, b=6, c=4, d=21, e=4;
int maxNum = a;
int maxNum = max(b, maxNum);
int maxNum = max(c, maxNum);
int maxNum = max(d, maxNum);
int maxNum = max(e, maxNum);
int findMin(int t1, int t2, int t3, int t4, int t5)
{
int min1, min2, min3;
min1 = std::min(t1, t2);
min2 = std::min(t3, t4);
min3 = std::min(min1, min2);
return std::min(min3, t5);
}
int findMax(int t1, int t2, int t3, int t4, int t5)
{
int max1, max2, max3;
max1 = std::max(t1, t2);
max2 = std::max(t3, t4);
max3 = std::max(max1, max2);
return std::max(max3, t5);
}
Ces fonctions sont très compliquées, mais faciles à suivre et donc faciles à mémoriser. Elle utilise uniquement les méthodes simples min et max qui fonctionnent le mieux pour 2 valeurs.
Heres ce que j'ai fait, sans utiliser un tableau. C'était une méthode pour renvoyer le plus grand nombre de 5 scores.
double findHighest(double score1, double score2, double score3, double score4, double score5)
{
double highest = score1;
if (score2 > score1 && score2 > score3 && score2 > score4 && score2 > score5)
highest = score2;
if(score3 > score1 && score3 > score2 && score3 > score4 && score3 > score5)
highest = score3;
if(score4 > score1 && score4 > score2 && score4 > score3 && score4 > score5)
highest = score4;
if (score5 > score1 && score5 > score2 && score5 > score3 && score5 > score4)
highest = score5;
return highest;
}
Un tableau sera beaucoup plus efficace, mais je devais le faire comme devoir sans utiliser de tableau.
Vous pouvez utiliser list (ou vector), qui n'est pas un tableau:
#include<list>
#include<algorithm>
#include<iostream>
using namespace std;
int main()
{
list<int> l;
l.Push_back(3);
l.Push_back(9);
l.Push_back(30);
l.Push_back(0);
l.Push_back(5);
list<int>::iterator it_max = max_element(l.begin(), l.end());
list<int>::iterator it_min = min_element(l.begin(), l.end());
cout << "Max: " << *it_max << endl;
cout << "Min: " << *it_min << endl;
}