发表了第一篇科研文章

23日凌晨修改上传完毕,28日晚上邮件通知接受。

https://doi.org/10.1364/OE.392230

这篇文章的idea是使用重掺杂半导体代替金属。原来给硕士师兄做,但是他不会仿真也不愿学,我去找老师要来。在另一位硕士师兄已发表的耦合模理论的基础上,作为主要优化手段,写成了这篇文章。时间跨度从2019年寒假之前开始学习仿真,3、4月份完成主要结果,和郑师兄讨论。5月份开始写作,7月22日完成第一版发给老师。后来陆陆续续改了6个版本。

2020年寒假回家,春节前后发给大老板看过之后,2月2日第一次投稿,因为英语问题被退回,修改。3月4日第二次投稿,4月2日收到大修意见,编辑给了10天期限,由于疫情原因老板又和编辑要了10天。

整个文章的贡献其实主要是老师的,文字也是他修改的多,和第一版相比基本天差地别。我的贡献只有仿真的数据、图片和一个发现(随掺杂浓度非单调变化的等离子体频率)。

整体时间跨度接近1年,也算完成了一年一篇文章的目标。

酒馆战棋,运气游戏

最近没有打天梯,沉迷于酒馆战棋,炉石也成为了战棋启动器。

已经是一个有惯性操作的游戏了,常规英雄的节奏都是,买怪、升本,买、买、升本买,买买,升买,然后可以顺利的在就费达到四本,算是真真的开是游戏。然而在这之前,如果几回合买不到高质量的怪被连续掉血,速八的几率都很大,但是通过五本和六本的怪补强战力,也可以吃到烂分。

虽然选怪,刷新都是可控的操作,然而每次刷出来的怪都有很大的随机性,被鲍勃制裁了,只能滚出酒馆了。另一方面战斗的时候也是随机的,我有过运气超好的时候,比如大螺丝技能秒掉对面机械阵容的两学徒,伐木机掉落卡德后配合瑞文加超展开。

但终究是个运气游戏,享受游戏带来的随机性。但是看直播的时候,会长冲13000分,被弹幕调侃分高都是靠时间打上去的,但是会长说分数的确是要靠时间打,然而也要看技术,因为你打10个小时,别人也打10个小时,你在努力的时候,别人也在努力,这个时候也就体现出技术的差距了。

炉石传说500胜金头进度

炉石传说大概在大二下学期入坑,大三刚开学战歌指挥官就被削了。
一开始没看攻略,也不看直播,纯属自己寻找卡牌游戏的乐趣(瞎玩),也没有氪金的需求,自然卡牌也很少。
后来氪了一点,加上日积月累,也有了很多卡牌之后,可以抄一些主流卡组,学学主播的玩法。
玩了这么久,遗憾没空抽出精力冲上传说,最高打到三级满星。
但是每天做任务,竟也刷出了八个金色头像,目前还差牧师的。

2017-03-08 术士

2017-05-20 猎人

2017-10-01 萨满

2018-02-11 德鲁伊

2018-09-24 法师

2018-10-04 战士

2018-10-13 盗贼

2018-11-4 骑士

2020-03-06

最后一个职业,牧师也500胜了,然而现在1000胜都出了。

1015 Reversible Primes (PTA)

reversible prime in any number system is a prime whose “reverse” in that number system is also a prime. For example in the decimal system 73 is a reversible prime because its reverse 37 is also a prime.

Now given any two positive integers N (<10​5​​) and D (1<D≤10), you are supposed to tell if N is a reversible prime with radix D.

Input Specification:

The input file consists of several test cases. Each case occupies a line which contains two integers N and D. The input is finished by a negative N.

Output Specification:

For each test case, print in one line Yes if N is a reversible prime with radix D, or No if not.

Sample Input:

73 10
23 2
23 10
-2

      
    

Sample Output:

Yes
Yes
No

编译器:Python(python3)

写了三个函数分别是:素数判断,十进制转任意进制的逆序和任意进制转十进制

import math
def IsPrime(num):
    if num == 0 | num == 1:
        return False
    for i in range(2,int(math.sqrt(num))+1):
        if num % i == 0:
            return False
    return True

def reverse_Radix(origin_num,base_num):
    result_num_lsit = []
    if origin_num < base_num:
        return origin_num
    else:
        while True:
            div, mod = divmod(origin_num,base_num)
            # result_num_lsit.insert(0,str(mod))
            result_num_lsit.append(str(mod))
            origin_num = div
            if origin_num < base_num:
                # result_num_lsit.insert(0,str(origin_num))
                result_num_lsit.append(str(origin_num))
                result_num = int(''.join(result_num_lsit))
                return result_num

