第一题

有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和。

def func1():
    fenzi = 2
    fenmu = 1
    li1 = [2]
    for i in range(1,20):
        #temp = fenzi
        #fenzi = temp + fenmu
        #fenmu = temp
        fenmu, fenzi = fenzi, fenzi + fenmu
        li1.append(fenzi/fenmu)
    print(sum(li1))


func1()

第二题

给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字。

n = int(input('请输入一个不超过五位的自然数：'))
while 1:
    if n == 0:
        break
    print(n % 10,end=' ')
    n //= 10

第三题

有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。

n2 = int(input('请输入人数：'))
li2 = [x for x in range(1,n2+1)]

while n2 > 2:
        li2.pop(2)
        temp1 = li2[2:]
        temp2 = li2[:2]
        li2 = temp1 + temp2
        n2 -= 1

li2.pop(0)

print(li2)

第四题

编写一个程序，根据控制台输入的事务日志计算银行帐户的净金额。 事务日志格式如下所示：
D 100
W 200

D表示存款，而W表示提款。
假设为程序提供了以下输入：
D 300
D 300
W 200
D 100
然后，输出应该是：
500

total = 0
while 1:
    a = input('存款输入D，取款输入W，空格输入金额；退出输入Q：')
    if a =='Q':
        break
    else:
        temp = a.split(' ')
        x = temp[0]
        y = int(temp[1])
        if x == 'D':
            total += y
            print('余额：',total)
        elif x == 'W':
            total -= y
            print('余额：', total)

第五题

机器人从原点（0,0）开始在平面中移动。 机器人可以通过给定的步骤向上，向下，向左和向右移动。 机器人运动的痕迹如下所示：
UP 5
DOWN 3
LETF 3
RIGHT 2
方向之后的数字是步骤。 请编写一个程序来计算一系列运动和原点之后距当前位置的距离。如果距离是浮点数，则只打印最接近的整数。
例：如果给出以下元组作为程序的输入：
UP 5
DOWN 3
LETF 3
RIGHT 2
然后，程序的输出应该是：2

def robot():
    x = 0
    y = 0
    final = 0
    while 1:
        direction = input('请输入移动的方向（UP/DOWN/LEFT/RIGHT）,结算按C,退出按Q：')
        if direction in ['UP','DOWN','LEFT','RIGHT','C','Q']:

            if direction != 'C' and direction != 'Q':
                distance = int(input('请输入移动的距离：'))
                if direction == 'UP':
                    y += distance
                elif direction == 'DOWN':
                    y -= distance
                elif direction == 'LEFT':
                    x -= distance
                elif direction == 'RIGHT':
                    x += distance
            elif direction == 'C':
                final = (float(abs(x)**2 + abs(y)**2))**0.5
                print('机器人距离原点%0.3f'%final)
            elif direction == 'Q':
                break
        else:
            print('输入有误，重新输入')
robot()

龟兔赛跑

(模拟龟兔赛跑)本练习中要模拟龟兔赛跑的寓言故事。用随机数产生器建立模拟龟兔赛跑的程序。 对手从70个方格的第1格开始起跑，每格表示跑道上的一个可能位置，终点线在第70格处。 第一个到达终点的选手奖励一个新鲜萝卜和莴苣。兔子要在山坡上睡一觉，因此可能失去冠军。 有一个每秒钟滴答一次的钟，程序应按下列规则调整动物的位置：

image.png

用变量跟踪动物的位置(即位置号1到70)。每个动物从位置1开始，如果动物跌到第1格以外，则移回第1格。 产生随机整数1≤i≤10)，以得到上表中的百分比。对于乌龟，1≤i≤5时快走，6≤i≤7时跌跤，8≤i≤10时慢走，兔子也用相似的方法。 起跑时，打印： BANG !!!!! AND THEY' RE OFF !!!!! 时钟每次滴答一下(即每个重复循环)，打印第70格位置的一条线，显示乌龟的位置T和兔子的位置H。 如果两者占用一格，则乌龟会咬兔子，程序从该位置开始打印 OUCH!!!。除T、H和OUCH!!!以外的其他打印位置都是空的。 打印每一行之后，测试某个动物是否超过了第70格，如果是,则打印获胜者，停止模拟。 如果乌龟赢，则打印TORTOISE WINS!!!YAY!!!。如果兔子赢，则打印Hare wins．Yush。 如果两个动物同时赢，则可以同情弱者，让乌龟赢，或者打印It's a tie。如果两者都没有赢，则再次循环，模拟下一个时钟滴答。 准备运行程序时，让一组拉拉队看比赛，你会发现观众有多么投入。

