Искусство ASCII в Python [ОБНОВЛЕНО] - программирование
Подтвердить что ты не робот

Искусство ASCII в Python [ОБНОВЛЕНО]

Я новичок в python, поднял его как интерес к интересам, и через некоторые поиски нашел себе кучу упражнений из "Практики вычисления", один из них спрашивает о написании ASCII-фигуры, обозначается ниже.

ascii cross

Все это кажется очень легким упражнением, но я не могу показаться обманутым вокруг использования числа, чтобы нарисовать это, в упражнении указано, что рисунок был нарисован с использованием числа "1".

В нем также указано, что для создания чертежа ASCII не может или должно использоваться число под 0 или выше 100.

Вот еще один пример:

Здесь вводилось число "2".

bigger ascii cross

Я нашел способ сделать первое изображение появлением, но не используя какое-либо использование данных чисел каким-либо образом, просто простую "else" внутри цикла while, чтобы я мог отфильтровать числа, которые находятся ниже или равным 0 и выше или равным 100.

Я врезался в мертвую точку, любая помощь приветствуется.

Мой код, как указано выше, не использует номер переменной для создания первого чертежа:

while True:
s = input("Give me a number to make a drawing with that is between 0 and 100: ")


if not s.isdigit():
    print ("Error, only numbers will make this program run.")
    continue #Try Again but with a number this time

if int(s) >= 100:
    print ("The number is bigger than or equal to 100 and won't work. \nDo try again.")
    continue #try again

if int(s) <= 0:
    print ("The number is smaller than or equal to 0 and won't work. \nDo try again.")
    continue #try again

else:
    print ("%5s" %("*" *3),"\n"'%5s' %("* *"),"\n" '%7s' %("*** ***"),"\n" '%7s' %("*     *"),"\n" '%7s' %("*** ***"),"\n" '%5s' %("* *"),"\n" '%5s' %("*" *3))


    print ('Want to make another drawing ?')
    continue #make another drawing

Упражнение утверждает следующее:

ASCII Рисунок размера $n $состоит из одной или нескольких строк. В каждой строке допускаются только пробелы и звезды (*), после каждой звезды на строке пробелы не допускаются как таковые, вы должны заканчивать "\n" или новую строку. Затем следуют приведенные выше примеры.

Мой новый пример кода, который зависит от ввода переменной: Кроме того, в этом примере кода он запускается, когда вход 1, у меня все еще возникают проблемы с "увеличением" всего чертежа, когда я увеличиваю номер ввода.

    while True:

 A = input("Give me a number to make a drawing with that is between 0 and 100: ")
 b = "***"
 c = "*"
 d = " "


 if not A.isdigit():
        print ("Error, only numbers will make this program run.")
        continue #Try Again but with a number this time

 if int(A) >= 100:
        print ("The number is bigger than or equal to 100 and won't work. \nDo try again.")
        continue #try again

 if int(A) <= 0:
        print ("The number is smaller than or equal to 0 and won't work. \nDo try again.")
        continue #try again


 else :
  range(1,99)
 if int(A) == (1) :
  print ((d *((int(A))*2)) + b,)
  print ((d *((int(A))*2))+ c + d + c,)
  print ((d *((int(A))*0))+ b + d + b,)
  print ((d *((int(A))*0))+ c + d*5 + c,)
  print ((d *((int(A))*0))+ b + d + b,)
  print ((d *((int(A))*2))+ c + d + c,)
  print ((d *((int(A))*2)) + b,)

  continue #try again

Но у меня все еще есть проблема с "увеличением" количества пробелов внутри фигуры ASCII наряду с увеличением от 1 до 2.

Как и проблема с линией 3, так как она должна быть обозначена вдоль сторон консоли, она должна иметь промежуток 0 со стороны, но она должна увеличиваться до интервала 2 с номер 2.

4b9b3361

Ответ 1

Подумайте о различии между 1 и 2. Попробуйте вручную нарисовать, как выглядят 3 и 4, чтобы заставить последовательность работать. Подумайте об этом, как о одной из тех проблем, когда вам дается начало последовательности, и вы должны работать с остальными.

Как

0 1 1 2 3 5 8 13

Если вы не сразу это осознаете, это последовательность Фибоначчи. Как только вы выясните шаблон, вы можете записать произвольно длинную последовательность значений.

И подумайте об этой простой последовательности ascii:

1)

#

2)

##
#

3)

###
##
#

Что такое 4)?

Или другая последовательность ascii:

1)

#

2)

 #
# #
 #

3)

  #
 # #
#   #
 # #
  #

Что такое (4)?

