[C_MM246-易] 矩陣反轉

成績: 0 / 倒扣: 0.8

問題描述 ：
請設計一程式，輸入一個陣列並且反轉後再輸出。

輸入說明 ：
第一行先輸入矩陣的行、列，之後再輸入陣列元素。

輸出說明 ：
反轉後的矩陣。

範例 ：

輸入範例	輸出範例
2 1 3 2 3 2 4 6 7 8 4 6 2 4 7 8 9 10 6 5 22 4 4 2 4 5 2 3 4 5 6 9	3 2 4 7 4 6 8 6 7 6 8 5 9 22 10 4 4 2 4 6 5 3 5 9

while True:  
    try:  
        r, c = map(int, input().split())  
        listo = []  
        for i in range(r):  
            m = list(map(int,input().split()))  
            listo.append(m)  
        for i in range(c):  
            strs = ''  
            for j in range(r):  
                strs = strs + str(listo[j][i]) + ' '  
            print(strs.strip())            
    except(EOFError):  
        break

[C_MM245-易] 找質數

成績: 0 / 倒扣: 0.8

問題描述 ：
找出輸入範圍內的質數。

輸入說明 ：
首先輸入一正整數N，代表範圍內的質數。
N < 100

輸出說明 ：
輸出範圍內的質數結果，數字間需間隔一隔空白，最後換行顯示總共幾個質數。

範例 ：

輸入範例	輸出範例
5	2 3 5 3

while True:  
    try:  
        def is_prime(n):  
            i, max =2, n**0.5  
            while True:  
                if n==1:return False; break  
                if n==2:return True; break  
  
                if n % i ==0:return False; break  
                if i > max:return True; break  
                i += 1  
        N = int(input())  
        strs, j = '', 0  
        for i in range(N+1):  
            if is_prime(i):  
                strs +=str(i)+' '  
                j+=1  
        print(strs.strip())  
        print(j)  
    except(EOFError):  
        break

[C_MM45-中] 分禮物

成績: 0 / 倒扣: 0.8

問題描述 ：
每年的耶誕節，都會有交換禮物的活動。現在有一群人，要交換彼此的禮物，但是每個人都不能拿到自己準備的禮物，且每個人都只有會拿到一件禮物，請問共有幾種情形，並把所有可能情形印出來。

輸入說明 ：
第一列輸入一個正整數n ( n ≤ 6 ) 。其後有n列，每一列代表每個人，每一列之資料依序為人名、禮物名。請注意人名與禮物名為英文字母。
輸出說明 ：
第一列顯示出可以有k種資料，其後顯示k組解列，其資料按照原本人名輸入的順序排列，即人名和禮物名視為同一組，一列中會有很多組，組與組間用逗號區分，用人名與禮物名用空白分隔。
範例 ：

Sample Input:	Sample Output:
3 A1 GIFT1 B1 GIFT2 C1 GIFT3	2 A1 GIFT2,B1 GIFT3,C1 GIFT1 A1 GIFT3,B1 GIFT1,C1 GIFT2

while True:
    try:
        def rot(data, n):           # 將第n個搬到最後
            val = data.pop(n)
            data.append(val)
            return data

        def rot_n_chk(data, n):     # 檢查第n個要不要搬
            for i in range(n-1):
                if data[i] == i:
                    rot(data, i+1)
                else:
                    break
            return data

        def chk_stop(data, n):      # 檢查所有的位置是否都歸位
            res = 1
            for i in range(n):      # 只要第i位置對 chk=1, 位置不對 chk=0
                chk=1 if data[i] == i else 0
                res *= chk          # 每位的乘積
            return res              # res乘積為1表示全歸位都輪完了
        
        n = int(input())
        Name, Gift, r = [], [], []
        for i in range(n):
            name, gift = map(str,input().split())
            Name.append(name)
            Gift.append(gift)
        
        data = [i for i in range(n)] # 預備產生個種排列 [0, 1, 2]
        while True:
            rot(data, 0)
            rot_n_chk(data, n)
            b = data[:]
            chr = 0 # 當有新排列時，檢查篩選出不在自已位置上的排列例如[1, 2, 0] 
            for i in range(n):
                if b[i] != i:chr += 1 # 位置不在位置上就 +1
            if chr == n:r.append(b) # chr = 排列的長度表示各個位置都錯開了再加入結果 r[]
            if chk_stop(data, n):break
        x = sorted(r)
        print(len(x))
        for i in range(len(x)):
            ws = ''
            for j in range(len(Name)):
                ws += Name[j] + ' '+Gift[x[i][j]]+','
            print(ws.rstrip(','))    
    except(EOFError):
        break

找出 n 個數所有排列

參考資料：海洋大學 丁培毅教授，旋轉法列出所有排列。
依教授的想法改用 python 的方法做出一樣的效果

n 個整數有 n! 種排列方式:
n = 3, n! = 3 * 2 = 6
六種排列如下:

            0 1 2
            0 2 1
            1 0 2
            1 2 0
            2 0 1
            2 1 0

以下我們來看一個特別的 "旋轉法" 的範例:

考慮 n = 4, n! = 24。

所有的 24 種排列，以及每一個動作詳細的說明如下：

設有一串列 data =[0, 1, 2, 3] 其元素值有以下的排列

0 1 2 3     ← 起始狀態，將 data[0] 移到最後產生下一個

1 2 3 0     ← 再將 data[0]移到最後產生下一個

2 3 0 1     ← 再將 data[0]移到最後產生下一個

3 0 1 2     ← 再將 data[0]移到最後產生下一個

0 1 2 3     ← 此時 0 回到原來的位置

                     將 data[1] 移到最後產生新的排列

0 2 3 1     ← 再將 data[0]移到最後產生下一個

2 3 1 0     ← 再將 data[0]移到最後產生下一個

3 1 0 2     ← 再將 data[0]移到最後產生下一個

1 0 2 3     ← 再將 data[0]移到最後產生下一個

0 2 3 1     ← 此時 0 回到原來的位置

                     將 data[1] 移到最後產生新的排列

0 3 1 2     ← 再將 data[0]移到最後產生下一個

3 1 2 0     ← 再將 data[0]移到最後產生下一個

1 2 0 3     ← 再將 data[0]移到最後產生下一個

2 0 3 1     ← 再將 data[0]移到最後產生下一個

0 3 1 2     ← 此時 0 回到原來的位置

                     將 data[1] 移到最後產生新的排列

0 1 2 3     ← 此時 1 也回到原來的位置

                     將 data[2] 移到最後產生新的排列

0 1 3 2     ← 再將 data[0]移到最後產生下一個

1 3 2 0     ← 再將 data[0]移到最後產生下一個

3 2 0 1     ← 再將 data[0]移到最後產生下一個

2 0 1 3     ← 再將 data[0]移到最後產生下一個

0 1 3 2     ← 此時 0 回到原來的位置

                     將 data[1] 移到最後產生新的排列

0 3 2 1     ← 再將 data[0]移到最後產生下一個

3 2 1 0     ← 再將 data[0]移到最後產生下一個

2 1 0 3     ← 再將 data[0]移到最後產生下一個

1 0 3 2     ← 再將 data[0]移到最後產生下一個

0 3 2 1     ← 此時 0 回到原來的位置

                     將 data[1] 移到最後產生新的排列