import random
T = 0
H = 0
print('BANG!!!AND THEY\'RE OFF!!!!!')
while 1:
    field = '-' * 70
    if T >= 70 and H < 70:
        print('TORTOISE WINS!!!YAY!!!')
        break
    elif T < 70 and H >= 70:
        print('Hare wins．Yush')
        break
    elif T >= 70 and H >= 70:
        print('It\'s a tie')
        break
    else:
        i_T = random.randint(0,10) + 1
        if 1 <= i_T <= 5:
            T += 3
        elif 6 <= i_T <= 7:
            T -= 6
        elif 8 <= i_T <= 10:
            T += 1
        i_H = random.randint(0,10) + 1
        if 3 <= i_H <= 4:
            H += 9
        elif i_H == 5:
            H -= 12
        elif 6 <= i_H <= 8:
            H += 1
        elif 9 <= i_H <= 10:
            H -= 2

        if T == H:
            field = field[0:T] + 'OUCH!!!' + field[T:]
        else:
            field = field[0:T] + 'T' + field[T:]
            field = field[0:H] + 'H' + field[H:]
        print(field)

猜单词

需求

给定单词数组（不少于10个），程序随机选择其中的一个，并显示单词字符长度个横线（-），用户有5次猜测机会，用户每次猜一个字母，如果正确，则将在相应的位置上显示出来；如错误则猜测机会减一，重复该过程，直至单词的全部字母全部猜出或者猜测次数用完，最后宣布用户胜利或失败。

实例

例如随机选出的单词是apple，程序先打印- - - - - 用户输入p，程序打印 -pp-- 用户输入e，程序打印 -pp-e 用户输入t，程序打印 -pp-e 您还有4次机会 用户输入a，程序打印 app-e 用户输入l，程序打印 apple 恭喜您，取得胜利。

import random
words = ['apple','python','exercise','basketball','program']
i = random.randint(0,4)
word = words[i]
chance = len(word)
temp =list('_'*len(word))
print(temp)
while 1:
    if chance == 0:
        print('失败了')
        break
    else:
        guess = input('请输入一个字母：')
        if guess not in word:
            print('猜错了')
            chance -= 1
        else:
#            idx = 0
#            for item in word:
#                if guess == item:
#                    temp[idx] = guess
#                idx += 1
            for idx,c in enumerate(word):
                if guess == c:
                    temp[idx] = guess
            print(temp)
            if temp == list(word):
                print('猜对了')
                break
            chance -= 1

奥运会足球队分组

已知有十六支男子足球队参加2008 北京奥运会。写一个程序，把这16 支球队随机分为4 个组。采用List集合和随机数

2008 北京奥运会男足参赛国家：

科特迪瓦，阿根廷，澳大利亚，塞尔维亚，荷兰，尼日利亚，日本，美国，中国，新西兰，巴西，比利时，韩国，喀麦隆，洪都拉斯，意大利

提示：分配一个，删除一个

image.png

temp = '科特迪瓦，阿根廷，澳大利亚，塞尔维亚，荷兰，尼日利亚，日本，美国，中国，新西兰，巴西，比利时，韩国，喀麦隆，洪都拉斯，意大利'
li3 = {x for x in temp.split('，')}
print(li3)
A = []
B = []
C = []
D = []
while len(li3) >= 4:
    A.append(li3.pop())
    B.append(li3.pop())
    C.append(li3.pop())
    D.append(li3.pop())