def ToDecimal(origin_num,base_num):
    result_num = 0
    index = 0
    while True:
        div, mod = divmod(origin_num,10)
        result_num = result_num + mod*base_num**index
        index+=1
        origin_num = div
        if div == 0:
            return result_num

while True:
    Input_Str = input().split(' ')
    if int(Input_Str[0]) < 0:
        break

    origin_num = int(Input_Str[0])
    base_num = int(Input_Str[1])

    reverse_num = reverse_Radix(origin_num,base_num)

    result_num = ToDecimal(reverse_num,base_num)

    if IsPrime(origin_num) & IsPrime(result_num):
        print('Yes')
    else:
        print('No')

1065 A+B and C (64bit) (PTA)

Given three integers AB and C in [−2​63​​,2​63​​], you are supposed to tell whether A+B>C.

Input Specification:

The first line of the input gives the positive number of test cases, T (≤10). Then T test cases follow, each consists of a single line containing three integers AB and C, separated by single spaces.

Output Specification:

For each test case, output in one line Case #X: true if A+B>C, or Case #X: false otherwise, where X is the case number (starting from 1).

Sample Input:

3
1 2 3
2 3 4
9223372036854775807 -9223372036854775808 0

      
    

Sample Output:

Case #1: false
Case #2: true
Case #3: false

编译器:Python(python3)

判断溢出

N = int(input())

index = 1
while(index<=N):
    flag = 0
    a, b, c = map(int,input().split(' '))
    if a>0 & b>0 & a+b<0:
        flag = 1
    elif a<0 & b<0 & a+b>=0:
        flag = 0
    elif a+b>c:
        flag = 1
    print('Case #{}:'.format(index),"true" if flag else "false")
    index +=1

1028 List Sorting (PTA)

Excel can sort records according to any column. Now you are supposed to imitate this function.

Input Specification:

Each input file contains one test case. For each case, the first line contains two integers N (≤10​5​​) and C, where N is the number of records and C is the column that you are supposed to sort the records with. Then N lines follow, each contains a record of a student. A student’s record consists of his or her distinct ID (a 6-digit number), name (a string with no more than 8 characters without space), and grade (an integer between 0 and 100, inclusive).

Output Specification:

For each test case, output the sorting result in N lines. That is, if C = 1 then the records must be sorted in increasing order according to ID’s; if C = 2 then the records must be sorted in non-decreasing order according to names; and if C = 3 then the records must be sorted in non-decreasing order according to grades. If there are several students who have the same name or grade, they must be sorted according to their ID’s in increasing order.

Sample Input 1:

3 1
000007 James 85
000010 Amy 90
000001 Zoe 60

      
    

Sample Output 1:

000001 Zoe 60
000007 James 85
000010 Amy 90

      
    

Sample Input 2:

4 2
000007 James 85
000010 Amy 90
000001 Zoe 60
000002 James 98

      
    

Sample Output 2:

000010 Amy 90
000002 James 98
000007 James 85
000001 Zoe 60

      
    

Sample Input 3:

4 3
000007 James 85
000010 Amy 90
000001 Zoe 60
000002 James 90

      
    

Sample Output 3:

000001 Zoe 60
000007 James 85
000002 James 90
000010 Amy 90

编译器:Python(python3)

这题用list的sort方法,其中可以按key关键字排序,但是python的缺点就是最后一个测试点超时,但是不想用C++再写了。

N, ref = map(int, input().split())

records = []

for i in range(N):
    s_id, name, score = input().split()
    records.append([s_id, name, score])

records.sort(key=lambda x: (x[ref - 1],x[0]))
for i in records:
    print(" ".join(i))

1031 Hello World for U (PTA)

Given any string of N (≥5) characters, you are asked to form the characters into the shape of U. For example, helloworld can be printed as:

h  d
e  l
l  r
lowo

      
    

That is, the characters must be printed in the original order, starting top-down from the left vertical line with n​1​​ characters, then left to right along the bottom line with n​2​​ characters, and finally bottom-up along the vertical line with n​3​​ characters. And more, we would like U to be as squared as possible — that is, it must be satisfied that n​1​​=n​3​​=max { k | kn​2​​ for all 3≤n​2​​≤N } with n​1​​+n​2​​+n​3​​−2=N.

Input Specification:

Each input file contains one test case. Each case contains one string with no less than 5 and no more than 80 characters in a line. The string contains no white space.

Output Specification:

For each test case, print the input string in the shape of U as specified in the description.

Sample Input:

helloworld!

      
    

Sample Output:

h   !
e   d
l   l
lowor

编译器:Python(python3)

string = input()
N = len(string)
height = (N+2)//3
width = N-2*height-2
for i in range(height - 1):
    print(string[i] + ' '*(width+2) + string[-i-1])
print(string[height-1:N-height+1])