Если это все еще не имеет смысла, попробуйте создать несколько рекурсивных фигур, которые немного похожи на ту, которую вы пытаетесь выяснить (может быть, что-то похожее на мой второй пример). Не беспокойтесь о том, как закодировать его сейчас, просто волнуйтесь о том, каким должен быть результат. Затем посмотрите на шаблоны и выработайте алгоритм.

Ответ 2

Сначала проанализируйте фигуру поочередно, чтобы идентифицировать различные типы шаблонов.

  • Крышка, которая отображается только в верхней и нижней строках. Это любое количество пробелов, за которыми следуют три звезды.
  • Стена, которая образует вертикальные участки фигуры. Это любое количество пробелов, за которым следует одна звезда, за которой следует любое количество пробелов, за которым следует звезда.
  • Пол, который образует горизонтальные сечения фигуры. Это любое количество пробелов, за которыми следуют три звезды, за которыми следует любое количество пробелов, за которыми следуют три звезды.

Мы можем написать функцию, которая печатает каждый из этих паттернов.

def cap(spacesBefore):
    print " " * spacesBefore + "***"

def wall(spacesBefore, spacesBetween):
    print " " * spacesBefore + "*" + " " * spacesBetween + "*"

def floor(spacesBefore, spacesBetween):
    print " " * spacesBefore + "***" + " " * spacesBetween + "***"

Затем напишите код, на котором будет отображаться цифра размера, 0, 1 и 2. Это должно дать вам представление о том, как отображать фигуру любого размера.

#size 0
cap(0)
wall(0,1)
cap(0)

print "\n"

#size 1
cap(2)
wall(2, 1)
floor(0, 1)
wall(0, 5)
floor(0, 1)
wall(2, 1)
cap(2)

print "\n"

#size 2
cap(4)
wall(4, 1)
floor(2, 1)
wall(2, 5)
floor(0, 5)
wall(0, 9)
floor(0, 5)
wall(2, 5)
floor(2, 1)
wall(4, 1)
cap(4)

Вывод:

***
* *
***


  ***
  * *
*** ***
*     *
*** ***
  * *
  ***


    ***
    * *
  *** ***
  *     *
***     ***
*         *
***     ***
  *     *
  *** ***
    * *
    ***

Анализируя код, используемый для создания этих цифр, некоторые шаблоны становятся очевидными. Для фигуры размера N:

  • Обе конечные колпачки имеют N * 2 перед пробелами.
  • Есть 2 * N + 1 настенные линии.
  • Есть 2 * N этажа.
  • Первая и вторая половины фигуры являются зеркальными изображениями.
  • Число предшествующих пространств для каждой стеновой линии начинается с N * 2, а затем уменьшается на два, пока не достигнет нуля; то он растет на два снова, пока не достигнет N * 2 еще раз.
  • Количество промежутков между стенками начинается с 1 и увеличивается на 4, пока не достигнет 4 * N + 1; затем он сжимается на четыре раза, пока не достигнет 1 еще раз.
  • Число предшествующих пробелов для каждого этажа начинается с 2N-2, а затем уменьшается на два, пока не достигнет нуля; то он растет на два раза, пока не достигнет 2N-2 еще раз.
  • Количество промежутков между этажами начинается с 1 и увеличивается на 4, пока не достигнет 4 * N-3; затем он сжимается на четыре раза, пока не достигнет 1 еще раз.

Все модели растут и сжимаются с линейной скоростью, а затем сжимаются и растут с линейной скоростью. Это означает, что мы должны использовать две петли for с противоположными условиями, с небольшим дополнительным кодом для крышек и центральной стены.

def draw(N):
    cap(2*N)
    for i in range(N):              #loop from 0 to N-1
        wall(2*(N-i), 1+(4*i))
        floor(2*(N-i-1), 1+(4*i))
    wall(0, 4*N+1)
    for i in range(N-1, -1, -1):    #loop from N-1 to 0
        floor(2*(N-i-1), 1+(4*i))
        wall(2*(N-i), 1+(4*i))
    cap(2*N)

Теперь протестируйте код.

for i in range(7,10):
    draw(i)
    print "\n"

Вывод:

              ***
              * *
            *** ***
            *     *
          ***     ***
          *         *
        ***         ***
        *             *
      ***             ***
      *                 *
    ***                 ***
    *                     *
  ***                     ***
  *                         *
***                         ***
*                             *
***                         ***
  *                         *
  ***                     ***
    *                     *
    ***                 ***
      *                 *
      ***             ***
        *             *
        ***         ***
          *         *
          ***     ***
            *     *
            *** ***
              * *
              ***


                ***
                * *
              *** ***
              *     *
            ***     ***
            *         *
          ***         ***
          *             *
        ***             ***
        *                 *
      ***                 ***
      *                     *
    ***                     ***
    *                         *
  ***                         ***
  *                             *
