टी एल: डॉ; आपका कोड पहले से ही सही और "साफ" है।
मैंने देखा कि बहुत से लोग जवाब के आसपास इंतजार कर रहे हैं लेकिन हर कोई पेड़ों के माध्यम से जंगल को याद कर रहा है। आइए इस प्रश्न को पूरी तरह से समझने के लिए पूर्ण कंप्यूटर विज्ञान और गणितीय विश्लेषण करें।
सबसे पहले, हम ध्यान दें कि हमारे पास 3 चर हैं, जिनमें से प्रत्येक में 3 राज्य हैं: <, =, या>। क्रमपरिवर्तन की कुल संख्या 3 ^ 3 = 27 राज्य है, जिसे मैं प्रत्येक राज्य के लिए P # नाम से निरूपित एक अद्वितीय संख्या बताऊंगा। यह P # संख्या एक भाज्य संख्या प्रणाली है ।
हमारे पास सभी क्रमपरिवर्तन की गणना:
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
निरीक्षण से हम देखते हैं कि हमारे पास है:
- 3 राज्य जहां A अधिकतम है,
- 3 राज्य जहां B अधिकतम है,
- 3 राज्य जहां C अधिकतम है, और
- 4 राज्य जहां या तो ए = बी, या बी = सी।
आइए एक प्रोग्राम लिखें (फुटनोट देखें) ए, बी, और सी के लिए इन सभी क्रमपरिवर्तन की गणना करें पी द्वारा # स्थिर छँटाई:
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
मामले में आप सोच रहे थे कि मैं कैसे जानता था कि कौन से P # राज्य असंभव थे, अब आप जानते हैं। :-)
आदेश का निर्धारण करने के लिए तुलना की न्यूनतम संख्या है:
लॉग 2 (27) = लॉग (27) / लॉग (2) = ~ 4.75 = 5 तुलना
कोरडंप ने सही 5 न्यूनतम संख्या की तुलना की। मैं उनके कोड को इस रूप में प्रारूपित करूंगा:
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 ;
}
}
आपकी समस्या के लिए हम समानता के लिए परीक्षण के बारे में परवाह नहीं करते हैं ताकि हम 2 परीक्षणों को छोड़ सकें।
इससे कोई फर्क नहीं पड़ता कि कोड कितना साफ / खराब है अगर उसे गलत उत्तर मिल जाता है तो यह एक अच्छा संकेत है कि आप सभी मामलों को सही तरीके से संभाल रहे हैं!
अगला, जैसा कि सादगी के लिए होता है, लोग उत्तर को "सुधार" करने की कोशिश करते रहते हैं, जहां उन्हें लगता है कि सुधार का मतलब तुलनाओं की संख्या को "अनुकूलित" करना है, लेकिन यह कड़ाई से नहीं है जो आप पूछ रहे हैं। आपने हर किसी को भ्रमित किया जहां आपने पूछा "मुझे लगता है कि एक बेहतर हो सकता है" लेकिन यह परिभाषित नहीं किया कि 'बेहतर' का क्या मतलब है। तुलना कम? कम कोड? इष्टतम तुलना?
अब चूंकि आप कोड की पठनीयता (शुद्धता के बारे में) के बारे में पूछ रहे हैं, मैं केवल पठनीयता के लिए आपके कोड में एक बदलाव करूंगा: दूसरों के साथ पहला परीक्षण संरेखित करें।
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
व्यक्तिगत रूप से मैं इसे निम्नलिखित तरीके से लिखूंगा लेकिन यह आपके कोडिंग मानकों के लिए बहुत ही अपरंपरागत हो सकता है:
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
फुटनोट: यहाँ क्रमचय उत्पन्न करने के लिए C ++ कोड है:
#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;
}
संपादन: फीडबैक के आधार पर, टीएल: डीआर को शीर्ष पर ले जाया गया, हटाए गए टेबल को हटा दिया, 27 को स्पष्ट किया, कोड को साफ किया, असंभव राज्यों को वर्णित किया।