用 Python 做商管程式設計（一） Week 5d

05d-01 存貨政策與自動訂補貨
(Q,R) policy
定義 : 若現貨量 I < Q 則 補貨R件
(s,S) policy
定義 : 若現貨量 I < s  則 補貨至 S 件

Optimizing the (Q,R) policy
    決定 Q 和 R
考量下列 costs
- Inventory cost :  買東西堆在庫房而浪費掉的投資機會
- Ordering cost : 處理貨物的成本
- Shortage cost : 因為沒有賣出去而損失的銷售

例題:
Q = 30 ，一單位貨品買入價1000元，年利率 7.3%，
一次訂貨成本 200，一個顧客來卻缺貨虧 2元，
過去20天需求量如下，20天前的存貨量 為 20件。
求 R 使得總成本最小?
---  code (此程式並沒有加入訂貨成本)
# past sales 
salesStr = "14,23,26,17,17,12,24,19,10,18,22,31,19,16,22,28,20,27,20,32"
sales = salesStr.split(',')
for i in range(len(sales)):
sales[i] = int(sales[i])

#given information 
stgCost = 2
invCost = 1000*0.073/365
Q = 30
I = 20

#finding the best R
bestR = 0
costOfBestR = 1000000000
for R in range(Q):
totalStgCost = 0
totalInvCost = 0

#finding the total cost of this R 
for s in sales:
I -=s
if I < 0 :
totalStgCost += -I * stgCost
I += Q
elif I < R:
I += Q
totalInvCost += I * invCost

#update bestR when necessary
totalCost = totalStgCost + totalInvCost
if totalCost < costOfBestR:
bestR = R
costOfBestR = totalCost
print(R, totalStgCost, totalInvCost, totalCost)
print(bestR)
---

找工作建議

1.想想我是誰? 瞭解自己:

人天天都跟自己相處在一起，但可能這一輩子最不了解的就是自己。

把每天自己完成的事是值得鼓勵/開心的事寫下來，另一邊寫今天不開心/做不好的事，

從中去分析自己的優點/缺點/喜歡的/討厭的。


例如:

O:我今天跟朋友一起聚餐，跟很熟悉的朋友在一起的那種無拘束感真好~ (分析: 我喜歡無拘束感) 。

X:預定今天要寫的心得還是沒寫。 (分析: 做事情總是拖延)


2.我想要甚麼? 我的人生價值觀/工作價值觀/我的座右銘 :

從你有記憶開始回想，你喜歡看的卡通是甚麼卡通? 甚麼電影吸引我? 甚麼樣的書我覺得好看?  小時候在做甚麼事的時候最開心?
對甚麼有興趣? 也回想一下小時候，作文"我的志願"/"我的夢想"，長大了變成喜歡甚麼，為何有此轉折/改變。


例如: 我喜歡看超人卡通，我喜歡看警匪片，心理學的書很吸引我，小時候學畫畫/作陶藝/玩樂高時最開心，
對學甚麼東西都很有興趣，我的志願好像是甚麼總統/警察/老師/太空人之類的。



超人卡通/警匪片: 公平/正義

心理學: 喜歡觀察人/探究人心/想幫助別人

小時候學畫畫/作陶藝/玩樂高: 喜歡有自主意見的操縱感/完成一樣作品的滿足感。

對學甚麼東西都很有興趣:有好奇心/喜歡新鮮感/喜歡不同的挑戰

老師:教育為重。總統/警察:服務人民，對社會有貢獻。太空人:一個很稀奇的職業，喜歡探索未知。


結論:我想要，一個可以幫助人/對社會有貢獻/能夠發揮自己所能/有新鮮感多變化的工作。



我的人生價值觀:做一個有用的人且對社會有貢獻

我的工作價值觀:工作時間有自由度/有自主性/用自己的能力創造價值

我的座右銘:人有無限的可能



(以上的概念都可能重複，而重覆性越高，代表你的志向越明確)



3.尋找搭配自己熱誠興趣的工作:

從上述，我找到了一個工作頗適合，觀護人。


觀護人算是一個講求公平正義的職業。對於被觀護人有好奇心，想觀察他/幫助他解決困難融入社會，如果幫到忙會很有成就感，
也算是對社會有貢獻。 不同的人帶來不同的新鮮感，不一樣性格的人有著不一樣的挑戰。


4.瞭解如何從事這樣職業，這項職業需要具備甚麼能力?

EX.如何考觀護人/需要具備哪些能力?