***                             ***
*                                 *
***                             ***
  *                             *
  ***                         ***
    *                         *
    ***                     ***
      *                     *
      ***                 ***
        *                 *
        ***             ***
          *             *
          ***         ***
            *         *
            ***     ***
              *     *
              *** ***
                * *
                ***


                  ***
                  * *
                *** ***
                *     *
              ***     ***
              *         *
            ***         ***
            *             *
          ***             ***
          *                 *
        ***                 ***
        *                     *
      ***                     ***
      *                         *
    ***                         ***
    *                             *
  ***                             ***
  *                                 *
***                                 ***
*                                     *
***                                 ***
  *                                 *
  ***                             ***
    *                             *
    ***                         ***
      *                         *
      ***                     ***
        *                     *
        ***                 ***
          *                 *
          ***             ***
            *             *
            ***         ***
              *         *
              ***     ***
                *     *
                *** ***
                  * *
                  ***

Ответ 3

Чтобы найти шаблон, вы могли бы представить, как turtle нарисовать его. Например, чтобы нарисовать:

***
* *
***

черепаха может следовать этим инструкциям:

  • повернуть направо, двигаться вперед
  • повернуть направо, двигаться вперед
  • повернуть направо, двигаться вперед
  • повернуть направо, двигаться вперед

Как программа Python:

import turtle

turtle.right(90); turtle.forward(50)
turtle.right(90); turtle.forward(50)
turtle.right(90); turtle.forward(50)
turtle.right(90); turtle.forward(50)
turtle.exitonclick() # leave GUI open until a click

Если мы сократим "повернуть направо" как 'r' и "переместимся вперед" как "f", тогда инструкции:

'rfrfrfrf'

Нетрудно видеть, что оно 'rf' * 4. Следуя той же процедуре для:

  ***  
  * *  
*** ***
*     *
*** ***
  * *  
  ***

инструкции 'rflfrfrflfrfrflfrfrflfrf' или 'rflfrf' * 4, где 'l' означает "повернуть налево".

Правило, описывающее оба случая для n, равное 0 и 1, равно:

("rf" + "lfrf" * n) * 4

i.e., если n = 0, то это 'rf' * 4, если n = 1, то это ('rf' + 'lfrf') * 4. Чтобы проверить формулу, вы можете нарисовать ее для n = 2 и сравнить ее с известным ответом:

    ***    
    * *    
  *** ***  
  *     *  
***     ***
*         *
***     ***
  *     *  
  *** ***  
    * *    
    ***    

Как программа Python:

from turtle import Turtle

def get_romb_program(n):
    assert n >= 0
    side = "rf" + "lfrf" * n
    program = side * 4  # romb has 4 sides
    return program


def draw(turtle, n):
    assert 0 <= n < 101
    commands = {'r': lambda t: t.right(90),  # turn right
       'l': lambda t: t.left(90),  # turn left
       'f': lambda t: t.forward(2)
    }
    run(get_romb_program(n), turtle, commands)

def run(program, t, commands):
    for c in program:
        commands[c](t)

n = 2
t = Turtle()
scr = t.getscreen()
scr.xscale, scr.yscale = [101 // (n + 1)] * 2
draw(t, n)
scr.exitonclick()

Чтобы напечатать это как искусство ascii, вы можете использовать AsciiTurtle вместо turtle.Turtle:

class AsciiTurtle(object):
    def __init__(self):
        self.path = [(0, 0)]
        self.direction = (1, 0)

    def forward(self, distance):
        x, y = self.path[-1]
        for i in range(1, distance + 1):
            self.path.append((x + self.direction[0] * i,
                              y + self.direction[1] * i))

    def right(self, angle_ignored):  # 90 degree turn right
        self.direction = self.direction[1], -self.direction[0]

    def left(self, angle_ignored):  # 90 degree turn left
        self.direction = -self.direction[1], self.direction[0]

    def show(self):
        minx, maxx, maxy, miny = [f(xy[i] for xy in self.path)
                                  for i in [0, 1] for f in [min, max]]
        miny, maxy = -miny, -maxy  # upside-down
        board = [[' '] * (maxx - minx + 1) for _ in range(maxy - miny + 1)]
        for x, y in self.path:
            board[-y - miny][x - minx] = '*'
        print('\n'.join(''.join(row) for row in board))

Пример

n = 5
t = AsciiTurtle()
draw(t, n) # defined above
t.show()

Выход

          ***          
          * *          
        *** ***        
        *     *        
      ***     ***      
      *         *      
    ***         ***    
    *             *    
  ***             ***  
  *                 *  
***                 ***
*                     *
***                 ***
  *                 *  
  ***             ***  
    *             *    
    ***         ***    
      *         *      
      ***     ***      
        *     *        
        *** ***        
          * *          
          ***