प्रिंटिंग पिरामिड पैटर्न अक्षरों से बाहर

Question

मुझे पिरामिड आकार में वर्णों की एक सरणी मुद्रित करने की आवश्यकता है।

char[] chars = {'F', 'E', 'L', 'I', 'Z', ' ', 'A', 'N','I', 'V', 'E', 'R', 'S', 'A', 'R', 'I', 'O'}; 
    int length = chars.length; 


    for (int i = 1; i < length; i += 2) { 
    for (int j = 0; j < 9 - i/2; j++) 
    System.out.print(" "); 

    for (int j = 0; j < i; j++) 
    System.out.print(chars[j]); 

    System.out.print("\n"); 
} 
    for (int i = length; i > 0; i -= 2) { 
    for (int j = 0; j < 9 - i/2; j++) 
    System.out.print(" "); 

    for (int j = 0; j < i; j++) 
    System.out.print(chars[j]); 

    System.out.print("\n"); 

और यह इस प्रिंट:: क्या मैं अब तक है यह है

  F 
      FEL 
     FELIZ 
     FELIZ A 
     FELIZ ANI 
     FELIZ ANIVE 
    FELIZ ANIVERS 
    FELIZ ANIVERSAR 
    FELIZ ANIVERSARIO 
    FELIZ ANIVERSAR 
    FELIZ ANIVERS 
     FELIZ ANIVE 
     FELIZ ANI 
     FELIZ A 
     FELIZ 
      FEL 
      F 

लेकिन मैं इसे सरणी के बीच में चरित्र से प्रिंट करने में शुरू करने के लिए की जरूरत है। अंतिम परिणाम इस तरह होना चाहिए:

     I 
         NIV 
        ANIVE 
        ANIVER 
        Z ANIVERS 
        IZ ANIVERSA 
       LIZ ANIVERSAR 
       ELIZ ANIVERSARI 
       FELIZ ANIVERSARIO 
       ELIZ ANIVERSARI 
       LIZ ANIVERSAR 
        IZ ANIVERSA 
        Z ANIVERS 
        ANIVER 
        ANIVE 
         NIV 
         I 

किसी भी मदद की सराहना की जाएगी।

Answer 1

आप नीचे दिए गए कोड पर दिखाए गए जैसा ही काम कर सकते हैं। यह लूप के लिए कम संख्या का उपयोग करेगा। मैंने कोड में इनलाइन टिप्पणियों को जोड़ा है।

char[] chars = { 'F', 'E', 'L', 'I', 'Z', ' ', 'A', 'N', 'I', 'V', 'E', 'R', 'S', 'A', 'R', 'I', 'O' }; 
    int length = chars.length; 


    for (int line=0;line<=length;line++) { 
     //This will print upper part of pyramid 
     if(line < length/2){ 
      String output=""; 
      int middelVal=length/2; 
      for (int i = middelVal - line; i > 0; i--) { 
       output=output+" "; 
      } 
      for (int i = middelVal - line; i <= middelVal + line; i++) { 
       output=output+chars[i]; 
      } 
      System.out.println(output); 
     }else if(line > length/2){ 
      //This will print lower part of pyramid 
      String output=""; 
      int middelVal=length/2; 
      int nwNum = chars.length-line; 
      for (int i = middelVal - nwNum; i > 0; i--) { 
       output=output+" "; 
      } 
      for (int i = middelVal - nwNum; i <= middelVal + nwNum; i++) { 
       output=output+chars[i]; 
      } 
      System.out.println(output); 
     } 
    } 

Answer 2

यह मेरे सिर के ऊपर से है, लेकिन एक विधि मैं इस तरह होगा की कोशिश करेंगे:

सरणी में मेरे बीच चरित्र के सूचकांक का पता लगाएं। इस 'startIndex' को कॉल करें

प्रत्येक पंक्ति के लिए, मुझे लंबाई मिल जाएगी, 2 (गोल नीचे) विभाजित करें और यह प्रारंभ इंडेक्स से प्रारंभिक ऑफ़सेट होगा जो निर्धारित करता है कि मेरा पहला चरित्र क्या होगा।

मान लें कि मैं लाइन 5 पर हूं, जो आपके पास "जेड एनीवर्स" है। इसकी लंबाई 9 है। 2 (और नीचे गोल) से विभाजित करें, आपको 4.

आपके वर्ण सरणी में, स्टार्ट इंडेक्स की गणना 8 (17/2, गोल नीचे) की जाती है। इस प्रकार मुझे चार चार से प्रिंट करना शुरू करना चाहिए (जो स्टार्ट इंडेक्स - 4 है) मेरे चार सरणी में हालांकि कई पात्रों की आवश्यकता है।

आप लूप में वर्णों को गिनने के बिना पूरी लाइन को आसानी से प्रिंट भी कर सकते हैं, क्योंकि यदि आप लाइन की लंबाई और शुरुआती चार इंडेक्स को जानते हैं, तो आप उस पंक्ति को केवल एक ही स्थान पर निकाल सकते हैं यदि आपके प्रारंभिक वर्ण थे एक स्ट्रिंग

अंत में, आप भी केवल आधा काम कर सकते हैं के बाद से यह लग रहा है अपने ऊपरी आधे की तरह नीचे आधा रूप में ही है (तार में परिणाम का निर्माण तो उन्हें एक साथ जोड़ पूर्ण परिणाम बाहर मुद्रित करने के लिए)

संपादित करें: मेरा उत्तर पढ़ना, आपको लाइन की लंबाई को वास्तव में 'ढूंढना' नहीं होगा क्योंकि यह केवल 1 से शुरू होता है और हर बार 2 से बढ़ता है, लेकिन मूल विधि अभी भी वही होगी।

संपादित 2:

के बाद से हर कोई (और जवाब स्वीकार किया गया है), मैं भी मेरा निम्नलिखित मैंने यही कहा जोड़ सकते हैं उनके कोडित संस्करण जोड़ रहा है:

String sourceString = "FELIZ ANIVERSARIO"; // source of characters 
    String padding = "  "; // used to create the padding offset for each line 

    int middle = sourceString.length()/2; 

    // top and bottom halves of the output 
    String top = ""; 
    String bottom = ""; 

    for(int currentLength = 1; currentLength < sourceString.length(); currentLength += 2){ 
     String linePadding = padding.substring(currentLength/2, padding.length()); 

     // speical case here, in the given example by the post, the 4th line the offset is one less as the I characters do not line up in the middle 
     // 7 is used as the 4th line has a length of 7 
     if(currentLength == 7){ 
      linePadding = linePadding.substring(1, linePadding.length()); 
     } 

     top += linePadding + sourceString.substring(middle - (currentLength/2), middle + (currentLength/2) + 1) +"\n"; 
     bottom = linePadding + sourceString.substring(middle - (currentLength/2), middle + (currentLength/2) + 1) + "\n" + bottom; 
    } 

    System.out.println(top + sourceString +"\n"+ bottom); 

सुनिश्चित नहीं हैं यह जानबूझकर था, लेकिन मैंने लूप में एक विशेष उम्मीद को जोड़ा जहां मैंने उपयोगकर्ता के उदाहरण में देखा कि चौथी पंक्ति 1 से बंद है (मैं वहां नहीं हूं)। यदि मुझे लाइन अप करना है और यह एक टाइपो था, तो इसे हटा दें अगर पूरी तरह ब्लॉक हो।

Answer 3

मध्य सूचकांक प्राप्त करना, इसे दो चरों में संग्रहीत करना, चरित्र मुद्रण को शुरू और समाप्त करने के लिए चिह्नित करेगा।

int mid = length/2; // left end 
int midLen = mid;  // right end 

पाश मुद्रण बाएं छोर mid जब तक रिक्त स्थान से शुरू होगा, तो वर्ण सही अंत midLen + 1 तक प्रिंट किया जाएगा।फिर आगे जाने के लिए midLen बढ़ाएं, और आगे बढ़ने के लिए mid घटाएं।

for(int i = mid; mid > -1; mid--, midLen++) { 
    for(int s = 0; s < mid; s++) 
     System.out.print(" "); 

    for (int j = mid; j < midLen + 1; j++) { 
     System.out.print(chars[j]); 
    } 
    System.out.print("\n"); 
} 

कम पिरामिड मुद्रित करने के लिए, हम 0 सूचकांक से length आने लगेंगे। इस बार, हम आगे बढ़ने के लिए mid बढ़ाते हैं, और आगे बढ़ने के लिए midLen घटाते हैं, मध्य वर्ण तक प्रति पंक्ति स्ट्रिंग लाइन को छोटा कर देते हैं।

mid = 0; 
midLen = length; 

for(int i = mid; midLen != length/2; mid++, midLen--) { 

    for(int s = 0; s < mid; s++) 
     System.out.print(" "); 

    for(int j = mid; j < midLen; j++) { 
     System.out.print(chars[j]); 
    } 
    System.out.print("\n"); 
} 

Test here

बोनस: उपयोग Java 8's new features। वही तंत्र, मैं आपके लिए जांच छोड़ दूंगा।

... 
static int mid; 
static int midLen; 
static String line = ""; 

public static void main(String[] args) { 
    char[] chars = {'F', 'E', 'L', 'I', 'Z', ' ', 'A', 'N','I', 'V', 'E', 'R', 'S', 'A', 'R', 'I', 'O'}; 

    mid = chars.length/2; 
    midLen = mid; 

    List<String> tri = new ArrayList<String>(); 
    IntStream.rangeClosed(0, mid) 
     .forEach(i -> { 
      Stream.of(chars).forEach(j -> { 
       IntStream.range(0, mid).forEach(x -> line += " "); 
       IntStream.rangeClosed(mid, midLen) 
        .forEach(x -> line += String.valueOf(chars[x])); 
       mid--; 
       midLen++; 
       tri.add(line); 
       line = ""; 
      }); 
     }); 

    tri.forEach(System.out::println); // print upper pyramid 
    Collections.reverse(tri); 
    tri.forEach(System.out::println); // print lower pyramid 
} 
... 

Answer 4

यहाँ 2 डी सरणी का उपयोग कर एक और दृष्टिकोण है

char[] chars = { 'F', 'E', 'L', 'I', 'Z', ' ', 'A', 'N', 'I', 'V', 'E', 'R', 'S', 'A', 'R', 'I', 'O' }; 
    int size = chars.length; 
    int mid = size/2 + 1; 
    char[][] matrix = new char[size][size]; 
    for (char[] cs : matrix) { 
     Arrays.fill(cs, ' '); 
    } 
    for (int i = 0; i < size; i++) { 
     int l = Math.abs(mid - 1 - i); 
     int r = size - l; 
     for (int m = l; m < r; m++) { 
      matrix[i][m] = chars[m]; 
     } 
    } 
    for (char[] cs : matrix) { 
     System.out.println(cs); 
    } 

उत्पादन

 I   
     NIV  
     ANIVE  
     ANIVER  
    Z ANIVERS  
    IZ ANIVERSA 
    LIZ ANIVERSAR 
ELIZ ANIVERSARI 
FELIZ ANIVERSARIO 
ELIZ ANIVERSARI 
    LIZ ANIVERSAR 
    IZ ANIVERSA 
    Z ANIVERS  
     ANIVER  
     ANIVE  
     NIV  
     I