0 2 1 3     ← 再將 data[0]移到最後產生下一個

2 1 3 0     ← 再將 data[0]移到最後產生下一個

1 3 0 2     ← 再將 data[0]移到最後產生下一個

3 0 2 1     ← 再將 data[0]移到最後產生下一個

0 2 1 3     ← 此時 0 回到原來的位置

                     將 data[1] 移到最後產生新的排列

0 1 3 2     ← 此時 1 也回到原來的位置

                     將 data[2] 移到最後產生新的排列

0 1 2 3     ← 此時 2 也回到原來的位置

                     將 data[3] 移到最後產生新的排列

0 1 2 3     ← 此時 3 也回到原來的位置，全部都歸位結束輪替

def rot(data, n):               # 將第n個搬到最後
    val = data.pop(n)
    data.append(val)
    return data

def rot_n_chk(data, n):         # 檢查第n個要不要搬
    for i in range(n-1):
        if data[i] == i:
            rot(data, i+1)
        else:
            break
    return data

def chk_stop(data, n):          # 檢查所有的位置是否都歸位
    res = 1
    for i in range(n):          # 只要第i位置對 chk=1, 位置不對 chk=0
        chk=1 if data[i] == i else 0
        res *= chk              # 每位的乘積
    return res                  # res乘積為1表示全歸位都輪完了

odata = [0, 1, 2, 3]
n = len(odata)
r= []
while True:
    rot(odata, 0)
    rot_n_chk(odata, n)
    #print(num, odata)
    b = odata[:]
    r.append(b)
    if chk_stop(odata, n):break
print(sorted(r))
  

[C_MM243-易] 找出眾數

成績: 0 / 倒扣: 0.8

Problem Description
找出一串數列 ( 數字與數字間以空格區隔 ) 中出現最多次的數字。
例如： 1 2 2 3 5 6 1 2
則數字 2 出現最多次，共 3 次
Input Format
5 6 5 5 5 5 5 9 9
Output Format
5 6
第一個代表哪一個數字，第二個代表次數
Example

Sample Input	Sample Output
5 6 5 5 5 5 5 9 9	5 6

  
while True:
    try:
        nums = list(map(int,input().split()))
        data = {}
        for i in range(len(nums)):
            if nums[i] in data.keys():continue
            data.update({nums[i]:nums.count(nums[i])})
            #print(data)
        for key,value in data.items():
            if value == max(data.values()):
                print('%d %d' % (key,value))
    except(EOFError):
        break

[C_MM241-易] 平均值與標準差

成績: 0 / 倒扣: 0.8

問題描述
寫一個程式輸入一組數字，然後計算這組數字的平均值與標準差。假設輸入之數值為： x₁, x₂, …, x_N （皆為整數），則平均值（ µ ）與標準差（ s）計算公式為：
 
輸入說明
輸入一組至多 20 個整數的數字，相鄰兩個整數以單一空白區隔。
輸出說明
輸出平均值 µ 與標準差 s ，第一行輸出： Mean = µ ，第二行輸出： Deviation = s 。等號前後各留一個空白。 µ 與 s 取小數點後兩位。
範例

Sample Input:	Sample Output:
10 15 20 24 18 20 40 15 24 18 30	Mean = 17.40 Deviation = 4.72 Mean = 24.50 Deviation = 8.40

while True:  
    try:  
        num = list(map(int,input().split()))  
        u = round(sum(num) / len(num),2)  
        s = 0  
        for i in range(len(num)):  
            s= s + ((num[i] - u )**2 / len(num))  
        print('Mean = %.2f' % round(u,2))  
        print('Deviation = %.2f' % round(s**0.5,2))  
    except(EOFError):  
        break

[C_MM239-中] 找除數

成績: 0 / 倒扣: 0.8

問題描述
一個數的除數表示小於等於這個數又能整除這個數的數字，例如 8 的所有除數為： 1, 2, 4, 8 。寫一個程式給定一個數字範圍，找出在這個範圍內哪個數字的除數最多。由於數字會很大，範圍也不小，你的程式必須很有效率。
輸入說明
輸入一個數字範圍 L 至 U ，中間以單一空白區隔。 L 與 U 均為正整數，且滿足 1 <= L <= U <= 1000000000 ， 0 <= U-L <= 10000 。
輸出說明
找出 L 至 U 之間，包含 L 與 U ，除數最多的數字。如果存在多個除數最多的數字，則以最小的那個數字表示。例如結果為 P ，除數共 N 個，則輸出格式為： P has a maximum of N divisors 。
範例

Sample Input:	Sample Output:
1 10 999999900 1000000000	6 has a maximum of 4 divisors 999999924 has a maximum of 192 divisors

    填上程式碼
  

[C_MM237-中] 多項式的微分

成績: 0 / 倒扣: 0.8

問題描述
一個多項式可以用下列通式表示：
f(x) = C_nxⁿ + C_n-1x^n-1 + . . . + C₁x¹ + C₀x⁰
其中 C_n 表示 x 的 n 次項係數， C_n 為包含零的任意正負整數，而 n 為包含零的任意正整數。而 f(x) 的微分可表示成：
f ¢ (x)=nC_nx^n-1 + (n-1)C_n-1x^n-2 + . . . + C₁
請寫一個程式輸入一個多項式，然後輸出這個多項式的微分方程式。多項式輸入方式為指定所有非零係數項的係數數值與該次項的冪次方，冪次方由大至小依序指定。相鄰數字請用單一空格區隔。例如多項式 f(x) = 2x⁴ + 10x² – 5x¹ – 10x⁰ 的輸入方式為： 2 4 10 2 -5 1 -10 0 。這個多項式的微分方程式輸出格式為：
8x^3+20x^1–5
每一項包含係數（含正負符號）、變數 x 、符號 ^ （表示次方）以及冪次方，請避免一個數字前面同時出現正負符號。項與項之間不必留空格。
輸入說明
輸入一個多項式所有非零係數項的係數數值（任意不為零的正負整數）與該次項的冪次方（ 0 或任意正整數）。
輸出說明
輸出多項式的微分方程式。
範例

Sample Input:	Sample Output:
1 4 -2 3 -5 0 -2 5 6 2 -10 1	4x^3-6x^2 -10x^4+12x^1-10