觀護人為司法四等特考，需要考許多的科目，涵蓋的範圍有法律/心理/社工，是個相對其他公職考試不容易考的職務，
且每年徵求的人數不多。要具備 同理心/觀察力/整合力/口說能力等.... 要讀的書是哪些等....


5.確認目標:我真的要做這個嗎? 我能勝任嗎? 做這項工作的優點缺點? 挑戰和困難? 現實與理想?

(略)

如果沒確認此目標，就在重新找一個。


6.再重新尋找/不斷尋找/持續思考



     人生本來就是這樣在一個不確定的情況下尋找人生的答案。答案，要自己尋找。

偉人也不是一出生就知道自己要做甚麼，有成就的人也是一步一步的了解自己到完成目標。

     有空就思考，我想學的東西/我有興趣的東西/我的理想/我的夢想/我覺得此生一定要做的事等，各自列出一個表，
你可以從中去定自己的目標。找到目標之後就設個大目標>中目標>小目標。

大目標是一個狀態，例如，考上研究所。

中目標是一個方向，例如，考研究所要讀書，要讀甚麼甚麼書....等。

小目標就是可執行/有可行性的方法，例如， 一天讀九小時，分成早中晚，各時段3HR，哪一個小時讀啥科目等





阿魏之獨門方法: 刪去法。



如果想不到甚麼事情自己最喜歡，那就倒過來，寫出自己不喜歡的。

例如: 我不喜歡跟別人推銷東西>>>不適合做業務/直銷

        我不喜歡天天重複做同樣的事情>>> 適合有挑戰/有新鮮感/多變化的工作



以上是綜合我看過的書和個人經驗和大家分享，在尋找自己時我發現最有用的就是書和自己。

我覺得夢想就像是在一張白色圖畫紙上繪圖，在紙上構想你的夢想是如何如何，

如果不去執行/努力，終究就只是一張圖畫紙!

套一位歌手說的，謝和弦:"夢想只是一個名詞，你要想辦法把他變成動詞。"


方法歸方法，如果不去思考和執行，建議永遠都只是紙上談兵。

真的還是自己要有決心去思考和尋找，共勉之~~~~~

用 Python 做商管程式設計（一） Week 5b

05-b01 作業管理與演算法
Operation Management (OM)
利用程式解OM問題-演算法

演算法 Algorithm
    A detailed description of actions such that action is doable.

Scheduling 
Makespan 最小化

• m 台機器
• n  個 jobs
• job j 的 processing time
•  一台機器完成 job j 共需要 pj 時間
• Complete time Cj  = Sj(開始時間) + pj

要分配這些jobs  給所有 機器 使得 最後的 completing time  最小

Longest processing time first (LPT)

• jobs 的 processing time 降冪排列
• 分配job 給目前最早完成時間之機器

--- code ---

# read and prepare n,m,p

n = int(input("Number of jobs: "))

m = int(input("Number of machines: "))

pStr = input("Processing times: ")

p  =  pStr.split(' ')

for i in range(n):

p[i] = int(p[i])

#sort and reverse

#p.sort()

#p.reverse()

# machine complete times 

loads  =  [0] * m

assignment = [0]  * n

#in iterarion j , assign job j to the least loaded machine 

for j in range(n):

#find the least loaded machine

leastLoadedMachine = 0

leastLoad = loads[0]

for i in range(1,m):

if loads[i] < leastLoad:

leastLoadedMachine = i

leastLoad = loads[i]

#schedule a job

loads[leastLoadedMachine] +=p[j]

assignment[j] = leastLoadedMachine + 1

#check the process

print(str(p[j]) + ": " + str(loads))

#the result 

print("Job assignment: "+str(assignment))

print("Machine loads: "+str(loads))

-------------

heuristic 不能保證得到最佳解

11

用 Python 做商管程式設計（一） Week 5a

05-a01 字串切割成清單
---
   gradeStr = input() #1 2 3 4 5
   grade = gradeStr.split() #用空白切開，若要用comma切開則: split(',')
   print(grade) # grade 是一個list
---
List 
是一個 ordered container
字串內元素(item)可用index 操作
如上例:print(grade[0]) #1 , print(grade[2]*2) #33

len() 可得 listlist長度
print(len(grade)) #5

List 宣告
aList = [0] * 3 # [0,0,0]

