Sortowanie czterech liczb bez użycia tablic

0

Witam, mam na zadanie napisać program w c++, który posortuje cztery liczby w kolejności od najmniejszej do największej bez użycia tablic, a potem największą liczbę podzielić przez najmniejszą. Napisałem pierwszą część sortowania, i mam problem z tym jak zrobić następne.

#include <iostream>
#include <math.h>

using namespace std;

int main()
{
cout<<endl<<"Podaj cztery liczby calkowite:"<<endl;
int a,b,c,d;
float x,c1;
cin >>a;
cin >>b;
cin >>c;
cin >>d;

    if (a < b && b < c && c < d) 
    {
        cout << a << " " << b << " " << c << " " << d << endl;
    }

    if (a < c && c < b && b < d) 
    {
        cout << a << " " << c << " " << b << " " << d << endl;
    }

    if (a < d && d < c && c < b) 
    {
        cout << a << " " << d << " " << c << " " << b << endl;
    }

    if (a < d && d < b && b < c) 
    {
        cout << a << " " << d << " " << b << " " << c << endl;
    }
}
2

Na razie nic nie posortowałeś, tylko wypisałeś, a i to błędnie. Posortuj liczby tak aby a < b < c <d (albo odwrotnie, jak tam chcesz) i wtedy dzielenie d/a (albo a/d, jeśli odwrotnie) będzie proste.

2

Obczaj sieci sortujące.

4--+--2--+---2--+--1
   |     |      |
2--+--4--|+--1--+--2
         ||     
1--+--1--|+--4--+--3
   |     |      |
3--+--3--+---3--+--4
2

Możesz użyć std::swap

    int a1, a2, a3, a4;

    std::cin >> a1 >> a2 >> a3 >> a4;

    if( a1 < a2 ) std::swap( a1 , a2 );
    if( a3 < a4 ) std::swap( a3 , a4 );
    if( a1 < a3 ) std::swap( a1 , a3 );
    if( a2 < a4 ) std::swap( a2 , a4 );
    if( a2 < a3 ) std::swap( a2 , a3 );

    std::cout << a4 << " " << a3 << " " << a2 << " " << a1 << "\n";
1

Możesz użyć std::sort

#include <algorithm>
#include <iostream>

struct Dupa {
    int a, b, c, d;
};

int main()
{
    Dupa dupa;
    std::cin >> dupa.a >> dupa.b >> dupa.c >> dupa.d;
    std::sort(&dupa.a, &dupa.d + 1);
    std::cout << dupa.a << ' ' << dupa.b << ' ' << dupa.c << ' ' << dupa.d;
}
0
Kuba Szczęch napisał(a):

a potem największą liczbę podzielić przez najmniejszą

w jednej linijce można wypisać najmniejszą i największą z liczb a, b, c i d, nawet dla większej ilości liczb.
Zakładając, że w = min{a, b, c, d} oraz z = max{a, b, c, d}:
int w = std::min(a, std::min(b, std::min(c, d))); - najmniejsza
int z = std::max(a, std::max(b, std::max(c, d))); - największa
z / w;

Edit:
Teraz wiedząc jaką wartość ma liczba najmniejsza i największa odejmij od a, b, c i d raz najmniejszą, raz największa i po porównaniu do 0 będziesz wiedział, która to z tych liczb. Zostaną Tobie dwie "środkowe", które porównasz w jednym ifie.
Edit:
Odejmowanie to operacja niepotrzebna, po prostu wystarczy porównać te liczby do w i do z i będzie wiadomo, która z nich jest najmniejsza, a która największa.

0

Idąc dalej sposobem @ReallyGrid:

int w = std::min(a, std::min(b, std::min(c, d))); // najmniejsza
int z = std::max(a, std::max(b, std::max(c, d))); // największa
int x = std::min(std::max(std::min(a, b), std::min(c, d)), std::min(std::max(a, b), std::max(c, d)));  // druga
int y = std::max(std::max(std::min(a, b), std::min(c, d)), std::min(std::max(a, b), std::max(c, d))); // trzecia
std::cout << w << ' ' << x << ' ' << y << ' ' << z << '\n';
1
template<typename T>
void sortVariables(T &x, T &y)
{
    if (x>y) std::swap(x, y);
}


template<typename T, typename...Args>
void sortVariables(T &x, T &y, Args& ... args)
{
     sortVariables(x, args...);
     sortVariables(y, args...);
     sortVariables(x, y);
}

https://wandbox.org/permlink/1RXIG3Ow1AgIrvYG

Albo jeszcze bardziej uniwersalnie:

template<typename Cmp, typename T>
std::enable_if_t<std::is_invocable_v<Cmp, T, T>>
sortVariables(Cmp cmp, T &x, T &y)
{
    if (!cmp(x, y)) std::swap(x, y);
}


template<typename Cmp, typename T, typename...Args>
std::enable_if_t<std::is_invocable_v<Cmp, T, T>>
sortVariables(Cmp cmp, T &x, T &y, Args& ... args)
{
     sortVariables(cmp, x, args...);
     sortVariables(cmp, y, args...);
     sortVariables(cmp, x, y);
}

template<typename T, typename...Args>
void sortVariables(T &x, Args& ... args)
{
     sortVariables(std::less<T>{}, x, args...);
}

https://wandbox.org/permlink/iQ6aJzTIddMQQVmX

1 użytkowników online, w tym zalogowanych: 0, gości: 1