पहले और अंतिम तत्व पर लूप केवल

Question

N तत्वों को देखते हुए, केवल पहले (0) और अंतिम (एन -1) तत्व को संसाधित करें।

लेकिन, यदि N = 1, केवल एक बार एक तत्व को संसाधित करें।

एक लूप का उपयोग करना जो एक या दो बार चलता है, उचित रूप से, हमें लूप बॉडी को डुप्लिकेट करने से बचने देता है। यदि ऐसा करने के लिए एक पठनीय तरीका है, तो इसका स्रोत-कोड आकार का लाभ होता है। यदि लूप बॉडी बड़ा है, तो इसमें मशीन-कोड आकार के फायदे भी हो सकते हैं, और संकलक इसे डुप्लिकेट नहीं कर सकता है।

---

मैं N-1 से incrementing कोशिश की, लेकिन यह काम नहीं करेगा जब N=1 (हमेशा के लिए लूप)। क्या वहां चालें हैं (रिवर्स लूप एफ.आई) जो इसे ठीक करेगी?

for (i = 0 ; i < N ; i += (N - 1)) 

संपादित करें:

मेरे मूल समस्या एक्स, वाई, जेड दिशा में तीन नेस्टेड छोरों से संबंधित है, जिसके कारण मैं कर सकता न सिर्फ प्रक्रिया ELEM [0]) और ELEM [एन 1]। अब मैं निम्नलिखित

#define forEachLglBound(i_,j_,k_)         \ 
     for(Int i_ = 0;i_ < NPX;i_+=((NPX>1) ? (NPX-1) : 1))  \ 
      for(Int j_ = 0;j_ < NPY;j_+=((NPY>1) ? (NPY-1) : 1)) \ 
       for(Int k_ = 0;k_ < NPZ;k_+=((NPZ>1) ? (NPZ-1) : 1)) 

---

Answer 1

निम्न पंक्ति के बारे में कैसे। मूल समाधान के लिए बहुत करीब (textwise!)।

for (i = 0 ; i < N ; i += (N > 1) ? N-1 : 1) 

Answer 2

for (i = 0, repeat = 0; repeat < 2 && repeat < N; repeat++, i = N-1) 

या

repeat = (N<2) ? N : 2; 
for (i = 0; repeat > 0; repeat--, i = N-1) 

Answer 3

इस बारे में है, हालांकि शायद एक for loop उपयोग करने के लिए की जरूरत नहीं है कैसे है, लेकिन यह एक आसान तरीका और समझने में आसान है।

for (int first = 0, last = N - 1;;) { 
    // the stuff use first 
    if (first != last) { 
    // the stuff use last 
    } 
    break; 
} 

Answer 4

आप एक समारोह या मैक्रो में पाश शरीर को अलग कर सकते हैं, शायद सबसे पठनीय तरीका है:

process(arr[0]); 
if (N-1 != 0) 
    process(arr[N-1]); 

---

अगर वह एक विकल्प नहीं है, या आप इनमें से किसी एक लगता है लूप संरचना पर्याप्त पठनीय है:

एक्सओआर 0 के बीच एक चर टॉगल कर सकता है और आपके साथ एक्सओआर मूल्य।

int i=0; 
do { 
    process(arr[i]); 
} while(i ^= (N-1)); // xor to toggle, but stays zero if N-1 is zero 

यह अन्य विकल्प, as you can see on godbolt में से किसी की तुलना में बेहतर एएसएम को संकलित करता है। मैंने अन्य उत्तरों से विचारों को शामिल किया, जिसमें सरल if शामिल है (जो ऑपरेशन को डुप्लिकेट करते समय बहुत अच्छा करता है)।

xor संस्करण ट्रिपल-नेस्टेड लूप में बहुत अच्छी तरह से काम करता रहता है (गॉडबॉल्ट लिंक के नीचे while_xor_triple फ़ंक्शन देखें)।

---

XOR का उपयोग कर के बिना, मुझे लगता है कि इस पाश मामूली पढ़ी जा सकती है:

int i=0; 
do { 
    process(arr[i]); 
} while((i!=N-1) && (i=N-1)); 

अगर i पहले से ही N-1, नहीं है कि करने के लिए यह सेट और पाश फिर से करना। यह एन-1 के अलावा किसी भी अभिव्यक्ति की गणना किए बिना, कंपाइलर को कुशलतापूर्वक परीक्षण करने के लिए आसान बनाना चाहिए। जीसीसी अभी भी && दोनों ऑपरेटरों पर परीक्षण और शाखाएं अलग-अलग हैं, लेकिन कुछ अन्य उत्तरों की तुलना में कम ओवरहेड के साथ।

---

2 जबकि पाश कुछ इस तरह के संकलन सकता है (लेकिन दुर्भाग्य से नहीं हुआ, क्योंकि जीसीसी मेरी पहली दो insns की प्रवंचना नहीं है):

xor edx, edx 
.repeat: 
    mov ecx, edx 
     ... loop body using i (ecx) 
    mov edx, [N] 
    dec edx  ; edx = N-1 
    cmp ecx, edx 
    jne .repeat 

मैं के बारे में सोचा एएसएम में इसे कैसे करें इसके बारे में सोचते समय एक्सओआर विचार। IDK अगर एक स्मार्ट संकलक while(i!=N-1 && i=N-1) संस्करण से इस उत्पादन कर सकता है, लेकिन यह निश्चित रूप से बेहतर है: mov/dec मक्खी पर यह गणना करने के लिए दूर जाना

xor ecx, ecx 
.repeat: 
     ... loop body using i (ecx) 
    mov edx, [N] 
    dec edx  ; edx = N-1 
    xor ecx, edx ; i ^= N-1 
    jnz .repeat  ; jump if the last result wasn't zero 

आप N-1 एक रजिस्टर या स्मृति में संग्रहीत है, तो।