अजगर के साथ सममितीय ascii घन

Question

(मेरे टूट भाषा के लिए खेद है)

मैं अजगर में अभी शुरुआत है, लेकिन मैं कोई विकल्प नहीं है, मैं एक परियोजना के लिए इसकी आवश्यकता है, और इस एक के लिए मैं ascii सममितीय बनाने के लिए प्रोग्रामिंग द्वारा घन। मैं वास्तव में यह कैसे करना है पता नहीं है, तो मैं विचार "कोनों" के निर्देशांक खोजने के लिए (नहीं सही शब्द लेकिन ...) के साथ शुरू हुआ एक टाइल

#what I expect really : 
- for a 2 wide 
     .-⁻``⁻-. 
    .-⁻`  `⁻-. 
    |    | 
    |    | 
    `⁻-.  .-⁻` 
     `⁻-..-⁻`  
- for 3 wide 
      .-⁻``⁻-. 
     .-⁻`  `⁻-. 
    .-⁻`    `⁻-. 
    |      | 
    |      | 
    `⁻-.    .-⁻` 
     `⁻-.  .-⁻` 
      `⁻-..-⁻` 

# what I except for the beginning 
- 2 wide 
     .-⁻``⁻-. 
    .-⁻`  `⁻-. 
    `⁻-.  .-⁻` 
     `⁻-..-⁻` 

- 3 wide (,etc.) 
      .-⁻``⁻-. 
     .-⁻`  `⁻-. 
    .-⁻`    `⁻-. 
    `⁻-.    .-⁻` 
     `⁻-.  .-⁻` 
      `⁻-..-⁻` 

मैं करने के लिए क्या करना शुरू किया आकर्षित करने के लिए

#! /usr/bin/env python 
import numpy as np 
x = 2 // number of tiles 
y = 2 // idem 
z = 2 // elevation, not used yet. 
w = 4 // wideness of a tile (.-⁻` ---> 4 characters) 
s = range (x * y) // just to apply a number to a corner 
c = 0 // counter 

def makeMatrix (x, y): 
    matrix = np.full (y*2*h+z, x*2*w), '.', dtype=str) 
    return matrix 

def getOut(): 
    global x, y, w, h, c 
    for i in range (int(x)): 
     for j in range (int(y)): 
     cx = (j - i) * w 
     cy = (j + i) 
     dec = w 
     cx += dec 
     matrix[cy][cx] = str (s[c]) 
     c += 1 
    return matrix 

matrix = makeMatrix (x, y) 
print (getOut()) 

मुझे कुछ निर्देशांक मिलते हैं, लेकिन वे एक अर्थ में गलत हैं। मैं थोड़ा उलझन में हूँ। मैं पहले से ही टाइल्स के साथ काम करता हूं लेकिन मुझे वास्तव में यह नहीं पता कि इस बार इसे कैसे किया जाए ... कोई विचार?

Answer 1

मैं recursive फ़ंक्शन का उपयोग करके स्क्रिप्ट का पुनर्निर्माण करने का सुझाव दूंगा। इस तरह आप अधिकतर निर्देशांक से छुटकारा पाने में सक्षम होंगे, क्योंकि आप शायद मध्य से (और बाद में नीचे) बनेंगे। इसके अलावा, आप घन क्षैतिज रूप से विभाजित कर सकते हैं, क्योंकि एक आधा दूसरे को अनुकूलित करने के लिए काफी आसान होगा।

Answer 2

यहां कुछ ऐसा है जो मैंने जल्दी से चाबुक किया। यह घन की चौड़ाई और ऊंचाई के लिए तर्क लेता है। चूंकि किनारों की ढलान अलग-अलग हो सकती है, इसलिए यह विभिन्न ढलानों को अच्छी तरह से संभाल नहीं लेती है; यह सिर्फ slanted किनारों (और ऊर्ध्वाधर किनारों के लिए एक पाइप) के लिए एक अवधि चरित्र का उपयोग करता है।

from math import sqrt 

def draw_cube(width, height): 
    cube = [[' ']*width for row in range(height)] 
    vertices = { 
     'tc': (width//2, 0), 
     'tl': (0, int(.25*height)), 
     'tr': (width-1, int(.25*height)), 
     'cc': (width//2, int(.5*height)), 
     'bl': (0, int(.75*height)), 
     'br': (width-1, int(.75*height)), 
     'bc': (width//2, height-1) 
    } 
    edges = (
     ('tc', 'tl'), 
     ('tc', 'tr'), 
     ('tl', 'cc'), 
     ('tl', 'bl'), 
     ('tr', 'cc'), 
     ('tr', 'br'), 
     ('bl', 'bc'), 
     ('br', 'bc'), 
     ('cc', 'bc') 
    ) 

    for edge in edges: 
     v1 = vertices[edge[0]] 
     v2 = vertices[edge[1]] 
     x1 = v1[0] 
     y1 = v1[1] 
     x2 = v2[0] 
     y2 = v2[1] 
     if x1 > x2: # Always moving left to right 
      x1, x2 = x2, x1 
      y1, y2 = y2, y1 
     try: 
      m = (y2-y1)/(x2-x1) 
     except ZeroDivisionError: 
      c = '|' 
      for yy in range(min(y1, y2), max(y1, y2)): 
       cube[yy][x1] = c 
     else: 
      c = '.' 
      yy = y1 
      for xx in range(x1, x2): 
       cube[int(yy)][xx] = c 
       yy += m 

    cube_str = '\n'.join(''.join(row) for row in cube) 
    return cube_str 

x = draw_cube(40,20) 
print(x) 

कौन सा प्रिंट:

    .......     
      ....  ....    
     ....    ....   
    ....      ....  
....        ... 
|...        ...| 
| ....      .... | 
|  ....    ....  | 
|   ....  ....   | 
|    .... ...    | 
|     |     | 
|     |     | 
|     |     | 
|     |     | 
|     |     | 
......    |    .... 
     .....   |   .....  
      ..... | .....   
       ....|....    
        .