append() 可新增Items 到 List
ex:
    gradeStr = input() #1 2 3 4 5
    grade = gradeStr.split()
    grade.append(-1)
    print(grade) # ['1','2','3','4','5',-1]
    grade.append([9,7,5])
    print(grade) # ['1','2','3','4','5',-1,[9,7,5]] , list裡面可以加list
    print(grade[6][1]) #7 , grade[6]為list ，可存取該list的元素

List 內  string  string  轉 int
ex:
    gradeStr = input()
    gradeList = gradeStr.split()
    print(gradeList)
    grades = []

    for g in gradeList: 
    grades.append(int(g))

    print(grades) #[1,2,3,4,5]
    #for 迴圈那邊可以替換成
    #for i in range(len(gradeList)):
    #    grades[i] = int(graedList[i])

range 複習
>>>range(10) # 从 0 开始到 10 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> range(1, 11) # 从 1 开始到 11 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

05-a03 List 相關函數

lst = [3,1,4,1,5,9]
lst.append(2)
print(lst)# [3, 1, 4, 1, 5, 9, 2], 新增2

lst.sort()
print(lst)# [1, 1, 2, 3, 4, 5, 9],list內數值排序

lst.reverse()
print(lst) # [9, 5, 4, 3, 2, 1, 1],list 內 item 翻轉

print(lst.index(4)) # 2 

lst.insert(4,"Hi")
print(lst)#[9, 5, 4, 3, 'Hi', 2, 1, 1] ,在第4個index位插入""

print(lst.count(1))# 2 , 數字1出現幾次

lst.remove(1)
print(lst)# [9, 5, 4, 3, 'Hi', 2, 1] ,移除掉第一個出現的 1

print(lst.pop(3))# 3 ,把 3 拿出來


print(lst)# [9, 5, 4, 'Hi', 2, 1]

List Copying
ex:
aList = [1,2,3]
bList = aList
bList[0] = 5
print(bList) #[5,2,3]

Why?
Python 中 list variable 是一個 reference
Copying a list is just copying the reference ,not those values

順序:
1.aList 參照 [1,2,3]
2.aList 的內容 copy 到 bList,有兩個list分別寫著[1,2,3]這塊地的地址
3.aList 和 bList並非兩個lists, 而是一個list的兩個名字
4.若要做到兩個lists 使用 append 把item 依序 複製進去

C 程式練習 : 撲克牌賭局-貢鐘

玩法與詳細規則:
40張撲克牌供一位莊家三位閒家遊玩。
每一波每家抽2張.一次用8張.共可以玩5波。
對子最大>>依序是10>9>8>7>6 A對最小。
紅黑不成對>>>例如紅磚7+紅心7[7仔對] 紅磚7+黑桃7[只有4點]
點數9點最大
9>8>7>6>5>4>3>2>1>0最小[目賊拉.媽殺摳]
點數相同時.則比手牌中最大點數者為贏
依序大小為10+9>8+1>7+2>6+3>5+4
若牌與莊家強碰[2副牌都一樣].則算莊家贏
例如莊家10+9.玩家10+9 算莊家贏
0點[目賊仔]一律算莊家贏
---
顯示結果