print(A)
print(B)
print(C)
print(D)

省市县查询

根据用户的输入，产生多级列表的效果，中途可按b返回，q直接退出

dic1 = {
    '山东' : {
        '青岛' : ['四方','黄岛','崂山','李沧','城阳'],
        '济南' : ['历城','槐荫','高新','长青','章丘'],
        '烟台' : ['龙口','莱山','牟平','蓬莱','招远']
    },
    '江苏' : {
        '苏州' : ['沧浪','相城','平江','吴中','昆山'],
        '南京' : ['白下','秦淮','浦口','栖霞','江宁'],
        '无锡' : ['崇安','南长','北塘','锡山','江阴']
    },
    '浙江' : {
        '杭州' : ['西湖','江干','下城','上城','滨江'],
        '宁波' : ['海曙','江东','江北','镇海','余姚'],
        '温州' : ['鹿城','龙湾','乐清','瑞安','永嘉']
    },
    '安徽' : {
        '合肥' : ['蜀山','庐阳','包河','经开','新站'],
        '芜湖' : ['镜湖','鸠江','无为','三山','南陵'],
        '蚌埠' : ['蚌山','龙子湖','淮上','怀远','固镇']
    },
    '广东' : {
        '深圳' : ['罗湖','福田','南山','宝安','布吉'],
        '广州' : ['天河','珠海','越秀','白云','黄埔'],
        '东莞' : ['莞城','长安','虎门','万江','大朗']
    }
}



while 1:
    print('省'.center(50,'*'))
    li_p = list(dic1)
    for idx in range(len(li_p)):
        print(idx + 1,'.',li_p[idx])
    temp1 = input('请输入省编号,或输入q(quit)退出：')
    if temp1 == 'q':
        break
    else:
        while 1:
            print('市'.center(50, '*'))
            p = li_p[int(temp1)-1]
            li_c = list(dic1[p])
            for idx in range(len(li_c)):
                print(idx + 1,'.',li_c[idx])
            temp2 = input('请输入市编号,或输入b(back)返回上级菜单，或输入q(quit)退出：')
            if temp2 == 'q':
                exit()
            elif temp2 == 'b':
                break
            else:
                while 1:
                    print('县'.center(50, '*'))
                    c = li_c[int(temp2)-1]
                    li_x = dic1[p][c]
                    for idx in range(len(li_x)):
                        print(idx + 1,'.',li_x[idx])
                    temp3 = input('输入b(back)返回上级菜单，或输入q(quit)退出：')
                    if temp3 == 'q':
                        exit()
                    elif temp3 == 'b':
                        break
                    else:
                        print('输入非法！')

摇骰子

题目：写一个摇骰子游戏，要求用户压大小，赔率一赔一。

要求：三个骰子，摇大小，每次打印摇骰子数。

import random
total = 1000
a = 0
b = 0
c = 0
res = ''
print('游戏开始'.center(10,'-'))
while 1:
    s_or_b = input('请下注， big or small：')
    cost = int(input('下注金额：'))
    a = random.randint(1,6)
    b = random.randint(1,6)
    c = random.randint(1,6)
    print([a,b,c],a+b+c)
    if a+b+c > 10:
        res = 'big'
    else:
        res = 'small'
    if s_or_b == res:
        total += cost
        print('恭喜， 你赢了%d元， 你现在的本金%d元'%(cost,total))
    elif s_or_b != res:
        total -= cost
        print('很遗憾， 你输了%d元， 你现在的本金%d元'%(cost,total))

判断变量名

1.变量名可以由字母,数字或者下划线组成
2.变量名只能以字母或者下划线开头

print('1.变量名可以由字母,数字或者下划线组成\n2.变量名只能以字母或者下划线开头')
s1 = input('请输入变量名：')
if s1[0].isalpha() or s1[0] == '_':
    for x in s1[1:]:
        if not (x.isalnum() or x == '_'):
            print('%s不是一个合法的变量名'%s1)
    print('%s是一个合法的变量名'%s1)
else:
    print('%s不是一个合法的变量名'%s1)

