TL: DR; Twój kod jest już poprawny i „czysty”.
Widzę wielu ludzi wahających się wokół odpowiedzi, ale wszyscy tęsknią za lasem przez drzewa. Zróbmy pełną informatykę i analizę matematyczną, aby całkowicie zrozumieć to pytanie.
Po pierwsze, zauważamy, że mamy 3 zmienne, każda z 3 stanami: <, = lub>. Całkowita liczba permutacji wynosi 3 ^ 3 = 27 stanów, do których przypisam unikalny numer, oznaczony P #, dla każdego stanu. Ten numer P # to system liczb czynnikowych .
Zliczając wszystkie permutacje, które mamy:
a ? b | a ? c | b ? c |P#| State
------+-------+-------+--+------------
a < b | a < c | b < c | 0| C
a = b | a < c | b < c | 1| C
a > b | a < c | b < c | 2| C
a < b | a = c | b < c | 3| impossible a<b b<a
a = b | a = c | b < c | 4| impossible a<a
a > b | a = c | b < c | 5| A=C > B
a < b | a > c | b < c | 6| impossible a<c a>c
a = b | a > c | b < c | 7| impossible a<c a>c
a > b | a > c | b < c | 8| A
a < b | a < c | b = c | 9| B=C > A
a = b | a < c | b = c |10| impossible a<a
a > b | a < c | b = c |11| impossible a<c a>c
a < b | a = c | b = c |12| impossible a<a
a = b | a = c | b = c |13| A=B=C
a > b | a = c | b = c |14| impossible a>a
a < b | a > c | b = c |15| impossible a<c a>c
a = b | a > c | b = c |16| impossible a>a
a > b | a > c | b = c |17| A
a < b | a < c | b > c |18| B
a = b | a < c | b > c |19| impossible b<c b>c
a > b | a < c | b > c |20| impossible a<c a>c
a < b | a = c | b > c |21| B
a = b | a = c | b > c |22| impossible a>a
a > b | a = c | b > c |23| impossible c>b b>c
a < b | a > c | b > c |24| B
a = b | a > c | b > c |25| A=B > C
a > b | a > c | b > c |26| A
Po kontroli stwierdzamy, że mamy:
- 3 stany, w których A jest wartością maksymalną,
- 3 stany, w których B jest maksimum,
- 3 stany, w których C jest wartością maksymalną, oraz
- 4 stany, w których A = B lub B = C.
Napiszmy program (patrz przypis), aby wyliczyć wszystkie te permutacje wartościami A, B i C. Sortowanie stabilne według P #:
a ?? b | a ?? c | b ?? c |P#| State
1 < 2 | 1 < 3 | 2 < 3 | 0| C
1 == 1 | 1 < 2 | 1 < 2 | 1| C
1 == 1 | 1 < 3 | 1 < 3 | 1| C
2 == 2 | 2 < 3 | 2 < 3 | 1| C
2 > 1 | 2 < 3 | 1 < 3 | 2| C
2 > 1 | 2 == 2 | 1 < 2 | 5| ??
3 > 1 | 3 == 3 | 1 < 3 | 5| ??
3 > 2 | 3 == 3 | 2 < 3 | 5| ??
3 > 1 | 3 > 2 | 1 < 2 | 8| A
1 < 2 | 1 < 2 | 2 == 2 | 9| ??
1 < 3 | 1 < 3 | 3 == 3 | 9| ??
2 < 3 | 2 < 3 | 3 == 3 | 9| ??
1 == 1 | 1 == 1 | 1 == 1 |13| ??
2 == 2 | 2 == 2 | 2 == 2 |13| ??
3 == 3 | 3 == 3 | 3 == 3 |13| ??
2 > 1 | 2 > 1 | 1 == 1 |17| A
3 > 1 | 3 > 1 | 1 == 1 |17| A
3 > 2 | 3 > 2 | 2 == 2 |17| A
1 < 3 | 1 < 2 | 3 > 2 |18| B
1 < 2 | 1 == 1 | 2 > 1 |21| B
1 < 3 | 1 == 1 | 3 > 1 |21| B
2 < 3 | 2 == 2 | 3 > 2 |21| B
2 < 3 | 2 > 1 | 3 > 1 |24| B
2 == 2 | 2 > 1 | 2 > 1 |25| ??
3 == 3 | 3 > 1 | 3 > 1 |25| ??
3 == 3 | 3 > 2 | 3 > 2 |25| ??
3 > 2 | 3 > 1 | 2 > 1 |26| A
Jeśli zastanawiasz się, skąd wiedziałem, które stany P # są niemożliwe, teraz już wiesz. :-)
Minimalna liczba porównań w celu ustalenia kolejności wynosi:
Log2 (27) = Log (27) / Log (2) = ~ 4,75 = 5 porównań
tzn. rdzeń rdzeniowy dał prawidłową 5 minimalną liczbę porównań. Sformatowałbym jego kod jako:
status_t index_of_max_3(a,b,c)
{
if (a > b) {
if (a == c) return DONT_KNOW; // max a or c
if (a > c) return MOSTLY_A ;
else return MOSTLY_C ;
} else {
if (a == b) return DONT_KNOW; // max a or b
if (b > c) return MOSTLY_B ;
else return MOSTLY_C ;
}
}
W przypadku Twojego problemu nie zależy nam na testowaniu równości, więc możemy pominąć 2 testy.
Nie ma znaczenia, jak czysty / zły jest kod, jeśli otrzyma złą odpowiedź, więc jest to dobry znak, że poprawnie załatwiasz wszystkie sprawy!
Następnie, jeśli chodzi o prostotę, ludzie próbują „poprawić” odpowiedź, w której ich zdaniem poprawa oznacza „optymalizację” liczby porównań, ale nie jest to dokładnie to, o co prosisz. Zdezorientowałeś wszystkich, gdy zapytałeś „Czuję, że może być lepszy”, ale nie zdefiniowałeś, co oznacza „lepszy”. Mniej porównań? Mniej kodu? Optymalne porównania?
Teraz, gdy pytasz o czytelność kodu (biorąc pod uwagę poprawność), dokonałbym tylko jednej zmiany w twoim kodzie dla czytelności: Dopasuj pierwszy test do pozostałych.
if (a > b && a > c)
status = MOSTLY_A;
else if (b > a && b > c)
status = MOSTLY_B;
else if (c > a && c > b)
status = MOSTLY_C;
else
status = DONT_KNOW; // a=b or b=c, we don't care
Osobiście napisałbym to w następujący sposób, ale może to być zbyt niekonwencjonalne dla twoich standardów kodowania:
if (a > b && a > c) status = MOSTLY_A ;
else if (b > a && b > c) status = MOSTLY_B ;
else if (c > a && c > b) status = MOSTLY_C ;
else /* a==b || b ==c*/status = DONT_KNOW; // a=b or b=c, we don't care
Przypis: Oto kod C ++ do generowania permutacji:
#include <stdio.h>
char txt[] = "< == > ";
enum cmp { LESS, EQUAL, GREATER };
int val[3] = { 1, 2, 3 };
enum state { DONT_KNOW, MOSTLY_A, MOSTLY_B, MOSTLY_C };
char descr[]= "??A B C ";
cmp Compare( int x, int y ) {
if( x < y ) return LESS;
if( x > y ) return GREATER;
/* x==y */ return EQUAL;
}
int main() {
int i, j, k;
int a, b, c;
printf( "a ?? b | a ?? c | b ?? c |P#| State\n" );
for( i = 0; i < 3; i++ ) {
a = val[ i ];
for( j = 0; j < 3; j++ ) {
b = val[ j ];
for( k = 0; k < 3; k++ ) {
c = val[ k ];
int cmpAB = Compare( a, b );
int cmpAC = Compare( a, c );
int cmpBC = Compare( b, c );
int n = (cmpBC * 9) + (cmpAC * 3) + cmpAB; // Reconstruct unique P#
printf( "%d %c%c %d | %d %c%c %d | %d %c%c %d |%2d| "
, a, txt[cmpAB*2+0], txt[cmpAB*2+1], b
, a, txt[cmpAC*2+0], txt[cmpAC*2+1], c
, b, txt[cmpBC*2+0], txt[cmpBC*2+1], c
, n
);
int status;
if (a > b && a > c) status = MOSTLY_A;
else if (b > a && b > c) status = MOSTLY_B;
else if (c > a && c > b) status = MOSTLY_C;
else /* a ==b || b== c*/status = DONT_KNOW; // a=b, or b=c
printf( "%c%c\n", descr[status*2+0], descr[status*2+1] );
}
}
}
return 0;
}
Edycje: Na podstawie opinii, przeniesiono TL: DR na górę, usunięto nieposortowaną tabelę, wyjaśniono 27, wyczyściłem kod, opisałem niemożliwe stany.