---
/*code*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define N 40
typedef struct
{
    int c1;
    int c2;
    int sum;
    int win;
} Player;
typedef struct
{
    int color;
    int number;

} Card;
void shuffle();
void battle();
int numsave[8];//移到全域變數 才解決亂數問題
int colsave[8];
int main()
{
    /*
    花色:S=0,H=1,D=2,C=3
    數字:1~10

    */
    srand(time(NULL));
    int cards[N];
    Player p1,p2,p3,bank;
    int i = 0, now = N, dice = -1, pick = 0,set = 1;
    for(i=0; i<N; i++)
    {
        cards[i] = i+1;
    }
    shuffle(cards);//洗牌
    while(now>0)
    {
        printf("★★★★★ 局 %d ★★★★★\n",set);
        dice = rand()%4;//丟骰子決定誰先抽牌
        switch(dice)
        {
        case 0:
            bank.c1 = cards[pick];
            bank.c2 = cards[pick+1];
            p1.c1 = cards[pick+2];
            p1.c2 = cards[pick+3];
            p2.c1 = cards[pick+4];
            p2.c2 = cards[pick+5];
            p3.c1 = cards[pick+6];
            p3.c2 = cards[pick+7];
            pick +=8;
            break;
        case 1:
            bank.c1 = cards[pick+6];
            bank.c2 = cards[pick+7];
            p1.c1 = cards[pick];
            p1.c2 = cards[pick+1];
            p2.c1 = cards[pick+2];
            p2.c2 = cards[pick+3];
            p3.c1 = cards[pick+4];
            p3.c2 = cards[pick+5];
            pick +=8;
            break;
        case 2:
            bank.c1 = cards[pick+4];
            bank.c2 = cards[pick+5];
            p1.c1 = cards[pick+6];
            p1.c2 = cards[pick+7];
            p2.c1 = cards[pick];
            p2.c2 = cards[pick+1];
            p3.c1 = cards[pick+2];
            p3.c2 = cards[pick+3];
            pick +=8;
            break;
        case 3:
            bank.c1 = cards[pick+2];
            bank.c2 = cards[pick+3];
            p1.c1 = cards[pick+4];
            p1.c2 = cards[pick+5];
            p2.c1 = cards[pick+6];
            p2.c2 = cards[pick+7];
            p3.c1 = cards[pick];
            p3.c2 = cards[pick+1];
            pick +=8;
            break;

        }

        battle(bank,p1,p2,p3);//比大小
        now-=8;
        set+=1;
    }

    return 0;
}
void shuffle(int* a)
{
    int j = 0, r = -1, tmp = -1;
    for(j=0; j<N; j++)
    {
        r = rand()%N;
        tmp = a[j];
        a[j] = a[r];
        a[r] = tmp;
    }
}
void battle(Player bank,Player p1,Player p2,Player p3)
{
    Card crd[8];

    char suit[4][2];
    int k = 0, m = 0, tmax=0, p = 0;

    crd[0].number = (bank.c1 % 10)==0?10:(bank.c1 % 10);
    crd[1].number = (bank.c2 % 10)==0?10:(bank.c2 % 10);
    crd[2].number = (p1.c1 % 10)==0?10:(p1.c1 % 10);
    crd[3].number = (p1.c2 % 10)==0?10:(p1.c2 % 10);
    crd[4].number = (p2.c1 % 10)==0?10:(p2.c1 % 10);
    crd[5].number = (p2.c2 % 10)==0?10:(p2.c2 % 10);
    crd[6].number = (p3.c1 % 10)==0?10:(p3.c1 % 10);
    crd[7].number = (p3.c2 % 10)==0?10:(p3.c2 % 10);
    crd[0].color = (bank.c1-1)/10;
    crd[1].color = (bank.c2-1)/10;
    crd[2].color = (p1.c1-1)/10;
    crd[3].color = (p1.c2-1)/10;
    crd[4].color = (p2.c1-1)/10;
    crd[5].color = (p2.c2-1)/10;
    crd[6].color = (p3.c1-1)/10;
    crd[7].color = (p3.c2-1)/10;


    for(k=0; k<8; k++) //暫存八張數字
    {
        numsave[k] = crd[k].number;
        colsave[k] = crd[k].color;
    }
    k=0;

    /*點數和*/
    while(k<8)
    {
        /*判斷是否為對子，紅黑不成對*/
        if(crd[k].number==crd[k+1].number) //數字同
        {
            if((crd[k].color==0&&crd[k+1].color==3)||(crd[k].color==3&&crd[k+1].color==0)||(crd[k].color==1&&crd[k+1].color==2)||(crd[k].color==2&&crd[k+1].color==1))
            {
                //同花色之對子
                switch(k)
                {
                case 0:
                    bank.sum = crd[k].number + crd[k+1].number ;
                    break;
                case 2:
                    p1.sum = crd[k].number + crd[k+1].number ;
                    break;
                case 4:
                    p2.sum = crd[k].number + crd[k+1].number ;
                    break;
                case 6:
                    p3.sum = crd[k].number + crd[k+1].number ;
                    break;
                }
            }
            else
            {
                //不同花色之對子，一樣取餘數
                switch(k)
                {
                case 0:
                    bank.sum = (crd[k].number + crd[k+1].number)%10 ;
                    break;
                case 2:
                    p1.sum = (crd[k].number + crd[k+1].number)%10 ;
                    break;
                case 4:
                    p2.sum = (crd[k].number + crd[k+1].number)%10 ;
                    break;
                case 6:
                    p3.sum = (crd[k].number + crd[k+1].number)%10 ;
                    break;
                }
            }
        }
        else
        {
            //兩張數字不同
            switch(k)
            {
            case 0:
                bank.sum = (crd[k].number + crd[k+1].number)%10 ;
                break;
            case 2:
                p1.sum = (crd[k].number + crd[k+1].number)%10 ;
                break;
            case 4:
                p2.sum = (crd[k].number + crd[k+1].number)%10 ;
                break;
            case 6:
                p3.sum = (crd[k].number + crd[k+1].number)%10 ;
                break;
            }
        }

        k+=2;
    }

    //printf("banker cards :  %d\n",crd[0].number);
    /*p1,p2,p3跟莊家比大小*/
    /*先比點數和*/

    if(p1.sum>bank.sum) p1.win = 1;
    else p1.win = 0;
    if(p2.sum>bank.sum) p2.win = 1;
    else p2.win = 0;
    if(p3.sum>bank.sum) p3.win = 1;
    else p3.win = 0;


    /*總數和相同判斷是否目賊，若非則比最大那張大小或同牌組*/
    if(p1.sum==bank.sum)
    {
        if(p1.sum==0)   p1.win = 0;//目賊
        tmax = (crd[2].number > crd[3].number)?crd[2].number : crd[3].number;
        if(tmax > crd[0].number && tmax > crd[1].number)
        {
            //最大的那張比莊家任一張都大
            p1.win = 1;
        }
        else
        {
            //包含了 牌組相同之情形 (EX:9+10,10+9)
            p1.win = 0;
        }
    }

    if(p2.sum==bank.sum)
    {
        if(p2.sum==0)   p2.win = 0;//目賊
        tmax = (crd[4].number > crd[5].number)?crd[4].number : crd[5].number;
        if(tmax > crd[0].number && tmax > crd[1].number)
        {
            //最大的那張比莊家任一張都大
            p2.win = 1;
        }
        else
        {
            p2.win = 0;
        }
    }

    if(p3.sum==bank.sum)
    {
        if(p3.sum==0)   p3.win = 0;//目賊
        tmax = (crd[6].number > crd[7].number)?crd[6].number : crd[7].number;
        if(tmax > crd[0].number && tmax > crd[1].number)
        {
            //最大的那張比莊家任一張都大
            p3.win = 1;
        }
        else
        {
            p3.win = 0;
        }
    }

    /*先印出牌組*/
    k=0,m=0;

    while(k<8)
    {
        //printf("k= %d m= %d\n",k,m);
        switch(colsave[2*k+m])
        {
        case 0:
            suit[k][m] = 'S';
            //printf(" %d ",k);
            break;
        case 1:
            suit[k][m] = 'H';
            //printf(" %d ",k);
            break;
        case 2:
            suit[k][m] = 'D';
            //printf(" %d ",k);
            break;
        case 3:
            suit[k][m] = 'C';
            //printf(" %d ",k);
            break;
        }
        m=(m+1)%2;
        if(m==0) k +=1;
    }
    printf("莊家牌組: %c_%d  %c_%d\n",suit[0][0],numsave[0],suit[0][1],numsave[1]);
    printf("閒一牌組: %c_%d  %c_%d\n",suit[1][0],numsave[2],suit[1][1],numsave[3]);
    printf("閒二牌組: %c_%d  %c_%d\n",suit[2][0],numsave[4],suit[2][1],numsave[5]);
    printf("閒三牌組: %c_%d  %c_%d\n",suit[3][0],numsave[6],suit[3][1],numsave[7]);

    printf("莊家點數和 : %d\n",bank.sum);
    printf("閒一點數和 : %d\n",p1.sum);
    printf("閒二點數和 : %d\n",p2.sum);
    printf("閒三點數和 : %d\n",p3.sum);

    printf("==========勝負==========\n");
    if(p1.win) printf("閒一勝\n");
    else printf("閒一敗_QQ\n");
    if(p2.win) printf("閒二勝\n");
    else printf("閒二敗_QQ\n");
    if(p3.win) printf("閒三勝\n");
    else printf("閒三敗_QQ\n");

    printf("\n");

}