考勤记录

给定一个字符串来代表一个学生的出勤纪录，这个纪录仅包含以下三个字符：
'A' : Absent，缺勤
'L' : Late，迟到
'P' : Present，到场
如果一个学生的出勤纪录中不超过一个'A'(缺勤)并且不超过两个连续的'L'(迟到),
那么这个学生会被奖赏。
你需要根据这个学生的出勤纪录判断他是否会被奖赏。
示例 1:
输入: "PPALLP"
输出: True
示例 2:
输入: "PPALLL"
输出: False

print('考勤记录规则'.center(20,'-'))
print('     \'A\' : Absent')
print('     \'L\' : Late')
print('     \'P\' : Present')

s2 = input('输入：')
count1 = int(len(s2))
count2 = 0
if s2.count('A') <= 1:

    while count1 > 0:
        temp = s2[count1-3:count1]
        if temp == 'LLL':
            count2 += 1
        count1 -= 1
    if count2 <= 2:
        print(True)
    else:
        print((False))

else:
    print(False)

替换字符

输入两个字符串，从第一字符串中删除第二个字符串中所有的字符。
例如，输入”They are students.”和”aeiou”，
则删除之后的第一个字符串变成”Thy r stdnts.”

输入描述:
每个测试输入包含2个字符串

输出描述:
输出删除后的字符串

示例1:

输入
They are students.
aeiou
输出
Thy r stdnts.

str1 = input('请输入字符串1：')
str2 = input('请输入字符串2：')
for i in str2:
    str1 = str1.replace(i,'')
print(str1)

计算均值

编写一个函数cacluate, 可以接收任意多个数,返回的是一个元组.
元组的第一个值为所有参数的平均值, 第二个值是大于平均值的所有数.

def caculate(*num):
    a = sum(num) / len(num)
    b = []
#    for i in num:
#        if i > a:
#            b.append(i)
    b = list(filter(lambda x:x>a,num))

    return (a,b)


print(caculate(1,2,3,4,5))

计数大小写字母

编写一个函数, 接收字符串参数, 返回一个元组,
元组的第一个值为大写字母的个数, 第二个值为小写字母个数.
例如
输入：'hello WORLD'
输出：（5，5）

def func1(*s):
    temp = s[0]
    a = 0
    b = 0
    for i in temp:
        if i.isupper():
            a += 1
        elif i.islower():
            b += 1
    return (a,b)




str1 = input('请输入字符串：')
print(func1(str1))

函数练习1

编写函数, 接收一个列表(包含30个1~100之间的随机整形数)
和一个整形数k, 返回一个新列表.

函数需求:

• 将列表下标k之前对应(不包含k)的元素逆序;
• 将下标k及之后的元素逆序;

import random
li_num = []
for i in range(30):
    num = random.randint(1,100)
    li_num.append(num)
print(li_num)

def func2(l,k):
    temp1 = l[:k]
    temp2 = l[k:]
    temp1.reverse()
    temp2.reverse()
    print(temp1)
    print(temp2)
    return

func2(li_num,10)

函数练习2 模拟轮盘抽奖游戏

轮盘分为三部分: 一等奖, 二等奖和三等奖;
轮盘转的时候是随机的,
如果范围在[0,0.08)之间,代表一等奖,
如果范围在[0.08,0.3)之间,代表2等奖,
如果范围在[0.3, 1.0)之间,代表3等奖,

模拟本次活动1000人参加, 模拟游戏时需要准备各等级奖品的个数.

import random
def func3():
    dic = {'一等奖':(0,0.08),'二等奖':(0.08,0.3),'三等奖':(0.3,1)}
    li = []
    a = 0
    b = 0
    c = 0
    for i in range(1000):
        num = random.random()
        for k,v in dic.items():
            if v[0] <= num and num <= v[1]:
                li.append(k)
    for i in li:
        if i == '一等奖':
            a += 1
        elif i == '二等奖':
            b += 1
        elif i == '三等奖':
            c += 1
    print('一等奖：%d'%a)
    print('二等奖：%d'%b)
    print('三等奖：%d'%c)


