इन अनुक्रमों को संतुष्ट करते समय निम्न अनुक्रम को मुद्रित करने के लिए

Question

यह वास्तव में एक साक्षात्कार प्रश्न था। मैं निम्नलिखित का उपयोग कर जावा मुद्रित करने के लिए किया था:

9 
9 8 9 
9 8 7 8 9 
9 8 7 6 7 8 9 
. . . 
. . . 

साक्षात्कार के दौरान, मैं कोड की एक शर्मनाक टुकड़ा लिखा था, लेकिन यह भी काम किया - एक बाहरी पाश का उपयोग कर, दो भीतरी छोरों (decrementing दृश्य के लिए एक और एक वृद्धिशील अनुक्रम के लिए!) और चर के एक टन। चरों में से एक प्रत्येक पंक्ति की लंबाई थी।

साक्षात्कारकर्ता ने मुझसे पूछा कोशिश करते हैं और पंक्ति लंबाई चर बिना

• सिर्फ एक बाहरी और एक आंतरिक पाश

• का उपयोग कर इसे पुनः लिखने के लिए।

नोट: जवाब को देखने के बाद, मुझे लगता है कि साक्षात्कारकर्ता वास्तव में दूसरी शर्त मतलब नहीं था। वह शायद मुझे अपने कोड को सरल बनाना चाहता था और दूसरी बात सिर्फ उसके मुंह से बाहर हो गई। यहाँ

int rowCnt = 5; 

for(int i = 1; i <= rowCnt; i++) 
{ 
    int val = 9; 
    int delta = -1; 
    int rowLen = i * 2 - 1; 

    for(int j = 1; j <= rowLen; j++) 
    { 
     System.out.print(val + " "); 

     val += delta; 

     if(j >= rowLen/2) delta = 1; 
    } 

    System.out.println(); 
} 

, मैं सिर्फ एक भीतरी पाश उपयोग कर रहा हूँ:

तो, बाद में घर वापस, मैं इस पर पहुंचे। मैं यह निर्धारित करने के लिए delta मान का उपयोग कर रहा हूं कि वृद्धि या कमी होती है या नहीं। प्रत्येक पंक्ति के लिए, मैं वर्तमान इंडेक्स की पंक्ति के मध्य बिंदु से तुलना करता हूं और डेल्टा बदलता हूं।

मैंने पहली शर्त को संतुष्ट किया - केवल एक आंतरिक लूप। लेकिन मैं पंक्ति लंबाई का उपयोग किए बिना ऐसा करने में सक्षम नहीं हूं।

पंक्ति लंबाई को जानने के बिना हम इसे कैसे प्रिंट कर सकते हैं?

कई उत्तरों स्वीकार्य थे, लेकिन मुझे एक चुनना पड़ा, और वह मेरे लिए समझने के लिए सबसे सरल था।

Answer 1

वे शायद शब्द 'प्रत्यावर्तन' सुनना चाहते थे।

countDownInMiddle("", 9, ""); 

private static void countDownInMiddle(String start, int n, String end) { 
    if (n < 0) { 
     return; 
    } 
    System.out.println(start + n + end); 
    countDownInMiddle(start + n, n - 1, n + end); 
} 

Answer 2

कैसे के बारे में:

int start = 9; 
    for (int i = 0; i <= start; i++) { 
     StringBuilder sb = new StringBuilder((start - i) + " "); 
     for (int j = start - i; j < start; j++) { 
      sb.insert(0, (j + 1) + " "); 
      sb.append((j + 1) + " "); 
     } 
     System.out.println(sb.toString()); 
    } 

Answer 3

यह सरल PHP है, आशा तर्क स्पष्ट और जावा के लिए आसानी से पोर्टेबल है:

$rowCount = 10; 
$startNum = 9; 

for ($idx =0; $idx <$rowCount; $idx ++) { 

    for ($jdx=0; $jdx < (2*$idx +1); $jdx++) { 

     if ($idx < $jdx) 
      echo $startNum -(2*$idx) + $jdx.' '; 
     else 
      echo $startNum - $jdx.' '; 
    } 
    echo '<br/>'; 
} 

Answer 4

public class Pyramid { 
    public static void main(String[] args) { 
     int start = 9; 
     String left = ""; 
     String right = ""; 
     for (int i=start; i>=0; i--) { 
      System.out.println(left+i+right); 
      left = left+i; 
      right = i+right; 
     } 
    } 
} 

नमूना उत्पादन:

9 
989 
98789 
9876789 
987656789 
98765456789 
9876543456789 
987654323456789 
98765432123456789 
987654321

यह पुनरावृत्ति समाधान पुनरावर्ती समाधान के बराबर है

यहाँ एक पुनरावर्ती समाधान है कि लंबाई की जरूरत नहीं है। मैं रिकर्सन पर पुनरावृत्ति का उपयोग करना पसंद करूंगा क्योंकि रिकर्सिव समाधान द्वारा आवश्यक अतिरिक्त स्टैक मेमोरी बड़ी हो सकती है जब पंक्तियों की संख्या बड़ी हो जाती है।

Answer 5

मेरे गैर पुनरावर्ती समाधान:

for(int i = 0; i < 9; i++) { 
     for(int j = 0; j < 2*i+1; j++) 
      System.out.print((Math.abs(j - i) + 9 - i) + " "); 
     System.out.println(); 
    }