---

Python 商管程設(一) 第四周練習 + 作業

---
Code
---
import math

c = int(input())
r = int(input())
N = int(input())
q = int(input())
list = []
list.append(float(input()))
list.append(float(input()))
list.append(float(input()))
list.append(float(input()))
list.append(float(input()))
list.append(float(input()))
list.append(float(input()))
list.append(float(input()))
list.append(float(input()))

exp = 0
sum = 0.0
D = 0.0
maxP = 0

for p in range(0,q+1) :
exp = r * p - c * q
if p != q :
sum += list[p] * exp
D += list[p]
else :
sum += (1-D) * exp
break

print(int(sum))

**************** 第四周作業 ******************
承上題，現在不給定進貨量，求在此機率分布下，各種進貨量(0到8)
所能得到之做大收益為何?  在何進貨量能夠得到此收益?
輸出 :
可獲得做大收益之進貨量 空格 最大收益
---
code
---
import math

c = int(input())
r = int(input())
N = int(input())
list = []
list.append(float(input()))
list.append(float(input()))
list.append(float(input()))
list.append(float(input()))
list.append(float(input()))
list.append(float(input()))
list.append(float(input()))
list.append(float(input()))
list.append(float(input()))

exp = 0 # 該進貨量下之預期收益
sum = 0.0
D = 0.0
maxP = 0.0 # 最大利潤
qMax = 0 # 可達最大利潤之進貨數
N = 8