func3()

函数练习3

对于一个十进制的正整数， 定义f(n)为其各位数字的平方和，如:
f(13) = 1^2 + 3^2 = 10
f(207) = 2^2 + 0^2 + 7^2 = 53
下面给出三个正整数k，a, b,你需要计算有多少个正整数n满足a<=n<=b,
且kf(n)=n
输入:
第一行包含3个正整数k，a, b, k>=1, a,b<=10*18, a<=b;
输出：
输出对应的答案;

范例:
输入: 51 5000 10000
输出: 3

def func4(k,a,b):
    count1 = 0
    def f(n):
        sum1 = 0
        while n:
            sum1 += (n % 10) ** 2
            n //= 10
        return sum1
    for i in range(a,b+1):
        if k * f(i) == i:
            count1 += 1

    return count1


print(func4(51, 5000, 10000))

综合练习1 地铁站

综合练习
1.站编号和站名对应关系如下：
1=朱辛庄
2=育知路
3=平西府
4=回龙观东大街
5=霍营
6 育新
7 西小口
8 永泰庄
9 林萃桥
10 森林公园南门
11 奥林匹克公园
12 奥体中心
13 北土城
14 安华桥
15 安德里北街
//....

将以上对应关系的数据存储到map集合中，key：表示站编号，value：表示站名，并遍历打印(可以不按顺序打印)：
第10站: 森林公园南门
第6站: 育新
第12站: 奥体中心
第13站: 北土城
//...

2.计算地铁票价规则：
总行程 3站内（包含3站）收费3元，
3站以上但不超过5站（包含5站）的收费4元，
5站以上的，在4元的基础上，每多1站增加2元，
10元封顶；

3.打印格式（需要对键盘录入的上车站和到达站进行判断，如果没有该站，提示重新输入，直到站名存在为止）：
注意：每站需要2分钟
请输入上车站：
沙河
您输入的上车站：沙河不存在，请重新输入上车站：
上地
您输入的上车站：上地不存在，请重新输入上车站：
朱辛庄
请输入到达站：
沙河
您输入的到达站：沙河不存在，请重新输入到达站：
西二旗
您输入的到达站：西二旗不存在，请重新输入到达站：
西小口
从朱辛庄到西小口共经过6站收费6元，大约需要 12分钟

str1 = '1=朱辛庄 2=育知路 3=平西府 4=回龙观东大街 5=霍营 6=育新 7=西小口 8=永泰庄 9=林萃桥 10=森林公园南门 11=奥林匹克公园 12=奥体中心 13=北土城 14=安华桥 15=安德里北街'
li1 = str1.split(' ')
dic1 = {}
for i in li1:
    a = i.split('=')
    dic1[a[1]] = a[0]
for k,v in dic1.items():
    print('第'+v+'站',k)

while 1:
    start = input('请输入上车站：')
    if start not in dic1.keys():
        print('您输入的上车站：%s不存在，请重新输入'%start)
        continue
    else:
        while 1:
            end = input('请输入到达站：')
            if end not in dic1.keys():
                print('您输入的到达站：%s不存在，请重新输入'%end)
                continue
            else:
                n = int(dic1[end]) - int(dic1[start])
                t = n * 2
                c = 0
                if n <= 3:
                    c = 3
                    print('从%s到%s共经过%d站收费%d元，大约需要%d分钟'%(start,end,n,c,t))
                    exit()
                elif 3 > n >= 5:
                    c = 4
                    print('从%s到%s共经过%d站收费%d元，大约需要%d分钟' % (start, end, n, c, t))
                    exit()
                elif n > 5:
                    c = 4 + (n - 5) * 2
                    if c > 10:
                        c = 10
                    print('从%s到%s共经过%d站收费%d元，大约需要%d分钟' % (start, end, n, c, t))
                    exit()

综合练习2 奖学金

问题描述
某校的惯例是在每学期的期末考试之后发放奖学金。发放的奖学金共有五种，获取的条件各自不同：