while True:  
    try:  
        m = list(map(int,input().split()))  
        r = []  
        for i in range(len(m)//2):  
            if m[2*i + 1]*m[2*i] == 0:  
                break  
            else:  
                r.append(m[2*i + 1]*m[2*i])  
                r.append(m[2*i + 1] - 1)  
        #print(r)  
        rs = ''  
        for i in range(len(r)//2):  
            if r[2*i + 1] == 0:  
                strs = '+' + str(r[2*i]) if r[2*i] > 0 else str(r[2*i])  
            else:  
                if i == 0:  
                    strs = str(r[2*i]) +'x^' + str(r[2*i + 1])  
                else:  
                    if r[2*i] > 0:  
                        strs = '+' + str(r[2*i]) + 'x^' + str(r[2*i + 1])  
                    else:  
                        strs = str(r[2*i]) + 'x^' + str(r[2*i + 1])  
            rs += strs  
        print(rs)  
    except(EOFError):  
        break

[C_MM236-中] 多項式的運算

成績: 0 / 倒扣: 0.8

問題描述
一個多項式可以用下列通式表示：
f(x) = C_nxⁿ + C_n-1x^n-1 + . . . + C₁x¹ + C₀x⁰
其中 C_n 表示 x 的 n 次項係數， C_n 為包含零的任意正負整數，而 n 為包含零的任意正整數。請寫一個程式輸入一個多項式，輸出代入某個 x 的數值，求得多項式的運算結果。多項式輸入方式為指定所有非零係數項的係數數值與該次項的冪次方，冪次方由大至小依序指定。相鄰數字請用單一空格區隔。例如多項式 f(x) = 2x⁴ + 10x² – 5x¹ – 10x⁰ 的輸入方式為： 2 4 10 2 -5 1 -10 0 。則代入數值 1 ，多項式的運算結果為 -3 。
輸入說明
第一行輸入一個多項式所有非零係數項的係數數值（任意不為零的正負整數）與該次項的冪次方（ 0 或任意正整數，最大值為 10 ），第二行輸入代入此多項式的數值（任意正負整數）。
輸出說明
求得代入給定數值後多項式的運算結果。
範例

Sample Input:	Sample Output:
2 4 10 2 -5 1 -10 0 2 1 3 -1 0 3	52 26

while True:  
    try:  
        m = list(map(int,input().split()))  
        x = int(input())  
        result = 0  
        for i in range(len(m)//2):  
            result += (m[2*i])*(x**m[2*i + 1])  
        print(result)  
    except(EOFError):  
        break

[C_MM235-中] 三點求圓

成績: 0 / 倒扣: 0.8

問題描述
在平面二維座標中給定不在同一直線上的三點，可求得通過這三點的唯一圓。如下圖所示，給定 A, B, C 三點座標（ x 軸與 y 軸），可利用 AB, BC 與 AC 線段，利用中垂線的交會點求得圓形的中心座標（ rx 與 ry ）。若這個圓的半徑為 r ，則這個圓可利用方程式： (x - rx)² + (y - ry)²= r² 表示。請寫一個程式，要求輸入三點不在一直線的座標，求得通過此三點的圓其中心座標與半徑。

輸入說明
要求輸入一行數字包含三個點的 x 與 y 軸的座標，共 6 個數字。每個數字可以為 0 或任何正負整數，數字間以單一空格分開。
輸出說明
於輸入數字的下一行輸出圓的中心點 x 軸與 y 軸座標，以及圓的半徑。每個輸出的數字以小數點取後三位數的方式呈現，並以單一空格與後方數字分隔。

範例

Sample Input:	Sample Output:
7 -5 -1 1 0 -6	3.000 -2.000 5.000
1 7 8 6 7 -2	3.921 2.447 5.409

    填上程式碼
  

[C_MM234-易] 找尋雙胞胎質數

成績: 0 / 倒扣: 0.8

找尋雙胞胎質數
Problem Description所謂的雙胞胎質數，指的是相差為 2 的質數。例如 (17,19) 就是一對雙胞胎質數。請你寫一隻程式，找出某個區間 [a,b] 中的雙胞胎質數對。例如 [a,b] = [20, 100] ，則雙胞胎質數對有：
(29,31)
(41,43)
(59,61)
(71,73)
Input File Format輸入只有一行，這一行中包含了 2 個整數 a 及 b ，這兩個整數以逗號隔開。整數 a 為區間的下限。整數 b 為區間的上限，兩個整數間沒有空白且 1<=a,b<=1000000 。
Output Format輸出 [a,b] 區間中所有的雙胞胎質數對。每一行一個質數對，質數對用小括號括起來（見底下的範例），兩個質數間用逗點分隔，且中間不需要包含空白。
Example

Sample Input:	Sample Output:
20,100	(29,31) (41,43) (59,61) (71,73)

while True:  
    try:  
        def is_prime(n):  
            i, max =2, n**0.5  
            while True:  
                if n==1:return False; break  
                if n==2:return True; break  
  
                if n % i ==0:return False; break  
                if i > max:return True; break  
                i += 1  
  
        m, n = map(int,input().split(','))  
        primes = []  
        for i in range(m, n):  
            if is_prime(i):  
                primes.append(i)  
        for i in range(len(primes) - 1):  
            if abs(primes[i] - primes[i+1]) == 2:  
                print('(%d,%d)' % (primes[i],primes[i+1]))  
    except(EOFError):  
        break

[C_MM233-易] 計算複利

成績: 0 / 倒扣: 0.8

計算複利
Problem Description你每個月存 10000 元到銀行中，銀行的每月利率為 0.1% ，以複利計算，請問 3 個月後，你的帳戶為多少錢？
底下的表格示範了如何得到第 3 個月時，帳戶中的本利和（本金 + 利率總合）。

月份	月初金額	月底本利和	備註
第一個月	10000	10010	月初存入 10000 元。 利息為 10000 * 0.1% = 10 所以本利和為 10010
第二個月	20010	20030.01	第二個月再存入 10000 加上前一個月的 10010 所以月初有 20010 元
第三個月	30030.01	30060.04001	所以第 3 個月時，本利和為 30060.04001 元。

我們定義底下幾個符號：
r: 每期利率。以前例而言， r = 0.1%
n: 期數。以前例而言， n = 3
p: 每期投入金額。以前例而言 p = 10000
現在，給你前述的三個值（即 r, n 及 p ），請計算期末的本利和。以前例而言，期未的本利合為 30060.04001 元。
Input File Format輸入有 3 行。第一行為 r ，為浮點數值。第二行為 n ，為一整數。第三行為 p ，為一整數。
Output Format輸出本利和，請將數值以「整數」表示（無條件捨去）
Example

Sample Input:	Sample Output:
0.001 3 10000	30060

while True:
    try:
        r = float(input())
        n = int(input())
        p = int(input())
        temp = p
        for i in range(n):
            m = temp*(1 + r)
            temp = p + m
        print(int(m))
    except(EOFError):
        break

[C_MM232-易] 判斷日期是否正確

成績: 0 / 倒扣: 0.8

判斷日期是否正確
Problem Description給定一個日期（以 yyyy-MM-dd 的格式來表示），請寫一支程式判斷這個日期是否正確。舉例而言：
2012-02-29 ：正確
2011-02-29 ：不正確，因為 2011 年的 2 月只有 28 天
-1111-02-29 ：不正確，因為年不可能為負數
2011-13-29 ：不正確，因為月份不可能超過 12
2011-01-32 ：不正確，因為 1 月不會有 32 天
Input File Format輸入的第一行為一個整數 n ，代表底下測資的個數（ n<=10 ）。
之後有 n 行字串。每一行字串為一日期，日期以 yyyy-MM-dd 的格式表示。
Output Format輸出每一個測資是否為正確的日期，若為正確的日期，請輸出 true ，否則請輸出 false （均小寫）
Example

Sample Input:	Sample Output:
5 2012-02-29 2011-02-29 -1111-02-29 2011-13-29 2011-01-32

while True:
    try:
        month_day = [29, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
        def Runnian(y):
            return True if y % 400 == 0 or(y % 4 == 0 and y % 100 !=0) else False
        N = int(input())
        for i in range(N):
            data = list(map(str,input().split('-')))

            if len(data) > 3: # 
                print('false')
            else:
                if int(data[1]) > 12: # 檢查月份
                    print('false')
                else:
                    if Runnian(int(data[0])): # 檢查天數 如果是閏年
                        if int(data[1]) ==2 and int(data[2]) <= month_day[0]:
                            print('true')
                        elif int(data[2]) <= month_day[int(data[1])]:
                            print('true')
                        else:
                            print('false')
                    else:
                        print('true') if int(data[2]) <= month_day[int(data[1])] else print('false')
    except(EOFError):
        break

[C_MM230-中] 螺旋矩陣對角線值

成績: 0 / 倒扣: 0.8

螺旋矩陣對角線值
問題描述
底下是一個 5*5 的螺旋矩陣。我們將對角線上的數值用紅色標出來。可以知道對角線的值相加後為 101 （ i.e., 1+3+5+7+9+13+17+21+25 = 101 ）。

21	22	23	24	25
20	7	8	9	10
19	6	1	2	11
18	5	4	3	12
17	16	15	14	13

現在，給你一個 k*k 的螺旋矩陣（ k 為奇數），請計算出其對角線值的加總。
註：本題取自 Project Euler ， Problem 28 （ http://projecteuler.net/problem=28) 。
輸入說明
輸入一個 k 值， k 必為奇數。 k<=2001
輸出說明
計算 k*k 螺旋矩陣的對角線值總合，並輸出。
範例

Sample Input:	Sample Output:
5	101

while True:
    try:
        N = int(input())
        n, j ,sum = 1, 2, 1
        while True:
            if n >= N**2:break
            for i in range(4):
                n += j
                sum += n
            j+=2
        print(sum)
    except(EOFError):
        break

[C_MM229-中] 生存之道

成績: 0 / 倒扣: 0.8

問題描述：
一位數學家在蠻荒探險，在部落做客，卻遇到外族強力來犯，酋長帶著族人和數學家總共３ 1 人，一同被圍困在一個山洞內，正面臨著無可避免的失敗 ，他們下定決心， 不成功便成仁 ，寧死不降 。於是他們決定安排自己在一圓圈上，其中酋長被指為 1 號， 然後開始進行他們的決定 ，方法是順時針方向由 1 號算起， 每二人按順序自殺， 直到所有人都死光為止。 很明顯的第一圈之 2 ， 4 ， ... ， 28, 30 相繼自殺， 接下來的是誰 ? 應該是 32 號嗎 ? 但他們才只有 31 人， 所以 32 除以 31 餘數是 1 , 接下來應該是輪到 1 號 , 再接下來的並不是 3 號，因為 2 號和 4 號剛才己經自殺身亡了， 我們這次不算他們，所以下一個是跳過 3 號的 5 號 ，依此類推。數學家不想平白死掉，但是又怕族人笑他懦弱，因此，他立即算出自己應該站在那一位置才是最後輪到的，如此他就不必犧牲了。我們不來評斷數學家的勇氣 , 僅就其數學層面來看，以一般的討論來看 , 我們假設有 N 人排成一圈 , 每二人退出圈 , 用 L （ N ）表示最後留下來的人。
輸入說明：
ex:
輸入 input.txt 含總人數 N
13
結果 L(13) 請寫入 output.txt
11
輸出輸入測試資料

1	1
3	3
4	1
9	3
10	5
11	7
13	11

while True:
    try:
        N = int(input())
        p, k = [i for i in range(1,N+1)], 2 # k是爆炸數
        index = 0
        while len(p) != 1:
            index =(index + (k-1))%len(p)
            del p[index]
        print(p[0])
    except(EOFError):
        break

[C_MM228-易] 圖形數

成績: 0 / 倒扣: 0.8

問題描述：

圖形數

Type	1st	2nd	3rd	4th	5th	6th
三角數
Value	1	3	6	10	15	21
四角數
Value	1	4	9	16	25	36
五角數
Value	1	5	12	22	35	51

nth x - gonal number 表示

輸入說明：

ex:

輸入 input.txt 含多角數 x 階層數 n

5 5

結果請寫入 output.txt

35

輸出輸入測試資料

1 1	1
3 2	3
3 3	6
3 4	10
4 2	4
4 3	9
4 4	16

while True:
    try:
        x, n = map(int,input().split())
        num = 0
        end = (n - 1)*(x - 2) + 1
        step = x-2 if x-2 > 0 else 1
        for i in range(1, end+1, step):
            num += i
        print(num)
    except(EOFError):
        break

[C_MM227-易] 對角線

成績: 0 / 倒扣: 0.8

問題描述 ：
在 Thinking Mathematically 這本書裡，有一道題：「方格紙上畫上一個三格乘以五格的長方形，並且連起一條對角線。有多少方格和對角線接觸？」
首先考慮長和寬互質 ( 最大公因數是 1) ，試著畫畫如右圖，並數一數接觸的方格數，將結果列表如下表。


輸入說明 ：
長 x 寬 y:如 5 3

輸出說明 ：
對角線接觸到的方格數量 7

範例 ：

輸入範例	輸出範例
2 1	2
3 1	3
4 1	4

參考資料：昌爸工作坊

while True:
    try:
        m, n = map(int,input().split())
        print(m+n-1)
    except(EOFError):
        break

[C_MM226-易] 薪水問題

成績: 0 / 倒扣: 0.8

問題描述：
阿哲是一個半導體公司的員工，他每個月的底薪是 36000 ，他每天的工時為 12 小時，一個月標準工作 15 天，若有加班每個小時 400 塊，若在非上班時段開會則每個小時 300 塊，低於標準工時則每小時扣 200 塊請設計出一個程式計算他每個月的薪水。
輸入說明：
輸入當月上班時數及開會時數
輸出說明：
輸出當月實得薪資
範例：

Sample Input:	Sample Output:
180 5	37500

while True:
    try:
        work = int(input())
        meet = int(input())
        if work > 180:
            money = 36000+ 400*(work-180)
        else:
            money = 36000 - 200*(180-work)
        print(money+meet*300)    
    except(EOFError):
        break

[C_MM225-易] 不能吵架辣

成績: 0 / 倒扣: 0.8

有一對好朋友吵架了，因為他們之後分東西的時候，不管怎麼樣都算不好。他們買之前已經先說好，每個人每次都分兩個蛋糕和一杯飲料直到分完為止，可是在買的時候才發現每買三個蛋糕或兩杯飲料，老闆就會送一包小餅乾。出乎意料的他們，決定說餅乾就每次一人分一包吧。請問一下，他們在怎麼樣買的情況下可以很公平的分完，讓兩個好朋友不會吵架。當兩個數量輸入都為 -1 時結束程式。
輸入格式
兩個正整數 m ,n 。 m 代表買多少個蛋糕 ， n 代表買了多少飲料。
輸出格式
能公平的依規則分，則輸出 yes
無法公平的依規則分，則輸出 no
Sample input
4 2
2 1
-1 -1
Sample output
yes
no

while True:
    try:
        m, n = map(int,input().split())
        if m==-1 and n==-1:break
        # cookie = m//3+n//2
        print('yes') if m%4==0 and n%2==0 and (m//3+n//2)%2==0 else print('no')
    except(EOFError):
        break

[C_MM224-易] 我要九十九

成績: 0 / 倒扣: 0.8

題目敘述
只要當過學生，一定很多人在算分數的時候，聽過老師跟大家說開根號乘以十 。 通常大家這樣都會很開心，因為只要 36 分就可以及格了 ! 但是， 36 分以下的同學就很頭痛了 。 在壓力太大的情況下，有些學生就作夢，夢到老師跟他們說，要讓他們開更號乘以十很多次，可是最後出來的分數要到 99 分才讓他們過 。 數學好的你，可以告訴他們到底最少需要做多少次開根號乘以十，才能夠讓分數等於 99 嗎 ? 當輸入為 -1 時結束程式 。 ( 開根號之後都四捨五入到小數第一位 )
輸入格式
輸入一個正整數 N ， 0 < N < 36
輸出格式
一個正整數 ( 共做了幾次開根號乘以十 )
Sample input
20
35
-1
Sample output
8
7

while True:
    try:
        N = int(input())
        i = 0
        if N == -1:break
        while N < 99:
            N = round((N**0.5)*10, 1)
            i += 1
        print(i)
    except(EOFError):
        break

[C_MM223-中] 薪資計算機

成績: 0 / 倒扣: 0.8

問題描述 ：
真好味便當店的老闆娘正在為員工們計算當月的薪資，但由於人數太多非常麻煩，想你幫忙設計一個薪資計算機，可以幫老闆娘快速算出員工薪資。

輸入說明 ：
首先輸入員工人數P，接著輸入P行，每行有六個整數，分別為起始小時H、起始分鐘M、結束小時h、結束分鐘m、時薪與工作天數(不滿一小時者無條件進位)，h恆大於等於H。

輸出說明 ：
輸出P個結果表示該員工應領薪資為多少。

範例 ：

輸入範例	輸出範例
4 8 30 17 10 85 20 9 05 18 30 105 22 7 22 17 21 99 20 6 38 16 58 102 21	15300 23100 19800 23562

import math
while True:
    try:
        def cal_S(H, M, h, m, s, d):
            t = math.ceil((h*60 + m - H*60 - M) / 60)
            return t*s*d
        P = int(input())
        for i in range(P):
            data = list(map(int,input().split()))
            print(cal_S(data[0], data[1], data[2], data[3], data[4], data[5]))
    except(EOFError):
        break

[C_MM222-中] 特惠時間

成績: 0 / 倒扣: 0.8

問題描述 ：
知名飲料店最近正在舉行新春大特惠的活動，任何飲料買一送一；每日特惠時間是11:30到14:30。請設計一程式判斷輸入時間是否為特惠時間。

輸入說明 ：
首先輸入一變數N，代表接下來會有幾筆輸入資料；接著請輸入小時(H，0≤H≤23)與分鐘(M，0≤M≤59)，表示所需判斷的時間。

輸出說明 ：
請輸出”YES”或”NO”表示是否為特惠時間。

範例 ：

輸入範例	輸出範例
3 10 01 11 31 14 21	NO YES YES

while True:
    try:
        N = int(input())
        start, end =690, 870
        for i in range(N):
            h, m = map(int,input().split())
            print('YES') if h*60 + m >= start and h*60 + m <= end else print('NO')
    except(EOFError):
        break

[C_MM220-中] 車牌算命

成績: 0 / 倒扣: 0.8

問題描述 ：
有一家車牌買賣貿易商，想了一個行銷手法，決定利用車牌算命來分級，因為貿易商賣的車牌都是自用小客車，車牌號碼都是2+4碼(例如：AB-1234)，於是他就將車牌末四碼的餘數用來分級，等級為[0~4]，以小到大分別代表為[大凶、凶、普通、吉、大吉]。

輸入說明 ：
輸入2+4碼的車牌號碼(例如：AB-1234)。

輸出說明 ：
輸出算命結果，區間為(0~4)。

範例 ：

輸入範例	輸出範例
AB-5566	1

while True:
    try:
        strs=input().strip()
        print(int(strs[-4:])%5)
    except(EOFError):
        break

[C_MM219-中] 黑色星期五

成績: 0 / 倒扣: 0.8

問題描述 ：
「黑色星期五」被認為是不吉利的日子，有一家保險公司想藉由「黑色星期五」及「2012世界末日」來當噱頭，因此保險公司想要設計一個長達數年的計畫，但他們必須先知道這數年中會出現幾次「黑色星期五」。
※提示：(西元年是400的倍數)或(西元年是4的倍數但不是100的倍數)就是閏年。

Y(year)：年份減2000

L(leap days)：從2000年1月1日到該日之間的閏日數目

M(month)：月份的代號，從一月到十二月分別是5、1、1、4、6、2、4、0、3、5、1、3，即是一月是５，二、三月是１，四月是4，五月是6，依此類推，十二月是3

D(date)：日號

星期 = (Y + L + M + D) mod 7

如2008年12月10日

​(8 + 3 + 3 + 10) mod 7 = 3，即該日是星期三。
輸入說明 ：
輸入兩筆西元年，中間以一個逗點隔開。 (西元年區間為0 ~ 2012，請依小到大輸入)
輸出說明 ：
輸出兩筆西元年之間共發生幾次黑色星期五。
範例 ：

輸入範例	輸出範例
1970,1975	10

def Runnian(y):# y年是否為閏年
    return True if y % 400 == 0 or(y % 4 == 0 and y % 100 !=0) else False
def Count_R(y):
    r = 0
    if y >= 2000:
        for i in range(2000, y+1):
            if Runnian(i):
                #print(i)
                r += 1
    else:
        for i in range(y, 2000):
            if Runnian(i):
                #print(i)
                r += 1
    return r
m, n = map(int,input().split(','))
M = [5, 1, 1, 4, 6, 2, 4, 0, 3, 5, 1, 3]
days = 0
for y in range(m, n+1):
    Y = y - 2000
    r = Count_R(y)
    if y >= 2000:
        for m in range(1, 13):
            if Runnian(y):
                L = r if m > 2 else r - 1
                if (Y + L + M[m-1] + 13) % 7 == 5:
                    #print('%d 月 13 日' % m)
                    days += 1
            else:
                L = r
                if (Y + L + M[m-1] + 13) % 7 == 5:
                    #print('%d 月 13 日' % m)
                    days += 1
    else:
        for m in range(1, 13):
            if Runnian(y):
                L = r - 1 if m > 2 else r
                if (Y - L + M[m-1] + 13) % 7 == 5:
                    #print('%d 月 13 日' % m)
                    days += 1
            else:
                L = r
                if (Y - L + M[m-1] + 13) % 7 == 5:
                    #print('%d 月 13 日' % m)
                    days += 1
print(days)
  

[C_MM218-中] 重排第幾個

成績: 0 / 倒扣: 0.8

問題描述 ：
1到N有N個正整數，這N個正整數排成一列共有N!排法，這N!個重排依字典排序法從小到大排列編號。第一號為「1 2 3 … N」，第N!號為「N N-1 N-2 … 1」。以下為N=3時的狀況。

順序	重排
1	1 2 3
2	1 3 2
3	2 1 3
4	2 3 1
5	3 1 2
6	3 2 1

現在輸入一個重排，試求該重排是在該長度重排中的第幾個。
輸入說明 ：
輸入一個1到N的重排，0 < N < 25。
輸出說明 ：
輸出該重排是N!個重排中的第幾個。
範例 ：

輸入範例	輸出範例
2 1 3	3

    while True:
    try:
        N = list(map(int,input().split()))
        for i in range(len(N)):
            N[i] = N[i] - 1
        def rot(data, n):               # 將第n個搬到最後
            val = data.pop(n)
            data.append(val)
            return data
        def rot_n_chk(data, n):         # 檢查第n個要不要搬
            for i in range(n-1):
                if data[i] == i:
                    rot(data, i+1)
                else:
                    break
            return data
        def chk_stop(data, n):          # 檢查所有的位置是否都歸位
            res = 1
            for i in range(n):          # 只要第i位置對 chk=1, 位置不對 chk=0
                chk=1 if data[i] == i else 0
                res *= chk              # 每位的乘積
            return res                  # res乘積為1表示全歸位都輪完了
        
        #data = [i for i in range(1, N+1)]      #[1, 2, 3...]
        data_i = [i for i in range(len(N))]     #[0, 1, 2...]
        data_p = []
        while True:
            rot(data_i, 0)
            rot_n_chk(data_i, len(N))
            #print(num, odata)
            b = data_i[:]
            data_p.append(b)
            if chk_stop(data_i, len(N)):break
        r = sorted(data_p)
        #print(r[K-1])
        print(r)
        print(r.index(N)+1)        
    except(EOFError):
        break

[C_MM217-中] 第K個重排

成績: 0 / 倒扣: 0.8

問題描述 ：
1到N有N個正整數，這N個正整數排成一列共有N!排法，這N!個重排依字典排序法從小到大排列編號。第一號為「1 2 3 … N」，第N!號為「N N-1 N-2 … 1」。以下為N=3時的狀況。

順序	重排
1	1 2 3
2	1 3 2
3	2 1 3
4	2 3 1
5	3 1 2
6	3 2 1

現在輸入兩個數字N與K，試求在1到N的重排中，排第K個的是誰。
輸入說明 ：
輸入兩個正整數N，K，用空白隔開，0 < N < 25。
輸出說明 ：
輸出1到N的重排中，排第K個的重排。輸出時，各數字中間請用空排隔開，兩旁不留空白。
範例 ：

輸入範例	輸出範例
3 3	2 1 3

while True:
    try:
        N, K = map(int,input().split())
        def rot(data, n):               # 將第n個搬到最後
            val = data.pop(n)
            data.append(val)
            return data
        def rot_n_chk(data, n):         # 檢查第n個要不要搬
            for i in range(n-1):
                if data[i] == i:
                    rot(data, i+1)
                else:
                    break
            return data
        def chk_stop(data, n):          # 檢查所有的位置是否都歸位
            res = 1
            for i in range(n):          # 只要第i位置對 chk=1, 位置不對 chk=0
                chk=1 if data[i] == i else 0
                res *= chk              # 每位的乘積
            return res                  # res乘積為1表示全歸位都輪完了
        
        #data = [i for i in range(1, N+1)]   #[1, 2, 3...]
        data_i = [i for i in range(N)]      #[0, 1, 2...]
        data_p = []
        while True:
            rot(data_i, 0)
            rot_n_chk(data_i, N)
            #print(num, odata)
            b = data_i[:]
            data_p.append(b)
            if chk_stop(data_i, N):break
        r = sorted(data_p)
        #print(r[K-1])
        strs = ''
        for i in r[K-1]:
            strs += str(i+1) + ' '
        print(strs.strip())
    except(EOFError):
        break

[C_MM214-易] 賣麵包

成績: 0 / 倒扣: 0.8

問題描述 ：
小明在麵包店打工，而店裡裝麵包的盒子有兩種分別為大盒子與小盒子。今天早上小明在收銀台幫客人結帳的時候，他突然想到一個問題：今天師傅烤了若干個麵包，並用數個大盒子與小盒子裝起來(每個盒子都有裝滿麵包)，假設我們已經知道麵包的總數量以及總共用了多少個盒子，你是否可幫小明計算出裝這些麵包分別使用了多少個大盒子以及小盒子?

輸入說明 ：
第一行為一個正整數N，代表共有N筆測資，接下來有N行。每筆測資有四個整數A,B,C,D(100≤A≤10000,100≤B≤10000,1≤C,D≤10000)，分別代表麵包總數量，總共使用的盒子個數，一個小盒子最多可裝的麵包數，以及一個大盒子最多可裝的麵包數。每個整數之間以一個空格隔開。

輸出說明 ：
每筆測資輸出兩個整數，分別為使用的小盒子個數以及大盒子個數，兩個整數間以空格隔開。每筆測資輸出於一行。

範例 ：

輸入範例	輸出範例
2 100 20 5 10 1000 127 7 10	20 0 90 37

while True: # 這題要算出最少用了幾個盒子，所以大盒子先用
    try:
        N = int(input())
        for i in range(N):
            data = list(map(int,input().split())) # data[0]麵 data[1]盒 data[2]小 data[3]大
            for j in reversed(range(data[1]+1)): # 先全部用大盒，依次遞減…大盒量+小盒量=麵包
                if j*data[3] + (data[1]-j)*data[2] == data[0]:
                    break
            print('%d %d' % (data[1]-j, j))
    except(EOFError):
        break

[C_MM213-易] 就決定是你了!!

成績: 0 / 倒扣: 0.8

題目說明： 在神奇寶貝世界裡，有一名怪獸馴服師名叫小智，他從小就立志要成為神奇寶貝大師，所以分析了神奇寶貝之間的關係，以下是他所分析的資料 :
很多隻神奇寶貝都有他自己屬性，共有 4 種屬性地、水、火、風，每一隻神奇寶貝都有他自己的等級、血量、防禦、招式威力和出招速度，以上都會根據不同屬性有不同的量。血量的算法為 : 水屬性 - 等級 *50+45 ，風屬性 - 等級 *45+45 ，地屬性 - 等級 *45+40 ，火屬性 - 等級 *40+45 ；防禦算法 : 地屬性 - 等級 *8+2 ，風屬性 - 等級 *6+3 ，火和水屬性 - 等級 *5+2 ，招式威力 : 火屬性 - 等級 *20+30 ，地和水屬性 - 等級 * 17+30 ，風屬性 - 等級 *15+30 ；速度算法 : 風屬性 - 等級 *10+10 ，火 - 等級 *8+8 ，水 - 等級 *7+9 ，地 - 等級 *5+10 。每個馴服師最多可帶三隻神奇寶貝，比賽的規則為算出身上每隻神奇寶貝的數值總合較大的為贏，若一樣則平手。每隻神奇寶貝數值算法 : 血量 *0.5+ 防禦 *1.5+ 攻擊 *1.3+ 速度 *2 ，請幫小智算出是否可以打贏對手。
例如 : 單隻等級 50 、水屬性的神奇寶貝，血量為 2545, 防禦 252 招式威力 880 速度 359 整體數值為 (2545*0.5 + 252*1.5 + 880*1.3 + 359*2)=3512.5
輸入說明： 第一行為一個整數 n ( 0 < n ≤ 16 ) 代表有幾個對手，之後有 2n 行，每兩行代表小智與對手，每一行的第一個數字 k 代表馴服師身上有 k ( 1 ≤ k ≤ 3 ) 隻神奇寶貝，之後有 2k 個數字分別代表每隻神奇寶貝的等級 Lv (1 ≤ Lv ≤100 ) 、屬性，屬性以 1,2,3,4 代表地 , 水 , 火 , 風。
輸出說明： 如果小智可以獲勝則輸出 win ，不行則輸出 lose ，平手則輸出 tie 。
範例

Sample Input:	Sample Output:
3 1 50 2 1 50 2 3 50 2 60 3 70 4 2 60 3 50 1 2 60 4 100 1 3 70 3 100 3 90 3	tie win lose

while True:
    try:
        def pok(g, att): #g→等級 n→屬性
            if att == 1:
                pow = (g*45+40)*0.5 + (g*8+2)*1.5 + (g*17+30)*1.3 + (g*5+10)*2
            elif att == 2:
                pow = (g*50+45)*0.5 + (g*5+2)*1.5 + (g*17+30)*1.3 + (g*7+9)*2
            elif att == 3:
                pow = (g*40+45)*0.5 + (g*5+2)*1.5 + (g*20+30)*1.3 + (g*8+8)*2
            else:
                pow = (g*45+45)*0.5 + (g*6+3)*1.5 + (g*15+30)*1.3 + (g*10+10)*2
            return pow
        n = int(input())
        for i in range(n):
            G = list(map(int,input().split()))
            K = list(map(int,input().split()))
            G_pow, K_pow = 0, 0
            for j in range(G[0]):
                G_pow += pok(G[2*j+1], G[2*j+2])
            for j in range(K[0]):
                K_pow += pok(K[2*j+1], K[2*j+2])
            if G_pow > K_pow:
                print('win')
            elif G_pow < K_pow:
                print('lose')
            else:
                print('tie')
    except(EOFError):
        break

[C_MM212-易] 路上的東西不要亂撿 !

成績: 0 / 倒扣: 0.8

題目說明： 有一天你在路上撿到一台機器，由於樣子非常奇特所以你決定帶回家好好的研究一番，不料當機器啟動的瞬間突然產生一道強烈的光芒，瞬間你失去了視覺。當你恢復視力時，發現你身處在一個奇怪的王國，並且被一堆拿著武器的人包圍著，隨後就被帶去類似監獄的地方。在那裏你發現也有很多被抓來的囚犯，一問之下發現大家都是啟動那台機器後就突然跑到這裡了，並且你被告知一個驚人的事實！就是這裡的人都將接受處決，而只有一位幸運兒才能活著離開；處決方式是這樣的：將 m 個 囚犯們賦予一個編號 (1~m) 並依順時針圍成一圈，從編號 1 的囚犯依順時鐘由 1 開始報數，報到 k 的這個數字即被立刻殺掉，然後再由下一個編號的囚犯再開始順時鐘依次報數，報到 的人再被殺掉，直到最後一個活著的人就可以活著離開。例如 m = 9 , k = 7 處決過程如下：
1 2 3 4 5 6 7 8 9 => 殺掉 7 號囚犯
1 2 3 4 5 6 8 9 => 殺掉 5 號囚犯
1 2 3 4 6 8 9 => 殺掉 4 號囚犯
1 2 3 6 8 9 => 殺掉 6 號囚犯
1 2 3 8 9 => 殺掉 9 號囚犯
1 2 3 8 => 殺掉 3 號囚犯
1 2 8 => 殺掉 8 號囚犯
1 2 => 殺掉 1 號囚犯
2 號囚犯於是可以活著離開。現在你還不想這麼早上天堂，因此想藉由寫一個程式來替自己解圍，算出在 m 個囚犯之中，自己應該排在第幾號才可以活著離開。
輸入說明： 第一列為一個 N <= 15 正整數 ，代表接下來有 N 組測試資料，每組測試資料均有兩個正整數 m, k ( 1 <= m <= 100000 , 1 <= k <= 999999) ，分別代表 m 個囚犯以及報數值 k，中間以一個空格隔開。
輸出說明： 輸出自己應該排在編號幾的位置才能夠存活。每筆輸出佔一列。
範例 ：

Sample Input:	Sample Output:
3 9 7 10 2 3 5	2 5 1

  
while True:
    try:
        N = int(input())
        for i in range(N):
            m, k = map(int,input().split())
            p = [i for i in range(1, m+1)]
            index = 0 #爆掉的索引值
            while len(p)!=1: #剩下1個時停止
                index = (index +(k - 1))%len(p)
                del p[index]
            print(p[0])
    except(EOFError):
        break

[C_MM211-易] 考試測驗

成績: 0 / 倒扣: 0.8

問題描述 : 某間學校舉辦英文檢定測驗，若是學生通過該測驗，則能通過畢業門檻。老師準備的英文測驗中分為三個項目當作考試，分別是聽力、閱讀、口說。每一個項目測驗滿分皆為 100 分，總分為 300 分。想要通過測驗有兩種方式。方式一：若是三個項目分數皆為 60 分以上 ( 包含 60 分 ) 即為通過測驗。方式二：若三個項目中有其中一個項目分數未滿 60 分，但三個項目分數總合超過 220 分，也可算通過測驗。若三個項目中有其中一個項目分數未滿 60 分，而三個項目分數總合也沒能超過 220 分，可獲得補考機會。若是三個項目中有兩個項目不及格，但另一個項目成績高於 80 分 ( 包含 80 分 ) ，也可獲得補考的機會。其餘皆判定為無法通過測驗。
輸入說明 ：
第一行為一個整數 N ，代表共有 N 組測試資料。之後有 N 行，每一行有 3 個非負整數 ( 範圍皆為 0 到 100), 分別代表該名學生聽力、閱讀、口說的測驗分數。
輸出說明 :
若是通過測驗，則輸出 ”P” 。若是需要補考，則輸出 ”M” 。若是無法通過測驗，則輸出 ”F” 。 每組答案結果輸出於一行。
Sample Run ：

Sample Input	Sample Output
5 95 86 100 30 60 80 80 55 85 20 30 60 10 80 10	P M P F M

  while True:  
    try:  
        N = int(input())  
        for i in range(N):  
            sco = list(map(int,input().split()))  
            if sco[0] >=60 and sco[1] >=60 and sco[2] >=60:  
                print('P')  
            elif (sco[0] < 60 and sum(sco) >= 220) or  \
            (sco[1] < 60 and sum(sco) >= 220) or  \
            (sco[2] < 60 and sum(sco) >= 220):  
                print('P')  
            elif (sco[0] < 60 and sco[1] >= 60 and sco[2] >= 60 and sum(sco) < 220) or  \
            (sco[1] <60 and sco[2] >= 60 and sco[0] >= 60 and sum(sco) < 220) or  \
            (sco[2] <60 and sco[0] >= 60 and sco[1] >=60 and sum(sco) < 220):  
                print('M')  
            elif (sco[0] >= 80 and sco[1] < 60 and sco[2] < 60) or  \
            (sco[1] >= 80 and sco[0] < 60 and sco[2] < 60) or  \
            (sco[2] >= 80 and sco[1] < 60 and sco[0] < 60):  
                print('M')  
            else:  
                print('F')  
    except(EOFError):  
        break

[C_MM210-易] 道路綠美化

成績: 0 / 倒扣: 0.8

問題描述： 環保市 政府想在大學路上進行道路綠美化工程，預計在道路上起始端 ( 第 0 公尺 ) 種一棵樹，之後每隔 x 公尺種一棵樹，而在道路終點處設立一支路燈，之後反向每隔 y 公尺設立一支路燈，為了夜間行路的安全視政府認為路燈比樹重要，所以當一處需要路燈以及樹時，將只設立路燈而不種樹，若大學路的長度為 M 公尺請幫 環保市 政府算算總共需要幾棵樹和幾支路燈。

輸入說明： 第一行有一個正整數 N ，表示共有 N 筆測試資料。接下來有 N 行，每行為一筆測試資料，內含三個整數，每個整數間有一個空格，各整數分別代表道路總長 M <= 10000 及路燈和樹的間距 1 <= x,y <= 100。
輸出說明： 每筆測試資料先 輸出樹後輸出路燈的數量 於一行，兩數間以一個空格隔開。
範例

Sample Input	Sample Output
2 19 2 3 120 5 4	7 7 18 31

這裡我用兩個串列來放樹及燈的位置，先按燈的要求放入燈，放樹時再檢查該位置是否已有樹，沒有再放樹，最後統計兩串列的長度就是答案

  while True:
    try:
        N = int(input())
        for i in range(N):
            T, L = [], []
            M, x, y = map(int,input().split())
            for l in range(M, -1, -y): #先放燈
                L.append(l)
            for t in range(0, M+1, x): #如果放樹時已有燈就不放樹
                if t not in L:T.append(t)
            print('%d %d' % (len(T), len(L)))
    except(EOFError):
        break

[C_MM209-易] 求移動位置與總移動長度

成績: 0 / 倒扣: 0.8

問題描述
小明開發了一個可以往上下左右四個方向移動的機器人，為了驗證機器人的移動能力，於是將機器人擺放在一個25x25的平面空間內。一開始機器人將放置在左上角標示為(0,0)的位置。當指令下達(4,5)時，機器人將先往右移動四格再往下移動五格抵達(4,5)的方格內(如圖紅線)，共移動了九格。接著當指令下達移動到(-1,-3)的位置時，機器人將先往左移動一格再往上移動三格抵達(3,2)的位置(如圖深藍線)，共移動了四格。接著指令下達(-5,1)，因往左移動五格將超出平面範圍，因此機器人將停在(0,2)的位置(如圖綠線)，也不會在往下移動。若指令下達(2,-7)，則機器人將先往移動兩格，接著再往上移動七格時因將超出平面範圍，因此機器人將停在(2,0)的位置(如圖水藍線)。因此在經過四次移動指令後，機器人共移動了20格。機器人的移動固定會先走X方向再走Y方面。現由檔案讀入五組移動指令，求出總共移動的格數與最後位置。

輸入格式
輸入五組移動指令。
-25 ≤ X,Y ≤ 25。
輸出格式
求出總共移動的格數與最後座標位置。
Example

Sample Input:	Sample Output:
1 1 2 2 3 3 4 4 5 5	30 15 15
1 1 2 -2 3 3 -14 -4 5 5	27 5 8

  while True:
    try:
        pt = [[0 for i in range(2)] for j in range(6)] #產生輸入串列
        co = [[0 for i in range(2)] for j in range(6)] #產生座標串列
        total = 0
        for i in range(1,6): #記錄輸入座標
            pt[i] = list(map(int,input().split()))
        for i in range(5): #記錄游走座標
            if co[i][0] + pt[i+1][0] < 0:
                co[i+1][0] = 0
                co[i+1][1] = co[i][1]
                continue
            elif co[i][0] + pt[i+1][0] >24:
                co[i+1][0] = 24
                co[i+1][1] = co[i][1]
                continue
            else:
                co[i+1][0] = co[i][0] + pt[i+1][0]
                if co[i][1] + pt[i+1][1] < 0: 
                    co[i+1][1] = 0
                else:
                    co[i+1][1] = co[i][1] + pt[i+1][1]
        for i in range(5):
            total += abs(co[i+1][0] - co[i][0]) + abs(co[i+1][1] -co[i][1])
        print('%d %d %d' % (total,co[-1][0],co[-1][1]))
    except(EOFError):
        break

[C_MM208-易] 求移動路徑格數

成績: 0 / 倒扣: 0.8

問題描述
小明開發了一個可以往上下左右四個方向移動的機器人，為了驗證機器人的移動能力，於是將機器人擺放在一個 25x25 的平面空間內。一開始機器人將放置在左上角標示為 (0,0) 的位置。當指令下達移動到 (4,5) 的位置時，機器人將先往右移動四格再往下移動五格抵達 (4,5) 的方格內，共移動了九格。接著當指令下達移動到 (1,10) 的位置時，機器人將先往左移動三格再往下移動五格抵達 (1,10) 的位置，共移動了八格。因此在經過兩次移動指令後，機器人共移動了 17 格。現由檔案讀入五組要移動的座標位置，求出總共移動的格數。
輸入格式
輸入 五組座標位置。
輸出格式
求出總共移動的格數。
Example

Sample Input:	Sample Output:
1 1 2 2 3 3 4 4 5 5 4 3 2 2 10 9 4 4 11 12	10 51

這題原題目的輸入要求是錯的，如果照原要求設計打死都不會AC， 應該改為一行輸入一個座標，例如：
1 1
2 2
3 3
4 4
5 5

輸入對了，每一個座標值減前一個座標值相加就是答案  

while True:
    try:
        co = [[0 for i in range(2)] for j in range(6)]
        total = 0
        for i in range(1,6):
            co[i] = list(map(int,input().split()))
        for i in range(5):
            total += abs(co[i+1][0] - co[i][0]) + abs(co[i+1][1] - co[i][1])
        print(total)
    except(EOFError):
        break

[C_MM205-易] 爬樓梯

成績: 0 / 倒扣: 0.8

問題描述
建中有個習慣，爬樓梯時會一階一階爬，也會一次爬二階，當他遇到樓梯有 N 階時他有幾種不同的爬法來爬完 N 階,
0<N<=20
輸入說明
輸入一個 N 代表樓梯階數
輸出說明
輸出有總共幾種不同的爬法
範例

Sample Input	Sample Output
5 10 20	8 89 10946

[C_MM204-易] 填入規律數字

成績: 0 / 倒扣: 0.8

問題描述
已知一數列前四項為等差或者等比級數，請撰寫一個程式以得出第五項。
輸入說明
第一行輸入一整數N，代表N組測試資料，接著每組測試資料需輸入前四項數字，數字皆為整數。
輸出說明
包含第五項的完整數列輸出
範例

Sample Input	Sample Output
3 1 2 3 4 1 2 4 8 2 4 6 8	1 2 3 4 5 1 2 4 8 16 2 4 6 8 10

  while True:
    try:
        N = int(input())
        for i in range(N):
            nums = list(map(int,input().split()))
            if nums[1]/nums[0] == nums[2]/nums[1]:
                nums.append(int(nums[3]*nums[1]/nums[0]))
            else:
                nums.append(nums[3]+nums[1]-nums[0])
            strs=''
            for i in nums:
                strs += str(i) + ' '
            print(strs.strip())
    except(EOFError):
        break