for q in range(0,N+1) :
sum = 0
D = 0.0
for p in range(0,q+1) :
# p 為 不大於進貨量下之需求量
exp = r * min(p,q) - c * q
if p != q :
sum += list[p] * exp
D += list[p]
else:
sum += (1-D) * exp
break
if sum > maxP :
maxP = sum
qMax = q


profit = int(maxP)
print(str(qMax)+" "+str(profit))

Python 商管程設(一) 第三周作業

題目敘述
如果你在一家零售店幫消費的客人結帳，你可能需要快速地挑出合適且數量正確的鈔票與零錢。假設客人的消費金額 aa 一定是 1 到 1000 之間的整數，而你有無限量的 500、100、50、10、5、1 這些面額的鈔票和零錢，我們希望你能依照下面的規則找錢：

你找的錢的總額要是 1000 - a1000−a。
與其給客人五張 100 元，不如給他一張 500 元；與其給客人兩個 50 元，不如給他一張 100 元……依此類推。
以下是一些範例：

如果客人消費 200 元，你應該找給他 1 張 500 元和 3 張 100 元。
如果客人消費 286 元，你應該找給他 1 張 500 元、2 張 100 元、1 個 10 元和 4 個一元。
如果客人消費 925 元，你應該找給他 1 個 50 元、2 個 10 元和 1 個 5 元。
在本題中，你將會被給予上述的整數 aa，而你要找出符合上述規則的唯一找錢方式。

輸入輸出格式
在每筆測試資料中，會有一個整數 aa 代表客人的消費金額，aa 會介於 1 到 999 之間（包含 1 跟 999）。讀入 aa 之後，你會依照題目指定的規則找出每種面額的鈔票或銅板應該要給幾張或幾個，然後由面額大至面額小依序輸出所需鈔票張數或銅板個數，但如果不應該找給客人某個面額的鈔票或銅板，就跳過該面額不要輸出。因為這樣一來可能只輸出少於 6 個數字，會不知道怎麼對應到面額，因此現在要把面額與所需張數（個數）成對地輸出，中間用一個逗點和一個空格隔開，而面額與面額之間用一個分號和一個空格隔開。



**************
CODE :
a = int(input()) # a介於1~999
tmp = 1000 - a
cnt = 0 # 計算非零面額數
p1 = tmp // 500
if p1 != 0:
cnt += 1
tmp = tmp - p1 * 500
p2 = tmp // 100
if p2 != 0:
cnt += 1
tmp = tmp - p2 * 100
p3 = tmp // 50
if p3 != 0:
cnt += 1
tmp = tmp - p3 * 50
p4 = tmp // 10
if p4 != 0:
cnt += 1
tmp = tmp - p4 * 10
p5 = tmp // 5
if p5 != 0:
cnt += 1
tmp = tmp - p5 * 5
p6 = tmp
if p6 != 0:
cnt += 1


if p1 != 0:
print("500, "+str(p1), end="")
cnt -= 1
if cnt != 0:
print("; ", end="")
else:
print("", end="")
if p2 != 0:
print("100, "+str(p2), end="")
cnt -= 1
if cnt != 0:
print("; ", end="")
else:
print("", end="")
if p3 != 0:
print("50, "+str(p3), end="")
cnt -= 1
if cnt != 0:
print("; ", end="")
else:
print("", end="")
if p4 != 0:
print("10, "+str(p4), end="")
cnt -= 1
if cnt != 0:
print("; ", end="")
else:
print("", end="")
if p5 != 0:
print("5, "+str(p5), end="")
cnt -= 1
if cnt != 0:
print("; ", end="")
else:
print("", end="")
if p6 != 0:
print("1, "+str(p6), end="")
p6 = 0
cnt -= 1
if cnt != 0:
print("; ", end="")
else:
print("", end="")

*** End Code ***
其實P6 那也可以不用判斷cnt 直接印出空白