院士奖学金，每人8000元，期末平均成绩高于80分（>80），并且在本学期内发表1篇或1篇以上论文的学生均可获得；
五四奖学金，每人4000元，期末平均成绩高于85分（>85），并且班级评议成绩高于80分（>80）的学生均可获得；
成绩优秀奖，每人2000元，期末平均成绩高于90分（>90）的学生均可获得；
西部奖学金，每人1000元，期末平均成绩高于85分（>85）的西部省份学生均可获得；
班级贡献奖，每人850元，班级评议成绩高于80分（>80）的学生干部均可获得；
只要符合条件就可以得奖，每项奖学金的获奖人数没有限制，每名学生也可以同时获得多项奖学金。例如姚林的期末
平均成绩是87分，班级评议成绩82分，同时他还是一位学生干部，那么他可以同时获得五四奖学金和班级贡献奖，奖金总数是4850元。
基本要求
现在给出若干学生的相关数据，请计算哪些同学获得的奖金总数最高（假设总有同学能满足获得奖学金的条件）。
输入数据格式格式：
输入的第一行是一个整数N（1 <= N <= 100），表示学生的总数。接下来的N行每行是一位学生的数据，从左向右依次是姓名，期末
平均成绩，班级评议成绩，是否是学生干部，是否是西部省份学生，以及发表的论文数。姓名是由大小写英文字母组成的长度不超过
20的字符串（不含空格）；期末平均成绩和班级评议成绩都是0到100之间的整数（包括0和100）；是否是学生干部和是否是西部省份
学生分别用一个字符表示，Y表示是，N表示不是；发表的论文数是0到10的整数（包括0和10）。每两个相邻数据项之间用一个空格分隔。
输出数据格式：
输出包括三行，第一行是获得最多奖金的学生的姓名，第二行是这名学生获得的奖金总数。如果有两位或两位以上的学生获得的奖金最
多，输出他们之中在输入文件中出现最早的学生的姓名。第三行是这N个学生获得的奖学金的总数。

N = int(input('请输入学生的总数：'))
dic1 = {}
dic2 = {}
yuanshi = []
wusi = []
chengji = []
xibu = []
banji = []
for i in range(N):
    s_info = input('请输入学生信息，以空格间隔：')
    s_li = s_info.split(' ')
    dic1[s_li[0]] = s_li[1:]
print(dic1)
for k,v in dic1.items():
    if int(v[0]) > 80 and int(v[4]) >= 1:
        yuanshi.append(k)
    if int(v[0]) > 85 and int(v[1]) > 80:
        wusi.append(k)
    if int(v[0]) > 90:
        chengji.append(k)
    if int(v[0]) > 85 and v[3] == 'Y':
        xibu.append(k)
    if int(v[1]) > 80 and v[2] == 'Y':
        banji.append(k)
print(yuanshi)
print(wusi)
print(chengji)
print(xibu)
print(banji)

for k in dic1.keys():
    dic2[k] = 0
print(dic2)

for k in dic1.keys():
    if k in yuanshi:
        dic2[k] += 8000
    if k in wusi:
        dic2[k] += 4000
    if k in chengji:
        dic2[k] += 2000
    if k in xibu:
        dic2[k] += 1000
    if k in banji:
        dic2[k] += 850
print(dic2)
li_sorted = list(sorted(dic2,key=lambda x:[x],reverse=False))
print(li_sorted)
total = len(yuanshi)*8000 + len(wusi)*4000 + len(chengji)*2000 + len(xibu)*1000 + len(banji)*850

print(li_sorted[0])
print(dic2[li_sorted[0]])
print(total)

综合练习3 海龟画图

设想有一只机械海龟，它在程序的控制下在屋里四处爬行。海龟拿了一支笔，这只笔或朝
上或朝下，当笔朝下时，海龟用笔画下自己的移动轨迹，当笔朝上时，海龟在移动过程中什么也不画。

使用一个50x50的数组，并把数组初始化为0。从一个装有命令的数组中读取各种命令。不
管是笔朝上还是笔朝下，都要跟踪海龟的当前位置。假定海龟总是从地板上（0，0）出发
，并且开始时笔是朝上的。程序必须处理的一组命令如下：
命令 含义
1 笔朝上
2 笔朝下
3 右转弯
4 左转弯
5，10 向前走10格（或其他的格数）
6 打印50x50的数组
9 数据结束（标记）

假设海龟现在处于靠近地板中心的某个位置，下面的“程序”绘制并打印出了一个12*12的方框。

2
5,12
3
5,12
3
5,12
3
5,12
1
6
9

在海龟爬行过程中，如果笔朝下，把数组floor中对应于海龟所处位置的元素置1。当给出命令6（打印）后，在数组中元素为1的位置全部用#号显示，元素为0的位置全部用*号显示。
编写一个可以处理上述海龟命令的程序。
编写一些其他的海龟命令，用自己编写的海龟命令处理程序解析，画出有趣的形状，比如一个“日”字。

实例
上面的海龟命令，经过我们编写的程序解析后，会打印出下面的图形

image.png

import numpy as np


command = """
2
5,12
3
5,12
3
5,12
3
5,12
1
6
9
"""
# command = """ #中间画口
# # 1
# # 5,19
# # 3
# # 5,19
# # 2
# # 4
# # 5,12
# # 3
# # 5,12
# # 3
# # 5,12
# # 3
# # 5,12
# # 1
# # 6
# # 9
# # """
# command = """  #中间画4
# 1
# 5,19
# 3
# 5,19
# 2
# 5,12
# 4
# 5,12
# 4
# 5,12
# 3
# 3
# 5,24
# 1
# 6
# 9
# """
# command = """  #中间画日
# 1
# 5,19
# 3
# 5,19
# 2
# 4
# 5,12
# 3
# 5,24
# 3
# 5,12
# 3
# 5,24
# 3
# 3
# 5,12
# 4
# 5,12
# 1
# 6
# 9
# """
lst = command.split()
print(lst)
floor = np.zeros((50,50),dtype='int32')
# print(map)
isPenUp = True
#0,1,2,3--->向右，向下，向左，向上
direction = 0
xPos = 0
yPos = 0

def print_floor():
    for i in range(floor.shape[0]):
        for j in range(floor.shape[1]):
            if floor[i,j] == 0:
                print('*',end=' ')
            else:
                print('#',end=' ')
        print()


for cmd in lst:
    true_cmd_lst = cmd.split(',')
    if len(true_cmd_lst) == 1:
        true_cmd = int(true_cmd_lst[0])
        if true_cmd == 1:
            isPenUp = True
        elif true_cmd == 2:
            isPenUp = False
        elif true_cmd == 3:
            direction += 1
            if direction > 3:
                direction = 0
        elif true_cmd == 4:
            direction -= 1
            if direction < 0:
                direction = 3
        elif true_cmd == 6:
            print_floor()
        elif true_cmd == 9:
            break
    else:
        true_cmd = int(true_cmd_lst[0])
        step = int(true_cmd_lst[1])
        if true_cmd == 5:
            #向右
            if direction == 0:
                target = xPos + step
                if target >= 50:
                    target = 49
                if not isPenUp:
                    floor[yPos,xPos:target] = 1
                    xPos = target - 1
                else:
                    xPos = target - 1
            # 向下
            if direction == 1:
                target = yPos + step
                if target >= 50:
                    target = 49
                if not isPenUp:
                    floor[yPos:target,xPos] = 1
                    yPos = target - 1
                else:
                    yPos = target - 1
            # 向左
            if direction == 2:
                target = xPos - (step - 1)
                if target < 0:
                    target = 0
                if not isPenUp:
                    floor[yPos, target:xPos] = 1
                    xPos = target
                else:
                    xPos = target

            # 向上
            if direction == 3:
                target = yPos - (step - 1)
                if target < 0:
                    target = 0
                if not isPenUp:
                    floor[target:yPos, xPos] = 1
                    yPos = target
                else:
                    yPos = target