all (420)
| # 5730090421 (0.00) 1 (2021-02-08 23:25) def peek_kth_card(cards, k): return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): return new_cards #--------------------------------------- def deal_n_cards(deck, n): return cards, new_deck #--------------------------------------- def cut(deck, m): return new_deck #--------------------------------------- def shuffle(deck): return new_deck #--------------------------------------- |
| # 6030048821 (17.11) 2 (2021-02-06 15:45) def peek_kth_card(cards, k): c=cards.strip('|').split('||') the_kth_card = '|' + c[k-1] + '|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): c=cards.strip('|').split('||') del c[k-1] new_cards = '|'*int(len(c)>0) + '||'.join(c) + '|'*int(len(c)>0) return new_cards #--------------------------------------- def deal_n_cards(deck, n): c=deck.strip('|').split('||') cards='|'*int(len(c[:n])>0) + '||'.join(c[:n]) + '|'*int(len(c[:n])>0) new_deck = '|'*int(len(c[n:])>0) + '||'.join(c[n:]) + '|'*int(len(c[n:])>0) return cards, new_deck #--------------------------------------- def cut(deck, m): c=deck.strip('|').split('||') c=(c+c[:m])[m:] new_deck='|'*int(len(c)>0) + '||'.join(c) + '|'*int(len(c)>0) return new_deck #--------------------------------------- def shuffle(deck): c=deck.strip('|').split('||') d=list(c) d[::2]=c[:len(c)//2] d[1::2]=c[len(c)//2:] new_deck='|'*int(len(d)>0) + '||'.join(d) + '|'*int(len(d)>0) return new_deck #--------------------------------------- def show_table_cards(cards, m): c=cards.strip('|').split('||') s = 'Table: ' + '....'*int(len(cards) > m) + '|' + '||'.join(c[-m:]) + '|' print('-'*len(s)) print(s) print('-'*len(s)) #----------------------------------------- |
| # 6030182121 (17.78) 3 (2021-02-08 23:24) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[(k-1)*0:(k-1)*4]+cards[k*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:n*4] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4:]+deck[:m*4] return new_deck #--------------------------------------- def shuffle(deck): return new_deck #--------------------------------------- def show_table_cards(cards, m): if len(cards)/4 > m: show_cards = cards[len(cards)-(m*4):] print("-"*len("Table: "+"...."+show_cards)) print("Table: "+"...."+show_cards) print("-"*len("Table: "+"...."+show_cards)) else : show_cards = cards[::] print("-"*len("Table: "+show_cards)) print("Table: "+show_cards) print("-"*len("Table: "+show_cards)) #----------------------------------------- |
| # 6030239321 (14.44) 4 (2021-02-08 14:42) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*(k)] print(the_kth_card) return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1)] + cards[4*(k):] # print(new_cards) return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] # print(new_deck) return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[:4*m] # print(new_deck) return new_deck #--------------------------------------- def shuffle(deck): if len(deck) == 4 : new_deck = deck else : c = deck[1:-1].split("||") n = int(len(c)/2) # print(c[:n],c[n:]) new = deck[1:-1].split("||") new[::2] = c[:n] new[1::2] = c[n:] new_deck = "|"+str("||".join(new))+"|" # print(new_deck) return new_deck #--------------------------------------- def show_table_cards(cards, m): d = int(len(cards)/4-m) if d<0 : d=0 out = '.'*int(4*(d)) + cards[4*d:] print(out) |
| # 6030380021 (20.00) 5 (2021-02-08 21:16) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:(k*4)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k-1)*4]+cards[(k*4):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:(n*4)] new_deck = deck[(n*4):] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(m*4):]+deck[:(m*4)] return new_deck #--------------------------------------- def shuffle(deck): deck_list = deck[1:-1].split("||") deck_A = deck_list[:(len((deck_list))+1)//2] deck_B = deck_list[(len((deck_list))+1)//2:] new_deck = [] for i in range(len(deck_A)): new_deck.append(deck_A[i]) if(i < len(deck_B)): new_deck.append(deck_B[i]) new_deck = "|"+"||".join(new_deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): table_cards = "Table: "+(("...."*(len(cards)-4*m))[:4])+cards[(-m*4):] print('-'*len(table_cards)) print(table_cards) print('-'*len(table_cards)) #----------------------------------------- |
| # 6030924521 (18.83) 6 (2021-02-08 15:45) def peek_kth_card(cards, k): card_list = cards[1:-1].split('||') the_kth_card = card_list[k-1] return '|'+ the_kth_card + '|' # the_kth_card = cards[k] # return the_kth_card # #--------------------------------------- def remove_kth_card(cards, k): card_list = cards[1:-1].split('||') card_list.remove(card_list[k-1]) new_cards = '||'.join(card_list) return '|'+new_cards+'|' # #--------------------------------------- def deal_n_cards(deck, n): card_list = deck[1:-1].split('||') new_deck = card_list[n:] new_deck = '||'.join(new_deck) old_deck = card_list[:n] cards = '||'.join(old_deck) return '|'+cards+'|', '|'+new_deck+'|' # #--------------------------------------- def cut(deck, m): card_list = deck[1:-1].split('||') deck_1 = card_list[:m] deck_2 = card_list[m:] new_deck = deck_2 + deck_1 new_deck = '||'.join(new_deck) return '|'+new_deck+'|' # #--------------------------------------- def shuffle(deck): card_list = deck[1:-1].split('||') len_card = len(card_list) new_deck = ['']*len_card #print(len_card) if len_card%2 ==0: len_card = int(len_card/2) first_half = card_list[:len_card] second_half = card_list[len_card:] else: len_card = len_card/2 len_card = math.ceil(len_card) first_half = card_list[:len_card] second_half = card_list[len_card:] for i in range(len(first_half)): n = i+1 new_deck[2*n-2] = first_half[i] for j in range(len(second_half)): n = j+1 #print(n) new_deck[2*n-1] = second_half[j] new_deck = '||'.join(new_deck) return '|'+new_deck+'|' # #--------------------------------------- def show_table_cards(cards, m) : card_list = cards[1:-1].split('||') if len(card_list) < m : print("-------"+ '-'*len(cards)) print("Table:",cards) print("-------"+ '-'*len(cards)) elif len(card_list) == m : print("-------"+ '-'*len(cards)) print("Table:",cards) print("-------"+ '-'*len(cards)) else : print("-----------"+ '-'*len(cards[-4*m:])) print("Table:", '....'+cards[-4*m:]) print("-----------"+ '-'*len(cards[-4*m:])) # #----------------------------------------- |
| # 6130097621 (18.53) 7 (2021-02-08 21:47) def peek_kth_card(cards, k): x = cards.split("|") y = x[1::2] the_kth_card = "|"+y[k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x = cards.split("|") y = x[1::2] y.pop(k-1) z = '||'.join(y) new_cards = "|"+z+"|" return new_cards #--------------------------------------- def deal_n_cards(deck, n): x = deck.split("|") y = x[1::2] z = y[0:n] a = "||".join(z) cards = "|"+a+"|" b = y[n:] c = "||".join(b) new_deck = "|"+c+"|" return cards, new_deck #--------------------------------------- def cut(deck, m): x = deck.split("|") a = deck.split("|") y = x[1::2] b = x[1::2] del y[0:m] y.extend(b[0:m]) z = "||".join(y) new_deck = "|"+z+"|" return new_deck #--------------------------------------- def shuffle(deck): x = deck.split("|") y = x[1::2] z = len(y)//2+len(y)%2 a = y[0:z] b = y[z:] c = len(y)*[""] c[::2] = a c[1::2] = b e = "||".join(c) new_deck = "|"+e+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): x = cards.split("|") y = x[1::2] a = min(len(y),m) b = y[::-1] c = b[0:a] d = c[::-1] + ['....'] n = len(y) table = ''.join(d[m:n])+'|'+'||'.join(d[:a])+'|' print("-"*(7+len(cards))) print("Table:",table) print("-"*(7+len(cards))) #----------------------------------------- |
| # 6130917221 (20.00) 8 (2021-02-08 22:14) def peek_kth_card(cards, k): the_kth_card = cards[(k*4)-4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(k*4)-4] + cards[k*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:n*4] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4:] + deck[:m*4] return new_deck #--------------------------------------- def shuffle(deck): s = deck.split('||') # half y y = s[(len(s)+1)//2:] jx2 = '|' + '|,|'.join(y) s2 = jx2.split(',') # half x jx1 = '|,1234,|'.join(s) s0 = jx1.split(',') x = '|,|'.join(s).split(',') # Replace t = s0[:len(x)] t[1::2] = s2 new_deck = ''.join(t) return new_deck #--------------------------------------- def show_table_cards(cards, m): n = len(cards)//4 show = ('Table: '+'....'*min(n-m,1))+cards[-4*m:] print('-'*len(show)) print(show) print('-'*len(show)) #----------------------------------------- |
| # 6130924621 (20.00) 9 (2021-02-08 23:30) def peek_kth_card(cards, k): the_kth_card=cards[4*(k-1):(4*(k-1))+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[0:(k-1)*4]+cards[((k-1)*4)+4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:4*n] new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[(4*m):]+deck[:(4*m)] return new_deck #--------------------------------------- def shuffle(deck): d=deck.split("||") x=d[(len(d)+1)//2:] x1="|"+"|,|".join(x) x2=x1.split(",") y2 = '|,####,|'.join(d) y1=y2.split(",") y='|,|'.join(d).split(",") r=y1[:len(y)] r[1::2]=x2 new_deck="".join(r) return new_deck #--------------------------------------- def show_table_cards(cards, m): y=len(cards)//4 x=("Table: " + "...."*min(y-m,1))+cards[-4*m:] print((len(x))*"-") print(x) print((len(x))*"-") #----------------------------------------- |
| # 6230041021 (17.78) 10 (2021-02-08 22:08) def peek_kth_card(cards, k): the_kth_card = cards[(k*4-4):k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): #|12||34||56||78| new_cards = cards[0:(k*4)-4]+cards[k*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:n*4] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck.strip('|') a = a.split('||') new_deck = a[m:]+ a[:m] new_deck ='||'.join(new_deck) new_deck = '|'+ new_deck +'|' return new_deck #--------------------------------------- def shuffle(deck): a = deck.strip('|') a = a.split('||') b = len(a) c = int(round(b/2,0)) z = '' w = a[:b-c+1] e = a[b-c:] if (b- c) == 0: for i in range(c-1): z += w[i] +' ' +e[i] if i != c-1: z += ' ' else: for i in range(c-1): z += a[i]+' '+a[i+b-c] if i != c-1: z += ' ' z += a[c] z = z.split() z = '||'.join(z) z = '|'+ z+ '|' new_deck = z return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards.strip('|') a = a.split('||') b = a[-1:-(m+1):-1] b = b[::-1] b = '||'.join(b) b = '|'+b+'|' c ='Table: ' if m >= len(a) : r = c + b print('-'*len(r)) print(r) print('-'*len(r)) else: r = c + '....'+b print('-'*len(r)) print(r) print('-'*len(r)) #----------------------------------------- |
| # 6230092021 (20.00) 11 (2021-02-07 02:01) def peek_kth_card(cards, k): cards2 = cards[1:-1].split('||') the_kth_card = '|'+ cards2[k-1] + '|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*(k-1)] + cards[k*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*(n)] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4:] + deck[0:4*(m)] return new_deck #--------------------------------------- def shuffle(deck): a = deck[1:-1].split('||') deck1 = a[0:(len(a)+1)//2] deck2 = a[-(len(a)-1)//2:] new_deck = (len(deck1)+len(deck2))*[' '] new_deck[::2] = deck1 new_deck[1::2] = deck2 new_deck = "|"+"||".join(new_deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards[1:-1].split('||') b = "|"+"||".join(a[(-1*m)::1])+"|" c = (len(a)-m) mini = min(len('....')//4,c) d = '....'*mini result = "Table: " + d + b line = "-"*len(result) print(line) print(result) print(line) #----------------------------------------- |
| # 6230131921 (20.00) 12 (2021-02-08 22:17) def peek_kth_card(cards, k): a = cards.split("|") the_kth_card = "|"+(a[2*k-1])+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): b2 = cards[1:-1:] c2 = b2.split("||") d2 = c2[0:k-1:]+c2[k::] e2 = (bool(len(d2)>0)) f2 = int(e2) new_cards = ("|"+"||".join(d2)+"|")*f2 return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:(4*n):] new_deck = deck[4*n::] return cards, new_deck #--------------------------------------- def cut(deck, m): left = deck[:4 * m] right = deck[4 * m:] new_deck = right + left return new_deck #--------------------------------------- def shuffle(deck): c = deck[1:-1:] d = c.split("||") e = d[0:(len(d)+1)//2:] f = d[(len(d)+1)//2::] g = [0]*len(d) g[::2] = e g[1::2] = f new_deck = "|"+"||".join(g)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): y = cards[1:-1:] y = y.split("||") a5 = cards[-4*m::] b5 ="."*4 l = bool(len(y)>m) h = int(l) result = b5*h + a5 print("-"*((len(result)+7))) print("Table: "+result) print("-"*((len(result)+7))) #----------------------------------------- |
| # 6230133121 (19.11) 13 (2021-02-08 21:31) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*k-4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): cut_deck = deck[0:4*m] new_deck = deck[4*m:]+cut_deck return new_deck #--------------------------------------- def shuffle(deck): cards = deck[1:-1] cards = cards.split('||') new_cards = [0]*len(cards) cards_0 = cards[0:(len(cards)+1)//2] cards_1 = cards[(len(cards)+1)//2:] new_cards[::2] = cards_0[0::] new_cards[1::2] = cards_1[0::] new_deck = '||'.join(new_cards) new_deck = '|'+new_deck+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): dot = '....' deck = cards[-4*m::1] second='table: '+dot[0:len(cards)-4*m]+deck dash = '-'*len(second) print(dash) print(second) print(dash) #----------------------------------------- |
| # 6230153721 (18.89) 14 (2021-02-07 19:33) def peek_kth_card(cards, k): the_kth_card=cards[4*(k-1):4*(k-1)+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[:4*(k-1)]+cards[4*(k-1)+4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:n*4] new_deck=deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m:]+deck[:4*m] return new_deck return new_deck #--------------------------------------- def shuffle(deck): a=deck.split('||') b=len(a)//2 x=deck[:(b+1)*4] y=deck[(b+1)*4:] z='' for i in range(0,b+1): z+=x[i*4:i*4+4] if i*4<len(y): z+=y[i*4:i*4+4] new_deck=z return new_deck #--------------------------------------- def show_table_cards(cards, m): z='' x=cards.split('||') if m>=len(x): z+=cards elif m<len(x): z+='.'*4+cards[(len(x)-m)*4:] y='' y+='Table: '+z print('-'*len(y)) print(y) print('-'*len(y)) #----------------------------------------- |
| # 6230154321 (20.00) 15 (2021-02-08 20:50) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*(k-1)+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[0:4*(k-1)]+cards[4*(k-1)+4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:4*(n-1)+4] new_deck=deck[4*(n):] return cards, new_deck #--------------------------------------- def cut(deck, m): a=deck[0:4*(m-1)+4] b=deck[4*(m):] new_deck=b+a return new_deck #--------------------------------------- def shuffle(deck): import math a=len(deck)/4 b=math.ceil(a/2) c=deck[0:4*(b-1)+4] d=deck[4*b:] new_deck='' n=1 while n<a: new_deck+=c[4*(n-1):4*(n-1)+4] new_deck+=d[4*(n-1):4*(n-1)+4] n+=1 return new_deck #--------------------------------------- def show_table_cards(cards, m): b = cards.split('|') c = b[1:len(b):2] d=c[-1:-m-1:-1] d.reverse() e='||'.join(d) if m<len(c): f='....'+'|'+e+'|' else: f='|'+e+'|' z='Table:'+' '+f print('-'*len(z)) print(z) print('-'*len(z)) #----------------------------------------- |
| # 6230444321 (16.43) 16 (2021-02-08 21:57) def peek_kth_card(cards, k): a = cards.split("|") a1 = a[1::2] the_kth_card = "|" + a1[k-1] + "|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): a = cards.split("|") a1 = a[1::2] a3 = a1[:k-1] + a1[k:] new_cards = "|" + '||'.join(a3) + "|" return new_cards #--------------------------------------- def deal_n_cards(deck, n): deckmai = deck.split("|") deckmai2 = deckmai[1::2] cardsmaijin = deckmai2[:n] cards = "|" + "||".join(cardsmaijin) + "|" deckmaijin = deckmai2[n:] new_deck = "|" + "||".join(deckmaijin) + "|" return cards, new_deck #--------------------------------------- def cut(deck, m): tadoox = m*4 new_deck = deck[tadoox:] + deck[:tadoox] return new_deck #--------------------------------------- def shuffle(deck): a = deck[1:-1].split("||") m = int((len(a)+1)/2) newdeck1 = [0]*len(a) newdeck1[:len(a):2] = a[:m] newdeck1[1::2] = a[m:] new_deck = "|"+"||".join(newdeck1)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards[1:-1].split("||") b = max(0,len(a)-m) a = a[b:] y = "||".join(a) if len(a) <= m : x = "Table: "+"|"+"||".join(a)+"|" else: x = "Table: ...."+"|"+"||".join(a[-m:])+"|" print("-"*len(x)) print(x) print("-"*len(x)) #----------------------------------------- |
| # 6230585121 (20.00) 17 (2021-02-08 23:14) def peek_kth_card(cards, k): s = cards.split('|') x = s[1::2] the_kth_card = "|"+x[k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): z = len(cards) new_cards = cards[0:4*(k-1)]+cards[(4*k):z] return new_cards #--------------------------------------- def deal_n_cards(deck, n): z = len(deck) cards = deck[0:4*n] new_deck = deck[4*n:z] return cards, new_deck #--------------------------------------- def cut(deck, m): z = len(deck) a = deck[0:4*m] b = deck[4*m:z] new_deck = b+a return new_deck #--------------------------------------- def shuffle(deck): import math n = len(deck)/4 x = math.ceil(n/2) a = deck[0:x*4:1] b = deck[x*4::] new_deck = a[0:4]+b[0:4] for i in range(1,x): new_deck += a[(i*4):(i*4)+4]+b[(i*4):(i*4)+4] return new_deck #--------------------------------------- def show_table_cards(cards, m): z = len(cards) x = z/4 y = z-(4*m) if m < x: c = cards[y:z:1] a = cards[0:y]+'....'+cards[y:] b = a[y:] n = len(b) else: b = cards n = z print("-"*(n+7)) print("Table: "+b) print("-"*(n+7)) #----------------------------------------- |
| # 6231004021 (20.00) 18 (2021-02-08 21:05) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4 : ((k-1)*4)+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0 : (k-1)*4] + cards[((k-1)*4)+4 : ] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[ : (n*4)] new_deck = deck[(n*4) : ] return cards, new_deck #--------------------------------------- def cut(deck, m): x = deck[ : (m*4)] y = deck[(m*4) : ] new_deck = y + x return new_deck #--------------------------------------- def shuffle(deck): deckList = deck[1:-1].split('||') n = len(deckList) x = deckList[: round((n/2) + 0.39)] y = deckList[round((n/2) + 0.39) :] z = [' ']*n z[::2] = x z[1::2] = y new_deck = '|' + '||'.join(z) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cardsList = cards[1:-1].split('||') cardsList = cardsList[::-1] n1 = len(cardsList) x = cardsList[:m] + ['....'] n2 = len(x) - 1 line2 = 'Table: ' + ''.join(x[m:n1]) + '|' + '||'.join(x[:n2][::-1]) + '|' print('-'*len(line2)) print(line2) print('-'*len(line2)) #----------------------------------------- |
| # 6231008621 (19.33) 19 (2021-02-08 23:34) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:((k-1)*4)+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(k-1)*4]+cards[((k-1)*4)+4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:(n*4)] new_deck = deck[(n*4):] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(4*m):]+deck[:(4*m)] return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1] pack = deck.split("||") left = pack[:(len(pack)//2)+(len(pack)%2)] right = pack[(len(pack)//2)+(len(pack)%2):] new_deck = [0]*len(pack) new_deck[0:len(pack):2] = left new_deck[1:len(pack):2] = right return "|"+"||".join(new_deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): import math listofcards = cards[1:-1].split("||") bar="-----------------------" print(bar) wtf = len(listofcards)-m print("Table: "+"...."*(max(0,math.ceil(abs(wtf)//(wtf-0.000005))))+cards[max(4*wtf,0):]) print(bar) #----------------------------------------- |
| # 6231012021 (19.50) 20 (2021-02-06 23:36) def peek_kth_card(cards, k): x=cards[1:-1].split('||') y=x[k-1] the_kth_card="|"+y+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x=cards[1:-1].split('||') print(x) y=x[0:k-1]+x[k:] z="||".join([''] + y + ['']) new_cards= z[1:-1] return new_cards #--------------------------------------- def deal_n_cards(deck, n): f=deck[1:-1].split('||') g=f[0:n] h=f[n:] cards="|"+"||".join(g)+"|" new_deck="|"+"||".join(h)+"|" return cards, new_deck #--------------------------------------- def cut(deck, m): f=deck[1:-1].split('||') i=f[0:m] j=f[m:] k=j+i new_deck="|"+"||".join(k)+"|" return new_deck #--------------------------------------- def shuffle(deck): f=deck[1:-1].split('||') g=len(f) first_half=f[0:(g+1)//2] sec_half=f[-(g-1)//2:] new_deck=(len(first_half)+len(sec_half))*[' '] new_deck[::2]=first_half new_deck[1::2]=sec_half new_deck="|"+"||".join(new_deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): x=cards[1:-1].split('||') p="|"+"||".join(x[-m::1])+"|" exceed=(len(x)-m) mini=min(len('....')//4,exceed) dot='....'*mini middle="Table: "+dot+p line="-"*len(middle) print(line) print(middle) print(line) #----------------------------------------- |
| # 6231019521 (18.78) 21 (2021-02-07 22:07) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:((k-1)*4)+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k-1)*4]+cards[((k-1)*4)+4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:((n-1)*4)+4] new_deck = deck[((n-1)*4)+4:] return cards, new_deck #--------------------------------------- def cut(deck, m): before = deck[:((m-1)*4)+4] new_deck = deck[((m-1)*4)+4:]+before return new_deck #--------------------------------------- def shuffle(deck): a=deck.split('||') a[0]=a[0][1:] a[-1]=a[-1][:-1] mid=len(a)//2+len(a)%2 left=a[:mid] right=a[mid:] a[0::2]=left a[1::2]=right new_deck='|'+'||'.join(a)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): x=cards.split('||') x[0]=x[0][1:] x[-1]=x[-1][:-1] n=len(x)-m y='|'+'||'.join(x[n::1])+'|' a=min(len('....')//4,n) b='....'*a print('-'*len("Table:"+b+y)) print("Table:"+b+y) print('-'*len("Table:"+b+y)) #----------------------------------------- |
| # 6231205921 (18.67) 22 (2021-02-08 23:54) def peek_kth_card(cards, k): a = cards[0:4] b = cards[4:8] c = cards[8:12] d = cards[12:16] e = [a,b,c,d] the_kth_card = e[k-1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1)]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): new_deck = deck[4*n:] cards = deck[:4*n] return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck[:4*m] b = deck[4*m:] new_deck = b+a return new_deck #--------------------------------------- def shuffle(deck): x = int(((len(deck)/4)//2)+((len(deck)/4)%2)) y = deck[:x*4] y = y[1:-1].split("||") z = deck[x*4:] z = z[1:-1].split("||") a = [" "]*int(len(deck)/4) a[::2] = y a[1::2] = z new_deck = "|"+"||".join(a)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards[-4*m:] a = "...."*(4*m<len(cards))+a print("-------"+"-"*len(a)) print("Table: "+a) print("-------"+"-"*len(a)) #----------------------------------------- |
| # 6231207121 (20.00) 23 (2021-02-05 22:41) def peek_kth_card(cards, k) : the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): t = deck[1:-1].split("||") f = [""]*len(t) l = t[:(len(t)+1)//2] r = t[(len(t)+1)//2:] f[::2] = l[:] f[1::2] = r[:] new_deck = "|"+"||".join(f)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): nd = len(cards)//4 n = cards[1:-1].split("||") n = n[-m:] dot = ["...."]*(nd-m)+[""]*(m) re = "|"+"||".join(n[-m:])+"|" s = (dot[0]+re) print("-------"+"-"*len(s)) print("Table: "+ s) print("-------"+"-"*len(s)) #----------------------------------------- |
| # 6231213921 (16.67) 24 (2021-02-08 21:15) def peek_kth_card(cards, k): cards = cards.split("||") cards[0] = (cards[0])[1:] cards[-1] = (cards[-1])[0:-1:1] the_kth_card ="||".join(cards[:k:]) the_kth_card = "|"+the_kth_card+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = card[0:4*(k-1):1]+card[4*k::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n:1] new_deck = deck[4*n::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m::]+deck[0:4*m:1] return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1:] deck = deck.split("||") shift = int(len(deck)//2)+int(len(deck)%2) move1 = deck[0:shift:1] move2 = deck[shift::] shuffle = ["0"]*len(deck) shuffle[0::2] = move1 shuffle[1::2] = move2 shuffle ="||".join(shuffle) new_deck = "|"+shuffle+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): pretable = cards[-4*m::] pretable = "Table: "+"...."*(4*m<len(cards))+pretable box = "-"*len(pretable) print(box) print(pretable) print(box) #----------------------------------------- |
| # 6231214521 (20.00) 25 (2021-02-08 17:52) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k:1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*(k-1):1]+cards[4*k::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n:1] new_deck = deck[4*n::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m::]+deck[0:4*m:1] return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1:] deck = deck.split("||") a = int(len(deck)//2) + int(len(deck)%2) x = deck[0:a:1] y = deck[a::] z = ["0"]*len(deck) z[0::2] = x z[1::2] = y z = "||".join(z) new_deck = "|"+z+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): z = cards[-4*m::] z = "Table: "+"...."*(4*m<len(cards))+z x = "-"*len(z) print(x) print(z) print(x) #----------------------------------------- |
| # 6231220221 (20.00) 26 (2021-02-08 22:51) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k:] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1):]+cards[4*k::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n:] new_deck = deck[4*n::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m::]+deck[:4*m:] return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1] deck = deck.split("||") a = len(deck) b = int((a/2)+0.5) new_deck = [0]*a new_deck[::2] = deck[:b:1] new_deck[1::2] = deck[b::1] new_deck = "||".join(new_deck) new_deck = "|"+new_deck+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): a = len(cards)/4 collect = cards[-4*m::] dot = "...."*(m<a) word = "Table: "+dot+collect print("-"*len(word)) print(word) print("-"*len(word)) #----------------------------------------- |
| # 6231222521 (19.33) 27 (2021-02-08 20:28) def peek_kth_card(cards, k): t = 4*k-4 the_kth_card = cards[t:t+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): t = 4*k-4 new_cards = cards[:t]+cards[t+4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): k = n+1 k2 = 4*k-4 cards = deck[:k2] new_deck = deck[k2:] return cards, new_deck #--------------------------------------- def cut(deck, m): k = m+1 k2 = 4*k-4 new_deck = deck[k2:]+deck[:k2] return new_deck #--------------------------------------- def shuffle(deck): #print(deck) deck = deck[1:-1].split("||") n = -(-len(deck)//2) #print(deck) nha = deck[:n] lung = deck[n:] deck[0::2] = nha deck[1::2] = lung new_deck = "|"+"||".join(deck)+"|" #print(new_deck) return new_deck #--------------------------------------- def show_table_cards(cards, m): n = len(cards)//4 print("-----------------------") cards = cards[1:-1] cards = cards.split("||") print("Table:","...."*int(max(0,abs(n-m)//(n-m-0.1)))+"|"+"||".join(cards[max(n-m,0):])+"|") print("-----------------------") #----------------------------------------- |
| # 6231223121 (20.00) 28 (2021-02-07 13:49) def peek_kth_card(cards, k): the_kth_card=cards[(4*(k-1)):(4*k):1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[0:4*(k-1):1]+cards[(4*k)::1] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:(4*n):1] new_deck=deck[(4*n)::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[(4*m)::]+deck[:(4*m):1] return new_deck #--------------------------------------- def shuffle(deck): j=deck[1:-1] k=j.split('||') l='##'.join(k) n=l.split('#') m=(len(n)//2)+(((len(n)//2)+1)%2) m=int(m) head=n[:m] head1=head[::2] tail=n[m:] tail1=tail[1::2] o=['']*(len(tail1)-len(head1)+1) p=head+o p[1::2]=tail1 q='||'.join(p) new_deck='|'+q+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): x=cards[1:-1] h=x.split('||') import math j=(len(h)-m)/len(h) y=math.ceil(j) k='....'*y l=h[(-m)::] n='||'.join(l) o='|'+n+'|' p=k+o print('-------'+'-'*len(p)) print('Table:',p) print('-------'+'-'*len(p)) #----------------------------------------- |
| # 6231510221 (20.00) 29 (2021-02-08 21:49) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k-1)*4]+cards[k*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:n*4] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): switch = deck[:m*4] nonswitch = deck[m*4:] new_deck = nonswitch + switch return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1:].split("||") new_deck = [0]*(len(deck)) deck1 = deck[:int((len(deck)/2+0.5)//1)] deck2 = deck[int((len(deck)/2+0.5)//1):] new_deck[::2] = deck1 new_deck[1::2] = deck2 new_deck = '|' + '||'.join(new_deck) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): x = len(cards) cards = '....' + cards[-4*m:] cards = 'Table: ' + cards[max(-x,-4*(m+1)):] print('-'*len(cards)) print(cards) print('-'*len(cards)) #----------------------------------------- |
| # 6231511921 (20.00) 30 (2021-02-08 10:22) def peek_kth_card(cards, k): the_kth_card = cards[(k*4)-4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): a = cards[:(k*4)-4] b = cards[k*4:] new_cards = a+b return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:n*4] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck[:m*4] b = deck[m*4:] new_deck = b + a return new_deck #--------------------------------------- def shuffle(deck): x = deck.split("|") a = x[1::2] y = len(a) w = len(a)//2 r = a[:-w-1:-1] s = r[::-1] #ครึ่งหลัง f = a[-w-1::-1] g = f[::-1] #ครึ่งหน้า new_list = [0]*y new_list[0::2] = g[:] new_list[1::2] = s[:] t = "||".join(new_list) new_deck = "|"+ t +"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): k = len(cards) t = "."*4 + cards[-4*m:] a = "Table: " cards = a + t[-k:] print("-"*len(cards)) print(cards) print("-"*len(cards)) #----------------------------------------- |
| # 6231707621 (17.78) 31 (2021-02-05 16:27) def peek_kth_card(cards, k): cards=cards[1:-1].split("||") the_kth_card="|"+cards[k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[0:(k-1)*4]+cards[(k)*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:(n)*4] new_deck=deck[(n)*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[(m)*4:]+deck[0:(m)*4] return new_deck #--------------------------------------- def shuffle(deck): deck=deck[1:-1].split("||") deck=deck[0::2]+deck[1::2] new_deck="|"+"||".join(deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): a="Table:"+" "+"...."*min(1,(len(cards)//4-m))+cards[-m*4:] print("-"*len(a)) print(a) print("-"*len(a)) #----------------------------------------- |
| # 6231709921 (20.00) 32 (2021-02-05 17:13) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:((k-1)*4)+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[0:(k-1)*4]+cards[((k-1)*4)+4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:(n)*4] new_deck = deck[(n)*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): cards1 = deck[0:(m)*4] cards2 = deck[(m)*4:] new_deck = cards2+cards1 return new_deck #--------------------------------------- def shuffle(deck): import math deck=deck.split('|') deck=deck[1:-1:2] m=math.ceil(len(deck)/2) cards1=deck[:m] cards2=deck[m:] deck[1::2]=cards2 deck[0::2]=cards1 new_deck = '|'+'||'.join(deck)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): deck=cards[-1:-((m*4)+1):-1] deck=deck[::-1] dot='....'*(min(1,((len(cards)//4)-m))) aws='Table: '+dot+deck line='-'*len(aws) print(line) print(aws) print(line) #----------------------------------------- |
| # 6231718521 (20.00) 33 (2021-02-07 22:31) def peek_kth_card(cards, k): the_kth_card=cards[(4*(k-1)):(4*k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[:(4*(k-1))]+cards[(4*k):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:(4*n)] new_deck=deck[(4*n):] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[((4*m)):]+deck[:((4*m))] return new_deck #--------------------------------------- def shuffle(deck): deck=deck[1:-1] deck=deck.split("||") a=len(deck)-(len(deck)//2) deck3=[""]*len(deck) deck3[::2]=deck[:a:] deck3[1::2]=deck[a::] new_deck=("|"+("||".join(deck3))+"|") return new_deck #--------------------------------------- def show_table_cards(cards, m): cards=cards[1:-1] cards=cards.split("||") a=min(m,len(cards)) c="|"+("||".join(cards[:-a-1:-1][::-1]))+"|" b=("Table: "+"...."*int(m<len(cards))+c) print("-"*len(b)) print(b) print("-"*len(b)) #----------------------------------------- |
| # 6330170421 (18.89) 34 (2021-02-04 23:54) def peek_kth_card(cards, k): x = cards.split('|') y = x[(2*k-1)-1:(2*k-1)+2:1] the_kth_card = '|'.join(y) return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x = cards.split('|') y = x[:(2*k-3)+2:1] y1 = '|'.join(y) z = x[(2*k-1)+1::1] z1 = '|'.join(z) new_cards = y1 + z1 return new_cards #--------------------------------------- def deal_n_cards(deck, n): x = deck.split('|') c = x[:(2*n-1)+2:1] cards = '|'.join(c) nd = x[(2*n-1)+1::1] new_deck = '|'.join(nd) return cards, new_deck #--------------------------------------- def cut(deck, m): x = deck.split('|') A = x[:(2*m-1)+2:1] a = '|'.join(A) B = x[(2*m-1)+1::1] b = '|'.join(B) new_deck = b + a return new_deck #--------------------------------------- def shuffle(deck): x = deck.split('|') y = x[1::2] n = len(y)//2 m = (len(y)+1)//2 A = y[:m:1] B = y[n::1] J = [0]*len(y) J[::2] = A J[1::2] = B new_deck = '|'+('||').join(J)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): x = cards.split('|') a = x[1::2] y = a[-m::1] z = '|'+('||').join(y)+'|' T = 'Table: '+'....'*min(1,(len(a)-m))+z print('-'*len(T)) print(T) print('-'*len(T)) #----------------------------------------- |
| # 6330171021 (18.67) 35 (2021-02-07 18:47) def peek_kth_card(cards, k): peek1 = cards.split("||") peek2 = '|,|'.join(peek1) the_kth_card = peek2.split(',') return the_kth_card[k-1] #--------------------------------------- def remove_kth_card(cards, k): remove_1 = cards.split('||') remove_2 = '|,|'.join(remove_1) new_cards = remove_2.split(',') del new_cards[k-1] new_cards = ''.join(map(str, new_cards)) return new_cards #--------------------------------------- def deal_n_cards(deck, n): deal1 = deck.split("||") deal2 = '|,|'.join(deal1) deal3 = deal2.split(',') cards = deal3[0:n] del deal3[0:n] new_deck = deal3 new_deck=''.join(map(str,new_deck)) cards =''.join(map(str,cards)) new_deck=''.join(map(str,new_deck)) return cards, new_deck #--------------------------------------- def cut(deck, m): cut1 = deck.split('||') cut2 = '|,|'.join(cut1) cut3 = cut2.split(',') deck =cut3[0:m+1:1] deck = ''.join(map(str,deck)) del cut3[0:m+1:1] cut3 = ''.join(map(str,cut3)) new_deck = cut3+deck return new_deck #--------------------------------------- def shuffle(deck): shuffle = deck.split('||') shuffle = '|,|'.join(shuffle) shuffle = shuffle.split(',') shuffle1 = shuffle[0:int((len(shuffle)+1)//2)] shuffle2 = shuffle[int((len(shuffle)+1)//2)::1] new_deck = [0]*len(shuffle) new_deck[0::2] = shuffle1 new_deck[1::2] = shuffle2 new_deck = ''.join(map(str,new_deck)) return new_deck #--------------------------------------- def show_table_cards(cards, m): cards1 = cards.split('||') cards2 = '|,|'.join(cards1) cards3 = cards2.split(',') p = min(len(cards3),m) Table = ['....'] import math Table[math.ceil((len(cards3)-m)/len(cards3)):] = cards3[len(cards3)-p:] Table = ''.join(map(str,Table)) print('-'*(len(Table)+7)) print('Table:',Table) print('-'*(len(Table)+7)) #----------------------------------------- |
| # 6330172721 (20.00) 36 (2021-02-06 23:25) def peek_kth_card(cards, k): cards = cards[1:-1].split("||") the_kth_card = "|"+cards[k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards = cards[1:-1].split("||") cards.pop(k-1) new_cards = bool(cards)*("|"+"||".join(cards)+"|") return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck = deck[1:-1].split("||") d_1 = deck[:n] d_2 = deck[n:] cards = "|"+"||".join(d_1)+"|" new_deck = bool(d_2) * ("|"+"||".join(d_2)+"|") return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): l=len(deck)//4 R = l//2 L = l-R jump = l//2+l%2 deck_list = (deck)[1:-1].split("||") deck_list = deck_list[:-R] + ['XX']*((l+1)%2) + deck_list[L:] deck_list*=jump new_deck = "|"+"||".join(deck_list[::jump+(l+1)%2])+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards[1:-1].split("||") l = len(cards) l_modi = bool(m<l) + m -bool(m>l)*(m-l) cards = cards[-m:] show= "Table: " + "...."*bool(m<l) + "|"+"||".join(cards)+"|" print("-"*7 + "----"*l_modi) print(show) print("-"*7 + "----"*l_modi) #----------------------------------------- |
| # 6330173321 (18.22) 37 (2021-02-07 12:54) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*(k-1)]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): left = deck[:len(deck)//2+(len(deck)//2)%4] right = deck[len(deck)//2+(len(deck)//2)%4:] new_deck = "" for i in range(len(deck)//2): new_deck += left[:4] left = left[4:] new_deck += right[:4] right = right[4:] return new_deck #--------------------------------------- def show_table_cards(cards, m): a = (len(cards)/4)-m b = int(a < len(cards)/4) c = "...."*b show_table_cards = c+ cards[(-4*m)::] x = "-"*(7+len(show_table_cards)) print(x) print("Table: "+ show_table_cards) print(x) #----------------------------------------- |
| # 6330174021 (17.78) 38 (2021-02-07 22:59) def peek_kth_card(cards, k): the_kth_card = '|'+ cards[1:-1].split('||')[k-1] +'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k-1)*4] + cards[(k-1)*4 + 4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck_l = deck[1:-1].split('||') cards, new_deck = '|' + '||'.join(deck_l[:n]) + '|', '|' + '||'.join(deck_l[n:]) + '|' return cards, new_deck #--------------------------------------- def cut(deck, m): deck_l = deck[1:-1].split('||') new_deck = '|' + '||'.join(deck_l[m:] + deck_l[:m]) + '|' return new_deck #--------------------------------------- def shuffle(deck): deck_l = deck.split('||') new_deck = ['']*len(deck_l) new_deck[::2] = deck_l[:(len(deck_l)+1)//2] new_deck[1::2] = deck_l[(len(deck_l)+1)//2:] return '||'.join(new_deck) #--------------------------------------- def show_table_cards(cards, m): card = cards[1:-1].split('||') mn = min(m, len(card)) con = ((len(card) + mn) // len(card)) % 2 #con = len(card) // mn ยังไมรัดกุม show = 'Table: ' + '.'*4*con + '|' + '||'.join(card[len(card)-mn:]) + '|' print('-'*len(show), show, '-'*len(show), sep="\n") #----------------------------------------- |
| # 6330176221 (19.50) 39 (2021-02-07 12:32) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k:1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x = cards.split('|') del x[2*k-2:2*k] new_cards = "|".join(x) return new_cards #--------------------------------------- def deal_n_cards(deck, n): x = deck.split('|') cards = x[:2*n+1] cards = "|".join(cards) del x[:2*n+1] y= '|'+"|".join(x) new_deck = y return cards, new_deck #--------------------------------------- def cut(deck, m): x = deck.split('|') cards = x[:2*m+1] cards = "|".join(cards) del x[:2*m] y= "|".join(x) + cards new_deck = y return new_deck #--------------------------------------- def shuffle(deck): x = deck[1:-1:1].split('||') n = int(len(deck)/4) a = x[0:int((n+1)//2)] b = x[int((n+1)//2):] c = [9]*n c[::2] = a c[1::2] = b new_deck = '|'+"||".join(c) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): x = cards[1:-1:1].split('||') c = len(x) mn = min(c,m) ans = x[c-mn:c] x = '|'+"||".join(ans) + '|' y = "Table:" + min(1,c-m)*"...."+x y = int(len(y)+1) print('-'*(int(y))) print("Table:" ,min(1,c-m)*"...."+x) print('-'*(int(y))) #----------------------------------------- |
| # 6330177921 (20.00) 40 (2021-02-06 21:06) def peek_kth_card(cards, k): the_kth_card = cards.split("|")[2*k-1] the_kth_card = "|"+the_kth_card+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): left = cards[:4*(k-1)] right = cards[4*(k):] new_cards = left+right return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*(n)] new_deck = deck[4*(n):] return cards, new_deck #--------------------------------------- def cut(deck, m): left = deck[:4*(m)] right = deck[4*(m):] new_deck = right+left return new_deck #--------------------------------------- def shuffle(deck): cards1 = deck.split("|")[1::2] i = int(0.5+len(cards1)/2) cards1[0:i] =" " x = " ".join(cards1) right = x.split() cards2 = deck.split("|")[1::2] cards2[i:] = " " a = " ".join(cards2) left = a.split() lst_new_deck = deck.split("|")[1::2] lst_new_deck[::2] = left lst_new_deck[1::2] = right new_deck = "|"+"||".join(lst_new_deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): n = int(len(cards)/4) c = min(m,n) right = cards[-4*c:] p = int(m<n) x = "...."*p+right show = "Table:"+" "+x print("-"*len(show)) print(show) print("-"*len(show)) #----------------------------------------- |
| # 6330178521 (20.00) 41 (2021-02-07 16:57) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1)] + cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*(m):] + deck[:4*(m)] return new_deck #--------------------------------------- def shuffle(deck): a = deck[1:-1].split('||') b = a[:round((len(a)+1)/2)] c = a[round((len(a)+1)/2):] d = ['']*len(a) d[::2] = b d[1::2] = c new_deck = '|' + '||'.join(d) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards[1:-1].split('||') b = a[-m:] c = '|' + '||'.join(b) + '|' d = min((len(a)-m),1) e = d*'....' answer = 'Table: '+ e + c x = '-'*len(answer) print(x) print(answer) print(x) #----------------------------------------- |
| # 6330179121 (17.11) 42 (2021-02-06 23:14) def peek_kth_card(cards, k): x = cards.strip('|').split('||') the_kth_card = '|' + x[k-1] + '|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x = cards.strip('|').split('||') new_cards = '|' + '||'.join(x[:k-1]+x[k:]) + '|' if len(new_cards) == 2 : new_cards = '' return new_cards #--------------------------------------- def deal_n_cards(deck, n): x = deck.strip('|').split('||') cards = '|' + '||'.join(x[:n]) + '|' new_deck = '|' + '||'.join(x[n:]) + '|' return cards, new_deck #--------------------------------------- def cut(deck, m): x = deck.strip('|').split('||') new_deck = '|' + '||'.join(x[m:]+x[:m]) + '|' return new_deck #--------------------------------------- def shuffle(deck): x = deck.strip('|').split('||') k = len(x)%2 n = int(len(x)/2 + k*1/2) a = x[:n] b = x[n:]+['']*k new_deck = '' for i in range(n) : new_deck += '|'+a[i]+'||'+b[i]+'|' new_deck = new_deck[:len(x)*4] return new_deck #--------------------------------------- def show_table_cards(cards, m): x = cards.strip('|').split('||') n = len(x) if n-m <= 0 : k = 0 a = '|'+'||'.join(x[k:])+'|' else : k = n-m a = '...'+'|'+'||'.join(x[k:])+'|' ans = 'Table: '+a print('-'*len(ans)) print('Table: '+a ) print('-'*len(ans)) #----------------------------------------- |
| # 6330180721 (18.67) 43 (2021-02-04 17:16) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k:] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1):]+ cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n:] new_deck = deck[4*n::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m+4::]+deck[:4*m:] return new_deck #--------------------------------------- def shuffle(deck): x = (len(deck)//4+1)//2 a = deck[:4*x:].split("|"); b = deck[x*4:].split("|") a[2:2*(len(deck)//4-x)+1:2] = b[1::2] c = "||".join(a) new_deck = c[1:len(deck):] + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): import math d = len(cards)//4 p = (abs(d-m)+ d-m)//2 o = cards[p*4:] l = math.ceil(p/(p+1)) print("-"*7 + "----"*l + "-"*len(o)) print("Table: "+"...."*l + o) print("-"*7 + "----"*l + "-"*len(o)) #----------------------------------------- |
| # 6330181321 (19.11) 44 (2021-02-06 14:48) def peek_kth_card(cards, k): the_kth_card=cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[:4*k-4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:4*n] new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): h=int((((len(deck)/4)+1)/2)) x1=(deck[:4*h].split("|"))+[" "]*50 x2=(deck[4*h:].split("|"))+[" "]*50 a=[x1[1],x2[1],x1[3],x2[3],x1[5],x2[5],x1[7],x2[7],x1[9],x2[9],x1[11],x2[11],x1[13],x2[13],x1[15],x2[15],x1[17],x2[17],x1[19],x2[19],x1[21],x2[21],x1[23],x2[23],x1[25],x2[25],x1[27],x2[27],x1[29],x2[29],x1[31],x2[31],x1[33],x2[33],x1[35],x2[35]] new_deck="|"+"||".join(a[:int(len(deck)/4):])+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): select=cards[-4*m::1] a=["...."] x=str(a[:int((len(cards)/4)//m):]) print("-------"+"-"*len(x[2:6])+"-"*len(cards[-4*m::1])) print("Table: "+x[2:6]+cards[-4*m::1]) print("-------"+"-"*len(x[2:6])+"-"*len(cards[-4*m::1])) #----------------------------------------- |
| # 6330182021 (20.00) 45 (2021-02-07 18:10) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:((k-1)*4)+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*(k-1)]+cards[(4*(k-1))+4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:n*4] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(4*(m-1))+4:]+deck[0:(4*(m-1))+4] return new_deck #--------------------------------------- def shuffle(deck): total = deck[1:-1] t = total.split("||") left = t[0:(len(t)+1)//2] right = t[(len(t)+1)//2:] t[0::2] = left t[1::2] = right d = "||".join(t) new_deck = "|"+d+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): c = cards[m*(-4):] x = "...."*((len(cards)//4)-m) y = x+c z = y[(m+1)*(-4):] tt = "Table: "+z print("-"*len(tt)) print(tt) print("-"*len(tt)) #----------------------------------------- |
| # 6330183621 (20.00) 46 (2021-02-04 13:35) def peek_kth_card(cards, k): cards=cards.split('|') k=k*2-1 a=cards[k] the_kth_card='|'+a+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards=cards.split('|') a=[] for n in range(1,len(cards),2): a.append(cards[n]) a.remove(a[k-1]) b='||'.join(a) if len(b)!= 0: new_cards='|'+b+'|' else: new_cards='' return new_cards #--------------------------------------- def deal_n_cards(deck, n): d=deck.split('|') a=[] for e in range(1,len(d),2): a.append(d[e]) cards=[] for i in range(n): cards.append(a[0]) a.remove(a[0]) cards='||'.join(cards) if len(cards) != 0: cards='|'+cards+'|' else: cards='' new_deck='||'.join(a) if len(new_deck) != 0: new_deck='|'+new_deck+'|' else: new_deck='' return cards, new_deck #--------------------------------------- def cut(deck, m): d=deck.split('|') a=[] for e in range(1,len(d),2): a.append(d[e]) for n in range(m): x=a.pop(0) a.append(x) new_deck='||'.join(a) new_deck='|'+new_deck+'|' return new_deck #--------------------------------------- def shuffle(deck): d=deck.split('|') a=[] for e in range(1,len(d),2): a.append(d[e]) l_r=len(a)//2 l_l=len(a)-l_r left=[] right=[] for n in range (l_l): left.append(a[n]) for g in range (l_l,len(a)): right.append(a[g]) b=[] for z in range(l_l): x=left.pop(0) b.append(x) if right!= []: y=right.pop(0) b.append(y) new_deck='||'.join(b) new_deck='|'+new_deck+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cards=cards.split('|') a=[] for n in range(1,len(cards),2): a.append(cards[n]) if m<len(a): b=[] for e in range (len(a)-(m),len(a)): b.append(a[e]) b='||'.join(b) b='|'+b+'|' b='....'+b elif m == len(a): b='||'.join(a) b='|'+b+'|' else: m=len(a) b='||'.join(a) b='|'+b+'|' c='-' d='Table: '+str(b) while len(c)<len(d): c+='-' print(c) print(d) print(c) #----------------------------------------- |
| # 6330184221 (20.00) 47 (2021-02-07 22:48) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:((k-1)*4)+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k-1)*4]+cards[((k-1)*4)+4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:n*4] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck[:m*4] b = deck[m*4:] new_deck = b+a return new_deck #--------------------------------------- def shuffle(deck): new_deck = deck[1:-1].split("||") n = len(new_deck) a = new_deck[:round((n/2)+0.49)] b = new_deck[round((n/2)+0.49):] new_deck[0::2] = a new_deck[1::2] = b new_deck = "|"+"||".join(new_deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards[1:-1].split("||") b = a[-m:] x = len(a)-m y = "...." z = int((abs(x)+x)/((abs(x)*2)-0.01)) w = y*z new = "|"+"||".join(b)+"|" table = "Table: "+str(w)+str(new) print("-"*len(table)) print(table) print("-"*len(table)) #----------------------------------------- |
| # 6330185921 (20.00) 48 (2021-02-08 20:56) def peek_kth_card(cards, k): b = slice(4*(k-1),4*(k-1)+4) the_kth_card = cards[b] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): b = slice(4*(k-1),4*(k-1)+4) the_kth_card = cards[b] new_cards = cards.replace(the_kth_card, '') return new_cards #--------------------------------------- def deal_n_cards(deck, n): h = slice(0,(n*4)) k = deck[h] new_deck = deck.replace(k, '') cards = deck[h] return cards, new_deck #--------------------------------------- def cut(deck, m): h = slice(0,4*(m)) k = deck[h] new_deck = deck.replace(k, '') new_deck =(new_deck+k) return new_deck #--------------------------------------- def shuffle(deck): a = int(len(deck)/8+0.5) b = slice(0,4*a) c = deck[b] d = slice(a*4,len(deck)) e = deck[d] f = list(deck) g = list(c) h = list(e) f[5::8]=h[1::4] f[6::8]=h[2::4] f[1::8]=g[1::4] f[2::8]=g[2::4] q= ','.join(f) new_deck = q.replace(',', '') return new_deck #--------------------------------------- def show_table_cards(cards, m): l = len(cards)/4 h = m-l k = (abs(h)-h)/2 d = slice(int(4*k),len(cards)) j = cards[d] g= ' ..............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................' b = slice(int(2*h+1),int(4*h+2),int(2*h+1)) the_kth_card = g[b] a = slice(0,1) c = the_kth_card[a] e = ' '+c+c+c+c+j t = e.replace(' ', '') y ='Table: '+t s = len(y) st=['-']*s q= ','.join(st) o = q.replace(',', '') print(o) print(y) print(o) #----------------------------------------- |
| # 6330186521 (20.00) 49 (2021-02-07 21:23) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*(k-1)+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1)] + cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): back = deck[:4*m] new_deck = deck[4*m:] + back return new_deck #--------------------------------------- def shuffle(deck): mid = deck[1:-1] sep = mid.split('||') half1 = sep[:round((len(sep))/2+0.5)] half2= sep[round((len(sep))/2):] mix =['']*len(sep) mix[::2] = half1 mix[1::2] =half2 j = '||'.join(mix) new_deck = '|' + j + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): mid = cards[1:-1] sep = mid.split('||') rev = sep[-1::-1] sh = rev[:m] sh.append('....') show = 'Table: ' + ''.join(sh[m:len(rev)]) +'|' +'||'.join(sh[:len(sh)-1][-1::-1])+ '|' edge = '-' * len(show) print(edge) print(show) print(edge) #----------------------------------------- |
| # 6330187121 (18.22) 50 (2021-02-04 23:47) def peek_kth_card(cards, k): arrang = cards.split('|') nu = (2 * k) - 1 the_kth_card = '|' +arrang[nu]+ '|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): arrang = cards.split('|') nu = (2 * k) - 1 new_cards = '|'.join(arrang[0:nu]) + '|'.join(arrang[(nu+1):]) return new_cards #--------------------------------------- def deal_n_cards(deck, n): arra = deck.split('|') nu = (2 * n) + 1 cards = '|'.join(arra[0:nu]) new_deck = '|'.join(arra[(nu-1):]) return cards, new_deck #--------------------------------------- def cut(deck, m): arra = deck.split('|') nu = (2 * m) + 1 ucard = '|'.join(arra[0:nu]) lcard = '|'.join(arra[(nu-1):]) new_deck = lcard + ucard return new_deck #--------------------------------------- def shuffle(deck): arrang = deck[1:-1].split('||') nn = len(arrang)//2 an = len(arrang) - nn A = arrang[:an] B = arrang[an:] AA = [0]*len(arrang) AA[::2] = A AA[1::2] = B new_deck = '|'+'||'.join(AA)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): arra = cards[1:-1].split('||') nn = len(arra) - m nm = int(((nn+abs(nn))/2)/abs(nn-0.5)) ar = arra[nm:] aa = '....'*int(nn>0) + '|' + '||'.join(ar) + '|' mi = 'Table: ' + aa li = '-'*len(mi) print(li) print(mi) print(li) #----------------------------------------- |
| # 6330188821 (20.00) 51 (2021-02-08 22:06) def peek_kth_card(cards, k): the_kth_card = cards[((k-1)*4) : (((k-1)*4)+4)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(4*(k-1))] + cards[(4*(k-1)) + 4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:(4*n)] new_deck = deck[(4*n):] return cards, new_deck #--------------------------------------- def cut(deck, m): x = deck[0:(4*m)] y = deck[(4*m):] new_deck = y + x return new_deck #--------------------------------------- def shuffle(deck): List = deck[1:-1].split('||') n = len(List) x = List[:(n+1)//2] y = List[(n+1)//2:] z = [' ']*n z[::2] = x z[1::2] = y new_deck = '|' + '||'.join(z) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): List = cards[1:-1].split('||') List = List[::-1] n1 = len(List) a = List[:m] + ['....'] line2 = 'Table: ' + ''.join(a[m:n1]) + '|' + '||'.join(a[:(len(a)-1)][::-1]) + '|' print('-'*len(line2)) print(line2) print('-'*len(line2)) #----------------------------------------- |
| # 6330189421 (20.00) 52 (2021-02-05 23:43) def peek_kth_card(cards, k): the_kth_card=cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[:4*k-4:]+cards[4*k::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:4*n] new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): a=deck[1:-1].split("||") b=len(a)//2 b1=a[-b::1] b2=a[:-b:] x=[""]*(len(deck)//4) x[::2]=b2 x[1::2]=b1 new_deck="|"+"||".join(x)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): A=cards[1:-1:].split("||") B=len(cards)//4 C="|"+"||".join(A[-m::])+"|" A=(B-m)*"...." A1="Table: "+A[0:4]+C A2="-"*len(A1) print(A2) print(A1) print(A2) #----------------------------------------- |
| # 6330190021 (20.00) 53 (2021-02-07 13:16) def peek_kth_card(cards, k): the_kth_card = cards[(4*k-4):(4*k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(4*k-4)]+cards[(4*k):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:(4*n)] new_deck = deck[(4*n):] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(4*m):]+deck[:(4*m)] return new_deck #--------------------------------------- def shuffle(deck): b1 = deck.split('|') c1 = b1[1::2] num = len(c1)//2 + len(c1)%2 bef = c1[:int(num)] aft = c1[int(num):] f1 = ' '.join(bef) f1 = f1.split(' ')+[''*((len(bef)+1)%2)] f1 = f1[::-1] f1 = f1[(len(bef)-len(aft)):] f1 = f1[::-1] f1[1::2] = aft new_deck = '|'+('||'.join(f1))+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): import math info = cards.split('|') info2 = info[1::2] out = '|'+'||'.join(info2[-m:])+'|' dot = (len(info2)*2+1)//(m*2+1.1) dotmid = int(math.atan2(dot,dot)/(math.pi/4))*'....' dottopbot = int(math.atan2(dot,dot)/(math.pi/4)) print('-------'+('----'*(dottopbot+min(len(info2),m)))) print('Table: '+dotmid+out) print('-------'+('----'*(dottopbot+min(len(info2),m)))) #----------------------------------------- |
| # 6330191621 (17.78) 54 (2021-02-08 10:47) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*(k-1)+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*(k-1)]+cards[4*(k-1)+4:99] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*(n)] new_deck = deck[4*(n):99] return cards, new_deck #--------------------------------------- def cut(deck, m): deck_list = [deck[i:i+4] for i in range(0, len(deck), 4)] new_deck_list = deck_list[m:len(deck_list)] + deck_list[:m] separator = '' new_deck = separator.join(new_deck_list) return new_deck #--------------------------------------- def shuffle(deck): import math deck_list = [deck[i:i+4] for i in range(0, len(deck), 4)] tot = len(deck_list) fh = deck_list[0:math.ceil(tot/2)] sh = deck_list[math.ceil(tot/2):tot] new_deck_list = [fh[i] + sh[i] for i in range(0 , math.ceil(tot/2)-1)] separator = '' new_deck = separator.join(new_deck_list) return new_deck #--------------------------------------- def show_table_cards(cards, m): cards_list = [cards[i:i+4] for i in range(0, len(cards), 4)] selected_cards_list = cards_list[len(cards_list) - m:len(cards_list)] separator = '' selected_cards = separator.join(selected_cards_list) if len(cards_list) > m: print("-"*(11+len(selected_cards))) print("Table" + ": ...." + selected_cards) print("-"*(11+len(selected_cards))) if len(cards_list) <= m: print("-"*(7+len(cards))) print("Table" + ": " + cards) print("-"*(7+len(cards))) #----------------------------------------- |
| # 6330192221 (20.00) 55 (2021-02-08 15:57) def peek_kth_card(cards, k): the_kth_card= cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[0:4*(k-1)]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:4*n] new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m:]+deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): import math new_deck=deck.split("|") new_deck=new_deck[1::2] blank=[0]*len(new_deck) half_deck=new_deck[math.ceil(len(new_deck)/2):] new_deck=new_deck[0:math.ceil(len(new_deck)/2):1] blank[0::2]=new_deck[0::] blank[1::2]=half_deck[0::] new_deck=blank new_deck="|"+"||".join(new_deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): cards=cards.split("|") cards=cards[1::2] k=len(cards) cards=cards[-m::] cards="|"+"||".join(cards)+"|" if(k<=m): print("-"*(len(cards)+7)) print("Table:",cards) print("-"*(len(cards)+7)) if(k>m): print("-"*(len(cards)+11)) print("Table: ...."+cards) print("-"*(len(cards)+11)) #----------------------------------------- |
| # 6330193921 (20.00) 56 (2021-02-06 12:50) def peek_kth_card(cards, k): the_kth_card = cards[(4*k-4):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4] + cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): i = deck.split("|") j = len(i)//2 l = i[1:int((len(i)+1)/2)] r = i[int(((j+1)//2)*2+1)::2] l[1::2]=r new_deck = "|"+"||".join(l)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): rightcards = cards[-4*m:] givencards = len(cards)/4 print("-"*7 + "-"*len(cards[-4*m:]) + "-"*(4*(min(int((givencards-m)),1)))) print("Table: "+"...."*min(int((givencards-m)),1) + rightcards) print("-"*7 + "-"*len(cards[-4*m:]) + "-"*(4*(min(int((givencards-m)),1)))) #----------------------------------------- |
| # 6330194521 (20.00) 57 (2021-02-07 17:27) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*(k-1)]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): left_deck = deck[:len(deck)//2+(len(deck)//2)%4] right_deck = deck[len(deck)//2+(len(deck)//2)%4:] new_deck = "" for i in range(len(deck)//2): new_deck += left_deck[:4] left_deck = left_deck[4:] new_deck += right_deck[:4] right_deck = right_deck[4:] return new_deck #--------------------------------------- def show_table_cards(cards, m): if m >= len(cards)//4: print("-"*(7+4*len(cards)//4)) print(f"Table: {cards}") print("-"*(7+4*len(cards)//4)) if len(cards)//4 > m: table = cards[m*(-4):] print("-"*(11+4*m)) print(f"Table: ....{table}") print("-"*(11+4*m)) #----------------------------------------- |
| # 6330197421 (17.78) 58 (2021-02-08 12:15) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4] + cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): import math number_of_cards = len(deck)/4 last_card = deck[-4:] half = math.ceil(len(deck)/2) deck = deck[:int(-4*max(0.25,0**(min(0.25,min(1,number_of_cards%2)))))] deck = deck.split("|")[1::2] deck = deck*half new_deck = deck[::half] new_deck = "|" + "||".join(new_deck) + "|" + last_card*int(0**max(0,number_of_cards%2)) return new_deck #--------------------------------------- def show_table_cards(cards, m): print("-"*7 + "-"*min(len(cards),(m+1)*4)) print("Table: " + "...."*min(len(cards)-m*4,1) + cards[-(m*4)::]) print("-"*7 + "-"*min(len(cards),(m+1)*4)) #----------------------------------------- |
| # 6330198021 (17.11) 59 (2021-02-08 23:58) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k-1)*4] + cards[k*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:n*4] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4:] + deck[:m*4] return new_deck #--------------------------------------- def shuffle(deck): a = deck.split("||") new_deck = str() if len(a)%2 == 0: b = len(a)//2 for i in range(b): if i == b-1: new_deck = new_deck + a[i] + "||" + a[i+b] if i != b-1: new_deck = new_deck + a[i] + "||" + a[i+b]+ "||" if len(a)%2 == 1: b = len(a)//2 for i in range(1,b+1): if i == b: new_deck = a[0]+"||" + a[i+b]+ "|"+ a[i] + "|" if i != b: new_deck = a[0]+"||" + a[i+b]+ "||"+ a[i] + "||" return new_deck #--------------------------------------- def show_table_cards(cards, m): c = cards.split("||") if m >= len(c): d ="Table: "+cards print("-"*len(d)) print(d) print("-"*len(d)) if m < len(c): for i in range(len(c)-m,len(c)): if i == len(c)-1: e = "Table: ....|"+ c[i] if i != len(c)-1: e = "Table: ....|" + c[i] +"||" print("-"*len(e)) print(e) print("-"*len(e)) #----------------------------------------- |
| # 6330199721 (20.00) 60 (2021-02-08 16:52) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = new_cards = cards[:(k-1)*4]+cards[k*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:n*4] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4:]+deck[:m*4] return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1].split('||') deck1 = deck[0:(len(deck)//2+len(deck)%2)] deck2 = deck[(len(deck)//2)+len(deck)%2:] new_deck = ['card']*len(deck) new_deck[0::2] = deck1 new_deck[1::2] = deck2 new_deck = '||'.join(new_deck) new_deck = '|' + new_deck + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards[1:-1].split('||') card = cards[-m:] card = '|'+'||'.join(card)+'|' table = '....'*min(1,(len(cards)-m))+ card print('-'*7+'-'*(len(table))) print('Table: '+str(table)) print('-'*7+'-'*(len(table))) #----------------------------------------- |
| # 6330200621 (20.00) 61 (2021-02-07 14:14) def peek_kth_card(cards, k): the_kth_card = cards[1:-1].split('||') the_kth_card = the_kth_card[k-1] the_kth_card = '|'+the_kth_card+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[1:-1].split('||') new_cards.remove(new_cards[k-1]) new_cards = '|'*min(len(new_cards),1)+'||'.join(new_cards)+'|'*min(len(new_cards),1) return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[1:-1].split('||') cards = cards[0:n] cards = '|'*min(len(cards),1)+'||'.join(cards)+'|'*min(len(cards),1) new_deck = deck[1:-1].split('||') new_deck = new_deck[n:] new_deck = '|'*min(len(new_deck),1)+'||'.join(new_deck)+'|'*min(len(new_deck),1) return cards, new_deck #--------------------------------------- def cut(deck, m): cards = deck[1:-1].split('||') cards = cards[0:m] cards = '|'*min(len(cards),1)+'||'.join(cards)+'|'*min(len(cards),1) new_deck = deck[1:-1].split('||') new_deck = new_deck[m:] new_deck = '|'*min(len(new_deck),1)+'||'.join(new_deck)+'|'*min(len(new_deck),1) new_deck = new_deck+cards return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1].split('||') deck1 = deck[0:(len(deck)//2)+len(deck)%2] deck2 = deck[(len(deck)//2)+len(deck)%2:] new_deck = ['2']*len(deck) new_deck[0::2] = deck1 new_deck[1::2] = deck2 new_deck = '|'+'||'.join(new_deck)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards[1:-1].split('||') card = cards[-m:] show = '|'+'||'.join(card)+'|' table = '....'*min(1,(len(cards)-m))+show keed = '-'*7+'-'*(len(table)) print(keed) print('Table:'+' '+str(table)) print(keed) #----------------------------------------- |
| # 6330201221 (19.50) 62 (2021-02-08 23:58) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1)] +cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:(4*n)+1] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): mi = deck.split("|") left = mi[1:((len(mi))//2)+((len(mi))%2)] right = mi[int(((len(mi)//2+1)//2)*2+1)::2] left[1::2] = right dex = "||".join(left) new_deck = "|" + dex + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): the = cards[-4*m::1] line = "...."*min(int(((len(cards))/4)-m),1) + the print("-"*(len(line)+7)) print("Table: " + line) print("-"*(len(line)+7)) #----------------------------------------- |
| # 6330203521 (20.00) 63 (2021-02-04 23:12) def peek_kth_card(cards, k): the_kth_card = cards[(4*k)-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(4*k)-4]+cards[(4*k):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck[:4*m] b = deck[4*m:] new_deck = b+a return new_deck #--------------------------------------- def shuffle(deck): A = deck[1:-1].split("||") A1 = A[0:((len(A)+1)//2)] A2 = A[((len(A)+1)//2):] A[1::2] = A2 A[0::2] = A1 new_deck = "|"+"||".join(A)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): data = cards[1:-1].split("||") x = len(data) a = "|"+"||".join(data[-m::])+"|" num = 1*(x-m>0) ans = "Table: "+"...."*num + a print("-"*len(ans)) print(ans) print("-"*len(ans)) #----------------------------------------- |
| # 6330205821 (16.44) 64 (2021-02-08 02:42) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*(k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(4*(k-1))]+cards[(4*k):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): x = deck.split("|") xx = int(len(x)//2) x[2:int((len(x)+1)/2):2] = x[int(((xx+1)//2)*2)+1::2] z = x[:int(xx)+1] zz = "||".join(z)+"|" new_deck = zz[1:] return new_deck #--------------------------------------- def show_table_cards(cards, m): table = "...."*-(max(m-int((len(cards)+1)/4),-1)) + cards[-4*m:] print('-'*int(len(table)+8)) print('Table','=',table) print('-'*int(len(table)+8)) #----------------------------------------- |
| # 6330206421 (20.00) 65 (2021-02-07 18:59) def peek_kth_card(cards, k): x = cards.split("|") del x[0::2] the_kth_cardop = x[k-1] the_kth_card = "|"+the_kth_cardop+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x = cards.split("|") del x[0::2] check = bool(len(x)>1) del x[k-1] t = '||'.join(x) new_cards = check*("|"+t+"|") return new_cards #--------------------------------------- def deal_n_cards(deck, n): x = deck.split("|") del x[0::2] check = bool(len(x)>n) checkv2 = int(n>0) cardsx = x[0:n:1] new_deckx = x[n::1] cardsy = '||'.join(cardsx) cards = checkv2*("|"+cardsy+"|") new_decky = '||'.join(new_deckx) new_deck = check*("|"+new_decky+"|") return cards, new_deck #--------------------------------------- def cut(deck, m): x = deck.split("|") del x[0::2] t = x[m:] + x[:m] new_deckx = '||'.join(t) new_deck = "|"+new_deckx+"|" return new_deck #--------------------------------------- def shuffle(deck): x = deck.split("|") del x[0::2] N = len(x) half = ((N+1)//2) right = x[half::1] left = x[:half:1] x[::2] = left[0:] x[1::2] = right[0:] new_deckx = '||'.join(x) new_deck = "|"+new_deckx+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): x = cards.split("|") del x[0::2] t = len(x) check = bool(t > m) s = check*"...." checkover = int(t > m) del x[0:checkover*(t-m):1] o = '||'.join(x) new_cards = "|"+o+"|" that = "-"*(len(s+new_cards)+7) print(that) print("Table:",s+new_cards) print(that) #----------------------------------------- |
| # 6330208721 (20.00) 66 (2021-02-06 22:30) def peek_kth_card(cards, k): cards = cards[1:-1].split("||") the_kth_card = "|"+cards[k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards = cards.split('|') a1 = cards[:(2*k-3)+2:1] b1 = '|'.join(a1) a2 = cards[(2*k-1)+1::1] b2 = '|'.join(a2) new_cards = b1+b2 return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck = deck.split('|') a = (2*n)+1 cards = '|'.join(deck[0:a]) new_deck = '|'.join(deck[a-1:]) return cards, new_deck #--------------------------------------- def cut(deck, m): deck = deck[1:-1].split("||") a = deck[m:]+deck[:m] new_deck = "|" + "||".join(a) + "|" return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1].split("||") a = deck[:int((len(deck)/2)+0.5)] b = deck[int((len(deck)/2)+0.5):] c = [0]*len(deck) c[::2] = a c[1::2] = b new_deck = new_deck = "|" + "||".join(c) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards[1:-1].split("||") a = "|" + "||".join(cards[-m:])+ "|" d = min((len(cards)-m),1) b = "...."*d c = "Table: " print("-"*len(c+b+a)) print(c+b+a) print("-"*len(c+b+a)) #----------------------------------------- |
| # 6330209321 (20.00) 67 (2021-02-08 18:05) def peek_kth_card(cards, k): the_kth_card=cards[(k-1)*4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[0:4*k-4]+cards[4*k::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:4*n] new_deck=deck[4*n::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m::]+deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): s=len(deck)//4 k=((s+1)//2)*4 left=deck[0:k] right=deck[k::] left_list=left.split("|") left_list2=left_list[1::2] right_list=right.split("|") right_list2=right_list[1::2] a=[0]*s a[0::2]=left_list2[0::] a[1::2]=right_list2[0::] new_deck="||".join(a) new_deck="|"+new_deck+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): cards=cards.split("|") cards=cards[1::2] x=len(cards)-m cards=cards[-m::] cards="||".join(cards) cards="|"+cards+"|" y=min(1,x) z="Table:"+" "+"...."*(y)+cards w=len(z) print("-"*w) print(z) print("-"*w) #----------------------------------------- |
| # 6330210921 (20.00) 68 (2021-02-06 21:23) def peek_kth_card(cards, k): cards_ = "|" + cards the_kth_card = cards_[4*k-3 : 4*k+1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards_ = "|" + cards new_cards = cards_[1:4*k-3] + cards_[4*k+1:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck_ = "|" + deck cards = deck_[1:4*n+1] new_deck = deck_[4*n+1:] return cards, new_deck #--------------------------------------- def cut(deck, m): deck_ = "|" + deck foward = max(1,4*m+1) new_deck = deck_[4*m+1:] + deck_[1:4*m+1] return new_deck #--------------------------------------- def shuffle(deck): deck_ = "|" + deck + "|" deck_ = deck_.split("||") deck_ = deck_[1:-1] leng_deck_ = len(deck_) a = leng_deck_ - leng_deck_//2 deck_ = deck_[:a] + (leng_deck_+1)%2*["*"] + deck_[a:] long_deck_ = (a+(leng_deck_+1)%2)*deck_ deck_ = ["*"] + long_deck_[0::a+(leng_deck_+1)%2] deck_part = deck_[1:leng_deck_] + deck_[leng_deck_:leng_deck_+1] deck_ = deck_part new_deck = "|" + "||".join(deck_) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): cards_print = cards[-4*m:] leng_cards = len(cards)//4 dot = min(1,(m-leng_cards+1)) dot = max(0,dot) print((7+len(cards_print))*"-" + (1-dot)*"----") print("Table: " + (1-dot)*"...." + cards_print) print((7+len(cards_print))*"-" + (1-dot)*"----") #----------------------------------------- |
| # 6330211521 (15.78) 69 (2021-02-08 13:06) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k-1)*4] + cards[k*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:n*4] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): m = m*4 new_deck = deck[m:] + deck[:m] return new_deck #--------------------------------------- def shuffle(deck): count_deck = len(deck) count_deck = int(count_deck/2) new_deck = deck[count_deck:] + deck[:count_deck] return new_deck #--------------------------------------- def show_table_cards(cards, m): print(int(1**(len(cards)-m)-(len(cards)//m))) c1 = "...."*int(1**(len(cards)-m)-(m/len(cards))) card = "Table:" + c1 +''.join(cards[(-m-1)*4::]) print("-"*len(card)) print(card) print("-"*len(card)) #----------------------------------------- |
| # 6330212121 (18.00) 70 (2021-02-04 22:53) def peek_kth_card(cards, k): a=cards[1:-1] a=a.split("||") the_kth_card="|"+a[k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): a=cards[1:-1] a=a.split("||") del a[k-1] t='||'.join(a) chk=int(bool(len(t)!=0)) new_cards='|'*chk+t+'|'*chk return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:4*n:] new_deck=deck[4*n::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck= deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): import itertools import math numcard=len(deck)/4 numa=math.ceil(numcard/2) list_a=deck[:4*numa] list_a=list_a[1:-1].split('||') list_b=deck[4*numa:] list_b=list_b[1:-1].split('||') a=list(itertools.chain.from_iterable(zip(list_a,list_b))) a='||'.join(a) new_deck='|'+a+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a=cards[1:-1] a=a.split("||") l=len(a) is_dot=int(bool(l>m)) #print(is_dot) x=a[l-m:] final='Table: '+'....'*is_dot+'|'+'||'.join(x)+'|' line='-'*len(final) print(line) print(final) print(line) #----------------------------------------- |
| # 6330213821 (20.00) 71 (2021-02-07 23:05) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:(k-1)*4+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(k-1)*4]+cards[(4*k):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:(n)*4] new_deck = deck[(n)*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(4*m):] + deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): a = deck[1:-1].split("||") b = a[0:(len(a)+1)//2] c = a[(len(a)+1)//2:] a[0::2] = b a[1::2] = c new_deck = "||".join(a) new_deck = "|"+new_deck+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards[(-4)*m:] b = "...." *int(((len(cards)/4)-m)) c = b + a d = c[(-4*m)-4:] e = "Table: " print ("-"*int(len(e+d))) print (e+d) print ("-"*int(len(e+d))) #----------------------------------------- |
| # 6330214421 (20.00) 72 (2021-02-06 13:40) def peek_kth_card(cards, k): the_kth_card = cards[(k*4)-4:(k*4)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(k*4)-4]+cards[(k*4)::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:(n*4)] new_deck = deck[(n*4)::] return cards, new_deck #--------------------------------------- def cut(deck, m): c_1 = deck[0:(m*4)] c_2 = deck[(m*4)::] new_deck = c_2+c_1 return new_deck #--------------------------------------- def shuffle(deck): s_1 = len(deck)/2 s_2 = s_1 % 4 s_3 = s_1+s_2 f_1 = deck[0:int(s_3)] f_2 = deck[int(s_3)::] e_1 = f_1.split("||") e_2 = "| |".join(e_1) e_3 = e_2.split() t_1 = f_2.split("||") t_2 = "| |".join(t_1) t_3 = t_2.split() a = ["x"]*(len(e_3)+len(t_3)) a[0::2] = e_3 a[1::2] = t_3 new_deck = "".join(a) return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards.split("||") b = "| |".join(a) c = b.split() c_1 = c[::-1] d = len(c) q_1 = c_1[0:m:] e = d-m r = ["...."]*e t = q_1+r t_1 = t[0:m+1:] t_2 = t_1[::-1] y = "".join(t_2) y_1 = len(y) x = "Table: "+y x_1 = len(x) w = "-"*x_1 print(w) print(x) print(w) #----------------------------------------- |
| # 6330215021 (20.00) 73 (2021-02-07 04:26) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*k-4] + cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1].split('||') left = deck[:((len(deck)+1)//2)] right = deck[((len(deck)+1)//2):] new_deck = ["n"]*len(deck) new_deck[0::2] = left new_deck[1::2] = right new_deck = '||'.join(new_deck) new_deck = '|'+ new_deck + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): print("-"*len("Table: " + "...."*int((len(cards)/4)>m) + str(cards[-4*m:]))) print("Table: " + "...."*int((len(cards)/4)>m) + str(cards[-4*m:])) print("-"*len("Table: " + "...."*int((len(cards)/4)>m) + str(cards[-4*m:]))) #----------------------------------------- |
| # 6330216721 (20.00) 74 (2021-02-08 16:42) def peek_kth_card(cards, k): i = 4*(k-1) the_kth_card = cards[i:i+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): i = 4*(k-1) new_cards = cards[:i] + cards[i+4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): deck_list = deck.split("|")[1::2] mid_index = (len(deck_list)+1)//2 left = deck_list[:mid_index] right = deck_list[mid_index:] new_deck_list = [''] * len(deck_list) new_deck_list[::2] = left new_deck_list[1::2] = right new_deck = ["|", ""][len(deck)==0] +"||".join(new_deck_list)+["|", ""][len(deck)==0] return new_deck #--------------------------------------- def show_table_cards(cards, m): i = max(len(cards)-4*m, 0) main_line = "Table: " + ['', '....'][len(cards) > 4*m] + cards[i:] dash_line = "-"*len(main_line) print(dash_line) print(main_line) print(dash_line) #----------------------------------------- |
| # 6330217321 (20.00) 75 (2021-02-07 03:35) def peek_kth_card(cards, k): the_kth_card=cards[k+(-1+3*(k-1)):k+(-1+3*(k-1))+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards.replace(cards[k+(-1+3*(k-1)):k+(-1+3*(k-1))+4],"") return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:4*n] new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m:] new_deck=new_deck + deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): t=len(deck) t=(t//4+1)//2 deck1=deck[0:t*4] deck1=deck1[1:-1] deck1=deck1.split("||") deck2=deck[t*4:] deck2=deck2[1:-1] deck2=deck2.split("||") deck3=[""]*(len(deck)//4) deck3[::2]=deck1 deck3[1::2]=deck2 new_deck="|"+"||".join(deck3)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): cards=cards[1:-1] cards=cards.split("||") b=cards[-m:] b="|"+"||".join(b)+"|" a=int(len(cards)>m) show="Table: "+"...."*a print("-"*(len(show)+len(b))) print("Table: "+"...."*a+b) print("-"*(len(show)+len(b))) #----------------------------------------- |
| # 6330219621 (16.44) 76 (2021-02-06 13:35) def peek_kth_card(cards, k): a = cards.split("||") a = "|,|".join(a) a = a.split(",") the_kth_card = a[k-1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): a = cards.split("||") a = "|,|".join(a) a = a.split(",") new_cards = a[0:k-1:1]+a[k::1] new_cards = "".join(new_cards) return new_cards #--------------------------------------- def deal_n_cards(deck, n): a = deck.split("||") a = "|,|".join(a) a = a.split(",") cards = a[:n:1] new_deck = a[n::1] cards = "".join(cards) new_deck = "".join(new_deck) return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck.split("||") a = "|,|".join(a) a = a.split(",") new_deck = a[m::1]+a[:m:1] new_deck = "".join(new_deck) return new_deck #--------------------------------------- def shuffle(deck): a = deck.split("||") a = "|,|".join(a) a = a.split(",") nd = [" "]*len(a) nd[0::2] = a[0:((len(a)-1)//2)+1:1] nd[1::2] = a[((len(a)-1)//2)+1::1] new_deck = "".join(nd) return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards.split("|") s = a[1::2] k = len(s)-1 p = s[-1:-m-1:-1] q = p[-1::-1] r = "TABLE : " + "...."*(min(k,m)//m) + "|" + "||".join(q) + "|" print("-"*len(r)) print(r) print("-"*len(r)) #----------------------------------------- |
| # 6330221821 (20.00) 77 (2021-02-08 00:21) def peek_kth_card(cards, k): ch = cards[(4*k-4):(4*k)] the_kth_card = ch return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(4*k-4)] + cards[(4*k):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): new_deck = deck[(4*n):] cards = deck[:(4*n)] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(4*m):] + deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): half = round((len(deck) + 1)/8) fhalf = deck[1:4*half-1] lhalf = deck[4*half+1:-1] sfh = fhalf.split('||') slh = lhalf.split('||') alt = [None]*(len(sfh)+len(slh)) alt[::2] = sfh alt[1::2] = slh strf = '||'.join(alt) new_deck = '|' + strf + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): ch = cards[-4*m:] check = m-len(cards)//4 n = round(check//(abs(check)+0.000001)) l = ['....'] add = l[n+1:] adj = ' '.join(add) line = '-'*(7+len(adj+ch)) print(line) print('Table:', adj + ch) print(line) #----------------------------------------- |
| # 6330222421 (19.11) 78 (2021-02-06 20:51) def peek_kth_card(cards, k): a = cards.split("||") b = '| |'.join(a) c = b.split() the_kth_card = c[k-1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): d = cards.split("||") e = '| |'.join(d) f = e.split() g = f[0:k-1]+f[k:] new_cards = ''.join(g) return new_cards #--------------------------------------- def deal_n_cards(deck, n): a = deck.split("||") b = '| |'.join(a) c = b.split() cards_1 = c[:n] new_deck_1 = c[n:] cards = ''.join(cards_1) new_deck = ''.join(new_deck_1) return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck.split("||") b = '| |'.join(a) c = b.split() d = c[m:]+c[:m] new_deck = ''.join(d) return new_deck #--------------------------------------- def shuffle(deck): a = deck.split("||") b = '| |'.join(a) c = b.split() d = round((len(c)+1)/2) e = c[:d] f = c[d:] r = [None]*(len(e)+len(f)) r[::2] = e r[1::2] = f new_deck = ''.join(r) return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards.split("||") b = '| |'.join(a) c = b.split() d = c[-m:] e = ''.join(d) e1 = "Table: " + "...."*((5-m)//2) + e a1 = "-"*len(e1) a2 = "-"*len(e1) print(a1) print(e1) print(a2) #----------------------------------------- |
| # 6330223021 (20.00) 79 (2021-02-05 22:07) def peek_kth_card(cards, k): cards = cards[1:-1].split('||') the_kth_card = '|'+cards[k-1]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards = cards.split('|') new_cards = cards[:2*k-1]+ cards[2*k+1:] new_cards = '|'.join(new_cards) return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck = deck.split('|') cards = deck[:(2*n)+1] cards = ('|').join(cards) new_deck = deck[(2*n):] new_deck = ('|').join(new_deck) return cards, new_deck #--------------------------------------- def cut(deck, m): deck = deck[1:-1].split('||') new_deck = deck[m:]+deck[:m] new_deck = '|'+(('||').join(new_deck)) + '|' return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1].split('||') x = int((len(deck)+1)//2) y = deck[:x] z = deck[x:] a = ['']*(len(y+z)) a[::2] = y[::1] a[1::2] = z[::1] b = (len(a)*2)*['']+[''] b[1::2] = a[::1] new_deck = ('|').join(b) return new_deck #--------------------------------------- def show_table_cards(cards, m): y = cards[1:-1].split('||') cards = y[-m:] x = ('||').join(cards) z = 'Table: '+(min(max((len(y)-m),0),1)*'....')+'|'+x+'|' print('-'*len(z)) print(z) print('-'*len(z)) #----------------------------------------- |
| # 6330224721 (19.33) 80 (2021-02-08 02:12) def peek_kth_card(cards, k): the_kth_card = cards[1:-1:1].split("||") the_kth_card = "|"+the_kth_card[k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x1 = cards[:4*k-4] x2 = cards[4*k:] new_cards = str(x1)+str(x2) return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n:1] new_deck = deck[4*n::1] return cards, new_deck #--------------------------------------- def cut(deck, m): x3 = deck[0:4*m:1] x4 = deck[4*m::1] new_deck = str(x3)+str(x4) return new_deck #--------------------------------------- def shuffle(deck): deck_x = deck[1:-1:1].split("||") new_deck = [0]*len(deck_x) half = (len(deck_x)+1)//2 new_deck[0::2] = deck_x[:half] new_deck[1::2] = deck_x[half:] new_deck="|"+"||".join(new_deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): cards1 = cards[1:-1].split("||") show = cards1[-m::] show1 = "|"+"||".join(show)+"|" print("-"*(len("Table: "+"...."*int(m<len(cards1))+show1))) print("Table: "+"...."*int(m<len(cards1))+show1) print("-"*(len("Table: "+"...."*int(m<len(cards1))+show1))) #----------------------------------------- |
| # 6330225321 (20.00) 81 (2021-02-07 10:24) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*k-4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): a = deck[1:-1].split('||') b = deck[1:-1].split('||') l = (len(a)+1)//2 a[0::2] = a[0:l] a[1::2] = b[l:] new_deck = '|'+'||'.join(a)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): l = len(cards)//4 a = min(l,m) b = min(l-m,1) c = cards[-a*4:] d = 'Table: ' + '....'*b + c print('-'*len(d)) print(d) print('-'*len(d)) #----------------------------------------- |
| # 6330226021 (20.00) 82 (2021-02-07 09:09) def peek_kth_card(cards, k): the_kth_card = cards[(4*k)-4:4*k:] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(4*k)-4:] + cards[4*k::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n:] new_deck = deck[4*n::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m::]+deck[:4*m:] return new_deck #--------------------------------------- def shuffle(deck): tud = deck[1:-1:] pai = tud.split("||") l1 = int(((len(pai)/2)+0.5)//1) p1 = pai[:l1:] p2 = pai[l1::] nd = [""]*len(pai) nd[0::2] = p1 nd[1::2] = p2 new_deck = "|"+"||".join(nd)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): tud = cards[1:-1:] pai = tud.split("||") s0 = pai[-m::] s1 = "|"+"||".join(s0)+"|" point = int(len(pai)>m) show = "Table: "+"...."*point+s1 print("-"*len(show)) print(show) print("-"*len(show)) #----------------------------------------- |
| # 6330227621 (17.33) 83 (2021-02-08 02:19) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:(k*4):] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k-1)*4:]+cards[k*4::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:n*4:] new_deck = deck[n*4::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4::]+deck[:m*4:] return new_deck #--------------------------------------- def shuffle(deck): D = deck.split("|") n = int(len(deck)/4) n1 = int(((len(deck)/4)+1)//2) n2 = int((len(deck)/4)//2) D1 = D[1:n1*2:2] D2 = D[(n1*2)+1:(n2+n1)*2:2] D3 = D1[0:1]+D2[0:1]+D1[1:2]+D2[1:2]+D1[2:3]+D2[2:3]+D1[3:4]+D2[3:4]+D1[4:5]+D2[4:5]+D1[5:6]+D2[5:6]+D1[6:7]+D2[6:7]+D1[7:8]+D2[7:8]+D1[8:9]+D2[8:9]+D1[9:10]+D2[9:10]+D1[10:11]+D2[10:11]+D1[11:12]+D2[11:12]+D1[12:13]+D2[12:13]+D1[13:14]+D2[13:14]+D1[14:15]+D2[14:15]+D1[15:16]+D2[15:16]+D1[16:17]+D2[16:17]+D1[17:18]+D2[17:18]+D1[18:19]+D2[18:19]+D1[19:20]+D2[19:20]+D1[20:21]+D2[20:21]+D1[21:22]+D2[21:22]+D1[22:23]+D2[22:23]+D1[23:24]+D2[23:24]+D1[24:25]+D2[24:25]+D1[25:26]+D2[25:26] D4 = D3[0:n:] new_deck = "|"+str("||".join(D4))+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): C = cards.split("|") C1 = C[1::2] C2 = "|"+"|,|".join(C1)+"|" C3 = C2.split(",") C41 = C3[:-m-1:-1] C42 = ['....']+C41[::-1]+['']*(m-3) C51 = C42[:-m-2:-1] C52 = C51[::-1] c = "Table: "+"".join(C52) n = len(c) print("-"*n) print(c) print("-"*n) #----------------------------------------- |
| # 6330228221 (17.56) 84 (2021-02-07 20:13) def peek_kth_card(cards, k): x = cards.split("|") newcard = x[1::2] the_kth_card = "|"+ newcard[k-1] + "|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x = cards.split("|") newcard_list = x[1::2] cards_before = newcard_list[:k-1:] + newcard_list[k::] cards_after = '||'.join(cards_before) new_cards = "|" + cards_after + "|" return new_cards #--------------------------------------- def deal_n_cards(deck, n): #x = deck.split("|") #deck_list = x[1::2] #cards1 = deck_list[:n:] #cards2 = "||".join(cards1) #cards = "|" + cards2 + "|" #deck1 = deck_list[n::] #deck2 = "||".join(deck1) #new_deck = "|" + deck2 + "|" deck_list = deck[1:-1:] deck_list = deck_list.split("||") cards1 = deck_list[:n:] cards2 = "||".join(cards1) cards = "|" + cards2 + "|" deck1 = deck_list[n::] print(len(deck1)) if len(deck1) == 0 : #deck2 = "||".join(deck1) new_deck = "" else: deck2 = "||".join(deck1) new_deck = "|" + deck2 + "|" return cards, new_deck #--------------------------------------- def cut(deck, m): card = deck[:4*m:] deck2 = deck[4*m::] new_deck = deck2 + card return new_deck #--------------------------------------- def shuffle(deck): import math as m deck_list = deck[1:-1:] deck_list = deck_list.split("||") #print(deck_list) num_left = m.ceil(len(deck_list)/2) #print(num_left) new_deck_list = "+"*(len(deck_list)-1) new_deck_list = new_deck_list.split("+") # + + + + + + + + + + + + + new_deck_list[0::2] = deck_list[:num_left:] new_deck_list[1::2] = deck_list[num_left::] new_deck_list1 = "||".join(new_deck_list) new_deck = '|' + new_deck_list1 + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cards_list = cards[1:-1:] cards_list = cards_list.split("||") if len(cards_list) > m and m>0 : newcard1 = "."*4 #"...." newcard2 = cards_list[-m::] newcard2 = "||".join(newcard2) newcard2 = "|" + newcard2 + "|" new_card = newcard1 + newcard2 print("Table:",new_card) else : newcard2 = cards_list[-m::] newcard2 = "||".join(newcard2) newcard2 = "|" + newcard2 + "|" print("Table:",newcard2) #----------------------------------------- |
| # 6330229921 (20.00) 85 (2021-02-07 23:39) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:((k-1)*4)] + cards[(k*4)::1] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:(n*4)] new_deck = deck[n*4::1] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m::1] + deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): l = deck[0:int((((len(deck)/4)+1)//2)*4)] r = deck[int((((len(deck)/4)+1)//2)*4)::1] Listl = l[1:-1:1].split("||") Listr = r[1:-1:1].split("||") new_deck = ["eiei"] * (int(len(deck)/4)) new_deck[0::2] = Listl new_deck[1::2] = Listr new_deck = "|" + "||".join(new_deck) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards[1:-1] b = a.split("||") c = b[-m:] d = "|"+"||".join(c)+"|" e = int(len(b)>m) f = "Table: "+"...."*e+d print("-"*len(f)) print(f) print("-"*len(f)) #----------------------------------------- |
| # 6330230421 (20.00) 86 (2021-02-06 23:45) def peek_kth_card(cards, k): cards = cards.split("|") the_kth_card = '|'.join(cards[2*k-2:2*k+1]) return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards = cards.split("|") new_cards = cards[:2*k-1]+cards[2*k+1:] new_cards = "|".join(new_cards) return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck = deck.split("|") cards = "|".join(deck[:2*n+1]) new_deck = "|".join(deck[2*n:]) return cards, new_deck #--------------------------------------- def cut(deck, m): deck = deck[1:-1] deck = deck.split("||") new_deck = [0]*len(deck) L = deck[m:] new_deck[:len(L)] = L R = deck[:m] new_deck[len(L):] = R new_deck = '|'+"||".join(new_deck)+'|' return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1] deck = deck.split("||") l = deck[:(len(deck)//2)+(len(deck)%2)] r = deck[(len(deck)//2)+(len(deck)%2):] new_deck = [0]*len(deck) new_deck[0::2] = l new_deck[1::2] = r new_deck = '|'+"||".join(new_deck)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards[1:-1] cards = cards.split("||") x = len(cards)-m cards = cards[-m:] cards = '|'+"||".join(cards)+'|' middle = "Table: "+"...."*min(1,x)+cards _up = "-"*len(middle) _down = "-"*len(middle) print(_up) print(middle) print(_down) #----------------------------------------- |
| # 6330232721 (20.00) 87 (2021-02-08 13:44) def peek_kth_card(cards, k): the_kth_card = cards[(4*k)-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): L_cards = cards[0:(4*k)-4] R_cards = cards[4*k:] new_cards = L_cards + R_cards return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:(n*4)] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): L_deck = deck[0:4*m] deck = deck[4*m:] new_deck = deck + L_deck return new_deck #--------------------------------------- def shuffle(deck): import math L_deck = deck[:(((len(deck)//4)+1)//2)*4] R_deck = deck[(((len(deck)//4)+1)//2)*4:] Lis_L_deck = str(L_deck[1:-1]).split("||") Lis_R_deck = str(R_deck[1:-1]).split("||") new_deck = ["tan"]*((len(deck))//4) new_deck[0::2] = Lis_L_deck new_deck[1::2] = Lis_R_deck new_deck = '|'+'||'.join(new_deck)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): A = cards[1:-1] A = A.split("||") M = A[-m:] M = '|'+'||'.join(M)+'|' L = int(len(A)>m) MID = "Table: "+"...."*L+M print("-"*len(MID)) print(MID) print("-"*len(MID)) #----------------------------------------- |
| # 6330233321 (18.67) 88 (2021-02-07 23:36) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards = cards.split("|") cards = cards[0:2*k-1] + cards[2*k+1:] new_cards = "|".join(cards) return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck = deck.split("|") cards = deck[:2*n+1] cards = "|".join(cards) new_deck = deck[2*n:] new_deck = "|".join(new_deck) return cards, new_deck #--------------------------------------- def cut(deck, m): deck = deck.split("|") new_deck = deck[2*m:] + deck[1:2*m+1] new_deck = "|".join(new_deck) return new_deck #--------------------------------------- def shuffle(deck): a = deck[0::4] l = (len(a)+1)//2 deck = deck.split("|") deck_a = deck[:2*l+1] deck_b = deck[2*l:] new_deck = [""]*(len(a)*2+1) new_deck[1::4] = deck_a[1::2] new_deck[3::4] = deck_b[1::2] new_deck = "|".join(new_deck) return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards[1:-1] cards = cards.split("||") a = len(cards)-m l = cards[-m:] cards = [0]*len(cards) cards[-m:] = l cards = "|" + "||".join(cards[-m:]) + "|" print((7+len(cards) + 4*min(1,a)) *"-") print("Table:" + "...."*min(1,a) + cards) print((7+len(cards) + 4*min(1,a)) *"-") #----------------------------------------- |
| # 6330234021 (18.90) 89 (2021-02-08 21:18) def peek_kth_card(cards, k): x = cards.split("|") del x[0::2] y = "|" + x[k-1] + "|" the_kth_card = y return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x = cards.split("|") del x[0::2] del x[k-1] if len(x) != 0 : new_cards = "|" + "||".join(x) + "|" else : new_cards = "" return new_cards #--------------------------------------- def deal_n_cards(deck, n): x = deck.split("|") del x[0::2] cards = "|" + "||".join(x[:n]) + "|" new_deck = "|" + "||".join(x[n:]) + "|" return cards, new_deck #--------------------------------------- def cut(deck, m): x = deck.split("|") del x[0::2] y = x[m:]+x[:m] new_deck = "|" + "||".join(y) + "|" return new_deck #--------------------------------------- def shuffle(deck): x = deck.split("|") del x[0::2] y = x[:len(x)//2 + len(x)%2] z = x[(len(x)+1)//2:] k = [0]*len(x) k[0::2] = y k[1::2] = z new_deck = "|" + "||".join(k) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): x = cards.split("|") del x[0::2] y = x[-m:] z = "|" + "||".join(y) + "|" print("-"*len("Table:" + "...."*min(1,len(x)-m) + z)) print("Table:" + "...."*min(1,len(x)-m) + z) print("-"*len("Table:" + "...."*min(1,len(x)-m) + z)) #----------------------------------------- |
| # 6330235621 (20.00) 90 (2021-02-08 23:30) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4] + cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): a = len(deck)/4 b = a//2 c = int(a-b)*4 d = int(a-2*b) e = deck[1:c-d] f = deck[c+1:-1] g = e.split("|") h = f.split("||") g[1::2] = h new_deck = "|" + "||".join(g) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): x = len(cards)/4 y = min(x,m) z = int(x-y) u = cards[z*4:] v = z*"...." r = v[:4] s = "Table:" + " " + r + u t = "-"*len(s) print(t) print(s) print(t) #----------------------------------------- |
| # 6330236221 (18.00) 91 (2021-02-08 12:33) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4: (k-1)*4 + 4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k -4] + cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m) : new_deck = deck[4*m:] + deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): x = int((len(deck))/2 + (len(deck)/2)%4) b = deck[:x] a = deck[x:] b = b[1:len(b)-1] a = a[1:len(a)-1] b = b.split("|") a = a.split("|") b = b + [" "]*int(len(a) -len(b) + 1 ) b[1::2] = a[::2] b[0] = "|"+ b[0] b[-1] += "|" b = "||".join(b) new_deck = b return new_deck #--------------------------------------- def show_table_cards(cards, m): import math a = int(len(cards)/4 - m)*4 p = cards cards = cards[a:] l = "...." o = ( -m + int(len(p[:a])) + 8 ) z = math.sqrt(o**2) e = int(o/z) print("-------" + "-"*(len(p[a:]))+"----"*e) print( "Table" +":",l*(e) + str(cards)) print("-------" + "-"*(len(p[a:]))+"----"*e) #----------------------------------------- |
| # 6330238521 (20.00) 92 (2021-02-06 21:34) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): deck1 = deck.replace("||","|,|") deck2 = deck1.split(",") L = deck2[:(len(deck2)//2)+((len(deck2))%2)] R = deck2[(len(deck2)//2)+((len(deck2))%2):] new_deck_list = [0]*(len(L)+len(R)) new_deck_list[::2] = L new_deck_list[1::2] = R new_deck = ''.join(new_deck_list) return new_deck #--------------------------------------- def show_table_cards(cards, m): table = ("Table: "+"...."*(min(max(0,(len(cards)//4)-m),1))+cards[-4*m:]) print("-------"+"-"*len("...."*(min(max(0,(len(cards)//4)-m),1))+cards[-4*m:])) print(table) print("-------"+("-"*len("...."*(min(max(0,(len(cards)//4)-m),1))+cards[-4*m:]))) #----------------------------------------- |
| # 6330239121 (20.00) 93 (2021-02-06 20:17) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4] + cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] +deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1:1] deck = deck.split("||") l_half = deck[:(len(deck)//2)+(len(deck)%2)] r_half = deck[(len(deck)//2)+(len(deck)%2):] new_deck = [0]*len(deck) new_deck[0::2] = l_half new_deck[1::2] = r_half new_deck = "|"+"||".join(new_deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards[1:-1] cards = cards.split("||") x = len(cards)-m l = cards[-m::] cards = [0]*len(cards) cards[-m::] = l cards = "|"+"||".join(cards[-m::])+"|" print((7+len(cards)+4*min(1,max(0,x)))*"-") print("Table: "+"...."*min(1,x)+ cards) print((7+len(cards)+4*min(1,max(0,x)))*"-") #----------------------------------------- |
| # 6330240721 (20.00) 94 (2021-02-07 02:16) def peek_kth_card(cards, k): deckz = cards[1:-1] vg = deckz.split("||") yg = vg[k - 1] the_kth_card = "|" + ("").join(yg) + "|" return the_kth_card # --------------------------------------- def remove_kth_card(cards, k): deckz = cards[1:-1] vg = deckz.split("||") cardx = vg[0:k - 1:] + vg[k::] new_cards = "|"+("||").join(cardx)+"|" if len(cardx)==0: return "" return new_cards # --------------------------------------- def deal_n_cards(deck, n): deckz = deck[1:-1] vg = deckz.split("||") yg = vg[0:n:] ws = vg[n::] cards = "|" + ("||").join(yg) + "|" new_deck = "|" + ("||").join(ws) + "|" if len(ws)==0: return cards,"" return cards, new_deck # --------------------------------------- def cut(deck, m): deckz = deck[1:-1] vg = deckz.split("||") yg = vg[m::] + vg[0:m] new_deck = "|" + ("||").join(yg) + "|" return new_deck # --------------------------------------- def shuffle(deck): deckx = deck.strip('|').split('||') nct = len(deckx) // 2 onetwoseven = deckx[nct::] dream = deckx[:nct:] if len(deckx) % 2 == 1: dream = deckx[:nct + 1] onetwoseven = deckx[nct + 1:] u = dream + onetwoseven u[::2] = dream u[1::2] = onetwoseven wayv = "|" + ("||").join(u) + "|" new_deck = wayv return new_deck # --------------------------------------- def show_table_cards(cards, m): deckz = cards[1:-1] vg = deckz.split("||") zero = min(1, min(m, len(vg[m::]))) dot = "...." * zero vgz = vg[:-(m + 1):-1] vgr = vgz[::-1] cardx = str("|" + ("||").join(vgr) + "|") hand = str(dot) + cardx print('-' * len("Table: " + hand)) print("Table: " + hand) print('-' * len("Table: " + hand)) # ----------------------------------------- |
| # 6330241321 (20.00) 95 (2021-02-07 21:49) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4 : ((k-1)*4)+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0 : (k-1)*4] + cards[((k-1)*4)+4 : ] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0 : (n*4)] new_deck = deck[(n*4) : ] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(m*4) : ] + deck[0 : (m*4)] return new_deck #--------------------------------------- def shuffle(deck): a = deck[1 : -1 ].split("||") b = len(a) c = a[:round((b/2) + 0.29)] d = a[round((b/2) + 0.29):] e = [" "]*b e[::2] = c e[1::2] = d new_deck = "|" + "||".join(e) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): a = (len(cards) - (4*m))/4 b = int((abs(a) + abs(a))/((2*a) - 0.1)) c = "Table: " + "...."*b + cards[-4*m :] print("-"*len(c)) print(c) print("-"*len(c)) #----------------------------------------- |
| # 6330242021 (19.11) 96 (2021-02-07 18:57) def peek_kth_card(cards, k): the_kth_card=cards[4*(int(k)-1):4*int(k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[0:4*(int(k)-1)]+cards[4*int(k)::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:4*int(n)] new_deck=deck[4*int(n)::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*int(m)::]+deck[0:4*int(m)] return new_deck #--------------------------------------- def shuffle(deck): i=deck.split("|") j=(len(deck)//4) e=((len(deck)//2)+2)//4 e1=i[1:e*2:2] f=((len(deck)//2))//4 f1=i[(e*2)+1:(e+f)*2:2] g=e1[0:1]+f1[0:1]+e1[1:2]+f1[1:2]+e1[2:3]+f1[2:3]+e1[3:4]+f1[3:4]+e1[4:5]+f1[4:5]+e1[5:6]+f1[5:6]+e1[6:7]+f1[6:7]+e1[7:8]+f1[7:8]+e1[8:9]+f1[8:9]+e1[9:10]+f1[9:10]+e1[10:11]+f1[10:11]+e1[11:12]+f1[11:12]+e1[12:13]+f1[12:13]+e1[13:14]+f1[13:14]+e1[14:15]+f1[14:15]+e1[15:16]+f1[15:16]+e1[16:17]+f1[16:17]+e1[17:18]+f1[17:18]+e1[18:19]+f1[18:19]+e1[19:20]+f1[19:20]+e1[20:21]+f1[20:21]+e1[21:22]+f1[21:22]+e1[22:23]+f1[22:23]+e1[23:24]+f1[23:24]+e1[24:25]+f1[24:25]+e1[25:26]+f1[25:26] h=g[0:j:] new_deck="|"+"||".join(h)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): x=cards[4*int((len(cards)//4)-int(m))::] y="Table: "+"...."*min((max((len(cards))//4-int(m),0),1))+str(x) print("-"*(len(y))) print(y) print("-"*(len(y))) #----------------------------------------- |
| # 6330243621 (20.00) 97 (2021-02-08 15:50) def peek_kth_card(cards, k): cards1 = cards.split('|') the_kth_card = '|'+cards1[2*k-1]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): c00 = cards.split('|') del c00[0::2] c01 = '|'+str((c00[k-1]))+'|' k1 = cards.find(c01) c02 = list(cards) c03 = c02[:k1:1]+c02[k1+4::1] new_cards = ''.join(c03) return new_cards #--------------------------------------- def deal_n_cards(deck, n): c10 = list(deck) c11 = c10[4*n::1] c12 = c10[:4*n:1] new_deck = ''.join(c11) cards = ''.join(c12) return cards, new_deck #--------------------------------------- def cut(deck, m): c20 = deck[0:4*m] c21 = list(deck) c22 = c21[4*m::1] new_deck = ''.join(c22) + c20 return new_deck #--------------------------------------- def shuffle(deck): d00 = ['']*(len(deck)//4) d10 = deck.split('|') del d10[0::2] lc = (len(d10)+1)//2 d20 = d10[:lc:] d30 = d10[lc::] d00[::2] = d20 d00[1::2] = d30 d80 = '||'.join(d00) new_deck = '|'+d80+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): c50 = cards.split('|') del c50[0::2] c51 = c50[-1:-m-1:-1] c52 = c51[-1::-1] c40 = len(c50) c42 = c40 - m c43 = '|'+'||'.join(c52)+'|' c44 = '....'*c42+c43 c55 = c44[-1:(-4*(m+1))-1:-1] c60 = c55[-1::-1] c88 = 'Table: '+c60 c62 = len(c88) print('-'*c62) print(c88) print('-'*c62) #----------------------------------------- |
| # 6330245921 (20.00) 98 (2021-02-07 21:47) def peek_kth_card(cards, k): cards = cards.split('|')[1::2] the_kth_card = '|'+str(cards[k-1])+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards = cards.split('|')[1::2] g = cards[:k-1] h = cards[k:] a = g+h new_cards = '|'*max(min(((len(a))),1),0)+'||'.join(a)+'|'*max(min(((len(a))),1),0) return new_cards #--------------------------------------- def deal_n_cards(deck, n): v = deck.split('|')[1::2] use = v[:n] left = v[n:] cards = '|'*max(min(((len(use))),1),0)+'||'.join(use)+'|'*max(min(((len(use))),1),0) new_deck = '|'*max(min(((len(left))),1),0)+'||'.join(left)+'|'*max(min(((len(left))),1),0) return cards, new_deck #--------------------------------------- def cut(deck, m): f = deck.split('|')[1::2] c1 = f[:m] c2 = f[m:] c3 = c2+c1 new_deck = '|'+'||'.join(c3)+'|' return new_deck #--------------------------------------- def shuffle(deck): spliter = deck.split('|')[1::2] num = len(spliter)+1 a = spliter[:num//2] b = spliter[num//2:] reserve = [0]*len(spliter) reserve[1::2] = b reserve[::2] = a new_deck = '|' + '||'.join(reserve) +'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards.split('|')[1::2] b = a[-m:] v = '|'+'||'.join(b)+'|' z = "Table: "+"...."*min(max(((len(a))-m),0),1)+v print(len(z)*'-') print(z) print(len(z)*'-') #----------------------------------------- |
| # 6330246521 (20.00) 99 (2021-02-06 21:36) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:k*4:] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k-1)*4] + cards[(k*4):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:n*4:] new_deck = deck[n*4::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4::] + deck[:m*4:] return new_deck #--------------------------------------- def shuffle(deck): ListOfCards = deck.split("|")[1::2] LeftSplit = ListOfCards[:(len(ListOfCards)+1)//2:] RightSplit = ListOfCards[(len(ListOfCards)+1)//2::] new_deck_list = [0]*len(ListOfCards) new_deck_list[::2] = LeftSplit[::] new_deck_list[1::2] = RightSplit[::] new_deck = "|" + '||'.join(new_deck_list) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): SelectCards = cards[-1:-4*m-1:-1][::-1] Show = "...."*(int((len(cards)/4-m-1)//(len(cards)/4+0.001)) + 1) + SelectCards print("-------" + "-"*len(SelectCards) + "----"*(int((len(cards)/4-m-1)//(len(cards)/4+0.001)) + 1)) print("Table:", Show) print("-------" + "-"*len(SelectCards) + "----"*(int((len(cards)/4-m-1)//(len(cards)/4+0.001)) + 1)) #----------------------------------------- |
| # 6330247121 (19.56) 100 (2021-02-08 17:14) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:4*k:] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k-1)*4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): new_deck = deck[(4*n)::] cards = deck[:(4*n):] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m::]+deck[0:4*m:] return new_deck #--------------------------------------- def shuffle(deck): x = deck.split("|")[1::2] a = x[:((len(x)+1)//2):] b = x[((len(x)+1)//2)::] c = [0]*len(x) c[0::2] = a[::] c[1::2] = b[::] t = '||'.join(c) new_deck = "|"+t+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards.split("|")[1::2] b = a[-m:] c = '|'+'||'.join(b) +'|' w = "Table"+":"+"...."*(min(max(((len(cards)//4)-m),0),1)) print("-"*len(w+c)) print(w+c) print("-"*len(w+c)) #----------------------------------------- |
| # 6330248821 (20.00) 101 (2021-02-07 21:35) def peek_kth_card(cards, k): a=cards[1:len(cards)-1:1] b=a.split("||") the_kth_card="|"+b[k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[0:4*k-4:1]+cards[4*k:len(cards):1] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:4*n:1] new_deck=deck[4*n:len(deck):1] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m:len(deck):1]+deck[0:4*m:1] return new_deck #--------------------------------------- def shuffle(deck): card =deck.strip("|").split("||") new_deck = '' if len(card)%2 ==1: for i in range(len(card)//2): new_deck += '|' + card[i] + '||' + card[i+(len(card)//2)+1] + '|' new_deck += '|' + card[len(card)//2] + '|' else : for i in range(len(card)//2): new_deck += '|' + card[i] + '||' + card[i+(len(card)//2)] + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): if len(cards) <= m*4: print('-'*(7+len(cards))) print('Table: '+cards) print('-'*(7+len(cards))) else: print('-'*(11+(m*4))) print('Table: ....' + cards[len(cards)-int(m*4):]) print('-'*(11+(m*4))) #----------------------------------------- |
| # 6330249421 (20.00) 102 (2021-02-07 23:34) def peek_kth_card(cards, k): a=cards.split("||") #["|2H", "4S", "TD", "AC|"] (a[0])=(a[0])[1::] (a[len(a)-1])=(a[len(a)-1])[:-1:] the_kth_card=("|"+a[k-1]+"|") return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[:(4*(k-1)):]+cards[(4*k)::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:(4*(n)):] new_deck=deck[(4*n)::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m::]+deck[:4*m:] return new_deck #--------------------------------------- def shuffle(deck): a=deck.split("||") (a[0])=(a[0])[1::] (a[len(a)-1])=(a[len(a)-1])[:-1:] x=[0]*int(len(deck)/4) x[1::2]=a[(len(x)+1)//2::] x[0::2]=a[:(len(x)+1)//2:] new_deck="|"+"||".join(x)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): n=len(cards)/4 x="...."*int(min(n-m,1))+cards[4*int(n-min(n,m))::] print("-------"+"-"*int(min(n-m,1))*4+"-"*4*int(min(m,n))) print("Table:"+" "+x) print("-------"+"-"*int(min(n-m,1))*4+"-"*4*int(min(m,n))) #----------------------------------------- |
| # 6330250021 (20.00) 103 (2021-02-07 10:39) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): d = deck[1:-1].split('||') d1 = d[:(len(d)+1)//2] d2 = d[(len(d)+1)//2:] newd = [0]*len(d) newd[::2] = d1 newd[1::2] = d2 new_deck = '|'+'||'.join(newd)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards.split('||') b = '|,|'.join(a) d = b.split(',') p = min(len(d),m+1) tab = ['....']*p tab[-1:-m-1:-1] = d[-1:-m-1:-1] table = ''.join(tab) print('-'*(len(table)+7)) print('Table:',table) print('-'*(len(table)+7)) #----------------------------------------- |
| # 6330251621 (20.00) 104 (2021-02-08 22:49) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4+(k-1)*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1)]+cards[4+(k-1)*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4+(n-1)*4] new_deck = deck[4+(n-1)*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4+(m-1)*4:]+deck[:4+(m-1)*4] return new_deck #--------------------------------------- def shuffle(deck): d = deck[1:-1] d = d.split("||") shub1 = d[0:int(len(deck)/8+0.5)] shub2 = d[int(len(deck)/8+0.5):len(deck)] p = [0]*int(len(deck)/4) p[0::2],p[1::2]=shub1,shub2 new_deck="|"+"||".join(p)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): noiz = min(len(cards)/4,m) last = cards[-4*m:] judjud = "...."*int((len(cards)/4-noiz)**(1/100000)) O = "Table: "+judjud+last print("-"*(len(O))) print(O) print("-"*(len(O))) #----------------------------------------- |
| # 6330252221 (20.00) 105 (2021-02-08 21:09) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(k-1)*4]+cards[k*4::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:n*4] new_deck=deck[n*4::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[m*4::]+deck[0:m*4] return new_deck #--------------------------------------- def shuffle(deck): a=int((len(deck))/4) b=int(a//2)+(a%2) c=int(a-b) d=deck[0:(b*4)]#ครึ่งแรก e=deck[-(c*4)::]#ครึ่งหลัง new_deck=d[0:4]+e[0:4]+d[4:8]+e[4:8]+d[8:12]+e[8:12]+d[12:16]+e[12:16]+d[16:20]+e[16:20]+d[20:24]+e[20:24]+d[24:28]+e[24:28]+d[28:32]+e[28:32]+d[32:36]+e[32:36]+d[36:40]+e[36:40]+d[40:44]+e[40:44]+d[44:48]+e[44:48]+d[48:52]+e[48:52]+d[52:56]+e[52:56]+d[56:60]+e[56:60]+d[60:64]+e[60:64]+d[64:68]+e[64:68]+d[68:72]+e[68:72]+d[72:76]+e[72:76]+d[76:80]+e[76:80]+d[80:84]+e[80:84]+d[84:88]+e[84:88]+d[88:92]+e[88:92]+d[92:96]+e[92:96]+d[96:100]+e[96:100]+d[100:104]+e[100:104]+d[104:108]+e[104:108]+d[108:112]+e[108:112] return new_deck #--------------------------------------- def show_table_cards(cards, m): x=len(cards) y=int(min(int(x)/4-m,1)) print("-"*7+"-"*(y*4)+"-"*(int(len(cards[-(m*4)::])))) print("Table: "+"...."*min(max(((len(cards)//4)-m),0),1)+cards[-(m*4)::]) print("-"*7+"-"*(y*4)+"-"*(int(len(cards[-(m*4)::])))) #----------------------------------------- |
| # 6330253921 (20.00) 106 (2021-02-07 20:20) def peek_kth_card(cards, k): #k = input() cards = cards[1:-1] cards = cards.split('||') the_kth_card = cards[int(k)-1] the_kth_card = '|'+the_kth_card+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): #k = input() cards = cards[1:-1] cards = cards.split('||') new_cards = cards[:int(k)-1]+cards[int(k):] new_cards = '|'*max(min(len(new_cards),1),0)+'||'.join(new_cards)+'|'*max(min(len(new_cards),1),0) return new_cards #--------------------------------------- def deal_n_cards(deck, n): #n = input() deck = deck[1:-1] deck = deck.split('||') cards = deck[0:int(n)] new_deck = deck[int(n):] cards = '|'*max(min(len(deck),1),0)+'||'.join(cards)+'|'*max(min(len(deck),1),0) new_deck = '|'*max(min(len(new_deck),1),0)+'||'.join(new_deck)+'|'*max(min(len(new_deck),1),0) return cards, new_deck #--------------------------------------- def cut(deck, m): #m = input() deck = deck[1:-1] deck = deck.split("||") new_deck = deck[int(m):]+deck[:int(m)] new_deck = '|'+'||'.join(new_deck)+'|' return new_deck #--------------------------------------- def shuffle(deck): #n1=left n2=right deck = deck[1:-1] deck = deck.split('||') #deck = deck.split('|') #deck = deck[1::2] n1 = deck[:(len(deck)+1)//2] n2 = deck[(len(deck)+1)//2:] n_deck = [0]*len(deck) n_deck[0::2] = n1 n_deck[1::2] = n2 new_deck = '|'+'||'.join(n_deck)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): #m = input() cards = cards[1:-1] cards = cards.split('||') show_table_cards = 'Table: '+'....'*min(max((len(cards)-int(m)),0),1)+'|'+'||'.join(cards[-int(m):])+'|' print('-'*len(show_table_cards)) print(show_table_cards) print('-'*len(show_table_cards)) #----------------------------------------- |
| # 6330254521 (20.00) 107 (2021-02-06 03:17) def peek_kth_card(cards, k): the_kth_card=cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[0:4*(k-1)]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): b=deck[0:4*n] cards = b new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m:]+deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): a_1 = deck[1:-1].split("||") s_1=a_1[0:int(len(a_1)/2+0.5)] s_2=a_1[int(len(a_1)/2+0.5):len(a_1)] v=[0]*len(a_1) v[0::2],v[1::2]=s_1,s_2 new_deck="|"+"||".join(v)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): q =min(m,len(cards)//4) show = cards[-4*m:] io="...."*int((len(cards)//4-q)**(1/100000000)) z ="Table: "+io+show print("-"*(4*q+len(io)+7)) print(z) print("-"*(4*q+len(io)+7)) #----------------------------------------- |
| # 6330255121 (20.00) 108 (2021-02-08 21:19) def peek_kth_card(cards, k): a = cards.replace("||","|,|") b = a.split(",") the_kth_card = b[k-1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): a = cards.replace("||","|,|") b = a.split(",") new_cards = b[:k-1] + b[k:] new_cards = "".join(new_cards) return new_cards #--------------------------------------- def deal_n_cards(deck, n): a = deck.replace("||","|,|") b = a.split(",") cards = b[:n] cards = "".join(cards) new_deck = b[n:] new_deck = "".join(new_deck) return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck.replace("||","|,|") b = a.split(",") f = b[:m] s = b[m:] new_deck = s + f new_deck = "".join(new_deck) return new_deck #--------------------------------------- def shuffle(deck): a = deck.replace("||","|,|") b = a.split(",") y = round((len(b)/2)+0.5) left = b[:y] right = b[y:] new_deck = [' ']*len(b) new_deck[::2] = left new_deck[1::2] = right new_deck = "".join(new_deck) return new_deck #--------------------------------------- def show_table_cards(cards, m): cardsList = cards[1:-1] cardsList = cardsList.split("||") cardsList = cardsList[::-1] n1 = len(cardsList) a = cardsList[:m] + ["...."] n2 = len(a) - 1 line2 = "Table: " + "".join(a[m:n1]) + "|" + "||".join(a[:n2][::-1]) + "|" print("-"*len(line2)) print(line2) print("-"*len(line2)) #----------------------------------------- |
| # 6330256821 (0.00) 109 (2021-02-08 23:54) def peek_kth_card(cards, k): the_kth_card=cards[2*k+1:2*k+5] return the_kth_card #--------------------------------------- |
| # 6330257421 (20.00) 110 (2021-02-08 23:18) def peek_kth_card(cards, k): the_kth_card=cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[0:4*(k-1)]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:4*n] new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m:]+deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): n=(len(deck)//4+1)//2 b=deck.split('|') b=b[1::2] b1=b[:n] b2=b[n:] b[::2]=b1 b[1::2]=b2 new_deck='|' new_deck=new_deck+'||'.join(b)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): n=(len(cards)//4) x=min(n,m) y=min((m+1),n) c=[] c[:0]=cards c[:(n-x)*4]='.'*(n-x)*4 c=c[(n-y)*4:] e='-'*(7+(y)*4) print(e) print('Table:',''.join(c)) print(e) #----------------------------------------- |
| # 6330258021 (20.00) 111 (2021-02-04 19:38) def peek_kth_card(cards, k): the_kth_card = '|'.join(cards.split('|')[2*k-2:2*k+1]) return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = '|'.join(cards.split('|')[:2*k-1]+cards.split('|')[2*k+1:]) return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = '|'.join(deck.split('|')[:2*n+1]) new_deck = '|'.join(deck.split('|')[2*n:]) return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = '|'.join(deck.split('|')[2*m:]) + '|'.join(deck.split('|')[:2*m+1]) return new_deck #--------------------------------------- def shuffle(deck) : ds = deck.split('|')[1::2] n = len(ds) ldeck = ['']*n ldeck[::2],ldeck[1::2] = ds[:(n//2)+(n%2)],ds[(n//2)+(n%2):] new_deck = '|' + '||'.join(ldeck) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): table = 'Table: ' + '....'*min(max(0,len(cards.split('|')[1::2])-m),1) + '|'.join(cards.split('|')[-2*m-1:]) print('-'*len(table)) print(table) print('-'*len(table)) # ----------------------------------------- |
| # 6330259721 (18.67) 112 (2021-02-05 22:09) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k-1)*4]+cards[k*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck + deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): a = deck.split("|") a = a[1::2] b = [0]*len(a) c1 = a[:int((len(a)/2)+0.5)] c2 = a[int((len(a)/2)+0.5):] b[::2] = c1 b[1::2] = c2 d = [0]*(len(b)*3) d[1::3] = b d[::3] = ["|"]*(int(len(b))) d[2::3] = ["|"]*(int(len(b))) new_deck = "".join(d) return new_deck #--------------------------------------- def show_table_cards(cards, m): e = cards.split("|") e = e[1::2] f = [0]*(len(e)*3) f[1::3] = e f[::3] = ["|"]*(int(len(e))) f[2::3] = ["|"]*(int(len(e))) g = min(len(f)/3,m) f[:int(len(f)-3*g)] = "...."*(int(len(f)-3*g)) k = "".join(f) l = min(m+1,len(cards)) p = k[-4*l:] print("-"*7 + "-"*len(p)) print("Table: " + p) print("-"*7 + "-"*len(p)) #----------------------------------------- |
| # 6330260221 (20.00) 113 (2021-02-08 18:54) def peek_kth_card(cards, k): the_kth_card=cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*(k-1)]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:(4 * n)] new_deck = deck[(4 * n):] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(4 * m):]+deck[0:(4 * m)] return new_deck #--------------------------------------- def shuffle(deck): z = [] z1 = [] a = deck.strip('|') b = a.split('||') for i in b: z.append('|' + i + '|') if len(z) % 2 == 0: q = 0 for i2 in range((len(z) // 2)): z1 += z[q::len(z)//2] q += 1 else: q = 0 for i2 in range((len(z) // 2) + 1): z1 += z[q::len(z)//2+1] q += 1 new_deck = ''.join(z1) return new_deck #--------------------------------------- def show_table_cards(cards, m): z = [] a = cards.strip('|') b = a.split('||') for i in b: z.append('|' + i + '|') if m >= len(z): z1 = ''.join(z[0:]) print('-'*(7+len(z1))) print('Table:',z1) print('-'*(7+len(z1))) else: z1 = ''.join(z[abs(len(z) - m):]) print('-'*(11+len(z1))) print('Table:'+' ....'+z1) print('-'*(11+len(z1))) #----------------------------------------- |
| # 6330261921 (20.00) 114 (2021-02-08 08:21) def peek_kth_card(cards, k): k-= 1 the_kth_card = cards[4*k:4*k+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): k-=1 a = cards[4*k:4*k+4] b = cards.split(a) c = ''.join(b) new_cards = c return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck [:4*n] new_deck = deck [4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck [4*m:] b =deck [:4*m] new_deck = a+b return new_deck #--------------------------------------- def shuffle(deck): g = deck.strip('|').split('|') n = len(g)//2 b = deck.strip('|').split('||') c = b[0:n] front = g[:n+1:] back = b[int(round(len(b)/2+0.1))::] front[1::2] = back new_deck = front new_deck = '|'+str(('||').join(new_deck))+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): b = cards .strip('|').split('||') n = len(b) c = cards[:(-m)*4-1:-1][::-1] e = n-m aa = 'Table: '+('....'*e)[:-5:-1]+c print('-'*len(aa)) print(aa) print('-'*len(aa)) #----------------------------------------- |
| # 6330262521 (20.00) 115 (2021-02-04 16:15) def peek_kth_card(cards, k): return cards[(k-1)*4:k*4] #--------------------------------------- def remove_kth_card(cards, k): return cards[:(k-1)*4] + cards[k*4:] #--------------------------------------- def deal_n_cards(deck, n): return deck[:n*4], deck[n*4:] #--------------------------------------- def cut(deck, m): left, right = deal_n_cards(deck, m) return right + left #--------------------------------------- def shuffle(deck): half = ((len(deck) // 4)//2)*4 d = deck[:half] + deck[-half:] buf = [" "]*len(d) left, right = deal_n_cards(d, half//4) left = list(left) right = list(right) buf[0::8] = left[0::4] buf[1::8] = left[1::4] buf[2::8] = left[2::4] buf[3::8] = left[3::4] buf[4::8] = right[0::4] buf[5::8] = right[1::4] buf[6::8] = right[2::4] buf[7::8] = right[3::4] s = ''.join(buf) + deck[half:-half] return s #--------------------------------------- def show_table_cards(cards, m): z = 1-(m//(len(cards)//4)) cards = z * "...." + cards[-(m*4):] show = 'Table: ' + ''.join(cards) dash = '-' * len(show) print(dash) print(show) print(dash) #----------------------------------------- |
| # 6330263121 (15.03) 116 (2021-02-08 08:53) def peek_kth_card(cards, k): the_kth_card=cards[4*(k-1):k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): a=cards[4*(k-1):k*4] d=cards.split(f'{a}') new_cards=''.join(d) return new_cards #--------------------------------------- def deal_n_cards(deck, n): new_deck=deck[4*(n):len(deck)+1] d=deck.split(f'{new_deck}') cards=''.join(d) return cards, new_deck #--------------------------------------- def cut(deck, m): a=deck[4*(m):len(deck)+1] d=deck.split(f'{a}') c=''.join(d) new_deck=a+c return new_deck #--------------------------------------- def show_table_cards(cards, m): a=int(f'{(len(cards))/4:.0f}') b=cards[4*(a-m):(a*4)+1] if m >=a: print('-----------------------') print(f'Table: {cards}') print('-----------------------') else: print('-----------------------') print(f'....{b}') print('-----------------------') #----------------------------------------- |
| # 6330264821 (19.75) 117 (2021-02-07 09:51) def peek_kth_card(cards, k): a = cards.split("|") b = a[1::2] the_kth_card = '|'+b[k-1]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): a = cards.split("|") b = a[1::2] d = b[0:k-1:1]+b[k::1] g = min(len(b)-1,1) h = len(b) e = '||'.join(d) new_cards = '|'*(g)+e+'|'*(g) return new_cards #--------------------------------------- def deal_n_cards(deck, n): a = deck.split("|") b = a[1::2] g = min(len(b)-1,1) c = '|'+'||'.join(b[0:n:1])+'|' d = '|'*g+'||'.join(b[n:])+'|'*g cards = c new_deck = d return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck.split("|") b = a[1::2] c = '|'+'||'.join(b[m::1]+b[:m])+'|' new_deck = c return new_deck #--------------------------------------- def shuffle(deck): a = deck.split('|') b = a[1::2] c = b[0:(len(b)+1)//2:1] d = b[(len(b)+1)//2:] e = a[1::2] e[1::2] = d[0::1] e[::2] = c[0::1] f = '|'+'||'.join(e)+'|' new_deck = f return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards.split("|") b = a[1::2] c = '|'+'||'.join(b[-m::1])+'|' d = max(len(b), m) e = (d-m) f = min(e,1) g = min((m+1),len(b)) print('-------'+'----'*(g)) print('Table: '+('....')*f + c) print('-------'+'----'*(g)) #----------------------------------------- |
| # 6330265421 (20.00) 118 (2021-02-05 23:36) def peek_kth_card(cards, k): the_kth_card = str(cards[(k-1)*4:4*k:1]) return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*(k-1)] + cards[k*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*(n)] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4:] + deck[0:4*(m)] return new_deck #--------------------------------------- def shuffle(deck): new_deck = ['']*(len(deck)//4) right = deck[-((len(deck)//4)//2)*4:] left = deck[:(((len(deck)//4)+1)//2)*4:] right = right[1:-1:].split("||") left = left[1:-1:].split("||") new_deck[::2] = left new_deck[1::2] = right new_deck = "||".join(new_deck) new_deck = "|"+new_deck+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): left = len(cards)//4-len(cards[-(m*4):])//4 Min = min(len("....")//4,left) x = cards[-(m*4):] print("--------"+("-"*(len(("...."*Min)+x)-1))) print("Table: "+("...."*Min)+x) print("--------"+("-"*(len(("...."*Min)+x)-1))) #----------------------------------------- |
| # 6330266021 (20.00) 119 (2021-02-08 22:59) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):(4*k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1)] + cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): w = deck[1:-1] w = w.split("||") cher = w[0:int(len(w)/2+0.5)] fond = w[int(len(w)/2+0.5):len(deck)] z = [0]*len(w) z[0::2],z[1::2] = cher,fond new_deck = "|" + "||".join(z) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): noey = min(len(cards)/4, m) kaew = cards[-4*m:] ft = "...."*int((len(cards)/4-noey)**(1/100000)) y = "Table: "+ ft + kaew print("-"*(len(y))) print(y) print("-"*(len(y))) #----------------------------------------- |
| # 6330267721 (18.13) 120 (2021-02-07 21:36) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[k*0:4*(k-1)]+cards[4*k:16*k**0] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[0:4*m] new_deck = deck[4*m:] + deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): deck = deck.split("||") deck = "|,|".join(deck) deck = deck.split(",") lenght = len(deck) rl = len(deck)//2 ll = len(deck)-rl left = deck[:ll] right = deck[ll:] new_deck = [] new_deck = [""]*(len(left)+len(right)) i = 0 nl = 0 nr = 0 while i < len(new_deck): if i%2 ==0: new_deck[i] = left[nl] i += 1 nl += 1 else : new_deck[i] = right[nr] i +=1 nr +=1 new_deck = "".join(new_deck) return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards.split('||') cards = '|,|'.join(cards) cards = cards.split(',') table = cards[:-m-1:-1] table.reverse() countdot = 0 if len(table) < len(cards): countdot = 4 else : countdot = 0 table =''.join(table) countline = 7+len(table) + countdot print('-'*int(countline)) print("table: "+"."*countdot + table) print("-"*int(countline)) #----------------------------------------- |
| # 6330268321 (19.33) 121 (2021-02-07 21:02) def peek_kth_card(cards, k): the_kth_card=cards[(k-1)*4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards=cards.strip("|").split("||") new_cards=cards[0:k-1]+cards[k::] new_cards="|"*int(k!=0)+"||".join(new_cards)+"|"*int(k!=0) return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck=deck.strip("|").split("||") cards=deck[0:n:] cards="|"+"||".join(cards)+"|" new_deck=deck[n::] new_deck="|"*int(n!=len(deck))+"||".join(new_deck)+"|"*int(n!=len(deck)) return cards, new_deck #--------------------------------------- def cut(deck, m): deck=deck.strip("|").split("||") new_deck=deck[m::]+deck[0:m] new_deck="|"+"||".join(new_deck)+"|" return new_deck #--------------------------------------- def shuffle(deck): deck=deck.strip("|").split("||") deck1=deck[0:(len(deck)+1)//2] deck2=deck[(len(deck)+1)//2::] new_deck=[0]*len(deck) new_deck[0::2]=deck1 new_deck[1::2]=deck2 new_deck="|"+"||".join(new_deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): a=cards.strip("|").split("||") b=a[-m::] d="|"+"||".join(b)+"|" c=min(len(a)-m,1) print("-"*len("Table: "+"...."*c+"|"+"||".join(b)+"|")) print("Table: "+"...."*c+"|"+"||".join(b)+"|") print("-"*len("Table: "+"...."*c+"|"+"||".join(b)+"|")) #----------------------------------------- |
| # 6330269021 (18.83) 122 (2021-02-07 02:08) def peek_kth_card(cards, k): li = cards.split("|") new_li = [x for x in li if x != ""] the_kth_card = "|" + new_li[k-1] + "|" return the_kth_card #--------------------------------------- def remove_kth_card (cards, k): li = cards.split("|") new_li = [x for x in li if x != ""] new_li.pop(k-1) new_cards = "|" + "||".join(new_li) + "|" return new_cards #--------------------------------------- def deal_n_cards(deck, n): li = deck.split("|") new_li = [x for x in li if x != ""] cards = "|" + "||".join(new_li[:n]) + "|" new_deck = "|" + "||".join(new_li[n:]) + "|" return cards, new_deck #--------------------------------------- def cut(deck, m): li = deck.split("|") new_li = [x for x in li if x != ""] cut_list = new_li[m:] + new_li[:m] new_deck = "|" + "||".join(cut_list) + "|" return new_deck #--------------------------------------- def shuffle(deck): li = deck.split("|") new_li = [x for x in li if x != ""] first = new_li[:round(len(new_li)/2)] second = new_li[round(len(new_li)/2):] shuffled = [None]*(len(new_li)) shuffled[::2] = first shuffled[1::2] = second new_deck = "|" + "||".join(shuffled) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): li = cards.split("|") new_li = [x for x in li if x != ""] card_out = new_li[-m:] if m < len(new_li): out = "...." + "|" + "||".join(card_out) + "|" else: out = "|" + "||".join(card_out) + "|" print("-"*(7+len(out))) print(f"Table: {out}") print("-"*(7+len(out))) #----------------------------------------- |
| # 6330270521 (18.83) 123 (2021-02-07 20:36) def peek_kth_card(cards, k): a = cards[1:-1].split("||") the_kth_card = "|" + a[k-1] + "|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): a = cards[1:-1].split("||") a.pop(k-1) b = '||'.join(a) new_cards = "|" + b + "|" return new_cards #--------------------------------------- def deal_n_cards(deck, n): a = deck[1:4*n-1].split("||") b = '||'.join(a) cards = "|" + b + "|" x = deck[4*n+1:-1].split("||") y = '||'.join(x) new_deck = "|" + y + "|" return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m::] + deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): a = deck[1:-1].split("||") b = a[:] b[::2] = a[:((len(a)+1)//2)] b[1::2] = a[((len(a)+1)//2):] n = '||'.join(b) new_deck = "|" + n +"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards[1:-1].split("||") x = min(1,max(len(a)-m,0)) b = cards[-(min(len(a),m))*4+1:-1].split("||") b1 = "||".join(b) x1 = "...."*x ans = x1 + "|" + b1 + "|" print("-------"+("----"*x)+("----"*min(len(a),m))) print("Table: " + ans) print("-------"+("----"*x)+("----"*min(len(a),m))) #----------------------------------------- |
| # 6330271121 (20.00) 124 (2021-02-05 09:47) def peek_kth_card(cards, k): x = cards.split('|') the_kth_card = '|'+str(x[k*2-1])+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x = cards.split('|') y = x[0:k*2-1:]+x[k*2+1::] new_cards = '|'.join(y) return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:n*4:] new_deck = deck[n*4::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4::]+deck[:m*4:] return new_deck #--------------------------------------- def shuffle(deck): x = deck.split('|') y = x[1::2] a = int((len(y)+1)/2) x[1::4] = y[:a:] x[3::4] = y[a::] new_deck = '|'.join(x) return new_deck #--------------------------------------- def show_table_cards(cards, m): y = min(len(cards)-m*4,1) a = 'Table: ' + '....'*y + cards[-(m*4)::] b = '-'*len(a) print(b) print(a) print(b) #----------------------------------------- |
| # 6330272821 (16.67) 125 (2021-02-08 23:34) def peek_kth_card(cards, k): cards_list = cards.strip("|").split("||") the_kth_card = "|" + cards_list[k-1] + "|" return the_kth_card # --------------------------------------- def remove_kth_card(cards, k): cards_list = cards.strip("|").split("||") del cards_list[k-1] new_cards = "|" + "||".join(cards_list) + "|" return new_cards # --------------------------------------- def deal_n_cards(deck, n): deck_list = deck.strip("|").split("||") new_deck_list = deck_list[n:] new_deck = "|"+"||".join(new_deck_list)+"|" cards_list = deck_list[:n] cards = "|"+"||".join(cards_list)+"|" return cards, new_deck # --------------------------------------- def cut(deck, m): deck_list = deck.strip("|").split("||") deck_cuted = deck_list[:m] del deck_list[:m] new_deck = deck_list + deck_cuted new_deck = "|" + "||".join(new_deck) + "|" return new_deck # --------------------------------------- def shuffle(deck): deck_list = deck.strip("|").split("||") yellow_list, green_list = deck_list[:(len(deck_list)//2)+1], deck_list[(len(deck_list)//2)+1:] new_deck_list = [""] * len(deck_list) new_deck_list[::2], new_deck_list[1::2] = yellow_list, green_list new_deck = "|" + "||".join(new_deck_list) + "|" return new_deck # --------------------------------------- def show_table_cards(cards, m): cards_list = cards.strip("|").split("||") x = -1*m cards_picked_list = cards_list[x:] cards_picked = "|" + "||".join(cards_picked_list) + "|" print("-------" + "----"*int(m<len(cards_list)) + "----"*len(cards_picked_list)) print("Table: " + "...."*int(m<len(cards_list)) + cards_picked) print("-------" + "----"*int(m<len(cards_list)) + "----"*len(cards_picked_list)) # ----------------------------------------- |
| # 6330273421 (20.00) 126 (2021-02-05 22:50) def peek_kth_card(cards, k): cards=cards[1:-1] cards1=cards.split('||') k-=1 the_kth_card='|'*(1-10**len(cards1)%10)+cards1[k]+'|'*(1-10**len(cards1)%10) return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards=cards[1:-1] cards1=cards.split('||') k-=1 new_cards2= cards1[:k]+cards1[k+1:] new_cards3='||'.join(new_cards2) new_cards = '|'*(1-10**len(new_cards2)%10)+new_cards3+'|'*(1-10**len(new_cards2)%10) return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck=deck[1:-1] deck1=deck.split('||') c=deck1[:n] c1='||'.join(c) cards='|'+c1+'|' nd=deck1[n:] nd1='||'.join(nd) new_deck ='|'*(1-10**len(nd1)%10)+nd1+'|'*(1-10**len(nd1)%10) return cards, new_deck #--------------------------------------- def cut(deck, m): deck=deck[1:-1] deck1=deck.split('||') deck2=deck1[m:]+deck1[:m] deck3='||'.join(deck2) new_deck='|'*(1-10**len(deck3)%10)+deck3+'|'*(1-10**len(deck3)%10) return new_deck #--------------------------------------- def shuffle(deck): deck=deck[1:-1] d1=deck.split('||') x='0 '*len(d1) newdeck=x.split() newdeck[::2]=d1[:(len(d1)+1)//2] newdeck[1::2]=d1[(len(d1)+1)//2:] x2='||'.join(newdeck) new_deck='|'*(1-10**len(x2)%10)+x2+'|'*(1-10**len(x2)%10) return new_deck #--------------------------------------- def show_table_cards(cards, m): cards=cards[1:-1] cards1=cards.split('||') a=m//len(cards1) b=10**a%10 sc=cards1[(len(cards1)-m)*b:] sc1='||'.join(sc) sc2='|'*(1-10**m%10)+sc1+'|'*(1-10**m%10) z='Table: '+(b)*'....'+sc2 print('-'*len(z)) print(z) print('-'*len(z)) #----------------------------------------- |
| # 6330274021 (20.00) 127 (2021-02-07 20:15) def peek_kth_card(cards, k): the_kth_card = cards.split("|") the_kth_card = the_kth_card[1::2] the_kth_card = "|"*min([1,len(the_kth_card)])+the_kth_card[k-1]+"|"*min([1,len(the_kth_card)]) return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards.split("|") new_cards = new_cards[1::2] del new_cards[k-1] new_cards = "|"*min([1,len(new_cards)])+"||".join(new_cards)+"|"*min([1,len(new_cards)]) return new_cards #--------------------------------------- def deal_n_cards(deck, n): new_deck = deck.split("|") new_deck = new_deck[1::2] cards = new_deck[:n] cards = "|"*min([1,len(cards)])+"||".join(cards)+"|"*min([1,len(cards)]) new_deck = new_deck[n:] new_deck = "|"*min([1,len(new_deck)])+"||".join(new_deck)+"|"*min([1,len(new_deck)]) return cards, new_deck #--------------------------------------- def cut(deck, m): deck = deck.split("|") deck = deck[1::2] a = deck[:m] new_deck = deck[m:]+a new_deck = "|"*min([1,len(new_deck)])+"||".join(new_deck)+"|"*min([1,len(new_deck)]) return new_deck #--------------------------------------- def shuffle(deck): import math deck = deck.split("|") deck = deck[1::2] a = len(deck) new_deck = [0]*a b = math.ceil(a/2) new_deck[::2] = deck[0:b] new_deck[1::2] = deck[b:] new_deck = "|"*min([1,len(new_deck)])+"||".join(new_deck)+"|"*min([1,len(new_deck)]) return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards.split("|") cards = cards[1::2] a = len(cards) cards = cards[::-1] cards = cards[:m] cards = cards[::-1] cards = "|"+"||".join(cards)+"|" print("-"*(7+(4*((max(min(1,a-m),0))+min(a,m))))) print("Table: "+ "...."*(max(min(1,a-m),0))+cards) print("-"*(7+(4*((max(min(1,a-m),0))+min(a,m))))) #----------------------------------------- |
| # 6330275721 (18.22) 128 (2021-02-07 17:57) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):(4*k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): the_kth_card = cards[4*(k-1):(4*k)] a1 = cards.split(the_kth_card) a2 = "".join(a1) new_cards = a2 return new_cards #--------------------------------------- def deal_n_cards(deck, n): b1 = deck[:(4*n)] b2 = deck[(4*n):] cards = b1 new_deck = b2 return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(4*m):] + deck[:(4*m)] return new_deck #--------------------------------------- def shuffle(deck): x = deck.split("|")[1:-1:2] xt1 = x[:(len(x)+1)//2] xt2 = x[(len(x)+1)//2::] x[1::2] = xt2 x[0::2] = xt1 x = "|"+"||".join(x)+"|" new_deck = x return new_deck #--------------------------------------- def show_table_cards(cards, m): y = cards[1:-1].split("||") y1 = y[-m:] y2 = "|"+"||".join(y1)+"|" z = "Table: "+"..."*min([1, len(y)-m])+str(y2) print("-"*len(z)) print(z) print("-"*len(z)) #----------------------------------------- |
| # 6330276321 (20.00) 129 (2021-02-05 20:53) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k:] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*(k-1)] + cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): selected_cards = deck[0:4*m:] cut_deck = deck[4*m:] new_deck = cut_deck + selected_cards return new_deck #--------------------------------------- def shuffle(deck): n_right = int(len(deck)/4) // 2 n_left = int(len(deck)/4) - n_right half_left = deck[0 : 4*n_left :] half_left = half_left[1:-1] half_left = half_left.split("||") half_right = deck[4*n_left :] half_right = half_right[1:-1] half_right = half_right.split("||") new_deck = [""] * int(len(deck)/4) new_deck[0::2] = half_left new_deck[1::2] = half_right new_deck = "|" + "||".join(new_deck) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): show_cards = cards[-(4*m) : ] try : n = int((len(cards)/4 - m)/abs(len(cards)/4 - m)) except ZeroDivisionError : n = 0 data = "Table: " + "...."*n + show_cards print("-" * len(data)) print("Table:", "...."*n + show_cards) print("-" * len(data)) #----------------------------------------- |
| # 6330277021 (20.00) 130 (2021-02-07 10:36) def peek_kth_card(cards, k): x1 = cards[1:-1:1] x1 = x1.split("||") the_kth_card = "|" + x1[k-1] + "|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x2 = cards[1:-1:1] x2 = x2.split("||") x2 = x2[:k-1:] + x2[k::] new_cards = "|" * min([1, len(x2)]) + "||".join(x2) + "|" * min([1, len(x2)]) return new_cards #--------------------------------------- def deal_n_cards(deck, n): x3 = deck[1:-1:1] x3 = x3.split("||") x3_1 = x3[:n:] cards = "|" + "||".join(x3_1) + "|" x3_2 = x3[n::] new_deck = "|" * min([1, len(x3_2)]) + "||".join(x3_2) + "|" * min([1, len(x3_2)]) return cards, new_deck #--------------------------------------- def cut(deck, m): x4 = deck[1:-1:1] x4 = x4.split("||") x4 = x4[m::] + x4[:m:] new_deck = "|" + "||".join(x4) + "|" return new_deck #--------------------------------------- def shuffle(deck): x5 = deck[1:-1:1] x5 = x5.split("||") x5_l = x5[0:int((len(x5)+1)/2):1] x5_r = x5[int((len(x5)+1)/2)::] x5_0 = [''] * len(x5) x5_0[::2] = x5_l x5_0[1::2] = x5_r new_deck = "|" + "||".join(x5_0) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): x6 = cards[1:-1:1] x6 = x6.split("||") x6_1 = x6[-m::] x6_s = "|" + "||".join(x6_1) + "|" Table = "Table: " + "...." * min([1, len(x6)-m]) + x6_s print("-" * len(Table)) print(Table) print("-" * len(Table)) #----------------------------------------- |
| # 6330278621 (20.00) 131 (2021-02-08 14:45) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):(4*k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x = cards[4*(k-1):(4*k)] y = cards.split(x) new_cards = y[0] + y[1] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[(4*n):] return cards, new_deck #--------------------------------------- def cut(deck, m): x = deck[:4*m] y = deck[4*m:] new_deck = y + x return new_deck #--------------------------------------- def shuffle(deck): x = deck[1:-1] x = x.split('||') y = x[:(len(x)+1)//2] z = x[(len(x)+1)//2:] a = ['0'] * len(x) a[::2] = y[:] a[1::2] = z[:] new_deck = '|'+'||'.join(a)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): x = cards[1:-1] x = x.split('||') y = x[-1:-m-1:-1] y = y[::-1] t = '|'+'||'.join(y) + '|' z = '....' * min(1,len(x)-m) k = z + t print('-'*7 + '-'*len(k)) print('Table:'+' '+k) print('-'*7 + '-'*len(k)) #----------------------------------------- |
| # 6330279221 (20.00) 132 (2021-02-07 01:02) def peek_kth_card(cards, k): the_kth_card = cards[4*(int(k)-1):4*int(k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*(int(k)-1)] + cards[4*int(k):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*int(n)] new_deck = deck[4*int(n):] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*int(m):] + deck[0:4*int(m)] return new_deck #--------------------------------------- def shuffle(deck): d1 = deck.split('|') d2 = d1[1::2] s = d2[:(len(d2)+1)//2] k = d2[(len(d2)+1)//2:] newdeck = [0]*len(d2) newdeck[::2] = s newdeck[1::2] = k new_deck = '|' + '||'.join(newdeck) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): table = 'Table:' + ' ' + '....'*min(max(((len(cards)//4)-m),0),1) + cards[-4*m:] print('-'*len(table)) print(table) print('-'*len(table)) #----------------------------------------- |
| # 6330280821 (20.00) 133 (2021-02-05 23:48) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*(k-1)]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): x = deck[1:-1].split("||") b = x[0:(len(x)+1)//2] c = x[(len(x)+1)//2:] x[0::2] = b x[1::2] = c new_deck = "|"+"||".join(x)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): x = cards[1:-1].split("||") y = "...."*(m<len(x)) a = cards[-1*m*4:] b = "Table: " + y + a c = "-"*len(b) print(c) print(b) print(c) #----------------------------------------- |
| # 6330281421 (20.00) 134 (2021-02-07 09:31) def peek_kth_card(cards, k): the_kth_card=cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*(k-1)]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): n = int((len(deck)+4)/8) f = deck[:4*n] b = deck[4*n:] new_deck = f[0:4*1]+b[0:4*1] + f[4*1:4*2]+b[4*1:4*2] + f[4*2:4*3]+b[4*2:4*3] + f[4*3:4*4]+b[4*3:4*4] + f[4*4:4*5]+b[4*4:4*5] + f[4*5:4*6]+b[4*5:4*6] + f[4*6:4*7]+b[4*6:4*7] + f[4*7:4*8]+b[4*7:4*8] + f[4*8:4*9]+b[4*8:4*9] + f[4*9:4*10]+b[4*9:4*10] + f[4*10:4*11]+b[4*10:4*11] + f[4*11:4*12]+b[4*11:4*12] + f[4*12:4*13]+b[4*12:4*13] + f[4*13:4*14]+b[4*13:4*14] +f[4*14:4*15]+b[4*14:4*15] + f[4*15:4*16]+b[4*15:4*16] + f[4*16:4*17]+b[4*16:4*17] + f[4*17:4*18]+b[4*17:4*18]+f[4*18:4*19]+b[4*18:4*19] + f[4*19:4*20]+b[4*19:4*20] + f[4*20:4*21]+b[4*20:4*21] + f[4*21:4*22]+b[4*21:4*22]+ f[4*22:4*23]+b[4*22:4*23] + f[4*23:4*24]+b[4*23:4*24] + f[4*24:4*25]+b[4*24:4*25] + f[4*25:4*26]+b[4*25:4*26] return new_deck #--------------------------------------- def show_table_cards(cards, m): number=int(len(cards)/4) print('-'*(11+4*min((number-1),m))) print('Table: '+'....'*min((int((len(cards))/4)-m),1)+cards[min(-m*4,number):]) print('-'*(11+4*min((number-1),m))) #----------------------------------------- |
| # 6330282021 (20.00) 135 (2021-02-04 18:18) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:((k-1)*4)+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(k-1)*4]+cards[((k-1)*4)+4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:n*4] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4:]+deck[0:m*4] return new_deck #--------------------------------------- def shuffle(deck): half_left = deck[0:int(((((len(deck)/4)+1)//2)*4))] half_right = deck[int(((((len(deck)/4)+1)//2)*4)):] list_left = half_left[1:int(len(half_left)-1)].split('||') list_right = half_right[1:int(len(half_right)-1)].split('||') new_left = ',0,'.join(list_left) + (',0'*(abs(((len(list_left)-len(list_right))-1)))) new_cardlist = new_left.split(',') new_cardlist[1::2] = list_right[::] new_deck = '|'+'||'.join(new_cardlist)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): table = cards[-1:-((m*4)+1):-1] table = table[::-1] table_card = '....'*(int(abs((len(cards)-(m*4))//(len(cards)-(m*4)-1)))) + table print('-'*(len(table_card)+7)) print('Table:',table_card) print('-'*(len(table_card)+7)) #----------------------------------------- |
| # 6330283721 (17.27) 136 (2021-02-05 23:46) def peek_kth_card(cards, k): a=cards[1:-1].split("||") the_kth_card="|"+a[k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): a=cards.split("|") a.pop(2*k) a.pop(2*k-1) new_cards="|".join(a) return new_cards #--------------------------------------- def deal_n_cards(deck, n): a=deck[1:-1].split("||") b=a[0:n] c=a[n:] cards="|"+"||".join(b)+"|" new_deck="|"+"||".join(c)+"|" return cards, new_deck #--------------------------------------- def cut(deck, m): a=deck[1:-1].split("||") new_deck="|"+("||").join(a[m:])+"|"+"|"+("||").join(a[0:m])+"|" return new_deck #--------------------------------------- def shuffle(deck): import math a1=deck[1:-1] a2=a1.split("||") b=a1.split("|") s=math.floor((len(a2)+1)/2) t=math.floor((len(b)+1)/2) n1=b[0:t] n2=a2[s:] n1[1::2]=n2 new_deck="|"+"||".join(n1)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): import math a=cards[1:-1].split("||") s= "...." b="|"+"||".join(a[-m:])+"|" c=min(0,(m-len(a))) cards= s *math.ceil(abs(c)/len(a))+b print("-----------------------") print("Table:",cards) print("-----------------------") #----------------------------------------- |
| # 6330284321 (20.00) 137 (2021-02-05 23:20) def peek_kth_card(cards, k): k = int(k) strat = 4 * k - 4 finish = 4 * k the_kth_card = cards[strat:finish] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): total = len(cards) peek_1 = cards[0:4*k-4] peek_2 = cards[4*k:total] new_cards = peek_1 + peek_2 return new_cards #--------------------------------------- def deal_n_cards(deck, n): n = int(n) the_end = len(deck) new_deck = deck[4 * n :the_end] cards = deck[0:4 * n] return cards, new_deck #--------------------------------------- def cut(deck, m): m = int(m) end_old_deck = len(deck) cutt = deck[0:4 * m] not_cutt = deck[4 * m :end_old_deck] new_deck = not_cutt + cutt return new_deck #--------------------------------------- def shuffle(deck): s = ("|" + deck + "|").split("||")[1:-1] cut_position = (len(s) + 1) // 2 first_cut = s[:cut_position] second_cut = s[cut_position:] ans = [""] * len(s) ans[::2] = first_cut ans[1::2] = second_cut new_deck = "|" + "||".join(ans) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): m = min(m, len(cards) // 4) clause = (min(0, max(m - len(cards) // 4 , -1)) + 2) % 2 show = "Table: " + "...." * clause + cards[-4*m:] print("-" * len(show)) print(show) print("-" * len(show)) #----------------------------------------- |
| # 6330285021 (20.00) 138 (2021-02-07 22:06) def peek_kth_card(cards, k): the_kth_card = cards[(4*k)-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(4*k)-4] + cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:(4*n)] new_deck = deck[(4*n):] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(4*m):] + deck[:(4*m)] return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1].split("||") n = len(deck) x = deck[:(n+1)//2:] y = deck[(n+1)//2::] deck[0::2] = x deck[1::2] = y new_deck = "|" + "||".join(deck) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards[1:-1].split("||") l = len(cards) a = cards[-m::] b = "|" + "||".join(a) + "|" x = "Table:" + " " + "...."*(l-m>0) + b print("-"*len(x)) print("Table:" + " " + "...."*(l-m>0) + b) print("-"*len(x)) #----------------------------------------- |
| # 6330286621 (18.22) 139 (2021-02-06 18:19) def peek_kth_card(cards, k): the_kth_card=cards[(k-1)*4:k*4] ;return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards.replace(cards[(k-1)*4:k*4],"") ;return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[slice(0,n*4)] ##ex a[slice(3, 5)] or x = slice(3, 5);print(a[x]) new_deck=deck[slice(n*4,len(deck))] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deal_n_cards(deck,m)[1]+deal_n_cards(deck,m)[0] return new_deck #--------------------------------------- def shuffle(deck): n=(len(deck)//4)//2 ldeck=deck[slice(0,-n*4)] rdeck=deck[slice(-n*4,len(deck))] ldeck=ldeck.split("|") ;ldeck=ldeck[1::2] #;print(ldeck) rdeck=rdeck.split("|") ;rdeck=rdeck[1::2] #;print(rdeck) new_deck=[None]*(len(ldeck)+len(rdeck)) new_deck[::2]=ldeck new_deck[1::2]=rdeck new_deck="|"+"||".join(new_deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): table=cards[slice(-m*4,len(cards))] k=(len(cards)//4-m) table=("...."*int(k//abs(k+0.000000000000001)) )+table table="Table: "+table print("-"*len(table)) print(table) print("-"*len(table)) #----------------------------------------- |
| # 6330288921 (20.00) 140 (2021-02-08 00:28) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k-1)*4]+cards[(k)*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:(n)*4] new_deck = deck[(n)*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(m)*4:] + deck[:(m)*4] return new_deck #--------------------------------------- def shuffle(deck): q = deck[1:-1:] q = q.split('||') n = len(q) a = q[:((n+1)//2)] b = q[((n+1)//2):] w = ['e']*n w[::2] = a w[1::2] = b new_deck = '|'+'||'.join(w) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): n = min(len(cards)//4,m) a = cards[-(m*4)::] b = (len(cards)//4 - n) d = (len(cards)//4 - n) + 0.00000000000000001 e = "Table: " + "...."*int(b//d) + a print("-"*len(e)) print(e) print("-"*len(e)) #----------------------------------------- |
| # 6330289521 (20.00) 141 (2021-02-07 20:33) def peek_kth_card(cards, k): cards=cards[1:-1:].split("||") the_kth_card="|"+cards[k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): import math cards=cards[1:-1:].split("||") a=len(cards) cards.remove(cards[k-1]) cards="||".join(cards) new_cards=("|"*int(math.atan2(a-1,a-1)//0.7))+cards+("|"*int(math.atan2(a-1,a-1)//0.7)) return new_cards #--------------------------------------- def deal_n_cards(deck, n): import math deck=deck[1:-1:].split("||") cards=deck[0:n:] cards='||'.join(cards) cards="|"*int(math.atan2(len(cards),len(cards))//0.7)+cards+"|"*int(math.atan2(len(cards),len(cards))//0.7) new_deck=deck[n::] new_deck='||'.join(new_deck) new_deck=("|"*int(math.atan2(len(new_deck),len(new_deck))//0.7))+new_deck+("|"*int(math.atan2(len(new_deck),len(new_deck))//0.7)) return cards, new_deck #--------------------------------------- def cut(deck, m): import math deck=deck[1:-1].split("||") a=len(deck) deck1=deck[0:m:] deck1="||".join(deck1) deck1=("|"*int(math.atan2(len(deck1),len(deck1))//0.7))+deck1+("|"*int(math.atan2(len(deck1),len(deck1))//0.7)) deck2=deck[m::] deck2="||".join(deck2) deck2=("|"*int(math.atan2(len(deck2),len(deck2))//0.7))+deck2+("|"*int(math.atan2(len(deck2),len(deck2))//0.7)) new_deck=deck2+deck1 return new_deck #--------------------------------------- def shuffle(deck): import math b=len(deck) deck=deck[1:-1].split("||") a=(int(len(deck)//2))+(int(len(deck))%2) deck2=deck[::] deck[1::2]=deck[a::] deck[::2]=deck2[:a:] deck=("|"*int(math.atan2(b,b)//0.7))+"||".join(deck)+("|"*int(math.atan2(b,b)//0.7)) new_deck=deck return new_deck #--------------------------------------- def show_table_cards(cards, m): import math cards=cards[1:-1:].split("||") show=cards[-m::] show="||".join(show) show="|"+show+"|" PP="Table: "+"...."*int((math.atan2((len(cards)-m),abs((len(cards)-m)))/0.7))+show print("-"*len(PP)) print(PP) print("-"*len(PP)) #----------------------------------------- |
| # 6330290021 (20.00) 142 (2021-02-07 16:36) def peek_kth_card(cards, k): cards = cards[1:-1].split('||') the_kth_card = cards[k-1] the_kth_card = '|' + the_kth_card + '|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k*4)-4:] + cards[k*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): new_deck = deck[n*4:] d = deck[1:-1].split('||') cards = d[:n] cards = ('||').join(cards) cards = '|' + cards + '|' return cards, new_deck #--------------------------------------- def cut(deck, m): d = deck[1:-1].split('||') select = d[:m] new_deck = d[m:]+ select new_deck = ('||').join(new_deck) new_deck = '|' + new_deck + '|' return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1].split('||') left = deck[0:((len(deck)+1)//2)] right = deck[(len(deck)+1)//2::] new_deck = [0]*len(deck) new_deck[0::2] = left[::] new_deck[1::2] = right[::] new_deck = ('||').join(new_deck) new_deck = '|' + new_deck + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards[1:-1].split('||') l = len(cards) p = cards[-m:len(cards)] p = '| |'.join(p) p = ' |' + p + '|' dot = cards[0:m] dot = ''.join(dot) f = [] f.append(dot) f[0] = '....' f.append(p) cards = ' '.join(f).split() cards = cards[-l:] cards = ''.join(cards) print('-'*(len('Table: ')+len(cards))) print('Table:',cards) print('-'*(len('Table: ')+len(cards))) #----------------------------------------- |
| # 6330291721 (20.00) 143 (2021-02-06 15:34) def peek_kth_card(cards, k): the_kth_card = cards[(k*4)-4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k*4)-4:] + cards[k*4::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:n*4:] new_deck = deck[n*4::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4::] + deck[:m*4:] return new_deck #--------------------------------------- def shuffle(deck): a=deck[1:-1:] b=a.split("||") left=b[:(len(b)+1)//2:] right=b[(len(b)+1)//2::] n=[0]*len(b) n[::2]=left[::] n[1::2]=right[::] new_deck = "|"+"||".join(n)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): n=(len(cards)//4)>m a="Table:" +" "+("...."*bool(n))+ cards[-(m*4)::] print("-"*len(a)) print(a) print("-"*len(a)) #----------------------------------------- |
| # 6330292321 (20.00) 144 (2021-02-06 10:25) def peek_kth_card(cards, k): the_kth_card = cards[(k*4)-4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(k*4)-4]+cards[k*4::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:(n*4)] new_deck = deck[n*4::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(m*4):]+deck[0:(m*4)] return new_deck #--------------------------------------- def shuffle(deck): c = deck[1:-1].split("||") ans = [0]*(len(c)) l = c[0:((len(c)+1)//2)] r = c[((len(c)+1)//2):] ans[0::2] = l ans[1::2] = r new_deck = "|"+"||".join(ans)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): c = cards[1:-1].split("||") ans = '|'+'||'.join(c[-m::1])+'|' n = 1*(len(c)-m>0) ans = "Table: "+"...."*n+ans print("-"*len(ans)) print(ans) print("-"*len(ans)) #----------------------------------------- |
| # 6330293021 (18.67) 145 (2021-02-07 13:26) def peek_kth_card(cards, k): x = cards.split('||') x[0] = x[0][1:] x[len(x)-1] = x[len(x)-1][0:2] the_kth_card = '|'+x[k-1]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x = cards.split('||') x[0] = x[0][1:] x[len(x)-1] = x[len(x)-1][0:2] x.remove(x[k-1]) if len(x) == 0: new_cards = '' else: c = '||'.join(x) new_cards = '|'+c+'|' return new_cards #--------------------------------------- def deal_n_cards(deck, n): x = deck.split('||') x[0] = x[0][1:] x[len(x)-1] = x[len(x)-1][0:2] cards = x[0:n] new_deck = x[n:] if len(new_deck) == 0 : new_deck = '' t = '||'.join(cards) cards = '|'+t+'|' else: c = '||'.join(new_deck) new_deck = '|'+c+'|' t = '||'.join(cards) cards = '|'+t+'|' return cards, new_deck #--------------------------------------- def cut(deck, m): x = deck.split('||') x[0] = x[0][1:] x[len(x)-1] = x[len(x)-1][0:2] deck = x[0:m] new_deck = x[m:] if len(new_deck) == 0 or len(deck) == 0: new_deck = '' deck = '' else: c = '||'.join(new_deck) new_deck = '|'+c+'|' t = '||'.join(deck) deck = '|'+t+'|' new_deck = new_deck+deck return new_deck #--------------------------------------- def shuffle(deck): x = deck.split('||') x[0] = x[0][1:] x[len(x)-1] = x[len(x)-1][0:2] if len(x)%2 == 0 : a = x[:(len(x)//2)] b = x[(len(x)//2):] else: a = x[:(len(x)//2)+1] b = x[(len(x)//2)+1:] c = [] d = 0 while d<len(a) : c.append(a[d]) if len(a)>len(b) and d == len(a)-1: pass else: c.append(b[d]) d = d+1 new_deck = '|'+'||'.join(c)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): x = cards.split('||') x[0] = x[0][1:] x[len(x)-1] = x[len(x)-1][0:2] new_deck = x[len(x)-m:] if m<len(x) : H ='Table: ....'+'|'+'||'.join(new_deck)+'|' elif m>=len(x) : H ='Table: '+cards print('-'*len(H)) print(H) print('-'*len(H)) #----------------------------------------- |
| # 6330294621 (20.00) 146 (2021-02-07 22:19) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:((k-1)*4)+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(k-1)*4]+cards[((k-1)*4)+4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:(n*4)] new_deck = deck[(n*4):] return cards, new_deck #--------------------------------------- def cut(deck, m): selected_cards = deck[:(4*m)] left_card = deck[(4*m):] new_deck = left_card+selected_cards return new_deck #--------------------------------------- def shuffle(deck): deck2 = deck[1:-1] new_deck = deck2.split('||') left_side_deck = new_deck[0:(len(new_deck)+1)//2] right_side_deck = new_deck[(len(new_deck)+1)//2:] new_deck[1::2] = right_side_deck new_deck[0::2] = left_side_deck new_deck = '||'.join(new_deck) new_deck = '|'+ new_deck +'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): o = len(cards)//4 dot_ = ('-')*len('Table: '+'....'*(min(o-m,1))+cards[-(m*4):]) print (dot_) print ('Table: '+'....'*(min(o-m,1))+cards[-(m*4):]) print (dot_) #----------------------------------------- |
| # 6330295221 (20.00) 147 (2021-02-05 23:46) def peek_kth_card(cards, k): k = int(k) a = (k-1)*4 c = k*4 b = cards[a:c] the_kth_card = b return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): k = int(k) a = (k-1)*4 c = k*4 b = cards[:a] + cards[c:] new_cards = b return new_cards #--------------------------------------- def deal_n_cards(deck, n): n = int(n) a = deck[:(n*4)] cards = a new_deck = deck[(n*4):] return cards, new_deck #--------------------------------------- def cut(deck, m): m = int(m) d = deck[:(m*4)] g = deck[(m*4):] new_deck = g + d return new_deck #--------------------------------------- def shuffle(deck): e = deck[1:-1] e = e.split("||") f1 = e[:(len(e)+1)//2] f2 = e[(len(e)+1)//2:] g = [0]*len(e) g[::2] = f1 g[1::2] = f2 new_deck = g new_deck = "|" + "||".join(new_deck) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): b = cards[1:-1] b = b.split("||") v = max(0, len(b)-m) v = min(1, v) v = max(0, v) v = "...."*v b = b[-m:] b = "|" + "||".join(b) + "|" c = "Table: " + v + b a = "-"*len(c) print(a) print(c) print(a) #----------------------------------------- |
| # 6330296921 (18.00) 148 (2021-02-08 16:51) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:((k-1)*4)+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(k-1)*4] + cards[(k-1)*4+4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:(n)*4] new_deck = deck[(n)*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4:] + deck[0:m*4] return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:] deck = deck.split("||") x = int(len(deck)/2+0.5) L = deck[0:x] R = deck[x:] new_deck = [0]*len(deck) new_deck[0::2] = L new_deck[1::2] = R new_deck = "|"+"||".join(new_deck) return new_deck #--------------------------------------- def show_table_cards(cards, m): diff = len(cards)-m*4 n = min(len(cards),m*4) Rightc = cards[-n:] t = "...."*min(1,diff) print((7+4*min(1,max(0,diff))+len(Rightc))*"-") print("table: "+t+Rightc) print((7+4*min(1,max(0,diff))+len(Rightc))*"-") #----------------------------------------- |
| # 6330298121 (18.89) 149 (2021-02-05 23:53) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): n = len(deck)/4 l = deck[:int(4*((n-1)//2+1))][1:-1] r = deck[int(4*((n-1)//2+1)):][1:-1] nl = l.split("|") + [""] nr = r.split("||") nl[1::2] = nr new_deck = "|" + "||".join(nl) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): scards = cards[:-4*m-1:-1] dscards = "...."+scards[::-1] ndscards = dscards[:-min(len(dscards),len(cards))-1:-1] print("-"*(7+len(ndscards))) print("Table: " + ndscards[::-1]) print("-"*(7+len(ndscards))) #----------------------------------------- |
| # 6330299821 (20.00) 150 (2021-02-06 00:13) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] return the_kth_card # --------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1)] + cards[4*k:] return new_cards # --------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck # --------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[:4*m] return new_deck # --------------------------------------- def shuffle(deck): a = deck[1:-1] a_list = a.split("||") hdl = (len(a_list)+1)//2 lh = a_list[:hdl] rh = a_list[hdl:] blank_deck = [""]*(len(deck)//4) blank_deck[::2] = lh blank_deck[1::2] = rh new_deck = "|"+ "||".join(blank_deck) + "|" return new_deck # --------------------------------------- def show_table_cards(cards, m): table1 = cards[(-4 * m):] table2 = "...." + table1 table3 = table2[-min(len(table2),len(cards)):] print ((7+len(table3)) * "-") print ("Table: " + table3) print ((7+len(table3)) * "-") # ----------------------------------------- |
| # 6330300721 (20.00) 151 (2021-02-07 11:56) def peek_kth_card(cards, k): cards = cards.split('|') the_kth_card = cards[(2*k-1)] the_kth_card = '|'+the_kth_card+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(4*k-4)]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): cut = deck[:4*m] new_deck = deck[4*m:]+cut return new_deck #--------------------------------------- def shuffle(deck): n = int(len(deck)/4) deck = deck.split('|') deck = deck[1::2] bedeck = deck[:int((len(deck)+1)//2)] afdeck = deck[int((len(deck)+1)//2):] u = [0]*n u[1::2] = afdeck u[::2] = bedeck new_deck = u new_deck = str(new_deck) new_deck = new_deck.replace("[", '') new_deck = new_deck.replace("]", '') new_deck = new_deck.replace("'", '|') new_deck = new_deck.replace(", ", '') return new_deck #--------------------------------------- def show_table_cards(cards, m): mx = min(m,int(len(cards)/4)) showcards = cards[-4*m:] w = min(int(len(cards)/4)-m,1) d = '....'*w k = '-'*(7+4*mx+len(d)) print(k) print('Table:', d+str(showcards)) print(k) #----------------------------------------- |
| # 6330301321 (20.00) 152 (2021-02-06 20:20) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*(k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1)] + cards[4*(k):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4:] + deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1].split('||') new_deck = ['']*len(deck) new_deck[0::2] = deck[:(len(deck)+1)//2] new_deck[1::2] = deck[(len(deck)+1)//2:] new_deck = '|'+'||'.join(new_deck)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): ncards = len(cards)//4 x = min(ncards, m) x = min(ncards-x,1) show = '....'*x + cards[(-4*m):] print('-------'+'-'*len(show)) print('Table: '+ show) print('-------'+'-'*len(show)) #----------------------------------------- |
| # 6330302021 (20.00) 153 (2021-02-08 22:38) def peek_kth_card(cards, k): the_kth_card = cards[(k*4)-4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k*4)-4] + cards[k*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:(n*4)] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(m*4):]+deck[0:m*4] return new_deck #--------------------------------------- def shuffle(deck): deck22 = deck[1:-1].split("||") sumdeck = [0]*len(deck22) firsthalf = deck22[0:((len(deck22)+1)//2)] lasthalf = deck22[((len(deck22)+1)//2):] sumdeck[0::2] = firsthalf sumdeck[1::2] = lasthalf new_deck = "|"+"||".join(sumdeck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): card22 = cards[1:-1].split("||") cardLength = len(card22) show = "|"+"||".join(card22[-m:cardLength:1])+"|" add = int(bool(1*((m<cardLength)))) show = "Table: "+"...."*add+show print("-"*len(show)) print(show) print("-"*len(show)) #----------------------------------------- |
| # 6330303621 (19.50) 154 (2021-02-07 13:28) def peek_kth_card(cards, k): x = cards[1:-1].split('||') the_kth_card = "|"+x[k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x = cards[1:-1].split('||') new_cards = x[0:k-1]+x[k:len(x)+1] new_cards = '|'*(min(len(new_cards), 1))+'||'.join(new_cards)+'|'*(min(len(new_cards), 1)) return new_cards #--------------------------------------- def deal_n_cards(deck, n): x = deck[1:-1].split('||') cards = x[0:n] new_deck = x[n:len(x)+1] cards = '|'+'||'.join(cards)+'|' new_deck = '|'+'||'.join(new_deck)+'|' return cards, new_deck #--------------------------------------- def cut(deck, m): x = deck[1:-1].split('||') new_deck = x[m:len(x)+1]+x[0:m] new_deck = '|'+'||'.join(new_deck)+'|' return new_deck #--------------------------------------- def shuffle(deck): import math x = deck[1:-1].split('||') a = x[0:math.ceil(len(x)/2)] b = x[math.ceil(len(x)/2):len(x)+1] new_deck = x new_deck[0:len(x)+1:2] = a[0:len(a)+1] new_deck[1:len(x)+1:2] = b[0:len(b)+1] new_deck = '|'+'||'.join(new_deck)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): x = cards[1:-1].split('||') y = x[-m:len(x)+1] z = '|'+'||'.join(y)+'|' print("-"*(7+(4*(min((len(x)-min(len(x), m)), 1)))+(4*(min(len(x), m))))) print("Table: "+"."*(4*(min((len(x)-min(len(x), m)), 1)))+z) print("-"*(7+(4*(min((len(x)-min(len(x), m)), 1)))+(4*(min(len(x), m))))) #----------------------------------------- |
| # 6330304221 (20.00) 155 (2021-02-07 11:43) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*k-4] + cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:(4*n)] new_deck = deck[(4*n):] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): import math n = math.ceil(len(deck)/2/4) * 4 left = deck[0:n] right = deck[n:] l1, l2, l3, l4 = left[0::4], left[1::4], left[2::4], left[3::4] r1, r2, r3, r4 = right[0::4], right[1::4], right[2::4], right[3::4] lst = [0] * len(deck) lst[0::8], lst[1::8], lst[2::8], lst[3::8] = l1, l2, l3, l4 lst[4::8], lst[5::8], lst[6::8], lst[7::8] = r1, r2, r3, r4 new_deck = ''.join(lst) return new_deck #--------------------------------------- def show_table_cards(cards, m): # 4 * m -- > m ใบ # len(card) > 4 * m n = len(cards[-4*m::]) exceed = len(cards) > 4 * m print('-------' + '-' * (n + 4 * exceed)) print('Table: ' + '....' * exceed + (cards[-4*m::])) print('-------' + '-' * (n + 4 * exceed)) #----------------------------------------- |
| # 6330305921 (19.50) 156 (2021-02-04 15:15) def peek_kth_card(cards, k): the_kth_cards = cards[1:-1].split('||') the_kth_card = '|'+the_kth_cards[k-1]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x = cards[1:-1].split('||') y = x[0:k-1] + x[k:] new_cards = '|'*min(len(y),1)+'||'.join(y)+'|'*min(len(y),1) return new_cards #--------------------------------------- def deal_n_cards(deck, n): d = deck[1:-1].split('||') cards = '|' + '||'.join(d[0:n]) + '|' new_deck = '|' + '||'.join(d[n:]) + '|' return cards, new_deck #--------------------------------------- def cut(deck, m): d = deck[1:-1].split('||') new_deck = '|' + '||'.join(d[m:]+d[0:m]) + '|' return new_deck #--------------------------------------- def shuffle(deck): d = deck[1:-1].split('||') x = d[0:(len(d)+1)//2] y = d[((len(d)+1)//2):] z = [0]*len(d) z[0::2] = x z[1::2] = y new_deck = '|' + '||'.join(z) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): d = cards[1:-1].split('||') n = min(m, len(d)) s = d[-n:] show = "Table: "+'....'*(min(len(d)-n,1))+'|' + '||'.join(s) + '|' print('-'*len(show)) print(show) print('-'*len(show)) #----------------------------------------- |
| # 6330306521 (15.11) 157 (2021-02-08 22:18) def peek_kth_card(cards, k): cards=cards.split("|") cards=cards[1::2] the_kth_card="|"+cards[k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards=cards.split("|") cards=cards[1::2] cards.remove(cards[k-1]) new_cards=("|"+"||".join(cards)+"|")*(len(cards)>0) return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck.split("|") cards=cards[1::2] cards=cards[:n:] cards=("|"+"||".join(cards)+"|")*(len(cards)>0) new_deck=cards new_deck=deck.split("|") new_deck=new_deck[1::2] new_deck=new_deck[n::] new_deck=("|"+"||".join(new_deck)+"|")*(len(new_deck)>0) return cards, new_deck #--------------------------------------- def cut(deck, m): deck1=deck deck=deck.split("|") deck=deck[1::2] deck=deck[:m:] deck="||".join(deck) deck="|"+deck+"|" new_deck=deck1 new_deck=new_deck.split("|") new_deck=new_deck[1::2] new_deck=new_deck[m::] new_deck="||".join(new_deck) new_deck="|"+new_deck+"|" new_deck=new_deck+deck return new_deck #--------------------------------------- def shuffle(deck): deck=deck.split("|") deck=deck[1::2] l=deck[:int((len(deck)+1)/2):] r=deck[int((len(deck)+1)/2)::] new_deck=[""]*(len(deck)) new_deck[::2]=l new_deck[1::2]=r new_deck="|"+"||".join(new_deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): card=cards.split("|") card=card[1::2] cards="Table: "+"...."*((m-len(card))-1<0) cards+="|"+"||".join(card)+"|" print("-"*len(cards)) print(cards) print("-"*len(cards)) #----------------------------------------- |
| # 6330307121 (20.00) 158 (2021-02-08 23:46) def peek_kth_card(cards, k): card_list = cards.strip('|').split('||') the_kth_card = '|'+card_list[k-1]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(k-1)*4] + cards[((k-1)*4)+4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:(n*4)] new_deck = deck[(n*4):] return cards, new_deck #--------------------------------------- def cut(deck, m): deck_list = deck.strip('|').split('||') left = deck_list[:m] right = deck_list[m:] new_deck = '|'+'||'.join(right+left)+'|' return new_deck #--------------------------------------- def shuffle(deck): import math deck_list = deck.strip('|').split('||') lenght = len(deck_list) left = deck_list[:math.ceil(lenght/2)] right = deck_list[math.ceil(lenght/2):] new_deck = [' ']*lenght new_deck[::2] = left new_deck[1::2] = right new_deck = '|' + '||'.join(new_deck) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): card_list = cards.strip('|').split('||') reverse_card_list = card_list[::-1] lenght = len(card_list) table_card = reverse_card_list[:m] + ['....'] lenght2 = len(table_card) - 1 table = 'Table: ' + ''.join(table_card[m:lenght]) + '|' + '||'.join(table_card[:lenght2][::-1]) + '|' print('-'*len(table)) print(table) print('-'*len(table)) #----------------------------------------- |
| # 6330308821 (20.00) 159 (2021-02-04 22:40) def peek_kth_card(cards, k): l = cards[1:-1].split("||") the_kth_card = "|"+l[k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k-1)*4]+cards[k*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:n*4] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4:]+deck[:m*4] return new_deck #--------------------------------------- def shuffle(deck): n = int(len(deck)/4) n1 = int(n/2+0.5) deck1 = deck[1:n1*4-1].split("||") deck2 = deck[n1*4+1:-1].split("||") l = ["a"]*n l[0::2] = deck1 l[1::2] = deck2 new_deck = "|"+"||".join(l)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): print("-------"+"----"*int((len(cards)-m*4-1)/abs((-len(cards)+m*4+1)))+"-"*len(cards[(-1)*m*4::1])) print("Table: "+"...."*int((len(cards)-m*4-1)/abs((-len(cards)+m*4+1)))+cards[(-1)*m*4::1]) print("-------"+"----"*int((len(cards)-m*4-1)/abs((-len(cards)+m*4+1)))+"-"*len(cards[(-1)*m*4::1])) #----------------------------------------- |
| # 6330309421 (20.00) 160 (2021-02-08 23:58) def peek_kth_card(cards, k): int(k) xx = 4*(k-1) yy = 4*k the_kth_card = cards[xx:yy] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cc = len(cards) pt_1 = cards[0:4*(k-1)] pt_2 = cards[4*k:cc] new_cards = pt_1 + pt_2 return new_cards #--------------------------------------- def deal_n_cards(deck, n): int(n) ss = len(deck) new_deck = deck[4 * n :ss] cards = deck[0:4 * n] return cards, new_deck #--------------------------------------- def cut(deck, m): int(m) ll = len(deck) aa = deck[0:4 * m] bb = deck[4 * m :ll] new_deck = bb + aa return new_deck #--------------------------------------- def shuffle(deck): st = '|'+deck+'|' nd = st.split('||') rd = nd[1:-1:] lngth = int((len(rd)+1)/2) lft = rd[0:lngth] rght = rd[lngth:] dum = [0]*len(rd) dum[0::2] = lft dum[1::2] = rght sep = '||'.join(dum) new_deck = '|'+ sep +'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): int(m) p = len(cards)//4 shown = '....'*int(m<p) + (cards[-4*m:]) line = 'Table: '+ shown print('-'*len(line)) print('Table: '+ shown) print('-'*len(line)) #----------------------------------------- |
| # 6330310021 (20.00) 161 (2021-02-08 14:49) def peek_kth_card(cards, k): the_kth_card = cards[(k - 1) * 4:(k - 1) * 4 + 4] return the_kth_card # --------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k - 1) * 4] + cards[(k - 1) * 4 + 4:] return new_cards # --------------------------------------- def deal_n_cards(deck, n): cards = deck[:4 * n] new_deck = deck[4 * n:] return cards, new_deck # --------------------------------------- def cut(deck, m): a = deck[1:-1] real_deck = a.split("||") x = "| |".join(real_deck) y = "|" + x + "|" z = y.split() first_m = z[:m] new_deck0 = z[m:] new_deck00 = new_deck0 + first_m new_deck = "".join(new_deck00) return new_deck # --------------------------------------- def shuffle(deck): a = deck[1:-1] real_deck = a.split("||") x = "| |".join(real_deck) y = "|" + x + "|" z = y.split() o = z[1::] first = o[:(len(o)//2)] second = o[(len(o)//2):] first.insert(0, z[0]) new_deck0 = [""]*(len(first)+len(second)) new_deck0[0::2] = first[0::] new_deck0[1::2] = second[0::] new_deck = "".join(new_deck0) return new_deck # --------------------------------------- def show_table_cards(cards, m): a = cards[1:-1] real_cards = a.split("||") x = "| |".join(real_cards) y = "|" + x + "|" z = y.split() w = z[-1:-m - 1:-1] u = w[::-1] v = "".join(u) f = max(len(z), m) h = f - 1 c = min(h, m) q = "Table: " + ("...." * (c - m + 1)) + v e = len(q) print("-" * e) print(q) print("-" * e) # ----------------------------------------- |
| # 6330311621 (20.00) 162 (2021-02-05 18:15) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*(k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1)]+cards[4*(k):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1].split("||") x = deck[:int((len(deck)+1)/2)] y = deck[int((len(deck)+1)/2):] deck[1::2] = y deck[::2] = x new_deck = "|"+"||".join(deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): x = cards[1:-1].split("||") y = len(x) z = x[-m:] z = "|"+"||".join(z)+"|" Table = "Table: "+"...."*1*((y-m)>0)+z c = len(Table) print("-"*c) print(Table) print("-"*c) #----------------------------------------- |
| # 6330312221 (20.00) 163 (2021-02-05 10:45) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(k-1)*4:1] + cards[k*4::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[4*n::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m::]+deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): d = deck[1:-1] nd = d.split("||") h = (len(nd)//2)+(len(nd)%2) nd1 = nd[0:h] nd2 = nd[h::] y = [0]*len(nd) y[::2] = nd1[::] y[1::2] = nd2[::] new_deck = "|" + "||".join(y) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): nc = cards[(len(cards)-(m*4))*((m*4)<len(cards))::] a = 'Table'+": "+(int(m < (len(cards))/4))*"...."+nc print("-"*(len(a))) print(a) print("-"*(len(a))) #----------------------------------------- |
| # 6330313921 (20.00) 164 (2021-02-08 16:27) def peek_kth_card(cards, k): k = int(k) start1 = 4*k - 4 final1 = 4*k the_kth_card = cards[start1:final1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): group1 = cards[0:4*k - 4] group2 = cards[4*k:] new_cards = group1 + group2 return new_cards #--------------------------------------- def deal_n_cards(deck, n): n = int(n) cards = deck[0:4*n] new_deck = deck[4*n:len(deck)] return cards, new_deck #--------------------------------------- def cut(deck, m): m = int(m) cut1 = deck[0:4*m] nocut = deck[4*m:len(deck)] new_deck = nocut + cut1 return new_deck #--------------------------------------- def shuffle(deck): new_deck = '|'+deck+'|' deck_split = new_deck.split('||')[1:-1] ndeck = (len(deck_split)+1)//2 ndeck_left = deck_split[0:ndeck] ndeck_right = deck_split[ndeck:] newd = [0] * len(deck_split) newd[0::2] = ndeck_left newd[1::2] = ndeck_right new_deck = '|'+'||'.join(newd)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): m = int(m) cardtable = cards[-4*m:] a = int(m >= (len(cards))//4) result = '....'*abs(a-1) + cardtable print('-'*(7 + len(result))) print('Table: ' + result) print('-'*(7 + len(result))) #----------------------------------------- |
| # 6330314521 (18.00) 165 (2021-02-08 23:57) def peek_kth_card(cards, k): the_kth_card = str(cards[(k-1)*4:4*k]) return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(k-1)*4:] + cards[k*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): #deck = '|2H||4S||TD||AC||AD||AS|' #half1 = deck[0:len(deck)//2] #|2H||4S||TD| #half2 = deck[len(deck)//2:] #|AC||AD||AS| #print(half2) #new_deck = half1[0::2] + half2[0::2] d0 = '|'+ deck +'|' d1 = d0.split('||') d2 = d1[1:-1:] #h = half h1 = d2[0:len(d2)//2] h2 = d2[len(d2)//2:] #nd = new deck nd = [1]*len(d2) nd[0::2] = h1 nd[1::2] = h2 new_deck = '|' + '||'.join(nd) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): c1 = ('....'* int(m <= (len(cards)//4)))+ cards[-4*m:] f = 'Table: '+ c1 #+ cards[:(4*m)-4:] #print(c1) print('-'*len(f)) print('Table: '+ c1) #:4*(m+1): ,-4*m: print('-'*len(f)) #----------------------------------------- |
| # 6330315121 (20.00) 166 (2021-02-07 22:02) def peek_kth_card(cards, k): cards = cards.strip('|').split('||') the_kth_card = '|' + cards[k-1] + '|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards = cards.strip('|').split('||') new_cards = cards[0:k-1] + cards[k::] x = int(len(cards)!=1) new_cards = '|'*x + '||'.join(new_cards) + '|'*x return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck=deck.strip('|').split('||') cards='|'+'||'.join(deck[0:n:])+'|' new_deck=deck[n::] x = int(n!=len(deck)) new_deck='|'*x +'||'.join(new_deck)+ '|'*x return cards, new_deck #--------------------------------------- def cut(deck, m): deck = deck.strip('|').split('||') deck1 = deck[0:m] new_deck = '|' + '||'.join(deck[m:] + deck1) + '|' return new_deck #--------------------------------------- def shuffle(deck): deck = deck.strip('|').split('||') R_deck = deck[int(len(deck)/2+0.5):] L_deck = deck[0:int(len(deck)/2+0.5)] new_deck = [0]*len(deck) new_deck[::2] = list(L_deck) new_deck[1::2] = list(R_deck) new_deck = '|' + '||'.join(new_deck) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards.strip('|').split('||') c_cards = len(cards) y = int(m<c_cards) cards = cards[-m::] cards = '|' + '||'.join(cards) + '|' x = len('Table: ') + len('....'*y) + len(cards) print('-'*x) print('Table:','....'*y+cards) print('-'*x) #----------------------------------------- |
| # 6330316821 (20.00) 167 (2021-02-08 00:32) def peek_kth_card(cards, k): min = 4 * k - 4 max = 4 * k the_kth_card = cards[min:max] return the_kth_card # --------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(4 * k - 4)] + cards[(4 * k):] return new_cards # --------------------------------------- def deal_n_cards(deck, n): cards = deck[:4 * n] new_deck = deck[4 * n:] return cards, new_deck # --------------------------------------- def cut(deck, m): new_deck = deck[4 * m:] + deck[:4 * m] return new_deck # --------------------------------------- def shuffle(deck): list1 = deck.split("||") list2 = "| |".join(list1) list3 = list2.split() empty = [""] * int(len(list3)) list4 = list3[1:] left = list4[:len(list4)//2] right = list4[len(list4)//2:] left = list3[0] + "".join(left) left = left.split("||") left = "| |".join(left) left = left.split() empty[0::2] = left[0:] empty[1::2] = right[0:] empty = "".join(empty) new_deck = empty return new_deck # --------------------------------------- def show_table_cards(cards, m): print(int(len(cards) / 4)) print("-------" + min(int(len(cards) / 4), m + 1) * 4 * "-") print("Table:", "...." * min(int(len(cards) / 4) - m, 1) + cards[-4 * m:]) print("-------" + min(int(len(cards) / 4), m + 1) * 4 * "-") # ----------------------------------------- |
| # 6330317421 (19.50) 168 (2021-02-08 04:27) def peek_kth_card(cards, k): c = cards.strip('|').split('||') the_kth_card = c[k-1] the_kth_card = '|'+''.join(the_kth_card)+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4] + cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck = deck.strip('|').split('||') cards = '|'+'||'.join(deck[:n])+'|' new_deck = '|'+'||'.join(deck[n:])+'|' return cards, new_deck #--------------------------------------- def cut(deck, m): Card = 4*m new_deck = deck[Card:] + deck[:Card] return new_deck #--------------------------------------- def shuffle(deck): deck = deck.strip('|').split('||') new_deck = 'zz'.join(deck[:(len(deck)+1)//2])+'z'*(1+(1)*(-1)**len(deck)) new_deck = new_deck[:len(new_deck)] new_deck = new_deck.split('z') new_deck = new_deck[:2*((len(deck)+1)//2)] new_deck[1::2] = deck[(len(deck)+1)//2:] new_deck = '|'+'||'.join(new_deck)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): n = len(cards)//4 t = '....'*min(n-min(n,m),1) + cards[-4*m::] print('-------' + '-'*len(t)) print('Table: ' + t) print('-------' + '-'*len(t)) #----------------------------------------- |
| # 6330318021 (20.00) 169 (2021-02-08 11:53) def peek_kth_card(cards, k): space1=(k-1)*4 the_kth_card=str(cards[space1:space1+4:1]) return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): space2=(k-1)*4 new_cards=cards[0:space2:]+cards[space2+4::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): space3=n*4 cards=deck[0:space3:] new_deck=deck[space3::] return cards, new_deck #--------------------------------------- def cut(deck, m): space4=m*4 new_deck=deck[space4::]+deck[:space4:] return new_deck #--------------------------------------- def shuffle(deck): d=deck.split('|') d=d[1:-1:2] d[0]='|'+d[0] d[-1]=d[-1]+'|' deck_str=('| |').join(d) deck_list=deck_str.split(' ') nf=int(len(deck)/8+0.5*((len(deck)/4)%2)) nd=['']*int(len(deck)/4) nd[0::2]=deck_list[0:nf:] nd[1::2]=deck_list[nf::] new_deck=('').join(nd) return new_deck #--------------------------------------- def show_table_cards(cards, m): space5=m*4 dot='....'*(int((len(cards)-space5)//abs(len(cards)-space5-1e-10))) c_in=cards[::-1] card=c_in[0:space5:] card=card[::-1] dash=int(len(card)+len(dot)) print('-------'+'-'*dash) print('Table: '+dot+card) print('-------'+'-'*dash) #----------------------------------------- |
| # 6330319721 (18.83) 170 (2021-02-08 18:56) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards.replace(cards[4*(k-1):4*k],'') return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[4*n:-1]+'|' return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck[0:4*m] new_deck = deck[4*m:-1]+'|'+a return new_deck #--------------------------------------- def shuffle(deck): import math cards = deck[1:-1] card = cards.split('||') q = math.ceil((len(card))/2) a = card[0:q] b = card[q:] new_deck=[1]*len(card) new_deck[0::2]=a new_deck[1::2]=b new_deck='||'.join(new_deck) new_deck='|'+new_deck+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): q=len(cards)-(m*4) p=max(q,0) h=min(q,1) u=max(h,0) x=cards[p::] a="Table:"+' '+(('.'*4)*(u))+x print(("-"*(len(x)+7))+(('-'*4)*u)) print(a) print(("-"*(len(x)+7))+(('-'*4)*u)) #----------------------------------------- |
| # 6330320221 (20.00) 171 (2021-02-06 14:04) def peek_kth_card(cards, k): the_kth_card=cards[4*(k-1):4*(k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards=cards[1:-1] listcard=cards.split('||') listcard.pop(k-1) x=int(len(listcard)!=0) new_cards='|'*x+'||'.join(listcard)+'|'*x return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:4*n] new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): cutposition=int(len(deck)/4/2+0.5) yellowcard=deck[:cutposition*4] greencard=deck[cutposition*4:] listofyellow=yellowcard[1:-1].split('||') listofgreen=greencard[1:-1].split('||') listofall=[None]*(len(listofyellow)+len(listofgreen)) listofall[::2]=listofyellow listofall[1::2]=listofgreen new_deck=('|'+'||'.join(listofall)+'|') return new_deck #--------------------------------------- def show_table_cards(cards, m): x=int(m>=3) y=int(len(cards)/4>m) show='.'*(4*y)+cards[-m*4:] print('-'*7+'-'*len(show)) print('Table: '+show) print('-'*7+'-'*len(show)) #----------------------------------------- |
| # 6330321921 (17.78) 172 (2021-02-08 12:55) def peek_kth_card(cards, k): c = cards.split('|') i = 2*k - 1 the_kth_card = '|' + c[i] + '|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): c = cards.split('|') i = 2 * k - 1 n = c[:i] + c[i + 2:] new_cards = '|'.join(n) return new_cards #--------------------------------------- def deal_n_cards(deck, n): d = deck.split('|') i = 2 * n + 1 c = d[:i] cards = '|'.join(c) nc = d[i - 1:] new_deck = '|'.join(nc) return cards, new_deck #--------------------------------------- def cut(deck, m): d = deck[1:-1] d = d.split('||') new_deck = d[m:] + d[:m] new_deck = '|' + '||'.join(new_deck) + '|' return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1] d = deck.split('||') x = [''] * 52 left = d[:int(((len(d) / 2) + 0.5))] right = d[int(((len(d) / 2) + 0.5)):] x[::2] = left x[1::2] = right new_deck = '|' + '||'.join(x) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards[1:-1] c = cards.split('||') sw = c[:-m - 1:-1] sw = sw[::-1] print('-----------' + '----' * min(m, len(c) - 1)) print('Table: ' + '....' * int((len(c) - (min(len(c), m))) // (len(c) - m + 10e-99)) + '|' + '||'.join(sw) + '|') print('-----------' + '----' * min(m, len(c) - 1)) #----------------------------------------- |
| # 6330322521 173 (2021-02-08 18:54) def peek_kth_card(cards, k): the_kth_card=cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): k=k-1 a=cards.split('|') a=cards[1::2] a=cards[0:k]+cards[k+1:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:4*n] new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): import math cards=deck[1:-1] card=cards.split('||') q=math.ceil((len(card))/2) A=card[0:q] B=card[q:] new_deck=[1]*len(card) new_deck[0::2]=A new_deck[1::2]=B new_deck='||'.join(new_deck) new_deck='|'+new_deck+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a=len(cards)-(m*4) b=max(a,0) c=min(a,1) d=max(c,0) x=cards[b::] e="Table:"+' '+(('.'*4)*(d))+x print(("-"*(len(x)+7))+(('-'*4)*d)) print(e) print(("-"*(len(x)+7))+(('-'*4)*d)) #----------------------------------------- |
| # 6330323121 (17.78) 174 (2021-02-08 22:23) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:4*n] new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m:1] return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1] d = deck.split('||') left = d[:int(((len(d) +1) //2))] right = d[int(((len(d) +1) //2)):] a = [''] * 52 a[::2] = left a[1::2] = right new_deck = '|' + '||'.join(a) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards[1:-1] c = cards.split('||') s = c[:-m - 1:-1] s = s[::-1] print('-----------' + '----' * min(m, len(c) - 1)) print('Table: ' + '....' * int((len(c) - (min(len(c), m))) // (len(c) - m +10e-99)) + '|' + '||'.join(s) + '|') print('-----------' + '----' * min(m, len(c) - 1)) #----------------------------------------- |
| # 6330324821 (16.44) 175 (2021-02-06 21:57) def peek_kth_card(cards, k): a=cards.split('|') the_kth_card='|'+a[k*2-1]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[0:k*4-4]+cards[k*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:n*4] new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m:]+deck[0:m*4] return new_deck #--------------------------------------- def shuffle(deck): a=deck[1:-1].split('||') b=(len(a)+1) c1=(a[0:b//2]) c2=(a[b//2::]) a[0::2]=c1 a[1::2]=c2 new_deck='|'+'||'.join(a)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a=cards[1:-1].split('||') b=len('Table: '+('....'*int(len(a)>m))+'|'+'|'.join(a[(-m)::])+'|') print('-'*b) print('Table: '+('....'*int(len(a)>m))+'|'+'|'.join(a[(-m)::])+'|') print('-'*b) #----------------------------------------- |
| # 6330325421 (20.00) 176 (2021-02-05 23:18) def peek_kth_card(cards, k): k=k-1 cards=cards.split('|') cards=cards[1::2] the_kth_card = '|'+cards[(k)]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): k=k-1 cards=cards.split('|') cards=cards[1::2] cards=cards[0:k]+cards[k+1:] new_cards=cards new_cards='||'.join(cards) new_cards='|'*int(len(new_cards)!=0)+new_cards new_cards=new_cards+'|'*int(len(new_cards)!=0) return new_cards #--------------------------------------- def deal_n_cards(deck, n): n=n-1 deck=deck.split('|') deck=deck[1::2] a=len(deck) cards=deck[0:n+1] new_deck=deck[n+1:] cards='||'.join(cards) cards='|'+cards cards=cards+'|' new_deck='||'.join(new_deck) new_deck=('|'*int(n+1!=a)+new_deck+'|'*int(n+1!=a)) return cards, new_deck #--------------------------------------- def cut(deck, m): m=m-1 deck=deck.split('|') deck=deck[1::2] new_deck=deck[m+1:]+deck[0:m+1] new_deck='||'.join(new_deck) new_deck='|'+new_deck+'|' return new_deck #--------------------------------------- def shuffle(deck): deck=deck.split('|') deck=deck[1::2] a=deck[0:(len(deck)+1)//2] b=deck[((len(deck)+1)//2):] deck[0::2]=a deck[1::2]=b deck="||".join(deck) deck='|'+deck+'|' new_deck=deck return new_deck #--------------------------------------- def show_table_cards(cards, m): str_amount=len(cards) cards=cards.split('|') cards=cards[1::2] cards_amount=len(cards) cards=cards[-m:] cards='||'.join(cards) cards='|'+cards+'|' cards='.'*4*(cards_amount-m)+cards cards=cards[(4*(cards_amount-m-1))*(int(cards_amount>m)):] mark='-'*7+'-'*len(cards) print(mark) print('Table: '+cards) print(mark) #----------------------------------------- |
| # 6330326021 (20.00) 177 (2021-02-08 12:51) def peek_kth_card(cards, k): the_kth_card = cards[(4*k)-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*k-4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): x = deck[1:-1].split("||") list_1 = x[0:(len(x)+1)//2] list_2 = x[(len(x)+1)//2:] list_3 = [0]*len(x) list_3[::2] = list_1 list_3[1::2] = list_2 new_deck = "|" + "||".join(list_3) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): x = cards[1:-1].split("||") y = len(x)-m z = min(max(0,y),1) t = x[max(y,0):] output = "Table: " + "...."*z + "|" + "||".join(t) + "|" print("-"*len(output)) print(output) print("-"*len(output)) #----------------------------------------- |
| # 6330327721 (20.00) 178 (2021-02-08 03:07) def peek_kth_card(cards, k): cards=cards[1:-1].split('||') the_kth_card='|'+cards[int(k)-1]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): card=cards[1:-1].split('||') n = len(card) a = 4*(int(k)-1) b = 4*(int(k)) c = n*4 new_cards = cards[0:a]+cards[b:c] return new_cards #--------------------------------------- def deal_n_cards(deck, n): a = 4*(int(n)) cards =deck[:a] new_deck = deck[a:] return cards, new_deck #--------------------------------------- def cut(deck, m): a = 4*(int(m)) new_deck = deck[a:]+deck[0:a] return new_deck #--------------------------------------- def shuffle(deck): cards=deck[1:-1].split('||') n = len(cards) m = (n+1)//2 card =['']*n card[0::2]=cards[0:m] card[1::2]=cards[m:] new_deck = '|'+'||'.join(card)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): card=cards[1:-1].split('||') n = len(card) a = 4*(int(m)) b=['....'] c=b[0:(n-int(m))]+[''] show = c[0]+cards[-a:] x = len(show)//4 print('-------'+'----'*(x)) print('Table: '+show) print('-------'+'----'*(x)) #----------------------------------------- |
| # 6330328321 (20.00) 179 (2021-02-06 18:32) def peek_kth_card(cards, k): lCards = cards.split("||") lCards = " ".join(lCards) lCards =lCards.split() lCards ="|+|".join(lCards) lCards =lCards.split("+") the_kth_card= lCards[k-1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): lCards = cards.split("||") lCards ="|+|".join(lCards) lCards =lCards.split("+") lCards[k-1]="" new_cards = "".join(lCards) return new_cards #--------------------------------------- def deal_n_cards(deck, n): sCard = 4*n cards =deck[:sCard] new_deck = deck[sCard:] return cards, new_deck #--------------------------------------- def cut(deck, m): sCard = 4*m new_deck = deck[sCard:]+deck[:sCard] return new_deck #--------------------------------------- def shuffle(deck): n = len(deck)//4 k=n//2 l=n-k init_deck = deck[0:l*4] reverse_deck = deck[-k*4:] new_deck = init_deck[:4]+reverse_deck[:4]+init_deck[4:8]+reverse_deck[4:8] new_deck +=init_deck[8:12]+reverse_deck[8:12]+init_deck[12:16]+reverse_deck[12:16] new_deck +=init_deck[16:20]+reverse_deck[16:20]+init_deck[20:24]+reverse_deck[20:24] new_deck +=init_deck[24:28]+reverse_deck[24:28]+init_deck[28:32]+reverse_deck[28:32] new_deck +=init_deck[32:36]+reverse_deck[32:36]+init_deck[36:40]+reverse_deck[36:40] new_deck +=init_deck[40:44]+reverse_deck[40:44]+init_deck[44:48]+reverse_deck[44:48] new_deck +=init_deck[48:52]+reverse_deck[48:52]+init_deck[52:56]+reverse_deck[52:56] new_deck +=init_deck[56:60]+reverse_deck[56:60]+init_deck[60:64]+reverse_deck[60:64] new_deck +=init_deck[64:68]+reverse_deck[64:68]+init_deck[68:72]+reverse_deck[68:72] new_deck +=init_deck[72:76]+reverse_deck[72:76]+init_deck[76:80]+reverse_deck[76:80] new_deck +=init_deck[80:84]+reverse_deck[80:84]+init_deck[84:88]+reverse_deck[84:88] new_deck +=init_deck[88:92]+reverse_deck[88:92]+init_deck[92:96]+reverse_deck[92:96] new_deck +=init_deck[96:100]+reverse_deck[96:100]+init_deck[100:104]+reverse_deck[100:104] return new_deck #--------------------------------------- def show_table_cards(cards, m): nCard=len(cards)//4 minQ = min(m,nCard) notChoose = min(nCard-minQ,1) getCards = "...."*notChoose getCards += cards[-minQ*4:] print("-"*(len("Table: ")+len(getCards))) print("Table:",getCards) print("-"*(len("Table: ")+len(getCards))) #----------------------------------------- |
| # 6330329021 (20.00) 180 (2021-02-07 18:06) def peek_kth_card(cards, k): x=cards.split('|') the_kth_card='|'+x[(2*k-1)]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x=(cards.split('|'))[1::2] y=x[0:k-1]+x[k:] new_cards='|'[:len(y)]+'||'.join(y)+'|'[:len(y)] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:n*4] new_deck=deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): x=deck[:m*4] y=deck[m*4:] new_deck=y+x return new_deck #--------------------------------------- def shuffle(deck): k=((len(deck)+4)//8)*4 x=(deck[:k]).split('|')[1::2] y=(deck[k:]).split('|')[1::2] t=1 m = x[t-1:t]+y[t-1:t] ;t+=1 #1 m+= x[t-1:t]+y[t-1:t] ;t+=1 #2 m+= x[t-1:t]+y[t-1:t] ;t+=1 #3 m+= x[t-1:t]+y[t-1:t] ;t+=1 #4 m+= x[t-1:t]+y[t-1:t] ;t+=1 #5 m+= x[t-1:t]+y[t-1:t] ;t+=1 #6 m+= x[t-1:t]+y[t-1:t] ;t+=1 #7 m+= x[t-1:t]+y[t-1:t] ;t+=1 #8 m+= x[t-1:t]+y[t-1:t] ;t+=1 #9 m+= x[t-1:t]+y[t-1:t] ;t+=1 #10 m+= x[t-1:t]+y[t-1:t] ;t+=1 #11 m+= x[t-1:t]+y[t-1:t] ;t+=1 #12 m+= x[t-1:t]+y[t-1:t] ;t+=1 #13 m+= x[t-1:t]+y[t-1:t] ;t+=1 #14 m+= x[t-1:t]+y[t-1:t] ;t+=1 #15 m+= x[t-1:t]+y[t-1:t] ;t+=1 #16 m+= x[t-1:t]+y[t-1:t] ;t+=1 #17 m+= x[t-1:t]+y[t-1:t] ;t+=1 #18 m+= x[t-1:t]+y[t-1:t] ;t+=1 #19 m+= x[t-1:t]+y[t-1:t] ;t+=1 #20 m+= x[t-1:t]+y[t-1:t] ;t+=1 #21 m+= x[t-1:t]+y[t-1:t] ;t+=1 #22 m+= x[t-1:t]+y[t-1:t] ;t+=1 #23 m+= x[t-1:t]+y[t-1:t] ;t+=1 #24 m+= x[t-1:t]+y[t-1:t] ;t+=1 #25 m+= x[t-1:t]+y[t-1:t] ;t+=1 #26 new_deck='|'+'||'.join(m)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): list_of_cards=cards.split('|')[1::2] p=len(list_of_cards) a=['....'] b=str(a[:p-m])[2:6]+'|'+'||'.join(list_of_cards[-m:])+'|' print(len('Table: '+b)*'-') print('Table: '+b) print(len('Table: '+b)*'-') #----------------------------------------- |
| # 6330330521 (18.22) 181 (2021-02-07 00:58) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards_left = cards[0:4*k-4] new_cards_right = cards[4*k:len(cards)] new_cards = new_cards_left + new_cards_right return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[4*n:len(deck)] return cards, new_deck #--------------------------------------- def cut(deck, m): deck_left = deck[0:4*m] deck_right = deck[4*m:len(deck)] new_deck = deck_right + deck_left return new_deck #--------------------------------------- def shuffle(deck): s = len(deck)//2 multiply = round(len(deck)/4) deck = deck.split("|") len_deck = len(deck)-int(len(deck)/2) odd_deck = deck[1:len_deck:2] even_deck = deck[len_deck+(1*(multiply%2))::2] new_deck = ['']*multiply new_deck[::2] = odd_deck new_deck[1::2] = even_deck new_deck = '||'.join(new_deck) new_deck = ('|'+ new_deck +'|') return new_deck #--------------------------------------- def show_table_cards(cards, m): new_card = cards[len(cards)-4*m:len(cards)] num_card = len(cards)//4 min_card_m = min(num_card,m) min_card_m_1 = min(min_card_m,1) point = "...."*min_card_m_1 print("-"*(7+len(new_card)+len(point))) print("Table:"+" "+point+new_card) print("-"*(7+len(new_card)+len(point))) #----------------------------------------- |
| # 6330331121 (20.00) 182 (2021-02-07 20:18) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4 : ((k-1)*4)+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0 : (k-1)*4] + cards[((k-1)*4)+4 :] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:(n*4)] new_deck = deck[(n*4):] return cards, new_deck #--------------------------------------- def cut(deck, m): dlist = deck[1:-1].split("||") a = dlist[0:m] b = dlist[m:] new_deck = "|" + "||".join(b+a) + "|" return new_deck #--------------------------------------- def shuffle(deck): dlist = deck[1:-1].split("||") a = dlist[0:(len(dlist)+1)//2 ] b = dlist[-(len(dlist)-1)//2:] c = [" "]*(len(dlist)) c[::2] = a c[1::2] = b new_deck = "|" + "||".join(c) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): clist = cards[1:-1].split("||") a = min(len(clist) - len(clist[-m:]), 1)*"...." b = "|" + '||'.join(clist[-m:]) + "|" c = a + b print("-"*7 + "-"*len(c)) print("Table: " + c) print("-"*7 + "-"*len(c)) #----------------------------------------- |
| # 6330332821 (12.67) 183 (2021-02-08 13:27) def peek_kth_card(cards, k): cards = cards.split('||') cards = '| |'.join(cards) cards = cards.split(' ') the_kth_card = cards[k-1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards.split('||') new_cards = '| |'.join(new_cards) new_cards = new_cards.split(' ') new_cards.remove(new_cards[k-1]) new_cards = ''.join(new_cards) return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck = deck.split('||') deck = '| |'.join(deck) deck = deck.split(' ') cards = ''.join(deck[0:n:]) new_deck = ''.join(deck[n::]) return cards, new_deck #--------------------------------------- def cut(deck, m): deck = deck.split('||') deck = '| |'.join(deck) deck = deck.split(' ') new_deck = deck[m::]+deck[0:m:] return new_deck #--------------------------------------- def shuffle(deck): import math deck = ' '.join(deck) deck = deck.split(' ') x = deck[0:(math.ceil(len(deck)/2)):1] y = deck[(math.ceil(len(deck)/2))::1] dk = ' c '.join(deck) dk = dk.split(' ') dk[1:(math.ceil(len(dk)/2)):2] = y dk = dk[0:len(deck):1] new_deck = ''.join(dk) return new_deck #--------------------------------------- def show_table_cards(cards, m): new_card = cards[len(cards)-4*m:len(cards)] x_card = len(cards)//4 x_card_m = min(x_card,m) x_card_m_1 = min(x_card_m,1) p = '....'*x_card_m_1 print('-'*(len(new_card)+len(p)+7)) print('Table:'+' '+p+new_card) print('-'*(len(new_card)+len(p)+7)) #----------------------------------------- |
| # 6330333421 (19.33) 184 (2021-02-07 17:44) def peek_kth_card(cards, k): list_cards = cards[1:-1].split('||') the_kth_card = '|'+list_cards[k-1]+'|' return the_kth_card #--------------------------------------- def remove_kth_card (cards, k): list_card = cards[1:-1].split('||') list_card=['']+list_card+[''] ans = list_card[:k] + list_card[k+1:] new_cards = ('||'.join(ans))[1:-1] return new_cards #--------------------------------------- def deal_n_cards (deck, n): cards=deck[:(n*4)] new_deck=deck[(n*4):] return cards, new_deck #--------------------------------------- def cut(deck, m): list_cards = deck[1:-1].split('||') new_deck = list_cards[:m] + list_cards[m:] new_deck = '|'+'||'.join(new_deck)+'|' return new_deck #--------------------------------------- def shuffle(deck): list_cards = deck[1:-1].split('||') cut_index = len(list_cards)//2 + len(list_cards)%2 first = list_cards[:cut_index] back = list_cards[cut_index:] new_deck = ['']*len(list_cards) new_deck[::2] = first new_deck[1::2] = back new_deck = '|'+'||'.join(new_deck)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): list_cards = cards[1:-1].split('||')[::-1] len_cards = len(list_cards) cut_cards = list_cards[:m]+['....'] show_cards = ''.join(cut_cards[m:len_cards]) + '|' + '||'.join(cut_cards[:-1][::-1]) + '|' display = 'Table: '+show_cards print("-"*len(display)) print(display) print("-"*len(display)) #----------------------------------------- |
| # 6330334021 (20.00) 185 (2021-02-07 21:42) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards.split('|') new_cards[2*k-1] = '' new_cards.pop(2*k-1) new_cards.pop(2*k-2) new_cards = '|'.join(new_cards) return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): amountleft = int((len(deck)/4+1)//2*4) new_d1 = deck[0:amountleft] new_d2 = deck[amountleft:] new_deck = new_d1[0:4]+new_d2[0:4]+new_d1[4:8]+new_d2[4:8]+new_d1[8:12]+new_d2[8:12]+new_d1[12:16]+new_d2[12:16]+new_d1[16:20]+new_d2[16:20]+new_d1[20:24]+new_d2[20:24]+new_d1[24:28]+new_d2[24:28]+new_d1[28:32]+new_d2[28:32]+new_d1[32:36]+new_d2[32:36]+new_d1[36:40]+new_d2[36:40]+new_d1[40:44]+new_d2[40:44]+new_d1[44:48]+new_d2[44:48]+new_d1[48:52]+new_d2[48:52]+new_d1[52:56]+new_d2[52:56]+new_d1[56:60]+new_d2[56:60]+new_d1[60:64]+new_d2[60:64]+new_d1[64:68]+new_d2[64:68]+new_d1[68:72]+new_d2[68:72]+new_d1[72:76]+new_d2[72:76]+new_d1[76:80]+new_d2[76:80]+new_d1[80:84]+new_d2[80:84]+new_d1[84:88]+new_d2[84:88]+new_d1[88:92]+new_d2[88:92]+new_d1[92:96]+new_d2[92:96]+new_d1[96:100]+new_d2[96:100]+new_d1[100:104]+new_d2[100:104] return new_deck #--------------------------------------- def show_table_cards(cards, m): import math print(7*'-'+min(int(len(cards)), 4*m+4)*'-') print('Table: '+math.ceil(int((len(cards)/4-m))/52)*'....'+cards[-4*m:]) print(7*'-'+min(int(len(cards)), 4*m+4)*'-') #----------------------------------------- |
| # 6330335721 (17.50) 186 (2021-02-07 19:05) def peek_kth_card(cards, k): cards = cards.strip("|").split("||") the_kth_card ="|"+cards[int(k-1)]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards = cards.strip("|").split("||") new_cards = cards new_cards[k-1:k]=[] new_cards = "||".join(new_cards) new_cards = "|"+new_cards+"|" return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck = deck.strip("|").split("||") cards = deck[:n] new_deck =deck[n:] cards = "||".join(cards) new_deck = "||".join(new_deck) cards = "|"+cards+"|" new_deck = "|"+new_deck+"|" return cards, new_deck #--------------------------------------- def cut(deck, m): deck0 = deck.strip("|").split("||") cards1 = deck0[:m] cards2 = deck0[m:] new_deck = '|'+"||".join(cards2)+"||"+"||".join(cards1)+"|" return new_deck #--------------------------------------- def shuffle(deck): deck0 = deck.strip("|").split("||") i = int(len(deck0)) ihalf = (int((i+1)*0.5)) deck1 = deck0[:ihalf] deck2 = deck0[ihalf:] new_deck =[" "]*(i) new_deck[::2] = deck1[::1] new_deck[1::2] = deck2[::1] new_deck = "||".join(new_deck) new_deck = "|"+new_deck+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): n=m cards = cards.strip("|").split("||") """ if n > len(cards): n=len(cards) cards = cards[len(cards)-n:] cards = "||".join(cards) toprint = "Table: "+"|"+str(cards)+"|" if n>3: print("-"*len(toprint)) print(str(toprint)) print("-"*len(toprint)) else: toprint = "Table: "+"...."+"|"+str(cards)+"|" print("-"*len(toprint)) print(str(toprint)) print("-"*len(toprint)) """ if n >=len(cards): cards = "||".join(cards) toprint = "Table: "+"|"+str(cards)+"|" print("-"*len(toprint)) print(str(toprint)) print("-"*len(toprint)) else: cards = cards[-n:] cards = "||".join(cards) toprint = "Table: "+"...."+"|"+str(cards)+"|" print("-"*len(toprint)) print(str(toprint)) print("-"*len(toprint)) #----------------------------------------- |
| # 6330336321 (20.00) 187 (2021-02-07 01:47) def peek_kth_card(cards, k): the_kth_card = cards[k*4-4:k*4:1] return the_kth_card # --------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:k*4-4:1]+cards[k*4::] return new_cards # --------------------------------------- def deal_n_cards(deck, n): cards = deck[0:n*4:1] new_deck = deck[n*4::] return cards, new_deck # --------------------------------------- def cut(deck, m): cards = deck[0:m * 4:1] new_deck = deck[m * 4::] new_deck += cards return new_deck # --------------------------------------- def shuffle(deck): import math cards2 = deck[1:-1:1] a = cards2.split("||") b = len(a) new_deck = ['?']*b a1 = a[0:math.ceil(b/2):1] a2 = a[math.ceil(b/2)::1] new_deck[0::2] = a1[::1] new_deck[1::2] = a2[::1] new_deck = '||'.join(new_deck) new_deck = '|' + new_deck + '|' return new_deck # --------------------------------------- def show_table_cards(cards, m): n = min(m, len(cards)//4 ) p = -4*m i = int(m < len(cards) // 4) text = "Table: " + "...."*(i) + cards[p::] length = len(text) print("-" * length) print("Table: " + "...."*(i) + cards[p::]) print("-" * length) # ----------------------------------------- |
| # 6330337021 (19.33) 188 (2021-02-07 01:04) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*(k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): rop = cards[4*k:]+cards[:4*k] new_cards = rop[0:len(cards)-4] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): import math left = deck[0:math.ceil((len(deck)//4)/2)*4] right = deck[math.ceil((len(deck)//4)/2)*4:] new_deck = left[:4]+right[:4]+left[4:8]+right[4:8]+left[8:12]+right[8:12]+left[12:16]+right[12:16]+left[16:20]+right[16:20]+left[20:24]+right[20:24]+left[24:28]+right[24:28]+left[28:32]+right[28:32]+left[32:36]+right[32:36]+left[36:40]+right[36:40]+left[40:44]+right[40:44]+left[44:48]+right[44:48]+left[48:52]+right[48:52]+left[52:56]+right[52:56]+left[56:60]+right[56:60]+left[60:64]+right[60:64]+left[64:68]+right[64:68]+left[68:72]+right[68:72]+left[72:76]+right[72:76]+left[76:80]+right[76:80]+left[80:84]+right[80:84]+left[84:88]+right[84:88]+left[88:92]+right[88:92]+left[92:96]+right[92:96]+left[96:100]+right[96:100]+left[100:104]+right[100:104]+left[104:108]+right[104:108]+left[108:112]+right[108:112]+left[112:116]+right[112:116]+left[116:120]+right[116:120]+left[120:124]+right[120:124]+left[124:128]+right[124:128]+left[128:132]+right[128:132]+left[132:136]+right[132:136]+left[136:140]+right[136:140]+left[140:144]+right[140:144]+left[144:148]+right[144:148]+left[148:152]+right[148:152]+left[152:156]+right[152:156]+left[156:160]+right[156:160]+left[160:164]+right[160:164]+left[164:168]+right[164:168]+left[168:172]+right[168:172]+left[172:176]+right[172:176]+left[176:180]+right[176:180]+left[180:184]+right[180:184]+left[184:188]+right[184:188]+left[188:192]+right[188:192]+left[192:196]+right[192:196]+left[196:200]+right[196:200]+left[200:204]+right[200:204]+left[204:208]+right[204:208] return new_deck #--------------------------------------- def show_table_cards(cards, m): k = min((len(cards)//4)-m,1) t = "...." p = "Table: "+t*k+cards[-m*4:] print("-"*len(p)) print(p) print("-"*len(p)) #----------------------------------------- |
| # 6330338621 (20.00) 189 (2021-02-06 14:07) def peek_kth_card(cards, k): the_kth_card = cards[(4*k)-4:(4*k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(4*k)-4] + cards[(4*k):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1] deck = deck.split('||') num = (len(deck)//2) + (len(deck)%2) deck1 = deck[:(num)] deck2 = deck[(num):] x = [0]*(len(deck)) x[0::2] = deck1 x[1::2] = deck2 x = '||'.join(x) x = '|' + x + '|' new_deck = x return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards[1:-1] cards1 = cards.split('||') cards2 = cards1[-m:] newcards1 = '||'.join(cards2) newcards2 = '|' + newcards1 + '|' table = 'Table:' + ' ' + '....'*(min(1,len(cards1)-m)) + newcards2 print('-'*len(table)) print(table) print('-'*len(table)) #----------------------------------------- |
| # 6330339221 (20.00) 190 (2021-02-06 18:27) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:(k)*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(k-1)*4]+cards[(k)*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:(n)*4] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4:]+deck[0:m*4] return new_deck #--------------------------------------- def shuffle(deck): a= deck.split('|') x= a[:(len(a)+1)//2] y= a[(len(a)+1)//2:] c = ''.join(x) d = ''.join(y) e = ((len(c)/2)-(len(d)/2)) e = int(e) x[2::2]=y[e::2] t='||'.join(x) t = t[1:] new_deck=t+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a = '....'*(max(0,min(1,((len(cards)//4)-m)))) b = 'Table:' c = cards[(max(0,(len(cards)//4)-m))*4:] d = int(len(a+b+c)) print('-'*(d+1)) print('Table:','....'*(max(0,min(1,((len(cards)//4)-m))))+cards[(max(0,(len(cards)//4)-m))*4:]) print('-'*(d+1)) #----------------------------------------- |
| # 6330340821 (20.00) 191 (2021-02-07 00:07) def peek_kth_card(cards, k): c1 = (int(k)-1)*4 the_kth_card = cards[c1:c1+4:] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): d1 = (int(k)-1)*4 d2 = int(k)*4 d3 = len(cards)/4 d4 = cards[d2::] d5 = cards[:d1:] new_cards = d5+d4 return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:int(n)*4:] new_deck = deck[int(n)*4::] return cards, new_deck #--------------------------------------- def cut(deck, m): e1 = deck[0:int(m)*4:] e2 = deck[int(m)*4::] new_deck = e2+e1 return new_deck #--------------------------------------- def shuffle(deck): g1 = deck[1:-1:] g2 = g1.split("||") g = int(((len(g2))+1)//2) g3 = g2[0:g:] g4 = g2[g::] room = [0]*len(g2) room[::2] = g3 room[1::2] = g4 g5 = "||".join(room) new_deck = "|"+str(g5)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): h3 = len(cards)/4 h4 = min(int(m),h3) h5 = int(h3-h4) h6 = cards[h5*4::] h9 = ("....")*min(1,int(h3-(len(h6)/4))) h10 = "-"*(7+len(h9+h6)) print(h10) print("Table:",h9+h6) print(h10) #----------------------------------------- |
| # 6330341421 (14.44) 192 (2021-02-06 22:18) def peek_kth_card(cards, k): cards = cards.split("||") cards = "| |".join(cards) cards = cards.split(" ") the_kth_card = cards[k-1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards.split("||") new_cards = "| |".join(new_cards) new_cards = new_cards.split(" ") new_cards.remove(new_cards[k-1]) new_cards = "".join(new_cards) return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck = deck.split("||") deck = "| |".join(deck) deck = deck.split(" ") cards = "".join(deck[0:n:1]) new_deck = "".join(deck[n::1]) return cards, new_deck #--------------------------------------- def cut(deck, m): deck = deck.split("||") deck = "| |".join(deck) deck = deck.split(" ") new_deck = deck[m::1]+deck[0:m:1] return new_deck #--------------------------------------- def shuffle(deck): import math deck = " ".join(deck) deck = deck.split(" ") a = deck[0:(math.ceil(len(deck)/2)):1] b = deck[(math.ceil(len(deck)/2))::1] de = " d ".join(deck) de = de.split(" ") de[1:(math.ceil(len(de)/2)):2] = b de = de[0:len(deck):1] new_deck = "".join(de) return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards.split("||") cards = "| |".join(cards) cards = cards.split(" ") a = len(cards) cards = "".join(cards) if m>=a: b = len(cards)+7 print('-'*b) print('Table:',cards) print('-'*b) else: cards = cards.split("||") cards = "| |".join(cards) cards = cards.split(" ") show = cards[-m::1] cards = "".join(show) b = len(cards)+11 print('-'*b) print('Table: ....'+cards) print('-'*b) #----------------------------------------- |
| # 6330342021 (19.78) 193 (2021-02-06 22:29) def peek_kth_card(cards, k): a=cards[1:-1].split('||') the_kth_card='|'+str(a[k-1])+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[:4*(k-1)]+cards[4*(k)::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:4*n] new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): a=deck[1:-1].split('||') deck_left=a[:(len(a)+1)//2] deck_right=a[(len(a)+1)//2:] new_deck1=a new_deck1[::2]=deck_left new_deck1[1::2]=deck_right new_deck='|'+'||'.join(new_deck1)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): k=cards[1:-1].split('||') table=k[-(m)::] x=len(k) a=min(x-m,1) b=max(a,0) r='Table'+':'+" " '....'*b+'|'+'||'.join(table)+'|' print('-'*len(r)) print(r) print('-'*len(r)) #----------------------------------------- |
| # 6330343721 (17.78) 194 (2021-02-08 21:44) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): k = int(len(deck)/4) half = int(round(k/2, 0)) firsthalf = deck[:4*half] lasthalf = deck[4*half:] firsthalfsplited = firsthalf.split("||") lasthalfsplited = lasthalf.split('||') sumhalf = firsthalfsplited+lasthalfsplited sumsumhalf = (half+1)*sumhalf sumsumsumhalf = sumsumhalf[:int(round(len(sumsumhalf),0)):int(round(len(sumhalf)/2,0))+1] sumsumsumsumhalf = '||'.join(sumsumsumhalf) k1 = sumsumsumsumhalf.split("|||") k2 = "||".join(k1) k3 = k2.split("|||") new_decku = "||".join(k3)+'|' new_deck = new_decku[: int(len(new_decku)/4)*4] return new_deck #--------------------------------------- def show_table_cards(cards, m): k = min(int(len(cards)), 4*m) cardright = cards[int(len(cards))-k:int(len(cards))] cardleft = cards[: int(len(cards))-k] cardcombine = str(cardleft)+"...."+str(cardright) cardd = "NOOB"+cardcombine[4:] SU = int(len(cardleft)) cardBB = cardd[SU:] NOOBREMOVE = cardBB.split('NOOB') NOOB = ''.join(NOOBREMOVE) print("-------"+int(len(str(NOOB)))*"-") #การบ้านสวยดีงับ นั่งทำนานมาก ๆๆๆๆๆๆๆๆๆๆๆๆๆๆๆๆๆๆ print("Table: "+NOOB) print("-------"+int(len(str(NOOB)))*"-") #----------------------------------------- |
| # 6330344321 (15.70) 195 (2021-02-08 23:59) def peek_kth_card(cards, k): the_kth_card = '|' + cards[1:-1].split('||')[k-1] + '|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): split_cards = cards[1:-1].split('||') del split_cards[k-1] new_cards = '|' + '||'.join(split_cards) + '|' return new_cards #--------------------------------------- def deal_n_cards(deck, n): split_cards = deck[1:-1].split('||') cards = '|' + '||'.join(split_cards[0:n]) + '|' new_deck = '|' + '||'.join(split_cards[n:]) + '|' return cards, new_deck #--------------------------------------- def cut(deck, m): split_cards = deck[1:-1].split('||') new_deck = '|' + ('||'.join(split_cards[m:])) + '||' + ('||'.join(split_cards[0:m])) + '|' return new_deck #--------------------------------------- def shuffle(deck): split_cards = deck[1:-1].split('||') new_deck = [''] * len(split_cards) new_deck[::2] = split_cards[0:(len(split_cards)+1)//2] new_deck[1::2] = split_cards[(len(split_cards)+1)//2:] new_deck = '|' + '||'.join(new_deck) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): split_cards = cards[1:-1].split('||') dot = '.' * min(999*(len(split_cards)-m),4) print('Table: ' + dot + '|' + '||'.join(split_cards[-m:]) + '|') #----------------------------------------- |
| # 6330345021 (20.00) 196 (2021-02-05 17:07) def peek_kth_card(cards, k): a = cards[1:-1] b = a.split("||") the_kth_card = "|"+b[k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): a = cards[1:-1] b = a.split("||") del b[k-1] c = "||".join(b) m = min(1,len(c)) new_cards = "|"*m + c + "|"*m return new_cards #--------------------------------------- def deal_n_cards(deck, n): a = deck[1:-1] b = a.split("||") c = b[:n] c_ = "||".join(c) m1 = min(1,len(c_)) cards = "|"*m1+c_+"|"*m1 nd = b[n:] nd_ = "||".join(nd) m2 = min(1,len(nd_)) new_deck = "|"*m2+nd_+"|"*m2 return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck[1:-1] b = a.split("||") c = b[m:] + b[:m] c = "||".join(c) new_deck = "|"+c+"|" return new_deck #--------------------------------------- def shuffle(deck): a = deck[1:-1].split("||") b1 = a[:(len(a)+1)//2] ; b2 = a[(len(a)+1)//2:] a[0::2] = b1 ; a[1::2] = b2 c = "||".join(a) new_deck = "|"+c+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards[-m*4:] b = min(len(cards),m*4) b_ = len(cards) - b b_1 = min(1,b_) c = "Table: " + "...."*b_1 + a print("-"*len(c)) print(c) print("-"*len(c)) #----------------------------------------- |
| # 6330346621 (18.22) 197 (2021-02-08 17:16) def peek_kth_card(cards, k): the_kth_card=cards[(k-1)*4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[0:(k-1)*4]+cards[k*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:(n)*4] new_deck=deck[(n)*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[(m)*4:]+deck[:(m)*4] return new_deck #--------------------------------------- def shuffle(deck): import math s=(deck[1:-1]).split('||') new_deck=list("."*int(len(deck)/4)) new_deck[0::2]=s[0:math.ceil(len(deck)/8)] new_deck[1::2]=s[math.ceil(len(deck)/8):] new_deck="|"+'||'.join(new_deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): c=min(len(cards),m*4) d=max(max(c-len(cards),0),1) print('-------'+'-'*d*4+'-'*c) print('Table:','.'*d*4+cards[len(cards)-c:]) print('-------'+'-'*d*4+'-'*c) #----------------------------------------- |
| # 6330347221 (20.00) 198 (2021-02-08 14:14) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(k-1)*4] + cards[4*(k+1)-4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:n*4] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4:] + deck[0:m*4] return new_deck #--------------------------------------- def shuffle(deck): b = ((len(deck)/4)+1)//2 leftside = deck[0:int(b*4)] rightside = deck[int(b*4):] new_deck = ['0']*int(len(deck)/4) leftside = leftside[1:-1].split('||') rightside = rightside[1:-1].split('||') new_deck[::2] = leftside new_deck[1::2] = rightside new_deck = '|'+'||'.join(new_deck)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): print('-'*len('Table: '+'....'*min(int(len(cards)/4)-m,1) + cards[-m*4:])) print('Table:','....'*min(int(len(cards)/4)-m,1) + cards[-m*4:]) print('-'*len('Table: '+'....'*min(int(len(cards)/4)-m,1) + cards[-m*4:])) #----------------------------------------- |
| # 6330348921 (19.56) 199 (2021-02-07 01:49) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:4*(k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k-1)*4] + cards[4*(k):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4:] + deck[:m*4] return new_deck #--------------------------------------- def shuffle(deck): a = deck.split('|') b = a[1:-1:2] y = a[1:-1:] y[1:-1:2] = b[:-1:] d = b[((len(y)+3)//4)::] w = y[:(len(y)+1)//2] w[1::2] = d[:] x = ('||').join(w) new_deck = '|' + x + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a = min(m,(len(cards)//4)) b = cards[-4*m:] print('-'*(6+len(b)+(4*int(((len(cards)//4)-a)**1e-10)))) print('Table:' + ('....'*int(((len(cards)//4)-a)**1e-10) + b)) print('-'*(6+len(b)+4*int(((len(cards)//4)-a)**1e-10))) #----------------------------------------- |
| # 6330349521 (20.00) 200 (2021-02-07 23:49) def peek_kth_card(cards, k): listpeek = cards.split('|') kth = listpeek[2*k-1] the_kth_card = '|'+kth+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): lr = cards.split('|') z1 = lr[1::2] x = int((len(lr)-1)/2) z = min(x,k) z2 = z1[:z-1]+z1[z:] new_cards = ('|'*int(z2!=[]))+'||'.join(z2)+('|'*int(z2!=[])) return new_cards #--------------------------------------- def deal_n_cards(deck, n): a = deck.split('|') x = int((len(a)-1)/2) b = int((len(a)-1)/2)-n c = a[-2*b::2] d = a[1:2*n:2] cards = ('|'+'||'.join(d)+'|')*int(n!=0) new_deck=('|'+'||'.join(c)+'|')*int(n!=x) return cards, new_deck #--------------------------------------- def cut(deck,m): a = deck.split('|') x = int((len(a)-1)/2) n = int((len(a)-1)/2)-m b = a[-2*n::2]+a[1:2*m:2]*int(m!=x) new_deck = ('|'+'||'.join(b)+'|')*int(m>=0 and m<x)+deck*int(m==x) return new_deck #--------------------------------------- def shuffle(deck): import math a = deck.split('|') b = int((len(a)-1)/2) c = math.ceil(b/2) d = math.floor(b/2) f = a[1:c*2:2] h = a[-d*2::2] s = ('|'*(b-1)).split('|') s[0::2]=f[0::1] s[1::2]=h[0::1] new_deck = ('|'+'||'.join(s)+'|') return new_deck #--------------------------------------- def show_table_cards(cards, m): import math a = cards.split('|') x = int((len(a)-1)/2) w = math.ceil(m/100) y = -(math.ceil((max(x,m)-m)/100)) s = y+1 z = min(x,m) b = a[-2*z::2] c = '|'*w+'||'.join(b)*w+'|'*w print('-----------'+'----'*(z-s)) print("Table:", "...."*(-y)+c) print('-----------'+'----'*(z-s)) #----------------------------------------- |
| # 6330350021 (20.00) 201 (2021-02-08 20:02) def peek_kth_card(cards, k): the_kth_card = cards[k*4-4:k*4:1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:k*4-4:1]+cards[k*4::1] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:n*4:1] new_deck = deck[n*4::1] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4::1]+deck[0:m*4:1] return new_deck #--------------------------------------- def shuffle(deck): aa = len(deck)/4 bb = aa//2 cc = int((aa-bb)*4) ff = int(aa-bb*2) uh = deck[1:cc-ff:] lh = deck[cc+1:-1:] dd = uh.split('|') ee = lh.split('||') dd[1::2]=ee new_deck = '|'+'||'.join(dd)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a = len(cards)/4 b = min( m , a ) c = int(a-b) d = cards[c*4::] e = c*"...." f = e[:4:] g ='Table:'+' '+f+d h = '-'*len(g) print(h) print(g) print(h) #----------------------------------------- |
| # 6330351721 (20.00) 202 (2021-02-07 22:36) def peek_kth_card(cards, k): the_kth_card = cards[(4*k-1)-3:(4*k):1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x = cards.split(cards[(4*k-1)-3:(4*k):1]) new_cards = x[0]+x[1] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n:1] new_deck = deck[4*n::1] return cards, new_deck #--------------------------------------- def cut(deck, m): x = deck[0:4*m:1] new_deck = deck[4*m::1]+x return new_deck #--------------------------------------- def shuffle(deck): a = int((len(deck)/4+1)//2) x = deck[0:a*4:1] y = deck[a*4::1] new_deck = ['0']*int(len(deck)/4) x1= x[1:-1].split('||') y1= y[1:-1].split('||') new_deck[::2] = x1 new_deck[1::2] = y1 new_deck = '||'.join(new_deck) new_deck = ('|'+new_deck+'|') return new_deck #--------------------------------------- def show_table_cards(cards, m): x = 7 + len(cards[-(4*m):]) diff = len(cards)//4-m y = min(max(0,diff),1) print('-'*(x+4*y)) print('Table: '+'....'*y+cards[-(4*m):]) print('-'*(x+4*y)) #----------------------------------------- |
| # 6330352321 (19.11) 203 (2021-02-08 03:08) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k:1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4:1] + cards[4*k::1] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n:1] new_deck = deck[4*n::1] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m::1]+deck[:4*m:1] return new_deck #--------------------------------------- def shuffle(deck): a = deck.split("||") b = a[0].split("|") c = a[-1].split("|") d = b+a[1:-1:1]+c deck_list = d[1:-1:1] x = [] left_deck = deck_list[0:(len(deck_list)+1)//2:1] right_deck = deck_list[(len(deck_list)+1)//2::1] for i in range(len(right_deck)): x.append(left_deck[i]) x.append(right_deck[i]) if len(left_deck)>len(right_deck): x.append(left_deck[-1]) y = "||".join(x) new_deck = "|"+y+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): if m*4 > len(cards) : print("-"*(len(cards)+7)) print("Table: "+cards) print("-"*(len(cards)+7)) else: print("-"*(m*4+11)) print("Table: ...."+cards[-m*4::1]) print("-"*(m*4+11)) #----------------------------------------- |
| # 6330353021 (20.00) 204 (2021-02-07 00:13) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*k-4]+cards[4*k::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[4*n::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m::]+deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): import math s = deck[1:len(deck)-1:] x = [0]* int(len(deck)/4) j = s.split('||') l = int(len(j)) k = j[:int(math.floor((l+1)/2))] m= j[int(math.floor((l+1)/2))::] f = x[::2] g = x[1::2] x[::2] = k x[1::2] = m z = '||'.join(x) new_deck = '|'+z+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): t1 = cards[::-1] t2 = t1[:4*m:] t3 = t2[::-1] a = '.'*(4*(int(len(t3)<len(cards)))) print('-'*(7+int(len(a)+len(t3)))) print('Table: '+a+t3) print('-'*(7+int(len(a)+len(t3)))) #----------------------------------------- |
| # 6330354621 (18.83) 205 (2021-02-08 12:53) def peek_kth_card(cards, k): the_kth_card= cards[(k-1)*4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards= cards.replace(cards[(k-1)*4:k*4],'') return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards= deck[0:n*4] new_deck=deck[n*4:-1]+'|' return cards, new_deck #--------------------------------------- def cut(deck, m): a=deck[0:m*4] new_deck=deck[m*4:-1]+'|'+a return new_deck #--------------------------------------- def shuffle(deck): import math cards=deck[1:-1] card=cards.split('||') q=math.ceil((len(card))/2) x=card[0:q] y=card[q:] new_deck=[1]*len(card) new_deck[0::2]=x new_deck[1::2]=y new_deck='||'.join(new_deck) new_deck='|'+new_deck+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): q=len(cards)-(m*4) p=max(q,0) h=min(q,1) u=max(h,0) x=cards[p::] a="Table:"+' '+(('.'*4)*(u))+x print(("-"*(len(x)+7))+(('-'*4)*u)) print(a) print(("-"*(len(x)+7))+(('-'*4)*u)) #----------------------------------------- |
| # 6330355221 (20.00) 206 (2021-02-08 19:05) def peek_kth_card(cards, k): cards = cards.split('|')[1::2] the_kth_card = '|'+str(cards[k-1])+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards = cards.split('|')[1::2] movecardd = cards[:k-1] moveinput = cards[k:] x = movecardd+moveinput new_cards = '|'*max(min(((len(x))),1),0)+'||'.join(x)+'|'*max(min(((len(x))),1),0) return new_cards #--------------------------------------- def deal_n_cards(deck, n): ydeal = deck.split('|')[1::2] della = ydeal[:n] poltf = ydeal[n:] cards = '|'*max(min(((len(della))),1),0)+'||'.join(della)+'|'*max(min(((len(della))),1),0) new_deck = '|'*max(min(((len(poltf))),1),0)+'||'.join(poltf)+'|'*max(min(((len(poltf))),1),0) return cards, new_deck return cards, new_deck #--------------------------------------- def cut(deck, m): card_decc = deck.split('|')[1::2] z_007 = card_decc[m:] z_008 = card_decc[:m] value_78 = z_007+z_008 new_deck = '|'+'||'.join(value_78)+'|' return new_deck #--------------------------------------- def shuffle(deck): deck01 = ' '.join(deck.split('|')).split() n = len(deck01)-(len(deck01)//2) adec = deck01[:n] ; bdec = deck01[n:] cdec = '/x/'.join(adec).split('/') ; cdec[1::2] = bdec[:n-1] summary_dec = cdec+([bdec[-1]] * (((2**(len(adec)-len(bdec))))%2)) new_deck = '|'+'||'.join(summary_dec)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): tab_dec = ' '.join(cards.split('|')).split() functab = min(len(tab_dec),m) ; valuetab = tab_dec[-m:] valtab = ((2**(len(tab_dec)-functab))+1)%2 destitab = 'Table: '+'....'*(valtab) + '|'+'||'.join(valuetab) + '|' print('-'*len(destitab)) print(destitab) print('-'*len(destitab)) #----------------------------------------- |
| # 6330356921 (20.00) 207 (2021-02-07 15:29) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):k*4:1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*(k-1):1]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n:1] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[0:4*m:1] return new_deck #--------------------------------------- def shuffle(deck): a = deck[0:(((len(deck)//4)+1)//2)*4:1] b = deck[(((len(deck)//4)+1)//2)*4:] a = a.split('|') b = b.split('|') c = abs((((len(a)-1)//2)-((len(b)-1)//2))-1) a += [""]*c a[2:-1:2] = b[1:-1:2] a = '||'.join(a) new_deck = a[1:-1:1] return new_deck #--------------------------------------- def show_table_cards(cards, m): a = (cards[(max(len(cards)-(4*m),0)):]) b = "...."*(min(max((len(cards)-(4*m)),0),1)) + a cards = "Table: " + b c = "-"*len(cards) print(c) print(cards) print(c) #----------------------------------------- |
| # 6330357521 (0.00) 208 (2021-02-08 01:23) |
| # 6330358121 (20.00) 209 (2021-02-06 00:14) def peek_kth_card(cards, k): lcards=' '.join(cards.split('|')).split() index=lcards[k-1] the_kth_card='|'+index+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): lc=' '.join(cards.split('|')).split() new=lc[:k-1]+lc[k:] j=(2**len(new)+1)%2 new_cards='|'*j+'||'.join(new)+'|'*j return new_cards #--------------------------------------- def deal_n_cards(deck, n): d=' '.join(deck.split('|')).split() bfcards=d[:n];bfnew_deck=d[n:] bc=(2**(len(d[:n]))+1)%2;bn=(2**(len(d[n:]))+1)%2 cards='|'*bc+'||'.join(bfcards)+'|'*bc new_deck='|'*bn+'||'.join(bfnew_deck)+'|'*bn return cards, new_deck #--------------------------------------- def cut(deck, m): ldeck=' '.join(deck.split('|')).split() ld1=ldeck[:m];ld2=ldeck[m:] new_deck='|'+'||'.join(ld2+ld1)+'|' return new_deck #--------------------------------------- def shuffle(deck): d3=' '.join(deck.split('|')).split() n=len(d3)-(len(d3)//2) d3a=d3[:n];d3b=d3[n:] d3c='/x/'.join(d3a).split('/');d3c[1::2]=d3b[:n-1] l=d3c+([d3b[-1]]*(((2**(len(d3a)-len(d3b))))%2)) new_deck='|'+'||'.join(l)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a=' '.join(cards.split('|')).split() b=min(len(a),m);c=a[-m:] e=((2**(len(a)-b))+1)%2 d='Table: '+'....'*(e)+'|'+'||'.join(c)+'|' print('-'*len(d)) print(d) print('-'*len(d)) #----------------------------------------- |
| # 6330360321 (18.89) 210 (2021-02-08 13:13) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:(k*4)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k-1)*4] + cards[(k*4):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:(n*4)] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4:]+deck[:m*4] return new_deck #--------------------------------------- def shuffle(deck): a = deck[1:-1].split("||") b = int(len(a)%2) c1 = a[:int((len(a)+b)/2)] c2 = a[int((len(a)-b)/2):] v = [0]*(int(len(a))) v[0::2],v[1::2] = c1,c2 new_deck = "|" + "||".join(v) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): a = 15 b = (4*m)-(len(cards)) b>>= a g = (-1*b) show = "Table: " +'....'*(g)+ cards[-m*4:] print('-'*(int(len(show)))) print(show) print('-'*(int(len(show)))) #----------------------------------------- |
| # 6330361021 (20.00) 211 (2021-02-07 14:02) def peek_kth_card(cards, k): the_kth_card = cards[(4*k-4):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(4*k-4)]+cards[4*k::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n:] new_deck = deck[4*n::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m::]+deck[:4*m:] return new_deck #--------------------------------------- def shuffle(deck): sh = deck.split("||") sh[0]=sh[0][1::] sh[len(sh)-1]=sh[len(sh)-1][:2:] sh = sh[::-1] sh_right = sh[:int((len(sh)/2)):] sh_right = sh_right[::-1] sh_left = sh[int((len(sh)/2))::] sh_left = sh_left[::-1] new_deck = sh[::-1] new_deck[::2] = sh_left new_deck[1::2] = sh_right new_deck = '||'.join(new_deck) new_deck = '|'+ new_deck + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): n_cards = len(cards)/4 a = min(1, n_cards-m) a = max(0, a) print("-"*(7+(4*a)+len(cards[-4*m::]))) print("Table:",'....'*a+cards[-4*m::]) print("-"*(7+(4*a)+len(cards[-4*m::]))) #----------------------------------------- |
| # 6330362621 (18.67) 212 (2021-02-06 21:01) def peek_kth_card(cards, k): kard = cards.strip('|').split('||') the_kth_card = '|' + (kard[k-1]) + '|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): kard = cards.strip('|').split('||') kard = kard[0:k-1]+kard[k::] new_cards = '||'.join(kard) new_cards ='|'*(not str(len(kard)).startswith('0'))+ new_cards + '|'*(not str(len(kard)).startswith('0')) return new_cards #--------------------------------------- def deal_n_cards(deck, n): dec=deck.strip('|').split('||') kard = dec[0:n] cards = '|'*(not str(len(kard)).startswith('0'))+ '||'.join(kard) + '|'*(not str(len(kard)).startswith('0')) new_dec = dec[n:] new_deck = '|'*(not str(len(new_dec)).startswith('0'))+ '||'.join(new_dec) + '|'*(not str(len(new_dec)).startswith('0')) return cards, new_deck #--------------------------------------- def cut(deck, m): dec1 = deck.strip('|').split('||') new_dec = dec1[m:]+dec1[:m] new_deck = '|'*(not str(len(new_dec)).startswith('0'))+ '||'.join(new_dec) + '|'*(not str(len(new_dec)).startswith('0')) return new_deck #--------------------------------------- def shuffle(deck): dec = deck.strip('|').split('||') num = (len(dec)+1)//2 dec[0::2],dec[1::2] = dec[:num],dec[num:] new_deck = '|'*(not str(len(dec)).startswith('0'))+ '||'.join(dec) + '|'*(not str(len(dec)).startswith('0')) return new_deck #--------------------------------------- def show_table_cards(cards, m): dec = cards.strip('|').split('||') dek = dec[-m:] panglnwza = '|'*(not str(len(dek)).startswith('0'))+ '||'.join(dek) + '|'*(not str(len(dek)).startswith('0')) b = str(len(dec) - m) panglnwza = 'Table: ' + (('....'*(not b.startswith('-')))*(not b.startswith('0')) + panglnwza)*(not str(m).startswith('0')) print(panglnwza) #----------------------------------------- |
| # 6330365521 (20.00) 213 (2021-02-04 22:36) def peek_kth_card(cards, k): the_kth_card=cards[4*(k-1):4*k:] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards.split("|") new_cards=new_cards[:2*(k-1)+1:]+new_cards[2*k+1::] new_cards="|".join(new_cards) return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:4*n:] new_deck=deck[4*n::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m::]+deck[:4*m:] return new_deck #--------------------------------------- def shuffle(deck): deck=deck.strip("|") new_deck=deck.split("||") a=len(new_deck)-len(new_deck)//2 hl=new_deck[0:a:] hr=new_deck[a::] new_deck[0::2]=hl new_deck[1::2]=hr new_deck="||".join(new_deck) new_deck="|"+new_deck+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): cardsrig=cards[-4*m::] cardsle=cards[0:-4*m:] a=min(len(cardsle),1) b="Table: "+"...."*a+cardsrig print("-"*len(b)) print("Table:","...."*a+cardsrig) print("-"*len(b)) #----------------------------------------- |
| # 6330366121 (20.00) 214 (2021-02-06 15:45) def peek_kth_card(cards, k): the_kth_card = cards[1:-1] the_kth_card = the_kth_card.split("||") the_kth_card = the_kth_card[k-1] the_kth_card = "|"+the_kth_card+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[1:-1] new_cards = new_cards.split("||") new_cards = new_cards[:k-1]+new_cards[k:] new_cards = "|"*min(len(new_cards),1)+"||".join(new_cards)+"|"*min(len(new_cards),1) return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:n*4] new_deck = deck[n*4::1] return cards, new_deck #--------------------------------------- def cut(deck, m): cards = deck[0:m*4] new_deck = deck[m*4::1] new_deck = new_deck+cards return new_deck #--------------------------------------- def shuffle(deck): new_deck = deck[1:-1] new_deck = new_deck.split("||") pond = new_deck[0:len(new_deck)//2+len(new_deck)%2] lln = new_deck[len(new_deck)//2+len(new_deck)%2::1] ex = ["0"]*len(new_deck) ex[0::2] = pond ex[1::2] = lln new_deck = "|"+"||".join(ex)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards[1:-1] black = cards.split("||") pok = black[-m:] deng = "|"+"||".join(pok)+"|" casino = "...."*min(1,-(m-len(black)))+deng print ("-"*((len(casino)+len("table:")+1))) print ("Table:"+" "+str(casino)) print ("-"*((len(casino)+len("table:")+1))) #----------------------------------------- |
| # 6330367821 (20.00) 215 (2021-02-08 15:46) def peek_kth_card(cards, k): the_kth_card = cards[(4*(k-1)):(4*k):1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(4*(k-1)):] + cards[(4*k)::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:(4*n):] new_deck = deck[(4*n)::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(4*m)::] + deck[:(4*m):] return new_deck #--------------------------------------- def shuffle(deck): x = deck[1:-1].split("||") y = [""]*len(x) y[::2] = x[:(len(x)+1)//2:] y[1::2] = x[(len(x)+1)//2::] new_deck = "|"+"||".join(y)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): print('-------' + '-' * int((4*(min((len(cards[:((-4)*m):])/4), 1)))+(len(cards[((-4)*m)::])))) print('Table: ' + '....' * int((min((len(cards[:((-4)*m):])/4), 1))) + cards[((-4)*m)::]) print('-------' + '-' * int((4*(min((len(cards[:((-4)*m):])/4), 1)))+(len(cards[((-4)*m)::])))) #----------------------------------------- |
| # 6330370621 (20.00) 216 (2021-02-04 16:20) def peek_kth_card(cards, k): the_kth_card = cards[(4*(k-1)):(4*k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(4*(k-1))]+cards[(4*k):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): a = deck.split("||") a0 = str(a[0]); ad = str(a[len(a)-1]) a[0] = a0[1:]; a[len(a)-1] = ad[:-1] l1 = a[:(len(a)+1)//2] l2 = a[(len(a)+1)//2:] L = [""]*(len(l1)+len(l2)) L[::2] = l1 L[1::2] = l2 L[0] = "|"+L[0] L[-1] = L[-1]+"|" new_deck = "||".join(L) return new_deck #--------------------------------------- def show_table_cards(cards, m): x = "Table:"+" "+"...."*min(max(0, (len(cards)-4*m))//4, 1)+cards[len(cards)-min(4*m, len(cards)):] print("-"*len(x)) print(x) print("-"*len(x)) #----------------------------------------- |
| # 6330371221 (15.56) 217 (2021-02-08 23:59) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*(k-1)]+cards[4*k:4*len(cards)] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[4*n:4*len(deck)] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:4*len(deck)] + deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): Sai = deck[0:(((len(deck)//4)+1)//2)*4:1] Kha = deck[(((len(deck)//4)+1)//2)*4:] left = Sai[1:(len(Sai)-1)].split("||") right = Kha[1:(len(Kha)-1)].split("||") a = [0]*(len(right)+len(left)) a[0::2]=left a[1::2]=right b = '||'.join(a) new_deck = b[2]+ b[0:len(b)]+b[2] return new_deck #--------------------------------------- def show_table_cards(cards, m): x = int(min((((len(cards))//4),-m),1)) y = int(min(((len(cards))//4),m)) k = ("-")*len("Table: "+"."*(4*x)+cards[-(4*y):]) print(k) print("Table: "+"."*(4*x)+cards[-(4*y):]) print(k) #----------------------------------------- |
| # 6330372921 (19.11) 218 (2021-02-08 16:35) def peek_kth_card(cards, k): a = cards[1:-1] b = [''] + a.split('||') the_kth_card = '|'+b[k]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*(k-1)] + cards[4*(k):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): a = int(int(((len(deck)/4)+1)//2)*4) b = deck[0:a] c = deck[a:] d = b[1:-1] e = c[1:-1] f = d.split('||') g = e.split('||') new_deck = ['']*int((len(deck)/4)) new_deck[::2] = f[::1] new_deck[1::2] = g[::1] new_deck = '||'.join(new_deck) new_deck = '|'+new_deck+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards[1:-1] b = a.split('||') c = len(b) d = min(c,m) #min=3 e = b[-d:] e = '||'.join(e) e = '|'+e+'|' f = 'Table: ' g = '....'*min(1,4-m) print('-'*len(f+g+e)) print(f+g+e) print('-'*len(f+g+e)) #----------------------------------------- |
| # 6330374121 (20.00) 219 (2021-02-07 21:30) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k-1)*4] + cards[k*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:n*4] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4:] + deck[:m*4] return new_deck #--------------------------------------- def shuffle(deck): li = deck[1:-1].split("||") new_li = [""]*len(li) new_li[::2] = li[:(len(li)+1)//2:] new_li[1::2] = li[(len(li)+1)//2::] new_deck = "|"+"||".join(new_li)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): str = "...." + cards[-m*4:] new_str = "Table: " + str[-len(cards):] print("-"*len(new_str)) print(new_str) print("-"*len(new_str)) #----------------------------------------- |
| # 6330375821 (18.67) 220 (2021-02-08 20:52) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k-1)*4]+ cards[(k)*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:n*4] new_deck=deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck= deck[m*4:]+ deck[:m*4] return new_deck #--------------------------------------- def shuffle(deck): from math import ceil d = deck[1:-1].split('||') n=d.copy() n[::2] = d[:ceil(len(d)/2)] n[1::2] = d[ceil(len(d)/2):] n = '||'.join(n) new_deck = '|'+n+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): c = int(min(len(cards)/4,m)) a = int(len(cards)/4) c2 ='....'*(a-c> 0)+cards[(a-c)*4:] print('-------'+'----'*int(len(c2)/4)) print('Table: ',c2) print('-------'+'----'*int(len(c2)/4)) #----------------------------------------- |
| # 6330376421 (18.89) 221 (2021-02-08 00:26) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k:] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:4*n] new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): deck=deck[1:-1].split("||") deck[0::2],deck[1::2]=deck[:(len(deck)//2)-len(deck)%2:],deck[(len(deck)//2)-len(deck)%2:] new_deck = "|"+"||".join(deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): cards=cards[1:-1].split("||") #แยกเป็นlist a=[] a.extend(cards[:-(m+1):-1]) a=a[:(len(cards)):] a=a[::-1] a="|"+"|,|".join(a)+"|" a=a.split(",") a=a[::-1] a+=['....'] a=a[:len(cards):] a=a[::-1] e=len(a) a=''.join(a) print("-------"+"----"*e) print("Table:",a) print("-------"+"----"*e) #----------------------------------------- |
| # 6330377021 (19.78) 222 (2021-02-07 23:58) def peek_kth_card(cards, k): the_kth_card = cards[(4*k-4):(4*k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(4*k-4)]+cards[(4*k):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): d1 = deck[:(((len(deck)//4)+1)//2)*4] d2 = deck[(((len(deck)//4)+1)//2)*4:] d1 = d1.split("|") d2 = d2.split("|") z = abs((((len(d1)-1)//2)-((len(d2)-1)//2))-1) d1 += [""]*z d1[2:-1:2] = d2[1:-1:2] d1 = "||".join(d1) new_deck = d1[1:-1] return new_deck #--------------------------------------- def show_table_cards(cards, m): t = cards[(max(len(cards)-(4*m),0)):] b = "...."*(min(max((len(cards)-(4*m)),0),1))+t print("-"*(len(cards)+7)) print("Table:",b) print("-"*(len(cards)+7)) #----------------------------------------- |
| # 6330378721 (20.00) 223 (2021-02-08 21:05) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k:] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*k-4:]+cards[4*k::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n:] new_deck = deck[4*n::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = (deck[4*m::]+deck[:4*m:]) return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1:].split('||') n_less = (len(deck)//2) n_more = ((len(deck))-(n_less)) deck[0::2],deck[1::2] = deck[0:n_more:1],deck[n_more::] new_deck = '|'+'||'.join(deck)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards[1:-1:].split('||') cards = ("...."*min(max(len(cards)-m,0),1))+"|"+"||".join(cards[len(cards)-min(len(cards),m):])+"|" print('-'*(len('Table: '+cards))) print('Table:',cards) print('-'*(len('Table: '+cards))) #----------------------------------------- |
| # 6330379321 (20.00) 224 (2021-02-07 21:09) def peek_kth_card(cards, k): the_kth_card =cards[4*k-4:4*k:] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): left_cards=cards[:4*(k-1)] right_cards=cards[4*(k)::] new_cards=left_cards+right_cards return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:4*n:] new_deck=deck[4*n::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m::]+deck[:4*m:] return new_deck #--------------------------------------- def shuffle(deck): import math x = (len(deck) / 2) % 4 + len(deck) / 2 left_deck = deck[0:int(x):] left = list(left_deck) right_deck = deck[int(x)::] new_deck = [0] * int(len(deck) / 4) left_deck =left_deck.split('|') left_deck =left_deck[1::2] right_deck =right_deck.split('|') right_deck =right_deck[1::2] new_deck[::2] = left_deck[::] new_deck[1::2] = right_deck[::] new_deck='||'.join(new_deck) y=int(len(new_deck)) y=10**y y=str(y) y=y[-1] y=(int(y)-1)*-1 new_deck=(y*'|')+new_deck+('|'*y) return new_deck #--------------------------------------- def show_table_cards(cards, m): num_card=int(len(cards)/4) show_deck=cards[-(4*m)::1] dot='....'*((-1)*((m//num_card)-1)) result = 'Table: '+dot+show_deck print('-'*int(len(result))) print(result) print('-'*int(len(result))) #----------------------------------------- |
| # 6330380921 (19.11) 225 (2021-02-08 16:38) def peek_kth_card(cards, k): string = cards[1:-1:] choose_index = string.split('||') choose_card = choose_index[k-1:k:] the_kth_card = '|'*min(1,k) + '|'.join(choose_card) + '|'*min(1,k) return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): st = cards.split('|') ch_index1 = st[1::2] del ch_index1[k-1] new_cards = '|'*min(1,len(ch_index1)) +'||'.join(ch_index1) + '|'*min(1,len(ch_index1)) #print(st) #print('ch1',ch_index1) #print('front',front) #print('back',back) #print('str',combstr) return new_cards #--------------------------------------- def deal_n_cards(deck, n): s_d1 = deck.split('|') ch_ind1 = s_d1[1::2] ch_ind2 = ch_ind1[:n:] ch_ind3 = ch_ind1[n::] cards = '|'*min(1,len(ch_ind2)) + '||'.join(ch_ind2) + '|'*min(1,len(ch_ind2)) new_deck = '|'*min(1,len(ch_ind3)) + '||'.join(ch_ind3) + '|'*min(1,len(ch_ind3)) #print(s_d) #print(ch_ind1) #print('seldeck',cards) return cards, new_deck #--------------------------------------- def cut(deck, m): s_d2 = deck.split('|') ch_ind2 = s_d2[1::2] selectpart = ch_ind2[:m:] pre_new_deck = ch_ind2[m::] post_new_deck = pre_new_deck + selectpart new_deck = '|'*min(1,max(len(selectpart),len(pre_new_deck))) + '||'.join(post_new_deck) + '|'*min(1,max(len(selectpart),len(pre_new_deck))) #print('selectpart',selectpart) #print('pre',pre_new_deck) #print('post',post_new_deck) #print('s_d2',s_d2) return new_deck #--------------------------------------- def shuffle(deck): s_d2 = deck.split('|') ch_ind2 = s_d2[1::2] first_half = ch_ind2[:len(ch_ind2)//2 + len(ch_ind2)%2:] last_half = ch_ind2[len(ch_ind2)//2 + len(ch_ind2)%2::] free = [''] varied = len(ch_ind2)*free varied[0::2] = first_half varied[1::2] = last_half comblist = '|'+'||'.join(varied)+ '|' new_deck = comblist #print(s_d2) #print(first_half) #print(last_half) #print(varied) #print(comblist) return new_deck #--------------------------------------- def show_table_cards(cards, m): start = cards[0:3:] print('-'*m + '-' + '-'*4*(((len(cards)//4))-1)) print('Table:','....'*(min(1,max((len(cards)//4)-m,0))%2)+cards[4*max(0,(len(cards)//4)-m):(len(cards)):] ) print('-'*m + '-' + '-'*4*(((len(cards))//4)-1)) #----------------------------------------- |
| # 6330381521 (19.33) 226 (2021-02-08 21:45) def peek_kth_card(cards, k): cards = cards.split("|")[1::2] the_kth_card = "|" + str(cards[k-1]) + "|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards = cards.split("|")[1::2] x = cards[:k-1] y = cards[k:] z = x + y new_cards = "|"*max(min(((len(z))),1),0) + "||".join(z) + "|"*max(min(((len(z))),1),0) return new_cards #--------------------------------------- def deal_n_cards(deck, n): x = deck.split("|")[1::2] add = x[n:] show = x[:n] new_deck = "|"*max(min(((len(add))),1),0) + "||".join(add) + "|"*max(min(((len(add))),1),0) cards = "|"*max(min(((len(show))),1),0) + "||".join(show) + "|"*max(min(((len(show))),1),0) return cards, new_deck #--------------------------------------- def cut(deck, m): card_deck = deck.split("|")[1::2] x = card_deck[:m] y = card_deck[m:] z = x + y new_deck = "|" + "||".join(z) + "|" return new_deck #--------------------------------------- def shuffle(deck): alternate = deck.split("|")[1::2] w = len(alternate) + 1 x = alternate[:w//2] y = alternate[w//2:] r = [0]*len(alternate) r[::2] = x r[1::2] = y new_deck = "|" + "||".join(r) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): x = cards.split("|")[1::2] y = x[-m:] q = "|" + "||".join(y) + "|" w = "Table: " + "...."*min(max(((len(x))-m),0),1) + q print(len(w)*"-") print(w) print(len(w)*"-") #----------------------------------------- |
| # 6330382121 (20.00) 227 (2021-02-08 23:07) def peek_kth_card(cards, k): a = cards.split('|') the_kth_card = '|' + a[2*k-1] + '|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*(k-1)] + cards[4*(k-1) + 4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck[0:4*m] b = deck[4*m:] new_deck = b + a return new_deck #--------------------------------------- def shuffle(deck): a = deck.split('|') b = len(a)//2 + 1 left = a[1:b] right = a[b+round(len(a)/4)- len(a)//4::2] left[1::2] = right new_deck = '|' + '||'.join(left) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a = len(cards) y = len(cards)/4.000001 x = '..' b = cards[::-1] c = b[:4*m] c = c[::-1] d = 'Table: ' + (int((abs((((m-y)-(abs(m-y)))/abs((m-y))))))) * x + c e = len(d) print('-' * e) print('Table: ' + (int((abs((((m-y)-(abs(m-y)))/abs((m-y))))))) * x + c) print('-' * e) #----------------------------------------- |
| # 6330384421 (20.00) 228 (2021-02-07 22:23) def peek_kth_card(cards, k): q=(k-1)*4 w=(k*4) the_kth_card=cards[q:w] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): q=(k-1)*4 w=(k*4) new_cards=cards[:q]+cards[w:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): q=n*4 cards=deck[:q] new_deck=deck[q:] return cards, new_deck #--------------------------------------- def cut(deck, m): q=m*4 new_deck=deck[q:]+deck[:q] return new_deck #--------------------------------------- def shuffle(deck): q = deck[1:-1] w = q.split('||') e = len(w) a = w[:e//2+e%2] s = w[e//2+e%2:] d = [' ']*e d[::2] = a;d[1::2] = s new_deck = '|' + '||'.join(d) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): q = cards[1:-1] w = q.split('||') e=w[-1:-m-1:-1] e=e[::-1] d=("....")*min(len(w)-m,1) s = d+'|' + '||'.join(e) + '|' print('-------'+len(s)*('-')) print('Table: '+s) print('-------'+len(s)*('-')) #----------------------------------------- |
| # 6330386721 (20.00) 229 (2021-02-08 23:43) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k-1)*4] + cards[k*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:n*4] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4:] + deck[:m*4] return new_deck #--------------------------------------- def shuffle(deck): a = int( ( len(deck) ) / 4 ) card_list = ['']*a x = deck.strip('|') y = x.split('||') card_list[0::2] = y[0:((a) - (a//2))] card_list[1::2] = y[((a) - (a//2)):a+1] z = '|' + '||'.join(card_list) + '|' new_deck = z return new_deck #--------------------------------------- def show_table_cards(cards, m): print('-------' + '----'*(min(((len(cards) // 4)),m+1) ) ) print('Table:' + ' ' + '....'*( min(((len(cards) // 4) - m),1) ) + cards[m*(-4):] ) print('-------' + '----'*(min(((len(cards) // 4)),m+1) ) ) #----------------------------------------- |
| # 6330387321 (19.33) 230 (2021-02-08 22:43) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1)]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[:4*m:]+deck[4*m::] return new_deck #--------------------------------------- def shuffle(deck): import math import re a = re.findall('....', deck) b = math.ceil(len(a)/2) c = a[:b] d = a[b:] e = [None]*(len(c)+len(d)) e[::2] = c e[1::2] = d new_deck = "".join(e) return new_deck #--------------------------------------- def show_table_cards(cards, m): import re a = re.findall('....', cards) b = [len(a), m] c = int(b[1]-b[0]) d = int(max(b)-abs(c)) e = cards[len(cards)-(4*d):] cards = "".join(e) f = int(len(a)-d) g = int(f/(f or not f)) h = "Table: "+"...."*(g)+cards i = "-"*len(h) print(i) print(h) print(i) #----------------------------------------- |
| # 6330388021 (20.00) 231 (2021-02-06 09:12) def peek_kth_card(cards, k): the_kth_card=cards[(k-1)*4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[:(k-1)*4]+cards[k*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:n*4] new_deck=deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[m*4:]+deck[:m*4] return new_deck #--------------------------------------- def shuffle(deck): d=deck.split("||") d[0]=d[0][1:] d[-1]=d[-1][:2] a=int((len(d)+1)//2) b=d[:a] c=d[a:] n=[0]*len(d) n[::2]=b[0:] n[1::2]=c[0:] new_deck="|"+"||".join(n)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): dif=(len(cards)-m*4)/4 a=int((abs(dif)+(dif))/(2*dif-0.1)) t="Table: "+"...."*a+cards[-4*m:] print("-"*len(t)) print(t) print("-"*len(t)) #----------------------------------------- |
| # 6330389621 (14.89) 232 (2021-02-08 23:17) def peek_kth_card(cards, k): the_kth_card=cards[4*k-4:k*4:] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[:(k-1)*4:] + cards[k*4::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[:4*m:]+deck[4*m::] return new_deck #--------------------------------------- def shuffle(deck): y=deck[1:len(deck)-1:].split("||") list_shuffle=len(y)*[0] z=len(y)-(len(y)//2) list_shuffle[::2]=y[:z] list_shuffle[1::2]=y[z:] new_deck="|"+"||".join(y)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): x=cards[4*((len(cards)//4)-m*4)::] s="Table: "+"...."*(min(1,(len(cards)//4)-m))+x print("-"*(len(s))) print(s) print("-"*(len(s))) #----------------------------------------- |
| # 6330391821 (20.00) 233 (2021-02-07 22:05) def peek_kth_card(cards, k): x = cards.split("|") y = (2*k)-1 the_kth_card = "|"+str(x[y])+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x = cards.split("|") z = x[:(2*k)-1]+x[(2*k)+1:] new_cards = "|".join(z) return new_cards #--------------------------------------- def deal_n_cards(deck, n): x = deck.split("|") a1 = x[:(2*n)+1] cards = "|".join(a1) a2 = x[(2*n):] new_deck = "|".join(a2) return cards, new_deck #--------------------------------------- def cut(deck, m): x = deck.split("|") x= x[1::2] a1 = x[m:]+x[:m] new_deck = "|"+"||".join(a1)+"|" return new_deck #--------------------------------------- def shuffle(deck): x = deck.split("|") nani = int((len(x)/4)+((len(x)/4)%1)) a = (x[1::2]) nani1 = float((((len(x))/4)+0.5)%1) nani2 = int(nani1+(nani1%1)) a1 = a+(a[nani2:]*(nani-1)) a2 = a1[::nani] new_deck = "|"+"||".join(a2)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): x = cards.split("|") x = x[1::2] a1 = ["Table: ","Table: ...."] y = "|"+"||".join(x[-m:])+"|" a2 = str(a1[m<len(x)::2]) a3 = a2[2:-2] z = a3+y print("-"*(len(z))) print(z) print("-"*(len(z))) #----------------------------------------- |
| # 6330392421 (20.00) 234 (2021-02-04 19:05) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*(k-1)]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): deckx = deck.split('|') deckx = deckx[1::2] x = deckx[0:int((len(deckx)+1)/2)] y = deckx[int((len(deckx)+1)/2):] new_deck = [0]*int(len(deckx)) new_deck[::2] = x new_deck[1::2] = y new_deck = '|'+'||'.join(new_deck)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cards_list = cards.split('|') cards_list = cards_list[1:-1:2] showing_no = int(min(m, len(cards_list))) cardx = cards_list[-showing_no::] cardx = '|'+'||'.join(cardx)+'|' develop = '....'*min((len(cards_list)-m),1) + cardx final = 'Table: '+ develop print('-'*len(final)) print(final) print('-'*len(final)) #----------------------------------------- |
| # 6330394721 (19.11) 235 (2021-02-08 21:49) def peek_kth_card(cards, k): a = cards[1:-1] a=a.split('||') the_kth_card=a[k-1] the_kth_card = '|'+the_kth_card+'|' if the_kth_card=='||': the_kth_cards="" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): a = cards[1:-1] a=a.split('||') a.pop(k-1) new_cards="||".join(a) new_cards='|'+new_cards+'|' if new_cards=='||': new_cards="" return new_cards #--------------------------------------- def deal_n_cards(deck, n): b=deck[1:-1] b=b.split('||') cards='|'+"||".join(b[0:n])+'|' del b[0:n] new_deck='|'+"||".join(b)+"|" if cards=='||': cards="" if new_deck=='||': new_deck="" return cards, new_deck #--------------------------------------- def cut(deck, m): c=deck[1:-1] c=c.split('||') d=c[:m] cards='|'+"||".join(c[:m])+'|' del c[:m] c=c+d new_deck='|'+"||".join(c)+'|' if new_deck=='||': new_deck="" return new_deck #--------------------------------------- def shuffle(deck): d=deck[1:-1] d=d.split('||') e=d[:int(0.5+len(d)/2)] f=d[int(0.5+len(d)/2):] new_deck=[None]*(len(d)) new_deck[::2]=e new_deck[1::2]=f new_deck='|'+'||'.join(new_deck)+'|' if new_deck=='||': new_deck="" return new_deck #--------------------------------------- def show_table_cards(cards, m): x=cards[1:-1] x=x.split('||') if m > len(x): l="Table: |"+"||".join(x)+'|' print("-"*len(l)) print(l) print("-"*len(l)) else: j="Table: ...."+"|"+"||".join(x[(len(x)-m):])+"|" print("-"*len(j)) print(j) print("-"*len(j)) #----------------------------------------- |
| # 6330395321 (18.67) 236 (2021-02-08 21:47) def peek_kth_card(cards, k): the_kth_card = cards[1:-1].split("||") the_kth_card = the_kth_card[k-1] the_kth_card = "|"+the_kth_card+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[1:-1].split("||") new_cards = new_cards[:k-1]+new_cards[k:] new_cards = "|"*min(len(new_cards),1)+"||".join(new_cards)+"|"*min(len(new_cards),1) return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[1:-1].split("||") cards = cards[:n] cards = "|"*min(len(cards),1)+"||".join(cards)+"|"*min(len(cards),1) new_deck = deck[1:-1].split("||") new_deck = new_deck[n:] new_deck = "|"*min(len(new_deck),1)+"||".join(new_deck)+"|"*min(len(new_deck),1) return cards, new_deck #--------------------------------------- def cut(deck, m): leftcards = deck[1:-1].split("||") leftcards = leftcards[:m] leftcards = "|"+"||".join(leftcards)+"|" new_deck = deck[1:-1].split("||") new_deck = new_deck[m:] new_deck = "|"+"||".join(new_deck)+"|" new_deck = new_deck + leftcards return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1].split("||") leftdeck = deck[:(len(deck)//2)+len(deck)%2] rightdeck = deck[(len(deck)//2)+len(deck)%2:] box = ["1"]*len(deck) box[0::2] = leftdeck box[1::2] = rightdeck new_deck = "|"+"||".join(box)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards[1:-1] allcards = cards.split("||") showcard1 = allcards[-m:] showcard2 = "|"+"||".join(showcard1)+"|" showcard3 = "...."*min(1,-m+len(allcards))+showcard2 print("-"*(len(showcard3)+len("table:")+1)) print("Table:"+" "+str(showcard3)) print("-"*(len(showcard3)+len("table:")+1)) #----------------------------------------- |
| # 6330396021 (20.00) 237 (2021-02-08 01:48) def peek_kth_card(cards, k): the_kth_card = cards[1:-1].split("||") #เอาตัวแรกกับตัวหลังออกแล้วแปลงเป็นlist the_kth_card = "|"+the_kth_card[int(k)-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards1 = cards[:4*int(k-1)] new_cards2 = cards[int(k)*4:] new_cards = new_cards1 + new_cards2 return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:n*4] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): deck_1 = deck[:m*4] new_deck = deck[m*4:] + deck_1 return new_deck #--------------------------------------- def shuffle(deck): new_deck1 = deck[1:-1].split("||") new_deck2 = deck[1:-1].split("||") new_deck99 = math.ceil(int(len(new_deck1))/2) new_deck3 = new_deck1[:int(new_deck99)] #listแบ่งครึ่งกองแรก new_deck3 = "||".join(new_deck3)+"|"*int(0**max(0,len(deck)/4%2)) new_deck = new_deck3[0:].split("|") new_deck4 = new_deck2[int(new_deck99):] #listแบ่งครึ่งกองหลัง new_deck[1::2] = new_deck4 new_deck = "|"+"||".join(new_deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): show1 = len(cards)/4 m1 = show1 - m cards1 = cards[-m*4:] print("-------" + "----"*(int(min(1, m1))) + "----"*int((int(len(cards1))/4))) print("Table: " + "...."*int(min(1, m1))+cards1) print("-------" + "----"*(int(min(1, m1))) + "----"*int((int(len(cards1))/4))) #----------------------------------------- |
| # 6330397621 (19.33) 238 (2021-02-08 22:17) def peek_kth_card(cards, k): c1 = cards.split('|')[1::2] the_kth_card = '|'+str(c1[k-1])+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): c2 = cards.split('|')[1::2] a = c2[k:] b = c2[:k-1] c = a+b new_cards = '|'*max(min(((len(c))),1),0)+'||'.join(c)+'|'*max(min(((len(c))),1),0) return new_cards #--------------------------------------- def deal_n_cards(deck, n): a = deck.split('|')[1::2] b = a[n:] c = a[:n] new_deck = '|'*max(min(((len(b))),1),0)+'||'.join(b)+'|'*max(min(((len(b))),1),0) cards = '|'*max(min(((len(c))),1),0)+'||'.join(c)+'|'*max(min(((len(c))),1),0) return cards, new_deck #--------------------------------------- def cut(deck, m): deck = deck.split('|')[1::2] a = deck[m:] b = deck[:m] c = a+b new_deck = '|'+'||'.join(c)+'|' return new_deck #--------------------------------------- def shuffle(deck): a = deck.split('|')[1::2] b = len(a)+1 c = a[b//2:] d = a[:b//2] e = [0]*len(a) e[1::2] = c e[::2] = d new_deck = '|' + '||'.join(e) +'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards.split('|')[1::2] b = a[-m:] c = '|'+'||'.join(b)+'|' d = "Table: "+"...."*min(max(((len(a))-m),0),1)+c print(len(d)*'-') print(d) print(len(d)*'-') #----------------------------------------- |
| # 6330398221 (20.00) 239 (2021-02-06 18:19) def peek_kth_card(cards, k): cards1=cards.split('|') x1=cards1[1:-1:2] #เอาช่องว่างออก the_kth_card='|'+x1[k-1]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[0:4*k-4:]+cards[4*k::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:4*n:] new_deck=deck[4*n::] return cards, new_deck #--------------------------------------- def cut(deck, m): deck4=deck.split('|') x4=['']+deck4[1:-1:2] cut=x4[1:m+1:] new=x4[m+1::]+cut new_deck='|'+'||'.join(new)+'|' return new_deck #--------------------------------------- def shuffle(deck): deck5=deck.split('|') x5=deck5[1:-1:2] s=(len(x5)+1)//2 left=x5[0:s:] right=x5[s::] shuf=[0]*len(x5) #สร้างลิสต์ไว้รอรับค่าไพ่ shuf[0::2]=left #ไพ่ครึ่งซ้าย shuf[1::2]=right #ไพ่ครึ่งขวา new_deck='|'+'||'.join(shuf)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cards6=cards.split('|') x6=cards6[1:-1:2] blank=max(0,len(x6)-m) blank1=min(blank,1) tab=['....']*blank1 choose=x6[-1:(-m-1):-1] choose1=choose[-1::-1] table='Table: '+''.join(tab)+'|'+'||'.join(choose1)+'|' print('-'*len(table)) print(table) print('-'*len(table)) #----------------------------------------- |
| # 6330399921 (20.00) 240 (2021-02-06 23:29) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1)] + cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): front = deck[:4*m] new_deck = deck[4*m:]+front return new_deck #--------------------------------------- def shuffle(deck): n = int((len(deck)/4)//2) m = int((len(deck)/4)-n) lis1 = deck[:4*m].strip('|').split('||') lis2 = deck[4*m:].strip('|').split('||') lis = ['']*(int(len(deck)/4)) lis[::2]= lis1[::1] lis[1::2]= lis2[::1] new_deck ='|'+'||'.join(lis)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): y = len(cards)/4-m x = '....'*int(y/(abs(y)-0.0000001))+cards[-4*m:] print('------'+'-'*(len(x)+1)) print('Table:',x) print('------'+'-'*(len(x)+1)) #----------------------------------------- |
| # 6330400821 (20.00) 241 (2021-02-06 16:21) def peek_kth_card(cards, k): the_kth_card = cards[(k - 1) * 4:((k - 1) * 4) + 4] return the_kth_card # --------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4 * k - 4] + cards[4 * (k):] return new_cards # --------------------------------------- def deal_n_cards(deck, n): cards = deck[:4 * n] new_deck = deck[4 * n:] return cards, new_deck # --------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[:4*m] return new_deck # --------------------------------------- def shuffle(deck): import math z_1 = deck.strip("|") z = z_1.split("||") m = len(z) my_list_1 = z[:math.ceil(m / 2)] my_list_2 = z[math.ceil(m / 2):] z[::2] = my_list_1[::] z[1::2] = my_list_2[::] new_deck_1 = "||".join(z) new_deck = "|" + new_deck_1 + "|" return new_deck # --------------------------------------- def show_table_cards(cards, m): import math cards1 = cards.strip("|") cards_list = cards1.split("||") z = math.ceil((len(cards_list) - m) / len(cards_list)) preview_cards = cards_list[-1 * m:] show_cards_1 = "||".join(preview_cards) show_cards_2 = "|" + show_cards_1 + "|" show_cards = z * "...." + show_cards_2 b = (7 + len(show_cards)) * "-" print(b + "\nTable:", show_cards + "\n" + b) # ----------------------------------------- |
| # 6330401421 (17.11) 242 (2021-02-08 13:23) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): s1 = cards[0:(k-1)*4] s2 = cards[k*4:] new_cards = s1 + s2 return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:n*4] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): d1 = deck[m*4:] d2 = deck[:m*4] new_deck = d1+d2 return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1] # remove || card = deck.split("||") # get single card nd = list() for i in range(len(card)//2 + 1): nd.append(card[i]) if i+1+len(card)//2 < len(card): nd.append(card[(i+1)+len(card)//2]) new_deck = "|" + "||".join(nd) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): x = cards[-m*4:] c = len(cards)/4 if m < c : print('table: '+'....'+ x) else : print('table: '+ x) #----------------------------------------- |
| # 6330402021 (20.00) 243 (2021-02-07 21:48) def peek_kth_card(cards, k): x = cards.split("|") x = x[1::2] k -=1 the_kth_card = "|"+str(x[k])+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): k-=1 x = cards.split("|") a = x[:2*k] + x[2*k+2:] new_cards ="|".join(a) return new_cards #--------------------------------------- def deal_n_cards(deck, n): x = deck.split("|") cards = "|".join(x[:2*n+1]) new_deck = "|".join(x[2*n:]) return cards, new_deck #--------------------------------------- def cut(deck, m): x = deck.split("|") x = x[1::2] a = x[m:] + x[:m] new_deck = "|"+"||".join(a)+"|" return new_deck #--------------------------------------- def shuffle(deck): x = deck.split("|") x = x[1::2] k = int((len(x)+1)/2) a = x[:k] b = x[k:] x[::2] = a x[1::2] = b new_deck = "|"+"||".join(x)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): x = cards.split("|") x = x[1::2] a=["Table: ","Table: ...."] b=a[m<len(x)] y="|"+"||".join(x[-m:])+"|" e=b+y print("-"*len(e)) print(e) print("-"*len(e)) #----------------------------------------- |
| # 6330403721 (17.78) 244 (2021-02-08 21:59) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1)] + cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] +deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): deck_list = deck.split('|') deck_list2 = deck_list[1:-1:2] d1 = deck_list2[::2] + deck_list2[1::2] d2 = d1[::2] + d1[1::2] d3 = d2[::2] + d2[1::2] new_deck = '|' + '||'.join(d3) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): n = len(cards)>4*m table = ('Table: '+'....'*n+cards[-4*m:]) print('-'*len(table)) print(table) print('-'*len(table)) #----------------------------------------- |
| # 6330404321 (20.00) 245 (2021-02-08 20:02) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*(k-1)]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards= deck[0:4*n] new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m:]+deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): top=deck.split("|") top=top[1::2] x=(len(top)+1)//2 half_1=top[:x] down=top[x:] y=[""]*len(top) y[::2]=half_1 y[1::2]=down new_deck="|"+"||".join(y)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): import math d=min(len(cards.split('||')), m) a=cards[-4*d:] b=(len(cards.split("||"))*2+1)//(m*2+1.01) c=int(math.atan2(b,b)/(math.pi/4)) print("-------"+"----"*(c+d)) print("Table: "+c*"...."+a) print("-------"+"----"*(c+d)) #----------------------------------------- |
| # 6330405021 (20.00) 246 (2021-02-05 01:41) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:4*n] new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): deck2=deck[1:len(deck)-1].split("||") a=[0]*len(deck2) l=(len(deck2)+1)//2 a[::2]=deck2[:l] a[1::2]=deck2[l:] new_deck="|"+"||".join(a)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): a=len(cards)-4*m Ans="Table: "+"...."*(a//(abs(a)+4*m//len(cards)))+cards[(a+abs(a))//2:] print("-"*len(Ans)) print(Ans) print("-"*len(Ans)) #----------------------------------------- |
| # 6330406621 (20.00) 247 (2021-02-07 22:01) def peek_kth_card(cards, k): import re cards1 = re.findall('....', cards) the_kth_card = cards1[k-1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): import re cards1 = re.findall('....', cards) remove = cards1[k-1] x = cards1[:k-1]+cards1[k:] new_cards = "".join(x) return new_cards #--------------------------------------- def deal_n_cards(deck, n): import re cards1 = re.findall('....', deck) cards2 = cards1[:n] cards = "".join(cards2) new_deck0 = cards1[n:] new_deck = "".join(new_deck0) return cards, new_deck #--------------------------------------- def cut(deck, m): import re cards1 = re.findall('....', deck) deck0 = cards1[:m] deck1 = cards1[m:] newdeck = deck1+deck0 new_deck = "".join(newdeck) return new_deck #--------------------------------------- def shuffle(deck): import re import math cards1 = re.findall('....', deck) a = math.ceil(len(cards1)/2) cards2 = cards1[:a] cards3 = cards1[a:] newdeck = [None]*(len(cards2)+len(cards3)) newdeck[::2] = cards2 newdeck[1::2] = cards3 new_deck = "".join(newdeck) return new_deck #--------------------------------------- def show_table_cards(cards, m): import re cards1 = re.findall('....', cards) noc = [len(cards1), m] a = int(noc[1]-noc[0]) b = int(max(noc)-abs(a)) ncd = cards[len(cards)-(4*b):] cards = "".join(ncd) f = int(len(cards1)-b) d = int(f/(f or not f)) e = "Table: "+"...."*(d)+cards c = "-"*len(e) print(c) print(e) print(c) #----------------------------------------- |
| # 6330407221 (19.56) 248 (2021-02-06 23:18) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*(k-1)+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1)]+cards[4*(k-1)+4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): moved = deck[:4*m] new_deck = deck[4*m:] new_deck = new_deck+moved return new_deck #--------------------------------------- def shuffle(deck): deck = deck.split('|') output = deck[1::2] count = len(output) count = (count+1)//2 deck_1 = output[:count] deck_2 = output[count:] num = min(len(deck_1), len(deck_2)) result = [None]*(num*2) result[::2] = deck_1[:num] result[1::2] = deck_2[:num] result.extend(deck_1[num:]) result.extend(deck_2[num:]) result new_deck = result new_deck = ('||').join(new_deck) new_deck = '|'+new_deck+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards.split('|') output = cards[1::2] output_2 = output[-1:-m-1:-1] output_3 = output_2[-1::-1] output_3 = ('||').join(output_3) output_3 = '|'+output_3+'|' count_start = len(output) a = min(count_start, m) dot = (1-a//count_start)*'....' answer = dot+output_3 lenght = len(answer) print ('------'+'-'*lenght) print ('Table:'+answer) print ('------'+'-'*lenght) #----------------------------------------- |
| # 6330408921 (20.00) 249 (2021-02-05 16:45) def peek_kth_card(cards, k): card_list = cards.split('|')[1::2] the_kth_card = '|'+card_list[k-1]+'|' return the_kth_card # --------------------------------------- def remove_kth_card(cards, k): m = (k-1)*4 new_cards = cards[:m]+cards[m+4:] return new_cards # --------------------------------------- def deal_n_cards(deck, n): m = (n-1)*4 cards = deck[:m+4] new_deck = deck[m+4:] return cards, new_deck # --------------------------------------- def cut(deck, m): deck_list = deck.split('|')[1::2] select = deck_list[:m] new_deck = '|'+('||').join(deck_list[m:]+select)+'|' return new_deck # --------------------------------------- def shuffle(deck): deck_list = deck.split('|')[1::2] new_deck = [0] * len(deck_list) half = -(-len(deck_list)//2) new_deck[::2] = deck_list[:half] new_deck[1::2] = deck_list[half:] new_deck = '|'+('||').join(new_deck)+'|' return new_deck # --------------------------------------- def show_table_cards(cards, m): cards_list = cards.split('|')[1::2] r = int(m < len(cards_list)) p = 'Table: '+'....'*r+'|'+('||').join(cards_list[-m:])+'|' print('-' * len(p)) print(p) print('-' * len(p)) # ----------------------------------------- |
| # 6330409521 (16.44) 250 (2021-02-08 20:21) def peek_kth_card(cards, k): the_kth_card = cards[((k-1)*4):k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:((k-1)*4)]+cards[(k*4):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:(n*4)] new_deck = deck[(n*4):] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(m*4):]+deck[0:(m*4)] return new_deck #--------------------------------------- def shuffle(deck): deck = deck.split("|") pay_off = deck[1::2] stock = len(pay_off) stock = (stock+1)//2 deck1 = pay_off[:stock] deck2 = pay_off[stock:] amt = min(len(deck1), len(deck2)) result = [None]*(amt*2) result[::2] = deck1[:amt] result[1::2] = deck2[:amt] result.extend(deck1[amt:]) result.extend(deck2[amt:]) new_deck = result new_deck = "||".join(new_deck) new_deck = "|"+new_deck+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): pay_off1 = cards[0::1] pay_off2 = pay_off1[0::1] pay_off3 = pay_off2[0::] stock_i = len(pay_off1) b = min(stock_i,m) pin = ((1-b//stock_i))*("....") final = pin+pay_off3 finalL = len(final) print("------"+"-"*finalL) print("Table " +final) print("------"+"-"*finalL) #----------------------------------------- |
| # 6330410021 (16.44) 251 (2021-02-07 14:58) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(k-1)*4]+cards[k*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:n*4] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(m)*4:]+deck[0:(m)*4] return new_deck #--------------------------------------- def shuffle(deck): k4 = int(len(deck)/8) new_deck = deck[0:4]+deck[(k4)*4:(k4+1)*4]+deck[-(k4+1)*4:-(k4)*4]+deck[(k4+1)*4:(k4+2)*4]+deck[-(k4+2)*4:-(k4+1)*4]+deck[(k4+2)*4:(k4+3)*4]+deck[-(k4+3)*4:-(k4+2)*4]+deck[(k4+3)*4:(k4+4)*4]+deck[-(k4+4)*4:-(k4+3)*4]+deck[(k4+4)*4:(k4+5)*4]+deck[-(k4+5)*4:-(k4+4)*4]+deck[(k4+5)*4:(k4+6)*4]+deck[-(k4+6)*4:-(k4+5)*4]+deck[(k4+6)*4:(k4+7)*4]+deck[-(k4+7)*4:-(k4+6)*4]+deck[(k4+7)*4:(k4+8)*4]+deck[-(k4+8)*4:-(k4+7)*4]+deck[(k4+8)*4:(k4+9)*4]+deck[-(k4+9)*4:-(k4+8)*4]+deck[(k4+9)*4:(k4+10)*4]+deck[-(k4+10)*4:-(k4+9)*4]+deck[(k4+10)*4:(k4+11)*4]+deck[-(k4+11)*4:-(k4+10)*4]+deck[(k4+11)*4:(k4+12)*4]+deck[-(k4+12)*4:-(k4+11)*4]+deck[(k4+12)*4:(k4+13)*4]+deck[-(k4+13)*4:-(k4+12)*4]+deck[(k4+13)*4:(k4+14)*4]+deck[-(k4+14)*4:-(k4+13)*4]+deck[(k4+14)*4:(k4+15)*4]+deck[-(k4+15)*4:-(k4+14)*4]+deck[(k4+15)*4:(k4+16)*4]+deck[-(k4+16)*4:-(k4+15)*4]+deck[(k4+16)*4:(k4+17)*4]+deck[-(k4+17)*4:-(k4+16)*4]+deck[(k4+17)*4:(k4+18)*4]+deck[-(k4+18)*4:-(k4+17)*4]+deck[(k4+18)*4:(k4+19)*4]+deck[-(k4+19)*4:-(k4+18)*4]+deck[(k4+19)*4:(k4+20)*4]+deck[-(k4+20)*4:-(k4+19)*4]+deck[(k4+20)*4:(k4+21)*4]+deck[-(k4+21)*4:-(k4+20)*4]+deck[(k4+21)*4:(k4+22)*4]+deck[-(k4+22)*4:-(k4+21)*4]+deck[(k4+22)*4:(k4+23)*4]+deck[-(k4+23)*4:-(k4+22)*4]+deck[(k4+23)*4:(k4+24)*4]+deck[-(k4+24)*4:-(k4+23)*4]+deck[(k4+24)*4:(k4+25)*4]+deck[-(k4+25)*4:-(k4+24)*4]+deck[(k4+25)*4:(k4+26)*4] return new_deck #--------------------------------------- def show_table_cards(cards, m): if len(cards)/4-m <= 0: x2 = 0 else: x2 = 1 x = "...."*x2 print("-------"+"-"*len(cards[-m*4:1000:1]+x));print("Table:"+x+cards[-m*4:1000:1]) ;print("-------"+"-"*len(cards[-m*4:1000:1]+x)); #----------------------------------------- |
| # 6330411721 (19.50) 252 (2021-02-08 11:23) def peek_kth_card(cards, k): the_kth_card = cards[1:-1].split("||") the_kth_card = "|" + the_kth_card[k-1] + "|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards1 = deck[1:-1].split("||") cards = cards1[:n] cards = "|"+"||".join(cards)+"|" new_deck = cards1[n:] new_deck = "|"+"||".join(new_deck)+"|" return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[1:-1].split("||") new_deck = new_deck[m:]+new_deck[:m] new_deck = "|"+"||".join(new_deck)+"|" return new_deck #--------------------------------------- def shuffle(deck): deck2=deck[1:-1].split("||") new_deck=["o"]*len(deck2) half=(len(deck2)+1)//2 new_deck[::2]=deck2[:half] new_deck[1::2]=deck2[half:] new_deck="|"+"||".join(new_deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): cards1 = cards[1:-1].split("||") show = cards1[-m::] show1 = "|"+"||".join(show)+"|" a = min(len(cards1)-1,m) print("---------------"+"----"*(a-1)) print("Table: "+"...."*int(m<len(cards1))+show1) print("---------------"+"----"*(a-1)) #----------------------------------------- |
| # 6330412321 (18.67) 253 (2021-02-08 00:24) def peek_kth_card(cards, k): x = cards.split("|") the_kth_card = "|"+x[int(2*k)-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x = cards.split("|") del x[int(2*k)-1] del x[int(2*k)-1] new_cards = "|".join(x) return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): x = deck.split("|") a = x[1::2] b = a[:int(m):1] c = a[int(m)::1] new_deck = "|"+"||".join(c)+"||"+"||".join(b)+"|" return new_deck #--------------------------------------- def shuffle(deck): x = deck.split("|") a = x[1::2] b = len(a) c = a[:int((b+1)/2):1] d = a[int((b+1)/2)::1] e = [0]*b e[::2] = c e[1::2] = d new_deck = "|"+"||".join(e)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): x = cards.split("|") a = x[1::2] b = a[int(-m)::1] c = "."*min((4*(len(a)-m)),4) cards = "|"+"||".join(b)+"|" print("-"*7+"-"*len(c)+"-"*len(cards)) print("Table: "+c+cards) print("-"*7+"-"*len(c)+"-"*len(cards)) #----------------------------------------- |
| # 6330413021 (20.00) 254 (2021-02-06 16:56) def peek_kth_card(cards, k): a = cards.replace('|',' ').split() the_kth_card = '|'+str(a[k-1])+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4]+cards[4*k:len(cards)] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): '''a = deck part1 = a[:4*-(-len(a)//8)] part2 = a[4*-(-len(a)//8):] new_deck = '' for i in range((len(a)//2) +1) : new_deck += part1[4*i:4*i+4]+part2[4*i:4*i+4]''' a = deck.replace('|',' ').split() decklist = [1]*len(a) half1 = a[:len(a)//2+len(a)%2] half2 = a[len(a)//2+len(a)%2:] decklist[::2] = half1[::] decklist[1::2] = half2[::] new_deck = '|'+'||'.join(decklist)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): print('-'*(len('table: '+'....'*int(len(cards)//4 > m)+str(cards[-4*m:])))) print('Table: '+'....'*int(len(cards)//4 > m)+cards[-4*m:]) print('-'*(len('table: '+'....'*int(len(cards)//4 > m)+str(cards[-4*m:])))) #----------------------------------------- |
| # 6330415221 (20.00) 255 (2021-02-07 01:18) def peek_kth_card(cards, k): c = cards.split("|") c = ' '.join(c).split() the_kth_card = "|"+c[k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): c = cards.split('|') c= ' '.join(c).split() c.remove(c[k-1]) b = ['']*((len(c)*2)+1) b[1::2] = c c = '|'.join(b) new_cards = c return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n:1] new_deck = deck[4*n::1] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m::1]+deck[0:4*m:1] return new_deck #--------------------------------------- def shuffle(deck): d = deck[1:-1] d = d.split("||") a = ((len(d))+1)//2 l = d[0:a:1] r = d[a::1] p = list(' '*len(d)) p[::2] = l p[1::2] = r p = "||".join(p) p = "|"+p+"|" new_deck = p return new_deck #--------------------------------------- def show_table_cards(cards, m): f = cards[-4*m::1] u = cards[:-4*m] r = len(cards)/4 d = "...."*int((r-m)) d = u+d+f y = d[-4*m-4::] h = "Table:"+" "+y print("-"*len(h)) print(h) print("-"*len(h)) #----------------------------------------- |
| # 6330416921 (18.42) 256 (2021-02-07 13:15) def peek_kth_card(cards, k): if len(cards)>4: x=cards.split("||") a=x[0][1:] b=x[len(x)-1][:-1] x[0]=a x[len(x)-1]=b m=x[k-1] the_kth_card ='|'+m+'|' else: the_kth_card=cards return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x=cards.split("||") a=x[0][1:] b=x[len(x)-1][:-1] x[0]=a x[len(x)-1]=b x.remove(x[k-1]) if x!=[]: new_cards= '|'+'||'.join(x)+'|' else: new_cards='' return new_cards #--------------------------------------- def deal_n_cards(deck, n): if len(deck)>4: x=deck.split("||") a=x[0][1:] b=x[len(x)-1][:-1] x[0]=a x[len(x)-1]=b m=x[:n] d=x[n:] cards = '|'+'||'.join(m)+'|' new_deck= '|'+'||'.join(d)+'|' else: cards=deck new_deck='' return cards, new_deck #--------------------------------------- def cut(deck, m): x=deck.split("||") a=x[0][1:] b=x[len(x)-1][:-1] x[0]=a x[len(x)-1]=b f=x[:m] p=x[m:] new_deck = '|'+'||'.join(p)+'|'+'|'+'||'.join(f)+'|' return new_deck #--------------------------------------- def shuffle(deck): x=deck.split("||") a=x[0][1:] b=x[len(x)-1][:-1] x[0]=a x[len(x)-1]=b if len(x)%2 !=0 : #หาร2ไม่ลงตัว m=x[:(len(x)//2)+1] p=x[(len(x)//2)+1:] else: #หาร2ลงตัว m=x[:(len(x)//2)] p=x[(len(x)//2):] q=[] w=0 #7 while w<len(m): q.append(m[w]) #เอาไปต่อท้าย [2H ] if len(m)>len(p) and w==len(m)-1 : pass else: q.append(p[w]) w+=1 new_deck='|'+'||'.join(q)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): x=cards.split("||") a=x[0][1:] b=x[len(x)-1][:-1] x[0]=a x[len(x)-1]=b p=x[len(x)-m:] if m<len(x) : e='Table: ....'+'|'+'||'.join(p)+'|' elif m>=len(x) : e='Table: '+cards i='-'*len(e) print(i) print(e) print(i) #----------------------------------------- |
| # 6330417521 (17.78) 257 (2021-02-08 23:46) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:4+(k-1)*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k-1)*4] + cards[4+(k-1)*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4+(n-1)*4] new_deck = deck[4+(n-1)*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck[:4*m] new_deck = deck[4*m:] + a return new_deck #--------------------------------------- def shuffle(deck): a = deck[1:len(deck)-1].split("||") b = len(a) c = [0]*b d = (b+1)//2 c[::2]=a[:d] c[1::2]=a[d:] new_deck="|"+"||".join(c)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards.split("|") b = a[1::2] c = b[int(-m)::1] d = min(4,(len(b)*4-m))*"." cards = "|"+"||".join(c)+"|" print(7*"-" + len(d)*"-" + len(cards)*"-") print("Table: "+ cards) print(7*"-" + len(d)*"-" + len(cards)*"-") #----------------------------------------- |
| # 6330418121 (20.00) 258 (2021-02-07 09:57) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(k*4)-4]+cards[k*4::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4:] + deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): deck_x = deck.strip("||").split("||") a = len(deck_x) m = (len(deck_x)+1)//2 new_deck_x = deck_x[:m] new_deck_y = deck_x[m::] new_deck = [] new_deck+= ["||"]*a new_deck[::2] = new_deck_x new_deck[1::2] = new_deck_y new_deck = "|"+"||".join(new_deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): m = int(m) cards = cards.split("||") cards = "|,|".join(cards) cards = cards.split(",") Table = cards[-1:-m-1:-1] Table.reverse() Table = "".join(Table) cards = "".join(cards) countdot = min(len(cards)-len(Table),4) count = 7+len(Table)+countdot print("-"*count) print("Table: "+"."*countdot+Table) print("-"*count) #----------------------------------------- |
| # 6330420321 (20.00) 259 (2021-02-06 11:15) def peek_kth_card(cards, k): cards = cards.split('|') cards = ' '.join(cards).split() the_kth_card = '|'+cards[k-1]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards = cards.split('|') cardss = ' '.join(cards).split() index = cards.index(cardss[k-1]) cards.remove(cardss[k-1]) del cards[index-1] new_cards = '|'.join(cards) return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:n*4] new_deck = deck[n*4::] return cards, new_deck #--------------------------------------- def cut(deck, m): first = deck[:m*4:] second = deck[m*4::] new_deck = second+first return new_deck #--------------------------------------- def shuffle(deck): decks = deck.split('|') cardss = ' '.join(decks).split() numc = len(cardss) rnumc = int(numc/2) lnumc = numc-rnumc LC = decks[:lnumc*2+1:] RC = decks[lnumc*2+1::2] LC[2:len(RC)*2+2:2] = RC[::] LC = '||'.join(LC) LC = LC.strip('|') new_deck =('|'+LC+'|') return new_deck #--------------------------------------- def show_table_cards(cards, m): card_num = int((len(cards)/4)) firstH = cards[:-m*4:] SH = cards[-m*4::] showpls = ((card_num-m)*'....') Realss = (firstH+showpls+SH) showw = Realss[-m*4-4::] sad = ('Table: '+showw) print('-'*len(sad)) print(sad) print('-'*len(sad)) #----------------------------------------- |
| # 6330422621 (19.33) 260 (2021-02-07 20:58) def peek_kth_card(cards, k): the_kth_card = cards[((k-1)*4):(k*4)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:((k-1)*4)]+cards[(k*4):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[(4*n):] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(4*m):]+deck[:(4*m)] return new_deck #--------------------------------------- def shuffle(deck): x = deck.split('|') y = x[1::2] z1 = len(y[:len(y):2]) x1 = y[:z1] x2 = y[z1:] r = [] for (a, b) in zip(x1, x2): r.append(a) r.append(b) if len(y)%2!=0: r.append(x1[z1-1]) t2 = '||'.join(r) new_deck = '|'+t2+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): show_table_cards = cards[::-1][:4*m][::-1] if 4*m < len(cards): show_table_cards = "...."+show_table_cards print('-----------------------') print('Table: '+show_table_cards) print('-----------------------') #----------------------------------------- |
| # 6330423221 (19.00) 261 (2021-02-08 23:59) def peek_kth_card(cards, k): the_kth_card=cards[(4*k-4):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[:4*(k-1)]+cards[4*(k+1)-4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:4*n-4:] new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): a=deck[:(4*m)] new_deck=deck[(4*m):] +a return new_deck #--------------------------------------- def shuffle(deck): deck=deck[1:-1] x=deck.split("||") z=len(x) l=(z+1)//2 h=[""]*z g=[h] b=x[:l] c=x[l:] h[::2]= b h[1::2]= c new_deck = "|" +"||".join(h)+ "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): a=min(m,len(cards)//4) b=cards[-4*m:] c="...."*int((len(cards)//4-a)**(1/100000000)) d="Table: " +c+b print("-"*(4*a+len(c)+7)) print(d) print("-"*(4*a+len(c)+7)) #----------------------------------------- |
| # 6330424921 (20.00) 262 (2021-02-05 22:26) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n-4:]+deck[4*n-4:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): deck = deck.split("||") deck = "|,|".join(deck) deck = deck.split(",") m = len(deck) a = deck[:(m+1)//2] b = deck[(m+1)//2:] new_deck = [] new_deck+= [""]*m new_deck[::2] = a new_deck[1::2] = b new_deck = "".join(new_deck) return new_deck #--------------------------------------- def show_table_cards(cards, m): m = int(m) cards = cards.split("||") cards = "|,|".join(cards) cards = cards.split(",") table = cards[-1:-m-1:-1] table.reverse() table = "".join(table) cards = "".join(cards) countdot = min(len(cards)-len(table),4) count = 7+len(table)+countdot print("-"*count) print("Table: "+"."*countdot+table) print("-"*count) #----------------------------------------- |
| # 6330425521 (20.00) 263 (2021-02-08 17:12) def peek_kth_card(cards, k): #k = int(input()) the_kth_card = cards[(k-1)*4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1)]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): #n = int(input()) new_deck = deck[4*n:] cards = deck[:4*n] return cards, new_deck #--------------------------------------- def cut(deck, m): #m = int(input()) new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): s = int(len(deck)//4) s = int((s/2)+0.5) s1 = deck[:4*s] s2 = deck[4*s:] s1 = s1.split("|") s1 = s1[1::2] s2 = s2.split("|") s2 = s2[1::2] deck = deck.split("|") deck = deck[1::2] deck[0::2] = s1 deck[1::2] = s2 new_deck = "|"+"||".join(deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): #m = int(input()) n = len(cards)//4 TF = int(m<n) table = "."*4*TF + cards[(-4)*min(n,m):] table = "Table: "+table print("-"*len(table)) print(table) print("-"*len(table)) #----------------------------------------- |
| # 6330426121 (18.89) 264 (2021-02-08 00:07) def peek_kth_card(cards, k): x = cards[1:-1].split('||') the_kth_card = '|'+x[k-1]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): r = peek_kth_card(cards, k) new_cards = ''.join(cards.split(r)) return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): N = int(len(deck)/4) n = int(N//2) DD = deck[:4*(N-n)]+'|oo|'*((N-n+1)%2)+deck[4*(N-n):] L_deck = DD[1:-1].split('||')*(n+1) LN = L_deck[:-n:n+1] ND = '|'+'||'.join(LN)+'|' new_deck = ND[:len(ND)-4*((N-n+1)%2)] return new_deck #--------------------------------------- def show_table_cards(cards, m): N = int(len(cards)/4) x = 'Table: '+('....'*(N-m))[:4]+cards[::-1][:m*4][::-1] print('-'*len(x)) print(x) print('-'*len(x)) #----------------------------------------- |
| # 6330427821 (19.00) 265 (2021-02-06 23:44) def peek_kth_card(cards, k): cards_split = cards.split("|") cards_split = list(filter(("").__ne__,cards_split)) the_kth_card = "|" + cards_split[k - 1] + "|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): del_cards = peek_kth_card(cards, k) new_cards = cards.replace(del_cards, "") return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck_split = deck.index("|", n*4 % len(deck)) cards = deck[0: deck_split] new_deck = deck[deck_split:] return cards, new_deck #--------------------------------------- def cut(deck, m): move_card = deal_n_cards(deck, m) new_deck = move_card[1] + move_card[0] return new_deck #--------------------------------------- def shuffle(deck): import math front_deck = deck[0: math.ceil((len(deck)/4) / 2) * 4] rear_deck = deck.replace(front_deck, "") front_split = list(filter(("").__ne__,front_deck.split("|"))) rear_split = list(filter(("").__ne__,rear_deck.split("|"))) new_deck = [None] * (len(front_split) + len(rear_split)) new_deck[::2], new_deck[1::2] = front_split, rear_split new_deck = "|" + '||'.join(new_deck) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): right_card = cards[(m * -4):] space_range = int(len(cards) / 4) - m check_dot = int((space_range*2)//((space_range*2)-0.1)) fill_line = int(len(right_card)/4) + check_dot print('-------'+'----'*fill_line) print('Table: '+'....'*check_dot + right_card) print('-------'+'----'*fill_line) #----------------------------------------- |
| # 6330428421 (20.00) 266 (2021-02-08 23:43) def peek_kth_card(cards, k): cards_list=cards.split('|') the_kth_card= '|'+cards_list[2*k-1]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=(cards[0:4*(k-1):1]+cards[k*4::1]) #print(new_cards) return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:4*n:1] new_deck=deck[4*n::1] #print(type(cards)) #print(type(new_deck)) return cards, new_deck #--------------------------------------- def cut(deck, m): cut=deck[0:4*m:1] new_deck =deck[4*m::1]+cut return new_deck #--------------------------------------- def shuffle(deck): deck_list= deck.split('|') new_deck=deck_list[1:(len(deck_list)+1)//2:1] new_deck[1::2]=deck_list[((len(deck_list)+1)//2)+int((len(deck)/4)%2)::2] new_deck[0]='|'+new_deck[0] new_deck[-1]=new_deck[-1]+'|' new_deck='||'.join(new_deck) #print(new_deck) return new_deck #--------------------------------------- def show_table_cards(cards, m): cards=cards[1:-4*m:1]+'....'*min((len(cards)//4)-m,1)+cards[-4*m::1] table='Table: '+cards[-4*(m+1)::1] print('-'*len(table)) print(table) print('-'*len(table)) #----------------------------------------- |
| # 6330429021 (20.00) 267 (2021-02-06 16:44) def peek_kth_card(cards, k): cards = cards.split("|")[1::2] the_kth_card = cards[k-1] the_kth_card = "|"+the_kth_card+"|" return the_kth_card # --------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4]+cards[4*k:] return new_cards # --------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck # --------------------------------------- def cut(deck, m): deck = deck.split("|")[1::2] new_deck = deck[m:] + deck[:m] new_deck = "|"+"||".join(new_deck)+"|" return new_deck # --------------------------------------- def shuffle(deck): deck = deck.split("|")[1::2] x = len(deck) // 2 + len(deck) % 2 l1 = deck[:x] l2 = deck[x:] new_deck = [""] * len(deck) new_deck[::2] = l1[::] new_deck[1::2] = l2[::] new_deck = "|"+"||".join(new_deck)+"|" return new_deck # --------------------------------------- def show_table_cards(cards, m): print("-"*7+"-"*4*int(len(cards)/4>m)+"-"*len(cards[-4*m:])) print("Table:","...."*int(len(cards)/4>m)+cards[-4*m:]) print("-"*7+"-"*4*int(len(cards)/4>m)+"-"*len(cards[-4*m:])) # ----------------------------------------- |
| # 6330430621 (20.00) 268 (2021-02-08 15:05) def peek_kth_card(cards, k): the_kth_card = cards[(4*k)-4:(4*k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(4*k)-4]+cards[(4*k):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:(4*n)] new_deck = deck[(4*n):] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(4*m):]+deck[0:(4*m)] return new_deck #--------------------------------------- def shuffle(deck): i = len(deck) h = deck.split('||') f = len(h) a = h[:int((f/2)+0.5):] b = h[int((f/2)+0.5)::] h[::2] = a[::] h[1::2] = b[::] u = '||'.join(h) y = u.split('|||') w = '||'.join(y) new_deck = w + '|'*(int(f%2)) return new_deck #--------------------------------------- def show_table_cards(cards, m): t = len(cards)-(m*4) z = max(t,0) r = min(t,1) w = max(r,0) c = cards[z::] print(("-"*(len(c)+7))+(('-'*4)*w)) print("Table:"+' '+(('.'*4)*(w))+c) print(("-"*(len(c)+7))+(('-'*4)*w)) #----------------------------------------- |
| # 6330431221 (19.11) 269 (2021-02-07 17:13) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(k-1)*4] + cards[k*4::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:n*4] new_deck = deck[n*4::] return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck[0:m*4]+ ',' + deck[m*4::] x = a.split(',') y = x[0] new_deck = deck[m*4:] + y return new_deck #--------------------------------------- def shuffle(deck): a = deck[1:-1].split("||") s1 = a[0:int(len(a)/2+0.5)] s2 = a[int(len(a)/2+0.5):len(a)] x = [0]*len(a) x[0::2],x[1::2]=s1,s2 new_deck="|"+"||".join(x)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): a = min(m,len(cards)//4) b = cards[(-4)*m::] c = '....'*int((len(cards)//4-a)//1) x = 'Table: '+c+b print('-'*(4*a+len(c)+7)) print(x) print('-'*(4*a+len(c)+7)) #----------------------------------------- |
| # 6330432921 (20.00) 270 (2021-02-08 23:03) def peek_kth_card(cards, k): a = cards[1:-1].split("||") k = a[k - 1] the_kth_card = "|"+k+"|" return the_kth_card # --------------------------------------- def remove_kth_card(cards, k): a = cards[:4*(k-1)] b = cards[4*k:] new_cards = a+b return new_cards # --------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck # --------------------------------------- def cut(deck, m): a = deck[1:-1].split("||") b = a[m:] + a[0:m] c = "||".join(b) new_deck = "|"+c+"|" return new_deck # --------------------------------------- def shuffle(deck): a = deck[1:-1].split("||") b = int((len(a) / 2) + 0.5) c = a[:b] d = a[b:] e = c + d e[::2] = c e[1::2] = d f = "||".join(e) new_deck = "|"+f+"|" return new_deck # --------------------------------------- def show_table_cards(cards, m): a = cards[1:-1].split("||") b = len(a) c = max(b - m, 0) d = a[c:] e = "||".join(d) e = "|"+e+"|" f = "Table:" + " " + "...." * int(max(0, (b - m) / max(abs(b - m), 1))) + e g = "-" * len(f) print(g) print(f) print(g) # ----------------------------------------- |
| # 6330433521 (18.89) 271 (2021-02-08 17:31) def peek_kth_card(cards, k): kcard = cards[1:-1] scard = kcard.split("||") the_kth_card = "|"+scard[k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x = peek_kth_card(cards, k) scard = cards.split(x) new_cards = ''.join(scard) return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): kcard = deck[1:-1] scard = kcard.split("||") ncard = scard[m:]+scard[:m] new_deck = '|'+'||'.join(ncard)+'|' return new_deck #--------------------------------------- def shuffle(deck): x = int(len(deck)/4) y = int(x//2) sdeck = deck[:4*(x-y)] + '|xx|'*((x-y+1)%2) + deck[4*(x-y):] adeck = sdeck[1:-1].split('||')*(y+1) sm = adeck[:-y:y+1] ndeck = '|'+'||'.join(sm)+'|' new_deck = ndeck[:len(ndeck) - 4*((x-y+1)%2)] return new_deck #--------------------------------------- def show_table_cards(cards, m): x = cards[-4*m:] lx = int(len(cards)/4) t = 'Table: '+ ((lx-m)* '....')[:4] + x print('-'*len(t)) print(t) print('-'*len(t)) #----------------------------------------- |
| # 6330434121 (20.00) 272 (2021-02-08 13:00) def peek_kth_card(cards, k): cards1 = cards[1:-1:] cards2 = cards1.split("||") the_kth_card = "|"+cards2[k-1]+"|" return the_kth_card # --------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4:]+cards[4*k::] return new_cards # --------------------------------------- def deal_n_cards(deck, n): cards = deck[:n*4:] new_deck = deck[n*4::] return cards, new_deck # --------------------------------------- def cut(deck, m): cards7 = deck[1:-1:] cards8 = cards7.split("||") cards9 = cards8[m::] + cards8[:m:] new_deck = "|" + "||".join(cards9[::]) + "|" return new_deck # --------------------------------------- def shuffle(deck): cards10 = deck[1:-1:] cards11 = cards10.split("||") num = len(cards11) x = int((num + 1) // 2) deck1 = cards11[:x:] deck2 = cards11[x::] new_deck = [0] * num new_deck[::2] = cards11[:x:] new_deck[1::2] = cards11[x::] new_deck = "|" + "||".join(new_deck[::]) + "|" return new_deck # --------------------------------------- def show_table_cards(cards, m): cards12 = cards[1:-1:] cards13 = cards12.split("||") cards14 = cards13[-m::1] new_deck = "|" + "||".join(cards14[::]) + "|" x = len(cards13) y = len(cards14) card_max = max(x - m, 0) card_min = min(card_max, 1) print("-----------" + "----" * (y - 1 + card_min)) print("Table: " + "...." * card_min + new_deck) print("-----------" + "----" * (y - 1 + card_min)) # ----------------------------------------- |
| # 6330435821 (19.00) 273 (2021-02-06 01:28) def peek_kth_card(cards, k): the_kth_card=cards[4*k-4:4*k] return the_kth_card # --------------------------------------- def remove_kth_card(cards, k): new_cards=cards[:4*k-4]+cards[4*k:] return new_cards # --------------------------------------- def deal_n_cards(deck, n): new_deck=deck[:-4*n] cards=deck[-4*n:] return cards, new_deck # --------------------------------------- def cut(deck, m): new_deck=deck[4*m:]+deck[:4*m] return new_deck # --------------------------------------- def shuffle(deck): deck_list=deck[1:-1].split('||') length=int(len(deck_list)/2+0.5) deck1=deck_list[:length] deck2=deck_list[length:] new_deck=deck_list[:] new_deck[::2]=deck1[:] new_deck[1::2]=deck2[:] new_deck='|'+("||".join(new_deck))+'|' return new_deck # --------------------------------------- def show_table_cards(cards, m): num_of_cards=int(min(len(cards)/4,m)) display_cards=cards[-4*num_of_cards:] print('-------'+"----"*int(m < (len(cards)/4))+"-"*len(display_cards)) print('Table: '+"...."*int(m < (len(cards)/4))+display_cards) print('-------'+"----"*int(m < (len(cards)/4))+"-"*len(display_cards)) # ----------------------------------------- |
| # 6330436421 (16.67) 274 (2021-02-08 23:07) def peek_kth_card(cards, k): return cards[(4 * (k - 1)):(4 * k)] #--------------------------------------- def remove_kth_card(cards, k): A=cards[:((k-1)*4)-1] B=cards[((k)*4)-1:] new_cards=A+B return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:((n)*4)] new_deck= deck[((n)*4):] return cards, new_deck #--------------------------------------- def cut(deck, m): cards = deck[:((m)*4)] choose= deck[((m)*4):] new_deck = choose+cards return new_deck #--------------------------------------- def shuffle(deck): B=deck[1:len(deck)-1].split('||') new_deck=[] if n%2 == 1 : C=B[0:int((n//2)+1)] D=B[int((n//2)+1):] for i in range(int((n//2)+1)): new_deck.append(C[i]) if i > len(D)-1: break new_deck.append(D[i]) if n%2==0: C=B[0:int((n//2))] D=B[int((n//2)):] for i in range(int(n/2)): new_deck.append(C[i]) new_deck.append(D[i]) for i in range(len(new_deck)): new_deck[i]='|'+new_deck[i]+'|' new_deck = ''.join([str(elem) for elem in new_deck]) return new_deck #--------------------------------------- def show_table_cards(cards, m): if len(cards) / 4 <= m: dot_num = 7 + len(cards) print(f"{'-' * dot_num}\nTable: {cards}\n{'-' * dot_num}") else: print_cards = cards[len(cards) - (m * 4):] dot_num = 11 + len(print_cards) print(f"{'-' * dot_num}\nTable: ....{print_cards}\n{'-' * dot_num}") #----------------------------------------- |
| # 6330437021 (20.00) 275 (2021-02-07 14:41) def peek_kth_card(cards, k): the_kth_card=cards[(k-1)*4:((k-1)*4)+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[0:(k-1)*4]+cards[((k-1)*4)+4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:(n*4)] new_deck=deck[(n*4):] return cards, new_deck #--------------------------------------- def cut(deck, m): I=deck[0:(m*4)] F=deck[(m*4):] new_deck=F+I return new_deck #--------------------------------------- def shuffle(deck): DCI=deck[1:-1].split("||") L=len(DCI) An=DCI[:((L+1)//2)] Bn=DCI[((L+1)//2):] Newlist=[""]*L Newlist[::2]=An Newlist[1::2]=Bn new_deck="|"+"||".join(Newlist)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): T=cards[1:-1].split("||") Q="...."*(min((len(T)-len(T[:m])), 1))+"|"+"||".join(T[-m:])+"|" O="Table: "+Q print("-"*len(O)) print(O) print("-"*len(O)) #----------------------------------------- |
| # 6330438721 (20.00) 276 (2021-02-08 20:48) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*(k-1)+4:1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4:] + cards[4*k::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n:] new_deck = deck[4*n::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m::] + deck[:4*m:] return new_deck #--------------------------------------- def shuffle(deck): d = deck[1:-1:].split("||") f = d[:(len(d)+1)//2:] s = d[(len(d)+1)//2::] shuffle_d = f[0:1]+s[0:1]+f[1:2]+s[1:2]+f[2:3]+s[2:3]+f[3:4]+s[3:4]+f[4:5]+s[4:5]+f[5:6]+s[5:6]+f[6:7]+s[6:7]+f[7:8]+s[7:8]+f[8:9]+s[8:9]+f[9:10]+s[9:10]+f[10:11]+s[10:11]+f[11:12]+s[11:12]+f[12:13]+s[12:13]+f[13:14]+s[13:14]+f[14:15]+s[14:15]+f[15:16]+s[15:16]+f[16:17]+s[16:17]+f[17:18]+s[17:18]+f[18:19]+s[18:19]+f[19:20]+s[19:20]+f[20:21]+s[20:21]+f[21:22]+s[21:22]+f[22:23]+s[22:23]+f[23:24]+s[23:24]+f[24:25]+s[24:25]+f[25:26]+s[25:26]+f[26:27]+s[26:27] new_deck = "|"+"||".join(shuffle_d)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): selected_cards = cards[-4*m::] n = int(min(len(cards)/4-m,1)) print("-------"+"-"*(n*4)+"-"*len(selected_cards)) print("Table: "+"...."*n + selected_cards) print("-------"+"-"*(n*4)+"-"*len(selected_cards)) #----------------------------------------- |
| # 6330439321 (15.56) 277 (2021-02-08 11:52) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0: 4*(k-1)] + cards[4*k: len(cards)] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards, new_deck = deck[0: 4*n], deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): upper_deck = deck[0: 4*m] lower_deck = deck[4*m: len(deck)] new_deck = lower_deck + upper_deck return new_deck #--------------------------------------- def shuffle(deck): n = len(deck)//4 all_cards = deck[1:(4*n)-1].split('||') deck1 = all_cards[:(n+1)//2] deck2 = all_cards[(n+1)//2:] new_deck = [''] * n new_deck[::2] = deck1 new_deck[1::2] = deck2 new_deck2 = '|' + '||'.join(new_deck) +'|' return new_deck2 #--------------------------------------- def show_table_cards(cards, m): d = {True: '....', False: ''} showing_line = 'Table: ' print(cards) showing_card = cards[::-1][:4*m][::-1] showing_line += d[4*m < len(cards)] + showing_card line = '-' * len(showing_line) print(line, showing_line, line, sep='\n') #----------------------------------------- |
| # 6330440921 (18.22) 278 (2021-02-06 13:37) def peek_kth_card(cards, k): range_slice = [int(e) for e in range(0,4*k,4)] the_kth_card = cards[range_slice[k - 1]:range_slice[k - 1] + 4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): range_slice = [int(e) for e in range(0,4*k,4)] new_cards = cards[range_slice[0]:range_slice[k - 1]] + cards[range_slice[k - 1] + 4::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): range_slice = [int(e) for e in range(4,13*n,4)] # [4, 8, 12, 16, 20, 24] cards = deck[0:range_slice[n - 1]] new_deck = deck[range_slice[n-1]::] return cards, new_deck #--------------------------------------- def cut(deck, m): range_slice = [int(e) for e in range(4,13*m + 100,4)] # [4, 8, 12, 16, 20, 24] left = deck[0:range_slice[m - 1]] new_deck = deck[range_slice[m-1]::] + left return new_deck #--------------------------------------- def shuffle(deck): num_deck = len(deck)/4 new_deck = '' if num_deck%2 == 0: left = deck[0:int(len(deck)/2)] right = deck[int(len(deck)/2)::] for i in range(0, len(left), 4): new_deck += left[i:i + 4] + right[i:i+4] else: deck2 = remove_kth_card(deck, int(len(deck)/8) + 1) peek = peek_kth_card(deck, int(len(deck)/8) + 1) left = deck2[0:int(len(deck2)/2)] right = deck2[int(len(deck2)/2)::] for i in range(0, len(left), 4): new_deck += left[i:i + 4] + right[i:i+4] new_deck += peek return new_deck #--------------------------------------- def show_table_cards(cards, m): range_slice = [int(e) for e in range(0,4*m + 48,4)] if len(cards)/4 <= m: show = cards else: show = '....' + cards[range_slice[int(len(cards)/4) - m + 1]::] print('-'*(7 + len(show))) print('Table:', show) print('-'*(7 + len(show))) #----------------------------------------- |
| # 6330441521 (20.00) 279 (2021-02-07 00:42) def peek_kth_card(cards, k): k = (int(k)*3)+(int(k)-4) the_kth_card = cards[k:k+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): k = (int(k)*3)+(int(k)-4) new_cards = cards[0:k]+cards[k+4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): n = 4*int(n)-1 cards = deck[0:n+1] new_deck = deck[n+1:] return cards, new_deck #--------------------------------------- def cut(deck, m): m = 4*int(m)-1 new_deck = deck[m+1:]+deck[0:m+1] return new_deck #--------------------------------------- def shuffle(deck): n = ((len(deck)//4) +1)//2*4 new_deck = list(deck) new_deck[1::8] = deck[1:n:4] new_deck[2::8] = deck[2:n:4] new_deck[5::8] = deck[n+1::4] new_deck[6::8] = deck[n+2::4] new_deck = ''.join(new_deck) return new_deck #--------------------------------------- def show_table_cards(cards, m): lft, rht = cards[::-1][m*4:][::-1], cards[::-1][:m*4][::-1] lft = lft[:1] + '.' + lft[-1:] lft = lft[1:-1] * 4 res = 'Table: ' + lft + rht print('-' * len(res)) print(res) print('-' * len(res)) #----------------------------------------- |
| # 6330443821 (15.33) 280 (2021-02-06 12:18) def peek_kth_card(cards, k): cards = cards.replace("|"," ") cards = cards.split() the_kth_card = "|"+cards[k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*(k-1)] + cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck = deck.replace("|"," ") deck = deck.split() cards = deck[:n] new_deck = deck[n:] cards = "|"+"||".join(cards)+"|" new_deck = "|"+ "||".join(new_deck)+"|" return cards, new_deck #--------------------------------------- def cut(deck, m): deck = deck.replace("|", " ") deck = deck.split() new_deck = deck[m:] + deck[:m] new_deck = "|"+ "||".join(new_deck)+"|" return new_deck #--------------------------------------- def shuffle(deck): deck = deck.replace("|", " ") deck = deck.split() l = [] r = [] new_deck = [0]*len(deck) l[0:int((len(deck)-1)/2)+1] = deck[0:int((len(deck)-1)/2)+1] r[int((len(deck)-1)/2)+1: ] = deck[int((len(deck)-1)/2)+1: ] new_deck[0::2] = l[0::1] new_deck[1::2] = r[0::1] new_deck = "|"+ "||".join(new_deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards.replace("|", " ") cards = cards.split() max1 = max(len(cards), m) e = max1 - 1 min1 = min(e, m) print("-"*len("Table: "+"...."*(min1-m+1) + "|" + "||".join(cards[len(cards)-m-4::]) +"|")) print("Table:","...."*(min1-m+1) + "|" + "||".join(cards[len(cards)-m-4::]) +"|") print("-"*len("Table: "+"...."*(min1-m+1) + "|" + "||".join(cards[len(cards)-m-4::]) +"|")) #----------------------------------------- |
| # 6330444421 (20.00) 281 (2021-02-08 21:45) def peek_kth_card(cards, k): b = slice(4*(k-1),4*(k-1)+4) the_kth_card = cards[b] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): d = slice(0,4*(k-1)) i = cards[d] a = slice(4*k,len(cards)) j = cards[a] new_cards = i+j return new_cards #--------------------------------------- def deal_n_cards(deck, n): h = slice(0,(n*4)) k = deck[h] new_deck = deck.replace(k, '') cards = deck[h] return cards, new_deck #--------------------------------------- def cut(deck, m): h = slice(0,4*(m)) k = deck[h] o = slice(4*(m),len(deck)) f = deck[o] new_deck = f+k return new_deck #--------------------------------------- def shuffle(deck): z = int(len(deck)/8+0.5) x = slice(0,4*z) c = deck[x] v = slice(z*4,len(deck)) e = deck[v] b = list(deck) n = list(c) m = list(e) b[1::8]=n[1::4] b[2::8]=n[2::4] b[5::8]=m[1::4] b[6::8]=m[2::4] q= ','.join(b) new_deck = q.replace(',', '') return new_deck #--------------------------------------- def show_table_cards(cards, m): c = cards[1:-1:1] d = c.split("||") f = int(len(d)>m) i = d[-m::1] j = "||".join(i) k = "|"+j+"|" l = f*"...." + k print('-'*(len(l)+7)) print("Table:", l ) print('-'*(len(l)+7)) #--------------------------------------- |
| # 6330445021 (20.00) 282 (2021-02-07 21:04) def peek_kth_card(cards, k): cards = str(cards) the_kth_card = str(cards[4*k - 4:4*k]) return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards = str(cards) new_cards = str(cards[:4*k - 4] + cards[4*k:]) return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck = str(deck) cards = str(deck[:4*n]) new_deck = str(deck[4*n:]) return cards, new_deck #--------------------------------------- def cut(deck, m): deck = str(deck) new_deck = str(deck[4*m:] + deck[:4*m]) return new_deck #--------------------------------------- def shuffle(deck): n = len(deck) - 4*(len(deck)//8) fh = deck[1:n-1].split('||') + [''] lh = deck[n:].split('|') lh[:n:2] = fh[:1 + len(deck)//8] new_deck = '|' + '||'.join(lh[:len(deck)//4]) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): n = min(4*m,len(cards)) x = 1//(len(cards)+1-n) showing = 'Table: ' + (1 - x) * '....' + cards[len(cards)-n:] print(len(showing)*'-') print(showing) print(len(showing)*'-') #----------------------------------------- |
| # 6330446721 (20.00) 283 (2021-02-06 22:16) def peek_kth_card(cards, k): the_kth_card = cards[(k*4)-4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cardx = cards.split("|") new_cardz = new_cardx[0:(k*2)-1:1]+new_cardx[(k*2)+1::1] # k = 2 new_cards = "|".join(new_cardz) return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck_x = deck.split("|") cards_lite = deck_x[0:(n*2)+1:1] new_deck_lite = deck_x[(n*2)::1] cards = "|".join(cards_lite) new_deck = "|".join(new_deck_lite) return cards, new_deck #--------------------------------------- def cut(deck, m): deck_x = deck.split("|") new_deck_x = deck_x[(m*2)::1] + deck_x[1:(m*2)+1:1] new_deck = "|".join(new_deck_x) return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1] deck_x = deck.split("||") a = len(deck_x) m = (len(deck_x) +1 )// 2 new_deck_x = deck_x[:m:] new_deck_y = deck_x[m::] new_deck = [ ] new_deck += [""]*a new_deck[::2] = new_deck_x new_deck[1::2] = new_deck_y new_deck = "|"+"||".join(new_deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): new_cardx = cards.split("|") x = new_cardx[1::2] cardmax = "...." * (min(1,len(x)-m)) +"|"+"||".join(x[-m:])+"|" display = cardmax print("-"*(7+len(display))) print("Table: " +display ) print("-"*(7+len(display))) #----------------------------------------- |
| # 6330447321 (20.00) 284 (2021-02-07 19:22) def peek_kth_card(cards, k): cards1=cards[1:-1] cards1=cards1.split("||") the_kth_card=cards1[k-1] the_kth_card="|"+the_kth_card+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): s1 = 4*(k-1)+1 s2 = 4*(k-1)+4 new_cards = cards[:s1-1] + cards[s2:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:4*(n)] new_deck=deck[4*(n):] return cards, new_deck #--------------------------------------- def cut(deck, m): a,b=deal_n_cards(deck, m) new_deck=b+a return new_deck #--------------------------------------- def shuffle(deck): deck1=deck.replace('|','') n=len(deck1)/2 l1=int(n/2+0.5) l2=n-l1 d1=deck1[:int(2*l1)] d2=deck1[-int(2*l2):] new_deck = [] for i in range (0,int(l2*2),2): i=int(i) new_deck.append(d1[i:i+2]) new_deck.append(d2[i:i+2]) if l2<l1: new_deck.append(d1[-2:]) new_deck='||'.join(new_deck) new_deck='|'+new_deck+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cards1 = cards.replace('|','') L = [] n = int(len(cards1)/2) #จำนวนไพ่ for i in range (0,len(cards1),2): L.append(cards1[i:i+2]) if m >= n: pp='Table: '+cards print('-'*len(pp)) print(pp) print('-'*len(pp)) else : p='Table: ....|' + '||'.join(L[-int(m):]) + '|' print('-'*len(p)) print(p) print('-'*len(p)) #----------------------------------------- |
| # 6330448021 (17.70) 285 (2021-02-08 14:56) def peek_kth_card(cards, k): a = cards.strip("|").split("||") k = k - 1 the_kth_card = "|" + a[k] + "|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] new_cards = cards.replace(the_kth_card,'') return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck = deck.strip("|").split("||") cards = deck[:n:] new_deck = deck[n::] cards = "|" + "||".join(cards) + "|" new_deck = "|" + "||".join(new_deck) + "|" return cards, new_deck #--------------------------------------- def cut(deck, m): deck = deck.strip("|").split("||") deck1 = deck[:m:] deck2 = deck[m::] new_deck = deck2 + deck1 new_deck = "|" + "||".join(new_deck) + "|" return new_deck #--------------------------------------- def shuffle(deck): import math deck = deck.strip("|").split("||") n=math.ceil(len(deck)/2) deck1 = deck[:n:] deck2 = deck[n::] new_deck = deck1 + deck2 new_deck[::2] = deck1 new_deck[1::2] = deck2 new_deck = "|" + "||".join(new_deck) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards.strip("|").split("||") m = min(len(cards), m) n = len(cards) - m n_dots = min(max(len(cards)-m,0),1) dots = n_dots*"...." cards = cards[n::] cards = dots + "|" + "||".join(cards) + "|" print("Table:",cards) #----------------------------------------- |
| # 6330449621 (19.56) 286 (2021-02-08 18:19) def peek_kth_card(cards, k): the_kth_card = cards[(4*k)-4:4*k:1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(4*k)-4:1]+cards[4*k::1] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n:1] new_deck = deck[4*n::1] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): card_deck = deck.split("||") card_deck[0] = card_deck[0][1:] card_deck[-1] = card_deck[-1][:-1] deck_len = len(card_deck) cardshuffle = [0]*deck_len cardshuffle[0::2] = card_deck[:int(deck_len/2)+deck_len%2] cardshuffle[1::2] = card_deck[int(deck_len/2)+deck_len%2:] new_deck = "|" + "||".join(cardshuffle) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): table = "Table : " + "...."*((abs(4*m-len(cards))-(4*m-len(cards)))//(2*abs(4*m-len(cards))+int(4*m-len(cards)==0))) + cards[(len(cards)-(4*m))*int(len(cards)-(4*m)>0):] print("-"*len(table)) print(table) print("-"*len(table)) #----------------------------------------- |
| # 6330450121 (19.50) 287 (2021-02-07 20:54) def peek_kth_card(cards, k): cardcut=cards[1:-1] cardlist=cardcut.split('||') the_kth_card='|'+cardlist[k-1]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cardcut=cards[1:-1].split('||') cardaddsth=['a']+cardcut+['a'] new_cards='||'.join(cardaddsth[:k]+cardaddsth[k+1:]) new_cards=new_cards[2:-2] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cardcut=deck[1:-1] cardlist=cardcut.split('||') cards='|'+'||'.join(cardlist[:n])+'|' new_deck='|'+'||'.join(cardlist[n:])+'|' return cards, new_deck #--------------------------------------- def cut(deck, m): cardcut=deck[1:-1] cardlist=cardcut.split('||') #print(cardlist) cardcutted=cardlist[m:]+cardlist[:m] new_deck='|'+'||'.join(cardcutted)+'|' return new_deck #--------------------------------------- def shuffle(deck): cardcut=deck[1:-1] cardlist=cardcut.split('||') rounding=round(((len(cardlist))/2)+0.3) first=cardlist[:rounding] second=cardlist[rounding:] emptylist=['']*(len(cardlist)) emptylist[::2]=first emptylist[1::2]=second new_deck='|'+'||'.join(emptylist)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cardcut=cards[1:-1] cardlist=cardcut.split('||') #สลับให้ไม่งง cause choosing from right side can be confusing cardlistreverse=cardlist[::-1] lencard=len(cardlist) #choose cardlist in range of m/ adding.... for if mimicking cardlistreverse=cardlistreverse[:m]+['....'] # real len of card (by using m filtration) reallen=len(cardlistreverse)-1 #m to length existed # code to extract list to string firstpart=''.join(cardlistreverse[m:lencard]) choosecard=cardlistreverse[:reallen] reinversecard=choosecard[::-1] secondpart='||'.join(reinversecard) total=firstpart+'|'+secondpart+'|' print('-------'+(len(total))*('-')) print('Table: '+total) print('-------'+(len(total))*('-')) #----------------------------------------- |
| # 6330452421 (20.00) 288 (2021-02-06 16:25) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): list_deck = deck.split("|")[1::2] list1_deck = list_deck[:int(((len(list_deck))/2)+0.5)] list2_deck = list_deck[int(((len(list_deck))/2)+0.5):] list_deck[0::2] = list1_deck list_deck[1::2] = list2_deck new_deck = "|"+("||".join(list_deck))+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): list_cards = cards.split("|")[1::2] pick_cards = list_cards[-m:] choose_cards = "|"+("||".join(pick_cards))+"|" n = min(len(list_cards),m) dot = min(1,max(len(list_cards)-m,0)) print("-"*(7+4*len(pick_cards)+dot*4)) print("Table: "+"...."*dot+choose_cards) print("-"*(7+4*len(pick_cards)+dot*4)) #----------------------------------------- |
| # 6330453021 (20.00) 289 (2021-02-07 21:20) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:(k-1)*4+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1)]+cards[4*(k-1)+4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:n*4:] new_deck = deck[n*4::] return cards, new_deck #--------------------------------------- def cut(deck, m): cut = deck[:m*4] new_deck = deck[m*4:] + cut return new_deck #--------------------------------------- def shuffle(deck): num_cards = int((len(deck)))/4 fh = deck[:int(((num_cards + 1) / 2)) * 4:] fh_list = fh.split("|") fh_list = fh_list[1::2] sh = deck[int(((num_cards + 1) / 2)) * 4::] sh_list = sh.split("|") sh_list = sh_list[1::2] new_deck = [0] * (int(num_cards)) new_deck[0::2] = fh_list[:] new_deck[1::2] = sh_list[:] new_deck = "||".join(new_deck) new_deck = "|"+new_deck+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): how_cards = int(len(cards)/4) print("-"*(7+4*int(max(min(how_cards-m, 1), 0))+len(cards[max(min((how_cards-m)*4,4*abs(how_cards-m)),0):]))) print("Table: "+"...."*int(max(min(how_cards-m, 1), 0))+cards[max(min((how_cards-m)*4,4*abs(how_cards-m)),0):]) print("-"*(7+4*int(max(min(how_cards-m, 1), 0))+len(cards[max(min((how_cards-m)*4,4*abs(how_cards-m)),0):]))) #----------------------------------------- |
| # 6330454721 (20.00) 290 (2021-02-07 22:41) def peek_kth_card(cards, k): the_kth_card = cards[(k*4)-4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k*4)-4] + cards[(k*4):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:(n*4)] new_deck = deck[(n*4):] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(m*4):]+deck[:(m*4)] return new_deck #--------------------------------------- def shuffle(deck): x = deck.split("|") y = x[1::2] firsthalf = y[:((len(y)+1)//2)] secondhalf = y[((len(y)+1)//2):] new_deck = [0]*len(y) new_deck[0::2] = firsthalf new_deck[1::2] = secondhalf new_deck = "|"+"||".join(new_deck) +"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): x = -(m//(len(cards)//4))+1 y = len("...."* x) print("-"*(len(cards[-m*4::1])+7+y)) print("Table: " + ("...."* x) +cards[-m*4::1]) print("-"*(len(cards[-m*4::1])+7+y)) #----------------------------------------- |
| # 6330455321 (20.00) 291 (2021-02-07 19:33) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*(k-1)]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): x = deck[0:4*m] y = deck[4*m:] new_deck = y+x return new_deck #--------------------------------------- def shuffle(deck): import math n = int(len(deck)/4) m = math.ceil(n/2) x = deck.split("||") x[0] = x[0][1:] x[-1] = x[-1][0:2] new_deck = [0]*n new_deck[::2] = x[0:m] new_deck[1::2] = x[m:] new_deck = "|"+"||".join(new_deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): x = int(len(cards)/4) y = cards[max(min(4*abs(m-x),4*(x-m)),0):] print("-"*(7+4*(int(max(min(1,x-m),0)))+len(y))) print("Table:","...."*(int(max(min(1,x-m),0)))+cards[max(min(4*abs(m-x),4*(x-m)),0):]) print("-"*(7+4*(int(max(min(1,x-m),0)))+len(y))) #----------------------------------------- |
| # 6330456021 (16.44) 292 (2021-02-07 20:27) def peek_kth_card(cards, k): a = int((k*4)-4) b = int((k*4)) the_kth_card = cards[a:b] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): pp=cards.replace('||','|_|') il=pp.split('_') il[k-1]='' arr=''.join(il) new_cards=arr return new_cards #--------------------------------------- def deal_n_cards(deck, n): indexa=(n-1)*4 cards=deck[0:indexa+4] new_deck=deck[indexa+4:] return cards, new_deck #--------------------------------------- def cut(deck, m): indexb=(m-1)*4 cards=deck[0:indexb+4] new_deck=deck[indexb+4:]+deck[0:indexb+4] return new_deck #--------------------------------------- def shuffle(deck): dp=int(((len(deck))/4)) #(len(deck)-1)*4 OorE=int((len(deck)/4)%2) numb=int(((len(deck)/4)//2)+(len(deck)/4)%2) ss=deck.replace('||','|_|') ss=ss.split('_') odd=ss*numb swap=int(1-((len(deck)/4)%2)) w=ss[-1]*swap w=w.split() ss.pop() even=ss*numb ne=even[0:numb*dp:numb]+w qe=odd[0:numb*dp:numb] evenSeries=''.join(ne) oddSeries=''.join(qe) new_deck=evenSeries*(1-OorE)+oddSeries*(OorE) return new_deck #--------------------------------------- def show_table_cards(cards, m): count=min(len(cards)//4,m) numb=int(len(cards)/4) gg=cards[((numb-m))*4:] gg=gg.replace('||','|_|') tt=gg.split('_') tt.reverse() new_deck=''.join(tt) qq=new_deck.replace('||','|_|') qq=qq+'_...._'*(numb-m) pp=qq.split('_') kk=pp[0:m+2] kk.reverse() fg=''.join(kk) print("-"*(len(fg)+6)) print("TABLE:"+fg) print("-"*(len(fg)+6)) # print(news) #----------------------------------------- |
| # 6330458221 (20.00) 293 (2021-02-04 23:51) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:(k-1)*4+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k-1)*4] + cards[(k-1)*4+4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:n*4] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4:] + deck[:m*4] return new_deck #--------------------------------------- def shuffle(deck): i1 = len(deck)/4 j2 = int(i1/2) f3 = deck[:j2*4].split('||') f3[0] = f3[0][1:] f3[-1] = f3[-1][:-1] s4 = deck[-(j2*4):].split('||') s4[0] = s4[0][1:] s4[-1] = s4[-1][:-1] m5 = deck[j2*4:-(j2*4)] m5 = m5[1:-1] n6 = ['']*int(i1) n6[0:2*j2:2] = f3 n6[1:2*j2+1:2] = s4 new_deck = '|' + '||'.join(n6)+ m5 +'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): g1 = cards[-(4*m):] b2 = min((len(cards)/4)-m,m) c3 = '....'*int(b2) p4 = 'Table:'+ ' ' + c3[0:4] + g1 print('-'*len(p4)) print('Table:',c3[0:4] + g1) print('-'*len(p4)) #----------------------------------------- |
| # 6330459921 (19.50) 294 (2021-02-06 11:44) def peek_kth_card(cards, k): cut = cards[1:-1] c = cut.split("||") the_kth_card = c[k-1] the_kth_card = "|"+the_kth_card+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cut = cards.replace("||","|,|") c = cut.split(",") new_cards = c[:k-1] + c[k:] new_cards = "".join(new_cards) return new_cards #--------------------------------------- def deal_n_cards(deck, n): cut = deck[1:-1] d = cut.split("||") cards = d[:n] cards = "|"+"||".join(cards)+"|" new_deck = d[n:] new_deck = "|"+"||".join(new_deck)+"|" return cards, new_deck #--------------------------------------- def cut(deck, m): cut1 = deck[1:-1] d = cut1.split("||") new_deck = d[m:] + d[:m] new_deck = "|"+"||".join(new_deck)+"|" return new_deck #--------------------------------------- def shuffle(deck): cut = deck[1:-1] d = cut.split("||") left = d[:int((len(d)/2)+0.5)] right = d[int((len(d)/2)+0.5):] new_deck = ["||"]*len(d) new_deck[::2] = left new_deck[1::2] = right new_deck = "|" +"||".join(new_deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): cut = cards[1:-1] c = cut.split("||") s = int(min(m,len(c))) sc = c[-s:] sc = "|"+"||".join(sc)+"|" d = "...."*min(len(c)-m,1) + sc f = "Table: "+ d print(("-")*len(f)) print(f) print(("-")*len(f)) #----------------------------------------- |
| # 6330460421 (20.00) 295 (2021-02-05 02:32) def peek_kth_card(cards, k): the_kth_card = cards[4 * k - 4:4 * k:1] return the_kth_card # --------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*k-4:]+cards[4*k::] return new_cards # --------------------------------------- def deal_n_cards(deck, n): cards = deck[:4 * n] new_deck = deck[4 * n::] return cards, new_deck # --------------------------------------- def cut(deck, m): new_deck = deck[4 * m::] + deck[:4 * m] return new_deck # --------------------------------------- def shuffle(deck): a = deck[1:-1:1] b = a.split("||") c = b[:int(round(len(b) / 2, 0)):] d = b[int(round(len(b) / 2, 0))::] g = ["0"] * len(b) g[::2] = c g[1::2] = d new_deck = "|" + "||".join(g) + "|" return new_deck # --------------------------------------- def show_table_cards(cards, m): a = cards[-4 * m::] b = "Table: " + "...." * int(len(cards) // 4 > m) + a print(len(b) * "-") print(b) print(len(b) * "-") # ----------------------------------------- |
| # 6330461021 (20.00) 296 (2021-02-08 02:24) def peek_kth_card(cards, k): the_kth_card = cards[(4*k-4):(4*k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(4*k-4):]+cards[(4*k)::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:(4*n)] new_deck = deck[(4*n):] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(4*m):]+deck[0:(4*m)] return new_deck #--------------------------------------- def shuffle(deck): b = int((len(deck)/4/2)+0.5) m = deck[:4*b:] m1 = m.replace('||', '| - |') m2 = m1.split() m2 += ['-']*int(len(deck)/4-len(m2)) n = deck[4*b::] n1 = n.replace('||', '| - |') n2 = n1.split() m2[1::2] = n2[0::2] new_deck = ''.join(m2) return new_deck #--------------------------------------- def show_table_cards(cards, m): d = "...." * int(len(cards)/4-m) d2 = d[0:4] d3 = cards[-4*m::1] e = d2 + d3 print("-"*(7+len(e))) print("Table: "+ e) print("-"*(7+len(e))) #----------------------------------------- |
| # 6330462721 (20.00) 297 (2021-02-05 22:29) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k:] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1):] + cards[4*k::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*(n):] ; new_deck = deck[4*(n)::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*(m)::] + deck[:4*(m):] return new_deck #--------------------------------------- def shuffle(deck): deck = deck.split("||") deck[0] = deck[0][1::] ; deck[-1] = deck[-1][:-1:] m = (int(len(deck))+1)//2 left = deck[:m:] right = deck[m::] new_deck = ["a"]*len(deck) new_deck[::2] = left new_deck[1::2] = right new_deck[0] = "|"+new_deck[0] ; new_deck[-1] = new_deck[-1]+"|" new_deck = "||".join(new_deck) return new_deck #--------------------------------------- def show_table_cards(cards, m): num = int(len(cards)/4) a = min(m,num) show = "...."*(min(num-a,1))+cards[-(4*a)::1] print("-"*(7+len(show))) print("Table: "+show) print("-"*(7+len(show))) #----------------------------------------- |
| # 6330463321 (20.00) 298 (2021-02-08 22:15) def peek_kth_card(cards, k): a = int((k-1)*4) b = int((k*4)) the_kth_card = cards[a:b] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): a = int((k-1)*4) b = int((k*4)) new_cards = cards[:a]+cards[b:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): a = int((n*4)) cards = deck[:a] new_deck = deck[a:] return cards, new_deck #--------------------------------------- def cut(deck, m): a = int((m*4)) deck1 = deck[:a] deck2 = deck[a:] new_deck = deck2+deck1 return new_deck #--------------------------------------- def shuffle(deck): a = len(deck)/4 b = int(a//2) c = int(a-b) d = int(c*4) x = deck[:d] y = deck[d:] new_deck = x[:4]+y[:4]+x[4:8]+y[4:8]+x[8:12]+y[8:12]+x[12:16]+y[12:16]+x[16:20]+y[16:20]+x[20:24]+y[20:24]+x[24:28]+y[24:28]+x[28:32]+y[28:32]+x[32:36]+y[32:36]+x[36:40]+y[36:40]+x[40:44]+y[40:44]+x[44:48]+y[44:48]+x[48:52]+y[48:52]+x[52:56]+y[52:56]+x[56:60]+y[56:60]+x[60:64]+y[60:64]+x[64:68]+y[64:68]+x[68:72]+y[68:72]+x[72:76]+y[72:76]+x[76:80]+y[76:80] return new_deck #--------------------------------------- def show_table_cards(cards, m): a = len(cards) b = int(m*4) c = cards[-b:a] d = len(c) x = min(1,((a//4)-m)) print("-------"+("----"*x)+("-"*d)) print("Table: "+("...."*x)+c) print("-------"+("----"*x)+("-"*d)) #----------------------------------------- |
| # 6330464021 (20.00) 299 (2021-02-08 15:19) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1)] + cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): a = deck[1:-1] b = a.split('||') c = b[0:(len(b)+1)//2] d = b[(len(b)+1)//2:] new = [1]*len(b) new[::2] = c[:] new[1::2] = d[:] new = "||".join(new) new_deck = "|"+new+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): e = cards[1:-1] f = e.split('||') g = f[-m:] g = "||".join(g) h = "|"+g+"|" cards = "...."*(min(len(cards)//4-m,1)) + h print("-"*(7+len(cards))) print("Table: "+cards) print("-"*(7+len(cards))) #----------------------------------------- |
| # 6330465621 (19.11) 300 (2021-02-05 11:21) def peek_kth_card(cards, k): x1 = cards[1:-1] x2 = x1.split('||') the_kth_card = '|' + x2[k-1] + '|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x1 = cards[1:-1] x2 = x1.split('||') del x2[k-1] y = int((len(x2)/51 + 0.99)//1) new_cards = y*'|'+ ('||').join(x2) + y*'|' return new_cards #--------------------------------------- def deal_n_cards(deck, n): x1 = deck[1:-1] x2 = x1.split('||') x3 = x2[:n] x4 = x2[n:] z = int((len(x3)/len(x2) + 0.99)//1) y = int((len(x4)/len(x2) + 0.99)//1) cards = (z*'|') + ('||').join(x3) + (z*'|') new_deck = (y*'|')+ ('||').join(x4) + (y*'|') return cards, new_deck #--------------------------------------- def cut(deck, m): x1 = deck[1:-1] x2 = x1.split('||') x3 = x2[:m] x4 = x2[m:] y = x4 + x3 new_deck = '|'+ ('||').join(y) + '|' return new_deck #--------------------------------------- def shuffle(deck): x1 = deck[1:-1] x2 = x1.split('||') nl = int((len(x2)/2 + 0.5)//1) x3 = x2[:nl] x4 = x2[nl:] y = [None]*(len(x2)) y[::2] = x3 y[1::2] = x4 y1 = ('||').join(y) new_deck = '|' + y1 + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): x1 = cards[1:-1] x2 = x1.split('||') n = len(x2) n1 = n - m n2 = max( n1 , 0 ) y = x2[(-m):] y1 = '|' + ('||').join(y) + '|' y2 = n2*"...." + y1 y3 = "Table: " + y2 print((len(y3))*'-') print(y3) print((len(y3))*'-') #----------------------------------------- |
| # 6330466221 (0.00) 301 (2021-02-08 23:54) |
| # 6330467921 (20.00) 302 (2021-02-06 22:45) def peek_kth_card(cards, k): split_string = cards.split("|") c = split_string[1::2] the_kth_card = "|"+c[k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): split_string = cards.split("|") c = split_string[1::2] remove_kth = c[0:k-1]+c[k:] #method1: รันแล้วมีปัญหา เกมไม่จบเมื่อผู้เล่นลงไพ่ใบสุดท้ายแล้ว ผลยังแสดงเป็น "Player # 1 : ||" #new_cards = "|"+"||".join(remove_kth)+"|" #END method1 #method2: รันแล้ว เกมจบ new_list = ['']*(2*len(remove_kth)+1) new_list[1::2] = remove_kth new_cards = "|".join(new_list) #END medthod2 return new_cards #--------------------------------------- def deal_n_cards(deck, n): split_deck = deck.split("|") d = split_deck[1::2] cards_list = d[0:n] new_cards_list = ['']*(2*len(cards_list)+1) new_cards_list[1::2] = cards_list cards = "|".join(new_cards_list) #cards = "|"+"||".join(cards_list)+"|" remain_cards = d[n:] new_deck_list = ['']*(2*len(remain_cards)+1) new_deck_list[1::2] = remain_cards new_deck = "|".join(new_deck_list) #new_deck = "|"+"||".join(remain_cards)+"|" return cards, new_deck #--------------------------------------- def cut(deck, m): split_deck = deck.split("|") d = split_deck[1::2] d_cut = d[m:]+d[:m] new_deck = "|"+"||".join(d_cut)+"|" return new_deck #--------------------------------------- def shuffle(deck): split_deck = deck.split("|") x = split_deck[1::2] halflist = [len(x)//2+1,len(x)//2] odd0_even1 = (len(x)+1)%2 # odd=0,even=1 half = halflist[odd0_even1] left = x[0:half] right = x[half:] join_left = "||".join(left) split_left = join_left.split("|")+[0]*(odd0_even1) split_left[1::2] = right new_deck = "|" + "||".join(split_left) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): split_cards = cards.split("|") c = split_cards[1::2] compare = len(c)-m # m>len(c)[-a], m=len(c)[0], m<len(c)[+a] a = max(compare,0) # m>len(c)[0], m=len(c)[0], m<len(c)[+a] bigc = "...."+"|"+"||".join(c[-m:])+"|" #len(c)>m bigm = "|"+"||".join(c[-m:])+"|" #len(c)<=m how_to_show = [bigm]+[bigc]*a show = how_to_show[a] print("-"*(7+len(show))) print("Table:",show) print("-"*(7+len(show))) #----------------------------------------- |
| # 6330468521 (20.00) 303 (2021-02-07 22:23) def peek_kth_card(cards, k): the_kth_card = cards[(k*4)-4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(4*k)-4]+cards[(4*k):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:(4*n)] new_deck = deck[(4*n):] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(4*m):]+deck[0:(4*m)] return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1] d = deck.split("||") l = len(d) l1 = int((l/2)+0.5) newdeck1 = d[l1::] newdeck2 = d[:l1:] new_deck = [""]*l new_deck[0::2] = newdeck2 new_deck[1::2] = newdeck1 new_deck = "|"+"||".join(new_deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): c = cards[1:-1] cards_list = c.split("||") l = len(cards_list) c2 = cards_list[-m:] cards2 = "|"+"||".join(c2)+"|" c3 = "...."*min(1,(l-m))+cards2 line2 = "Table:"+" "+c3 l2 = len(line2) print("-"*l2) print(line2) print("-"*l2) #----------------------------------------- |
| # 6330469121 (14.97) 304 (2021-02-08 04:55) def peek_kth_card(cards, k): cards=cards[1:-1] cards=cards.split('||') the_kth_card=cards[k-1] the_kth_card='|'+the_kth_card+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards=cards[1:-1] cards=cards.split('||') cards=cards[0:k-1]+cards[k:] t='||'.join(cards) if len(t)>0 : new_cards='|'+t+'|' if len(t)==0 : new_cards='' return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[1:-1] card=cards.split('||') a=card[:n] b=card[n:] w='||'.join(a) if len(w) >0: cards='|'+w+'|' if len(w)==0: cards='' e='||'.join(b) if len(e) >0: new_deck='|'+e+'|' if len(w)==0: new_deck='' return cards, new_deck #--------------------------------------- def cut(deck, m): cards=deck[1:-1] card=cards.split('||') a=card[:m] b=card[m:] new_deck='|'+'||'.join(b)+'||'+'||'.join(a)+'|' return new_deck #--------------------------------------- def shuffle(deck): cards=deck[1:-1] card=cards.split('||') q=math.ceil((len(card))/2) A1=card[0:q] A2=card[q:] new_deck=[1]*len(card) new_deck[0::2]=A1 new_deck[1::2]=A2 new_deck='||'.join(new_deck) new_deck='|'+new_deck+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cards=cards[1:-1] cards=cards.split('||') if m<len(cards) : a='Table:' + '....'+'|'+'||'.join(cards)+'|' if m>=len(cards) : a='Table:'+ '|'+'||'.join(cards)+'|' print('-'*len(a)) print(a) print('-'*len(a)) #----------------------------------------- |
| # 6330470721 (20.00) 305 (2021-02-08 00:00) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:(k-1)*4+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[(k-1)*0:(k-1)*4:] + cards[(k-1)*4+4::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[4*n::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m::] + deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): s = deck.split("||") t = '|,|'.join(s) y = t.split(",") m = len(y) x = [0]*m z = int((m+1)/2) x[::2] = y[0:z] x[1::2] = y[z::] v = ''.join(x) new_deck = v return new_deck #--------------------------------------- def show_table_cards(cards, m): x = cards[1:-1].split("||") y = x[-m::] z = "||".join(y) a = min(max(int(len(x)/m-0.1),0),1) print("-------" + "----"*a + "----"*len(y)) print("Table:",a*"...." + "|" + z + "|") print("-------" + "----"*a + "----"*len(y)) #----------------------------------------- |
| # 6330471321 (18.00) 306 (2021-02-08 15:09) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): lcards=list(cards) xcards=lcards[:4*(k-1)]+lcards[4*k:] new_cards=(''.join(xcards)) return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:4*n] new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): y=deck[0:4*m] x=deck[4*m:] new_deck=x+y return new_deck #--------------------------------------- def shuffle(deck): deck=deck.split('||') deck1=deck[:int(len(deck)/2)] deck2=deck[int(len(deck)/2):] deck[::2]=deck1 deck[1::2]=deck2 x='||'.join(deck) new_deck = x return new_deck #--------------------------------------- def show_table_cards(cards, m): a= cards[1:-1].split('||') b=a[-m:] b1=len(b) new="||".join(b) new1='|'+new+'|' L=int(len(a)/m) K=max(L,0) J=min(K,1) print("-------"+"----"*J+"----"*b1) print("Table: "+"...."*J+new1) print("-------"+"----"*J+"----"*b1) #----------------------------------------- |
| # 6330472021 (19.50) 307 (2021-02-07 21:53) def peek_kth_card(cards, k): s=cards.split("|") k=2*k-1 b=min(max(len(s),0),1) the_kth_card="|"*b+s[k]+"|"*b return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x=len(cards)-1 s=cards[1:x:1] t=s.split("||") y=k-1 u=t[0:y:1]+t[k::] b=min(max(len(u),0),1) new_cards="|"*b+"||".join(u)+"|"*b return new_cards #--------------------------------------- def deal_n_cards(deck, n): x=len(deck)-1 s=deck[1:x:1] t=s.split("||") u=t[0:n:1] v=t[n::] b=min(max(len(v),0),1) cards="|"*b+"||".join(u)+"|"*b new_deck="|"*b+"||".join(v)+"|"*b return cards, new_deck #--------------------------------------- def cut(deck, m): x=len(deck)-1 s=deck[1:x:1] t=s.split("||") u=t[0:m:1] v=t[m::] w=v+u b=min(max(len(w),0),1) new_deck="|"*b+"||".join(w)+"|"*b return new_deck #--------------------------------------- def shuffle(deck): x=len(deck)-1 s=deck[1:x:1] t=s.split("||") import math p=math.ceil(len(t)/2) u=t[0:p:1] v=t[p::] w=[1]*len(t) w[::2]=u w[1::2]=v b=min(max(len(w),0),1) new_deck="|"*b+"||".join(w)+"|"*b return new_deck #--------------------------------------- def show_table_cards(cards, m): x=len(cards)-1 s=cards[1:x:1] t=s.split("||") a=-min(m,len(cards)) u=t[:a-1:-1] v=u[::-1] import math b=max(math.ceil((len(t)-m)/len(t)),0) w="...."*b+"|"+"||".join(v)+"|" p="Table: "+w print("-"*len(p)) print(p) print("-"*len(p)) #----------------------------------------- |
| # 6330473621 (19.50) 308 (2021-02-07 15:57) def peek_kth_card(cards, k): x = cards.split("|") y = x[1::2] z = y[k-1] a = "|"+z+"|" the_kth_card = a return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x = cards.split("|") y = x[1::2] z = y[0:k-1]+y[k:] a = "||".join(z) b = "|"*min(1,len(y)-1)+a+"|"*min(1,len(y)-1) new_cards = b return new_cards #--------------------------------------- def deal_n_cards(deck, n): x = deck.split("|") y = x[1::2] z = y[0:n] a = "||".join(z) b = "|"+a+"|" cards = b #cards k = y[n:] c = "||".join(k) d = "|"+c+"|" new_deck = d #new_deck return cards, new_deck #--------------------------------------- def cut(deck, m): x = deck.split("|") y = x[1::2] z = y[m:]+y[0:m] c = "||".join(z) d = "|"*min(1,len(z)-1)+c+"|"*min(1,len(z)-1) new_deck = d return new_deck #--------------------------------------- def shuffle(deck): import math x = deck.split("|") y = x[1::2] z = [""]*len(y) z[::2] = y[:math.ceil(len(y)/2)] z[1::2] = y[math.ceil(len(y)/2):] c = "||".join(z) d = "|"*min(1,len(z)-1)+c+"|"*min(1,len(z)-1) new_deck = d return new_deck #--------------------------------------- def show_table_cards(cards, m): x = cards.split("|") y = x[1::2] z = y[-1:-m-1:-1] a = z[-1::-1] c = "||".join(a) d = "|"+c+"|" print("-------"+"----"*(min(1,len(y)-m))+(4*len(a))*"-") print("Table: "+"...."*(min(1,len(y)-m))+d) print("-------"+"----"*(min(1,len(y)-m))+(4*len(a))*"-") #----------------------------------------- |
| # 6330474221 (20.00) 309 (2021-02-08 23:38) def peek_kth_card(cards, k): a=cards[1:len(cards)-1:1] x=a.split("||") the_kth_card="|"+x[k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[0:4*k-4:1]+cards[4*k:len(cards):1] return new_cards #--------------------------------------- def deal_n_cards(deck, n): new_deck=deck[4*n:] cards=deck[0:4*n:1] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m:]+deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): import math d = deck.strip('|') d = d.split('||') k = math.ceil(len(d)/2) a1 = d[:k] b = d[k:] new_deck = '' if len(a1)==len(b): for i in range(len(b)): new_deck += '|'+a1[i]+'||'+b[i]+'|' else: for i in range(len(b)): new_deck += '|'+a1[i]+'||'+b[i]+'|' new_deck += '|'+a1[k-1]+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): x2=cards.strip("|").split("||") if m >= len(x2): print('-'*(4*len(x2)+7)) print('Table: '+'|'+'||'.join(x2)+'|') print('-'*(4*len(x2)+7)) if m < len(x2): f=x2[len(x2)-m::] print('-'*(4*(m+1)+7)) print('Table: '+'....|'+'||'.join(f)+'|') print('-'*(4*(m+1)+7)) #----------------------------------------- |
| # 6330475921 (20.00) 310 (2021-02-08 22:15) def peek_kth_card(cards, k): the_kth_card=cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=(cards[0:4*(k-1)]+cards[4*k:]) return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:4*n] new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=(deck[4*m:]+deck[0:4*m]) return new_deck #--------------------------------------- def shuffle(deck): a1=deck[1:-1] ndeck=a1.split("||") deck1=ndeck[0:(len(ndeck)+1)//2] deck2=ndeck[(len(ndeck)+1)//2:] nwdeck=["r"]*len(ndeck) nwdeck[0::2]=deck1 nwdeck[1::2]=deck2 new_deck="|"+"||".join(nwdeck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): a1=cards[1:-1] c=a1.split("||") d=c[-m::1] #print(d) new="|"+"||".join(d)+"|" #print(new) nn="...."*int(m<len(c))+new e="Table: " print("-"*(len(e)+len(nn))) print(e+nn) print("-"*(len(e)+len(nn))) #----------------------------------------- |
| # 6330476521 (16.67) 311 (2021-02-08 12:33) def peek_kth_card(cards, k): cards = cards[1:-1] cards = cards.split("||") the_kth_card = "|"+cards[k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards = cards.split("|") k = 2*k-1 new_cards = cards[0:k-1]+cards[k+1:] new_cards = "|".join(new_cards) return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck = deck[1:-1] deck = deck.split("||") new_deck = deck[n:] new_deck = "|"+"||".join(new_deck)+"|" cards = deck[:n] cards = "|"+"||".join(cards)+"|" return cards, new_deck #--------------------------------------- def cut(deck, m): deck = deck[1:-1] deck = deck.split("||") new_deck = deck[m:]+deck[:m] new_deck = "|"+"||".join(new_deck)+"|" return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1] deck = deck.split("||") half_left = deck[:int(((len(deck)/2)+0.5))] half_right = deck[int(((len(deck)/2)+0.5)):] new_deck = ['']*52 new_deck[::2] = half_left new_deck[1::2] = half_right new_deck = "|"+"||".join(new_deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards[1:-1] cards = cards.split("||") cards_1 = cards[-1:-m-1:-1] cards_1 = cards_1[-1::-1] cards_1 = "|"+"||".join(cards_1)+"|" print("-------"+("----"*int((len(cards)-min(len(cards),m))//(len(cards)-m+(10e-34))))+("----"*min(len(cards),m))) print("Table:",("...."*int((len(cards)-min(len(cards),m))//(len(cards)-m+(10e-34))))+cards_1) print("-------"+("----"*int((len(cards)-min(len(cards),m))//(len(cards)-m+(10e-34))))+("----"*min(len(cards),m))) #----------------------------------------- |
| # 6330477121 (20.00) 312 (2021-02-07 19:29) def peek_kth_card(cards, k): a = 4*(k-1) the_kth_card = cards[a:a+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): a = 4*(k-1) new_cards = cards[0:a] + cards[a+4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[ :(4*n)] new_deck = deck[(4*n): ] return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck[ :(4*m)] b = deck[(4*m): ] new_deck = b+a return new_deck #--------------------------------------- def shuffle(deck): deckList = deck[1:-1].split('||') n = len(deckList) a = deckList[:round((n/2))] b = deckList[round((n/2)):] c = n*[' '] c[::2] = a c[1::2] = b new_deck = '|' + '||'.join(c)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cardsList = cards[1:-1].split('||') cardsList = cardsList[::-1] n1 = len(cardsList) a = cardsList[:m]+['....'] n2 = len(a)-1 line2 = 'Table: '+''.join(a[m:n1])+'|' + '||'.join(a[:n2][::-1])+'|' print('-'*len(line2)) print(line2) print('-'*len(line2)) #----------------------------------------- |
| # 6330478821 (20.00) 313 (2021-02-08 19:10) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4 : ((k-1)*4)+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0 : (k-1)*4] + cards[((k-1)*4)+4 : ] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[ : (n*4)] new_deck = deck[(n*4) : ] return cards, new_deck #-------------------------------------- def cut(deck, m): a = deck[ : (m*4)] b = deck[(m*4) : ] new_deck = b + a return new_deck #--------------------------------------- def shuffle(deck): deckList = deck[1:-1].split('||') n = len(deckList) a = deckList[: round((n/2) + 0.39)] b = deckList[round((n/2) + 0.39) :] z = [' ']*n z[::2] = a z[1::2] = b new_deck = '|' + '||'.join(z) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cardsList = cards[1:-1].split('||') cardsList = cardsList[::-1] n1 = len(cardsList) a = cardsList[:m] + ['....'] n2 = len(a) - 1 line2 = 'Table: ' + ''.join(a[m:n1]) + '|' + '||'.join(a[:n2][::-1]) + '|' print('-'*len(line2)) print(line2) print('-'*len(line2)) #----------------------------------------- |
| # 6330481621 (20.00) 314 (2021-02-07 11:14) def peek_kth_card(cards, k): the_kth_card=cards[4*(k-1):4*k:1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[0:4*(k-1):1]+cards[4*k::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:4*n:1] new_deck=deck[4*n::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m::]+deck[0:4*m:1] return new_deck #--------------------------------------- def shuffle(deck): b=deck[1:-1:] c=b.split("||") g=(len(c)+1)//2 h=c[0:g:] i=c[g::] j=[""]*len(c) j[::2]=h j[1::2]=i d="||".join(j) new_deck="|"+d+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): c="Table: "+"...."*(4*m<len(cards))+cards[-4*m::] d="-"*len(c) print(d) print(c) print(d) #----------------------------------------- |
| # 6330482221 (20.00) 315 (2021-02-05 02:31) def peek_kth_card(cards, k): the_kth_card = cards[(k*4)-4:k*4] return the_kth_card # --------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:k*4-4]+cards[k*4:] return new_cards # --------------------------------------- def deal_n_cards(deck, n): cards = deck[0:n*4] new_deck = deck[n*4:] return cards, new_deck # --------------------------------------- def cut(deck, m): v1 = deck[0:m*4] v2 = deck[m*4:] new_deck = v2 + v1 return new_deck # --------------------------------------- def shuffle(deck): C = deck.split("|") C = C[1:-1:2] l1 = len(C) l2 = (l1 + 1) // 2 C1 = C[0:l2:1] C2 = C[l2::1] new_deck = [""] * l1 new_deck[::2] = C1 new_deck[1::2] = C2 new_deck = "|" + ("||").join(new_deck) + "|" return new_deck # --------------------------------------- def show_table_cards(cards, m): t = 'Table: ' + '....' * int(len(cards) // 4 > m) + cards[-4 * m::1] b = '-' * len(t) print(b) print(t) print(b) # ----------------------------------------- |
| # 6330483921 (20.00) 316 (2021-02-07 20:54) def peek_kth_card(cards, k): a=cards[1:len(cards)-1:1] b=a.split("||") the_kth_card="|"+b[k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[0:4*(k-1):1]+cards[4*k:len(cards):1] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:4*n:1] new_deck=deck[4*n::1] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m::1]+deck[0:4*m:1] return new_deck #--------------------------------------- def shuffle(deck): a1=deck[1:len(deck)-1:1] b1=a1.split("||") new_deck='' if len(b1)%2 == 1: for i in range(len(b1)//2): new_deck += '|'+b1[i]+'||'+b1[i+int((len(b1)+1)/2)]+'|' new_deck += '|'+b1[int((len(b1)-1)/2)]+'|' if len(b1)%2 == 0: for i in range(len(b1)//2): new_deck += '|'+b1[i]+'||'+b1[i+int((len(b1)+1)/2)]+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a2=cards[1:len(cards)-1:1] b2=a2.split("||") c2=b2[::-1] d2=c2[0:m:] e2=d2[::-1] print('-'*min((4*(m+1)+7),(4*len(b2)+7))) print('Table: '+'....'*min((len(b2)-m),1)+'|'+'||'.join(e2)+'|') print('-'*min((4*(m+1)+7),(4*len(b2)+7))) #----------------------------------------- |
| # 6330484521 (20.00) 317 (2021-02-08 23:35) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*(k-1)+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1)]+cards[4*(k-1)+4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck =deck[(4*m):] + deck[:(4*m)] return new_deck #--------------------------------------- def shuffle(deck): new_deck = [None]*(len(deck)) import re import math s=(math.ceil(len(deck)/8))*4 x=deck[:s] y=deck[s:] q=re.findall(r"\|\S\S\|",x) o=re.findall(r"\|\S\S\|",y) C = [None]*(len(q)+len(o)) C[::2] = q C[1::2] = o new_deck=''.join(C) return new_deck #--------------------------------------- def show_table_cards(cards, m): s=int(len(cards) >(4*m)) print(((len(cards)-s*(len(cards)-4*m))+7+s*4)*"-") print("Table:",s*"...."+cards[s*(len(cards)-4*m):]) print(((len(cards)-s*(len(cards)-4*m))+7+s*4)*"-") #----------------------------------------- |
| # 6330485121 (19.78) 318 (2021-02-07 20:18) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*k-4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): a = deck.strip('|') b = a.split('||') #['1S','2S','3S','4S','5S'] c = (len(b)+1)//2 #2 d = b[0:c] #['1S','2S','3S'] e = b[c:] #['4S','5S'] newlist = ['']*len(b) newlist[0::2] = d newlist[1::2] = e new_deck = newlist new_deck = '||'.join(new_deck) new_deck = '|'+new_deck+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): d = 'Table:'+' ....'*int(bool((len(cards)/4)>m))+cards[-4*m:] print('-'*len(d)) print(d) print('-'*len(d)) #----------------------------------------- |
| # 6330486821 (20.00) 319 (2021-02-05 02:32) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4] + cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1].split('||') a = len(deck)//2 + len(deck)%2 new_deck = ['']*len(deck) new_deck[::2] = deck[:a] new_deck[1::2] = deck[a:] new_deck = '|'+('||').join(new_deck)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): text = 'Table: ' + '....'*int(len(cards)//4>m) + cards[-4*m:] bord = '-'*len(text) print(bord) print(text) print(bord) #----------------------------------------- |
| # 6330487421 (20.00) 320 (2021-02-08 18:48) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*(k-1)]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): j=deck[4*m:] k=deck[0:4*m] new_deck = j+k return new_deck #--------------------------------------- def shuffle(deck): deck=deck[1:-1] deck=deck.split("||") a=deck[0:int(len(deck)/2+0.5)] b=deck[int(len(deck)/2+0.5):] new_deck=deck new_deck[::2]=a new_deck[1::2]=b new_deck='||'.join(new_deck) new_deck='|'+ new_deck +'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cards=cards[1:-1] cards=cards.split("||") mm=cards[-1:-m-1:-1] mm=mm[::-1] dash=mm+['....'] product='Table: '+''.join(dash[m:len(cards)])+'|'+'||'.join(mm)+'|' print('-' *len(product)) print(product) print('-' *len(product)) #----------------------------------------- |
| # 6330488021 (20.00) 321 (2021-02-05 00:58) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):(4*k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): a= cards[0:4*(k-1)] b= cards[(4*k):] new_cards=a+b return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): a=deck[0:4*m] b=deck[4*m:] new_deck = b+a return new_deck #--------------------------------------- def shuffle(deck): a=deck[1:-1] b=a.split('||') # join | later ได้ listไพ่ len=26 c=b[:((len(b)+1)//2)] #left d=b[((len(b)+1)//2):] #right n=[0]*len(b) n[::2] = c n[1::2] = d x='||'.join(n) new_deck='|'+x+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): n=cards[1:-1] a=n.split('||') b=a[-m::] c='||'.join(b) d='|'+c+'|' x= ('.'*min(4*((len(a))-m),4)) +d t='Table: ' print('-'*(len(t)+len(x))) print(t+x) print('-'*(len(t)+len(x))) #----------------------------------------- |
| # 6330489721 (20.00) 322 (2021-02-07 12:53) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): a = cards[:4*k-4] b = cards[4*k:] new_cards = a+b return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:(4)*n] new_deck = deck[(4)*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): c = deck[4*m:] d = deck[:4*m] new_deck = c+d return new_deck #--------------------------------------- def shuffle(deck): e = deck[1:-1].split('||') f = (len(e)+1)//2 new_deck = ['']*len(e) new_deck[::2] = e[0:f:1] new_deck[1::2] = e[f::1] new_deck = '|'+('||').join(new_deck) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): g = cards[1:-1].split('||') h = g[-m:] i = '|'+ '||'.join(h) + '|' j = '' if m>=len(cards)/4: j = '.'*0 else: j = '.'*4 l = 'Table: ' print('-'*(len(l)+len(j)+len(i))) print(l+j+i) print('-'*(len(l)+len(j)+len(i))) #----------------------------------------- |
| # 6330491921 (19.56) 323 (2021-02-06 23:44) def peek_kth_card(cards, k): cards22 = cards.split("|") the_kth_card ='|'+cards22[(2*k)-1]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k-1)*4]+cards[(k*4):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): x = deck[1:-1].split('|') y = '|'.join(x) z = '|'+y+'|' a = z[:4*m] a2 = z[4*m:] new_deck = a2+a return new_deck #--------------------------------------- def shuffle(deck): import math deck22 = deck.split('|') deck22 = deck22[1::2] new_deck=deck22.copy() new_deck[::2] = deck22[:math.ceil(len(deck22)/2)] new_deck[1::2] = deck22[math.ceil(len(deck22)/2):] new_deck = '||'.join(new_deck) new_deck = '|'+new_deck+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): bb = int(len(cards)/4) aa = int(min(len(cards)/4,m)) card_new ='....'*(bb-aa> 0)+cards[(bb-aa)*4:] print('--------'+'----'*int(len(card_new)/4)) print('Table: ',card_new) print('--------'+'----'*int(len(card_new)/4)) #----------------------------------------- |
| # 6330492521 (18.67) 324 (2021-02-05 15:44) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:4*k] #complete return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:((k-1)*4)]+cards[4*k:] #complete return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:(n)*4] #complete new_deck = deck[(n)*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(m)*4:]+deck[:(m)*4] #complete return new_deck #--------------------------------------- def shuffle(deck): from math import ceil deck = deck[1:-1].split('||') new_deck=deck.copy() new_deck[::2] = deck[:ceil(len(deck)/2)] new_deck[1::2] = deck[ceil(len(deck)/2):] #complete new_deck = '||'.join(new_deck) new_deck = '|'+new_deck+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cd = int(min(len(cards)/4,m)) no = int(len(cards)/4) card2 ='....'*(no-cd> 0)+cards[(no-cd)*4:] #complete print('-------'+'----'*int(len(card2)/4)) print('Table: ',card2) print('-------'+'----'*int(len(card2)/4)) #----------------------------------------- |
| # 6330494821 (20.00) 325 (2021-02-06 15:49) def peek_kth_card(cards, k): x=cards[1:-1] y=x.split('||') z=y[k-1] the_kth_card ='|'+z+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x=cards[1:-1] y=x.split('||') z=y[:k-1]+y[k:] new_cards='|'*(len(z)>0)+'||'.join(z)+'|'*(len(z)>0) return new_cards #--------------------------------------- def deal_n_cards(deck, n): x=deck[1:-1] y=x.split('||') w=y[0:n] z=y[n:] cards='|'*(len(w)>0)+'||'.join(w)+'|'*(len(w)>0) new_deck='|'*(len(z)>0)+'||'.join(z)+'|'*(len(z)>0) return cards, new_deck #--------------------------------------- def cut(deck, m): x=deck[1:-1] y=x.split('||') z=y[m:]+y[0:m] new_deck='|'*(len(z)>0)+'||'.join(z)+'|'*(len(z)>0) return new_deck #--------------------------------------- def shuffle(deck): import math x=deck[1:-1] y=x.split('||') z=[0]*len(y) z[0::2]=y[:math.ceil(len(y)/2)] z[1::2]=y[math.ceil(len(y)/2):] new_deck='|'*(len(z)>0)+'||'.join(z)+'|'*(len(z)>0) return new_deck #--------------------------------------- def show_table_cards(cards, m): x=int(len(cards)/4) y=int(min(x,m)) z='....'*(x-y>0)+cards[(x-y)*4:] print('-------'+'-'*len(z)) print('Table:',z) print('-------'+'-'*len(z)) #----------------------------------------- |
| # 6330495421 (20.00) 326 (2021-02-08 02:23) def peek_kth_card(cards, k): cards=cards[1:-1] cards=cards.split("||") the_kth_card="|"+cards[k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards=cards[1:-1] cards=cards.split("||") cards=cards[:k-1]+cards[k:] new_cards=min(len(cards),1)*"|"+"||".join(cards)+"|"*min(len(cards),1) return new_cards #--------------------------------------- def deal_n_cards(deck, n): s=len(deck)//4 deck=deck[1:-1] deck=deck.split("||") cards=min(n,1)*"|"+"||".join(deck[:n])+"|"*min(n,1) new_deck=min(s-n,1)*"|"+"||".join(deck[n:])+min(s-n,1)*"|" return cards, new_deck #--------------------------------------- def cut(deck, m): deck=deck[1:-1] deck=deck.split("||") new_deck="|"+"||".join(deck[m:]+deck[:m])+"|" return new_deck #--------------------------------------- def shuffle(deck): deck=deck[1:-1] deck=deck.split("||") a=deck[:len(deck)//2+len(deck)%2] b=deck[len(deck)//2+len(deck)%2:] total=[1]*len(deck) total[::2]=a total[1::2]=b new_deck="|"+"||".join(total)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): cards=cards[1:-1] cards=cards.split("||") k=len(cards) cards=cards[-m:] cards="|"+"||".join(cards)+"|" print ("-"*(len("table:"+" "+cards)+len("...."*(min(k-m,1))))) print ("Table:"+" "+("...."*min(k-m,1))+cards) print ("-"*(len("table:"+" "+cards)+len("...."*min(k-m,1)))) #----------------------------------------- |
| # 6330496021 (18.17) 327 (2021-02-08 23:58) def peek_kth_card(cards, k): card_ = cards.split("|") l = 2*k-1 the_kth_card = '|'+card_[l]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): l = k-1 card0 = cards[1:-1].split("||") new_cards ='|'+'||'.join(card0[:l])+'||'.join(card0[l+1:])+'|' return new_cards #--------------------------------------- def deal_n_cards(deck, n): l = n-1 deck_ = deck[1:-1].split("||") cards = '|'+'||'.join(deck_[:l+1])+'|' new_deck = '|'+'||'.join(deck_[l+1:])+'|' return cards, new_deck #--------------------------------------- def cut(deck, m): l = m-1 deck_ = deck[1:-1].split("||") a = '||'.join(deck_[:l+1]) b = '||'.join(deck_[l+1:]) cards = '|'*int((float(len(a)))//(float(len(a))-0.1))+a+'|'*int((float(len(a)))//(float(len(a))-0.1)) new_deck = '|'*int((float(len(b)))//(float(len(b))-0.1))+b+'|'*int((float(len(b)))//(float(len(b))-0.1))+cards return new_deck #--------------------------------------- def shuffle(deck): deck_ = deck[1:-1].split('||') a = deck_[:int(len(deck_)/2-0.5)+1] b = deck_[int(len(deck_)/2-0.5)+1:] deck_[::2] = a deck_[1::2] = b new_deck = '|'+'||'.join(deck_[:])+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cards_ = cards[1:-1].split('||') a = len(cards_) b = int(m<a) t = '....'*b+'|'+'||'.join(cards_[-1*m:])+'|' print('-----------'+'-'*(4*min(m,a-1))) print("Table:",t) print('-----------'+'-'*(4*min(m,a-1))) #----------------------------------------- |
| # 6330497721 (20.00) 328 (2021-02-05 21:55) def peek_kth_card(cards, k): the_kth_card=cards[(4*(k-1)):(4*k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x=cards.split('|') new_cards=x[0:2*(k-1)]+x[2*k:] new_cards="|".join(new_cards) return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:(4*n)] new_deck=deck[(4*n):] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m:]+deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): x=deck.split("|") n=len(x)%2+len(x)//2 new_deck=[] if n%2!=0: x1=x[1:n] x2=x[n:] else: x1=x[:n] x2=x[n:] for i in range(n//2): new_deck+=x1[2*i:2*(i+1)]+x2[2*i:2*(i+1)] new_deck="|".join(new_deck) if n%2!=0: new_deck="|"+new_deck return new_deck #--------------------------------------- def show_table_cards(cards, m): n=len(cards) if m<n//4: x="Table: "+"...."+cards[-n-(4*(m-n//4))::1] else: x="Table: "+cards[-n-(4*(m-n//4))::1] print("-"*len(x)) print(x) print("-"*len(x)) #----------------------------------------- |
| # 6330498321 (20.00) 329 (2021-02-08 09:54) def peek_kth_card(cards, k): i=0 allc=[] while i+4 < len(cards)+1: allc.append(cards[i:i+4]) i+=4 the_kth_card=allc[k-1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): hand=[] i=0 while i+4 < len(cards)+1: hand.append(cards[i:i+4]) i+=4 hand[k-1:k]=[] new_cards='' for i in hand: new_cards+=i return new_cards #--------------------------------------- def deal_n_cards(deck, n): i=0 hand=[] while i+4 < len(deck)+1: hand.append(deck[i:i+4]) i+=4 get=hand[0:n] for j in range(n): hand[0:1]=[] new_deck='' cards='' for k in get: cards+=k for m in hand: new_deck+=m return cards, new_deck #--------------------------------------- def cut(deck, m): i=0 allc=[] while i+4 < len(deck)+1: allc.append(deck[i:i+4]) i+=4 hand=allc[0:m] for i in range(0,m): allc[0:1]=[] cards='' new_deck='' for j in hand: cards+=j for k in allc: new_deck+=k new_deck+=cards return new_deck #--------------------------------------- def shuffle(deck): deck2=[] new_deck='' i=0 while i+4 <len(deck)+1: deck2.append(deck[i:i+4]) i+=4 if (len(deck2))%2!=0: p=len(deck2)//2 left=deck2[0:p+1] right=deck2[p+1:] e=0 for i in right: new_deck+=(left[e]) new_deck+=(i) e+=1 new_deck+=(left[p]) if (len(deck2))%2==0: p=len(deck2)//2 left=deck2[0:p] right=deck2[p:] e=0 for i in left: new_deck+=(i) new_deck+=(right[e]) e+=1 return new_deck #--------------------------------------- def show_table_cards(cards, m): line='-' cards=cards.strip('| |').split('||') n=len(cards) if m<n: ca=cards[-m:] show='Table:'+' ....'+'|'+'||'.join(ca)+'|' if m>=n: ca=cards[-n:] show='Table:'+' '+'|'+'||'.join(cards)+'|' print(line*len(show)) print(show) print(line*len(show)) #----------------------------------------- |
| # 6330499021 (19.50) 330 (2021-02-08 16:06) def peek_kth_card(cards, k): cards_split = cards.split('|') cards_skip = cards_split[1::2] the_kth_card = '|' + cards_skip[k - 1] + '|' return the_kth_card # --------------------------------------- def remove_kth_card(cards, k): cards_split = cards.split('|') cards_skip = cards_split[1::2] cards_skip.pop(k - 1) if (len(cards_skip)==0): return '' new_cards = '|' + '||'.join(cards_skip) + '|' return new_cards # --------------------------------------- def deal_n_cards(deck, n): deck_split = deck.split('|') deck_skip = deck_split[1::2] cards = deck_skip[0:n] cards = '|' + '||'.join(cards) + '|' new_deck = deck_skip[n:] if (len(new_deck)==0): return cards,'|' new_deck = '|' + '||'.join(new_deck) + '|' return cards, new_deck # --------------------------------------- def cut(deck, m): deck_split = deck.split('|') deck_skip = deck_split[1::2] new_cut = deck_skip[m::] +deck_skip[0:m] new_deck = '|' + '||'.join(new_cut) +'|' return new_deck # --------------------------------------- def shuffle(deck): deck_split = deck.split('|') deck_skip = deck_split[1::2] total_cards = len(deck_skip) odd_even = total_cards % 2 x = total_cards // 2 + odd_even deck_left = deck_skip[:x] deck_right = deck_skip[x:] deck_skip[::2], deck_skip[1::2] = deck_left, deck_right full_deck = '||'.join(deck_skip) new_deck = '|' + full_deck + '|' return new_deck # --------------------------------------- def show_table_cards(cards, m): cards_split = cards.split('|') cards_skip = cards_split[1::2] cards_amount = len(cards_skip) table = cards_skip[-m:] table = '||'.join(table) if cards_amount > m : full_table = 'Table: ....|' + table + '|' else: full_table = 'Table: |' + table + '|' amount = len(full_table) print('-' * amount) print(full_table) print('-' * amount) # ----------------------------------------- |
| # 6330500921 (20.00) 331 (2021-02-07 14:27) def peek_kth_card(cards, k): the_kth_card=cards[(4*(k-1)):(4*k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[:(4*(k-1))]+cards[(4*k):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:(4*n)] new_deck=deck[(4*n):] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[(4*m):]+deck[0:(4*m)] return new_deck #--------------------------------------- def shuffle(deck): d=deck[1:-1] e=d.split('||') f=d.split('||') l=(len(e)+1)//2 e[0::2]=e[0:l] e[1::2]=f[l:] new_deck='|'+'||'.join(e)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a=int(min((((len(cards))/4)-m),1)) b=int(min(((len(cards))/4),m)) c='Table: '+'.'*(4*a)+cards[(-1*4*b):] print('-'*len(c)) print(c) print('-'*len(c)) #----------------------------------------- |
| # 6330501521 (20.00) 332 (2021-02-07 01:07) def peek_kth_card(cards, k): the_kth_card=cards[(4*k)-4:(4*k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[0:(4*k)-4:]+cards[4*k::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:4*n:] new_deck=deck[4*n::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m::]+deck[0:4*m:] return new_deck #--------------------------------------- def shuffle(deck): a=deck[1:-1:] d=a.split('||') d1=d[0:int(len(d)/2+0.5):] d2=d[int(len(d)/2+0.5)::] new_deck=[0]*len(d) new_deck[0::2]=d1 new_deck[1::2]=d2 new_deck='||'.join(new_deck) new_deck='|'+new_deck+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): c=int(len(cards)/4) c1=min(c,m) show=cards[-(c1*4)::] show='....'*min(1,c-c1)+show print('-'*(7+len(show))) print('Table: '+show) print('-'*(7+len(show))) #----------------------------------------- |
| # 6330502121 (20.00) 333 (2021-02-06 23:07) def peek_kth_card(cards, k): cards=cards[1:-1] cards=cards.split('||') the_kth_card = cards[k-1] the_kth_card = '|'*min(len(cards),1)+the_kth_card+'|'*min(len(cards),1) return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards=cards[1:-1] cards=cards.split('||') new_cards = cards[:k-1]+cards[k:] cards=new_cards new_cards='||'.join(new_cards) new_cards = '|'*min(len(cards),1)+new_cards+'|'*min(len(cards),1) return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck=deck[1:-1] deck=deck.split('||') cards = deck[0:n] new_deck = deck[n:] cards='||'.join(cards) deck=new_deck new_deck='||'.join(new_deck) cards = '|'*min(len(cards),1)+cards+'|'*min(len(cards),1) new_deck = '|'*min(len(deck),1)+new_deck+'|'*min(len(deck),1) return cards, new_deck #--------------------------------------- def cut(deck, m): deck=deck[1:-1] deck=deck.split('||') new_deck=deck[m:] deck=deck[0:m] new_deck.extend(deck) new_deck='||'.join(new_deck) new_deck='|'+new_deck+'|' return new_deck #--------------------------------------- def shuffle(deck): deck=deck[1:-1] deck=deck.split('||') n=len(deck) a=deck[0:n//2+n%2] b=deck[-n//2+n%2:] l=[0]*n l[0::2]=a l[1::2]=b new_deck=l new_deck='||'.join(l) new_deck='|'+new_deck+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cards=cards[1:-1] cards=cards.split('||') n=len(cards) cards = cards[-m:] cards='||'.join(cards) table=("-"*len("Table: "+'|'+cards+'|'+"...."*min(n-m,1))) print(table) print("Table: "+"...."*min(n-m,1)+'|'+cards+'|') print(table) #----------------------------------------- |
| # 6330503821 (20.00) 334 (2021-02-07 22:12) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*(k-1)] + cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): deck_list = deck.strip('|').split('||') deck_amount=len(deck_list) deck_odd=deck_amount%2 deck_half_split=deck_amount//2+deck_odd deck1=deck_list[:deck_half_split] deck2=deck_list[deck_half_split:] deck_list[::2]=deck1 deck_list[1::2]=deck2 new_deck='|'+'||'.join(deck_list)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): c=min(m,len(cards)//4) show=cards[-4*m:] d="...."*int((len(cards)//4-c)**(1/100000)) z="Table: "+d+show print("-"*(4*c+len(d)+7)) print(z) print("-"*(4*c+len(d)+7)) #----------------------------------------- |
| # 6330504421 (20.00) 335 (2021-02-07 01:16) def peek_kth_card(cards, k): a = cards.split('||') b = '|,|'.join(a) c = b.split(',') the_kth_card = c[k-1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): a = cards.split('||') b = '|,|'.join(a) c = b.split(',') d = c[0:k-1]+c[k:] new_cards = ''.join(d) return new_cards #--------------------------------------- def deal_n_cards(deck, n): a = deck.split('||') b = '|,|'.join(a) c = b.split(',') d = c[0:n] e = c[n:] cards = ''.join(d) new_deck = ''.join(e) return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck.split('||') b = '|,|'.join(a) c = b.split(',') d = c[0:m] e = c[m:] f = e+d new_deck = ''.join(f) return new_deck #--------------------------------------- def shuffle(deck): a = deck.split('||') b = '|,|'.join(a) c = b.split(',') d = ((len(c)+1)//2) e = c[0:d] f = c[d:] g = [0]*len(c) g[0::2] = e g[1::2] = f new_deck = ''.join(g) return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards.split('||') b = '|,|'.join(a) c = b.split(',') d = min(len(c),m) e = c[len(c)-d:] import math f = math.ceil((len(c) - d)/len(c)) g = ['....']*len(c) g[f:] = e h = ''.join(g) print('-'*(len(h)+7)) print('Table:',h) print('-'*(len(h)+7)) #----------------------------------------- |
| # 6330505021 (20.00) 336 (2021-02-07 21:19) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:((k-1)*4+4)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(k-1)*4] + cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): g = deck.split('||') o = len(g) new_deck = '' if o%2==0: p = o//2 for i in range(p): if i != p-1: new_deck =new_deck+g[i] +'||'+ g[i+p]+ '||' if i == p-1: new_deck =new_deck+g[i] +'||'+ g[i+p] if o%2 != 0: p = o//2 new_deck = g[0]+'||' for i in range(1,p+1): if i != p: new_deck =new_deck + g[i+p]+ '||'+ g[i] + '||' else: new_deck =new_deck + g[i+p]+ '|'+ g[i] + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): g = cards.split('||') p = len(g) k='Table: ....|' if m >= len(g): eiei='Table: '+cards o = '-'*len(eiei) print(o) print(eiei) print(o) if m < len(g): mo = p - m for i in range(mo,p): if i == p-1: k = k+g[i] else: k = k+g[i]+'||' o = '-'*len(k) print(o) print(k) print(o) #----------------------------------------- |
| # 6330507321 (20.00) 337 (2021-02-08 01:27) def peek_kth_card(cards, k): the_kth_card=cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards =cards[0:4*k-4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:4*n] new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m:]+deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): a=deck[1:len(deck)-1] a=a.split('||') b=a[0:(len(a)+1)//2] c=a[(len(a)+1)//2:] x=[0]*len(a) x[::2]=b x[1::2]=c new_deck='|'+'||'.join(x)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a=cards[1:len(cards)-1] a=a.split('||') x=2**(int(m)//len(a))%2 y=a[x*(len(a)-int(m)):] z='Table:'+' '+('....'*x)+'|'+'||'.join(y)+'|' print('-'*len(z)) print(z) print('-'*len(z)) #----------------------------------------- |
| # 6330508021 (18.67) 338 (2021-02-06 10:50) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:4*(k-1)+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k-1)*4+1]+cards[k*4+1:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): A = deck[:4*m] new_deck = deck[4*m:]+A return new_deck #--------------------------------------- def shuffle(deck): decklist = ("|,|".join(deck.split("||"))).split(",") ndeck = len(decklist) front = decklist[:(ndeck+1)//2] behind = decklist[(ndeck+1)//2:] A= list('a'*ndeck) A[0::2]=front ; A[1::2]=behind new_deck = "".join(A) return new_deck #--------------------------------------- def show_table_cards(cards, m): a = len(cards)-m*4 b = a*"."+cards[-4*m:] c = b[(m+1)*(-4):] print("-------"+"-"*len(c)) print("Table: "+c) print("-------"+"-"*len(c)) #----------------------------------------- |
| # 6330509621 (18.44) 339 (2021-02-07 22:13) def peek_kth_card(cards, k): #"|2H||4S||TD||AC|" c = cards.split("|") the_kth_card = "|".join(c[2*k-2:2*k+1]) return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): c = cards.split("|") cr = c.pop(2*k-1) cr = c.pop(2*k-1) new_cards = "|".join(c) return new_cards #--------------------------------------- def deal_n_cards(deck, n): #"|2H||4S||TD||AC||AD||AS|" d = deck.split("|") dc = d[:2*n+1] dn = d[2*n:] cards = "|".join(dc) new_deck = "|".join(dn) return cards, new_deck #--------------------------------------- def cut(deck, m): d = deck.split("|") dc = "|".join(d[:2*m+1]) dn = "|".join(d[2*m:]) new_deck = dn + dc return new_deck #--------------------------------------- def shuffle(deck): d = deck[1:-1].split("|") a = len(d) d1 = d[:a//2+1] d2 = d[a//2:] d1[1::2] = d2[1::2] new_deck = "|" + "||".join(d1) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): c = cards[1:-1].split("||") t = "|" + "||".join(c[-1*m:]) + "|" a = len(c) table = "Table: " + int(m<a)*"...." + t print(len(table)*"-") print(table) print(len(table)*"-") #----------------------------------------- |
| # 6330511821 (20.00) 340 (2021-02-07 00:32) def peek_kth_card(cards, k): the_kth_card = cards[(4*k-4):(4*k):] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x = cards[(0):(4*k-4):] y = cards[4*k::] new_cards = x + y return new_cards #-------------------------------------- def deal_n_cards(deck, n): new_deck = deck[4*n::] cards = deck[0:4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m::] cards = deck[0:4*m:] new_deck = new_deck + cards return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1] deck = deck.split('||') x=int((len(deck)+1)//2) deck1 = deck[0:x:] deck2 = deck[x::] new_deck = ['']*len(deck) new_deck[::2] = deck1 new_deck[1::2] = deck2 new_deck = '||'.join(new_deck) new_deck = '|'+new_deck+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): total_card = int(len(cards)/4) total_keep = int(min(m, total_card)) total_remove = int(total_card - total_keep) total_lens = len("Table: "+ "...."*min(1,total_remove)+ cards[total_remove*4:]) print("-"*total_lens) print("Table: "+ "...."*min(1,total_remove)+ cards[total_remove*4:]) print("-"*total_lens) #----------------------------------------- |
| # 6330512421 (19.11) 341 (2021-02-06 01:40) def peek_kth_card(cards, k): the_kth_card=cards[4*k-4:4*k] return the_kth_card def remove_kth_card(cards, k): new_cards=cards[:4*k-4]+cards[4*k:] return new_cards def deal_n_cards(deck, n): cards=deck[:4*n] new_deck=deck[4*n:] return cards, new_deck def cut(deck, m): new_deck=deck[4*m:]+deck[:4*m] return new_deck def shuffle(deck): C = deck[1:-1].split("||") C1 = C[:(len(C)+1)//2] C2 = C[(len(C)+1)//2:] new_deck = list("x"*(len(C1)+len(C2))) new_deck[::2] = C1[:len(C1)+1] new_deck[1::2] = C2 new_deck = "|"+"||".join(new_deck)+"|" return new_deck def show_table_cards(cards, m): table = cards[-4*m::1] print("-"*(len("Table: ")+len(cards))) print("Table: "+("."*(len(cards)-len(table)))+table) print("-"*(len("Table: ")+len(cards))) #----------------------------------------- |
| # 6330513021 (18.00) 342 (2021-02-05 00:36) def peek_kth_card(cards, k): c = cards.split("|") the_kth_card = '|' + c[2*k-1] + '|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k-1)*4:]+cards[k*4::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:n*4:] new_deck= deck[n*4::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(m-1)*4::]+deck[:(m-1)*4:] return new_deck #--------------------------------------- def shuffle(deck): a = deck.split("|") d =a[1:-1:] c =d[::2] l = int((len(c)+1)/2) n1= c[:l:] n2= c[l::] e = len(c)*[1] e[::2] = n1[::] e[1::2] = n2[::] new_deck='|'+'||'.join(e)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): d = len(cards) a = cards[((d-(m*4)>0)*(d-(m*4)))::] x ="Table"+": "+"...."*(m< d/4) + a print(len(x)*"-") print(x) print(len(x)*"-") #----------------------------------------- |
| # 6330514721 (20.00) 343 (2021-02-07 18:29) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k:1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[0:4*(k-1):1]+cards[4*k::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:4*n:1] new_deck=deck[4*n::1] return cards, new_deck #--------------------------------------- def cut(deck, m): b=deck[0:4*m:1] a=deck[4*m::] new_deck=a+b return new_deck #--------------------------------------- def shuffle(deck): y=int(len(deck)/4) z=y//2 a=y-z deck=deck[1:-1:] c=deck.split("||") new_deck=["m"]*y l=c[0:a:1] p=c[a::] new_deck[::2]=l new_deck[1::2]=p new_deck = "|"+"||".join(new_deck)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): y=int(len(cards)/4) a=min(m,y) b="...."*min(y-a,1)+cards[(-4*a)::1] print("-"*(7+len(b))) print("Table: "+b) print("-"*(7+len(b))) #----------------------------------------- |
| # 6330515321 (20.00) 344 (2021-02-08 22:16) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*k-4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): left = deck[:4*m] right = deck[4*m:] new_deck = right+left return new_deck #--------------------------------------- def shuffle(deck): a = deck[1:-1] b = a.split("|") c = b[:len(b)//2+len(b)%2] d = a.split("||") e = d[len(d)//2+len(d)%2:] c[1::2] = e f = "||".join(c) new_deck = "|"+f+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): if len(cards) <= 4*m : print("-"*7+"-"*len(cards)) print("Table: "+cards) print("-"*7+"-"*len(cards)) else : print("-"*7+"-"*len(cards[-4*m:])+"-"*4) print("Table: "+"...."+cards[-4*m:]) print("-"*7+"-"*len(cards[-4*m:])+"-"*4) #----------------------------------------- |
| # 6330516021 (19.11) 345 (2021-02-05 09:38) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k:1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4:]+cards[4*k::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n:] new_deck = deck[4*n::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m::]+deck[:4*m:] return new_deck #--------------------------------------- def shuffle(deck): n = int(len(deck)/4) k = int(n//2+n%2) d = deck.split('|') v = d[:n] v1 = d[1:2*k+1:2] v2 = d[2*k+1::2] v[::2] = v1 v[1::2] = v2 A = '||'.join(v) new_deck = '|'+ A + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): n = int(len(cards)/4) v = cards[-4*m:-1] r = min(n,m) t = 'Table: '+ '....'*(r//m) + v + '|' print('-'*(len(t))) print(t) print('-'*(len(t))) #----------------------------------------- |
| # 6330517621 (18.67) 346 (2021-02-05 01:11) def peek_kth_card(cards, k): stn1 = cards.split('|') ntip1 = (2*k)-1 the_kth_card = '|'+stn1[ntip1]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): stn2 = cards.split('|') ntip2 = k f = stn2[:(2*ntip2-3)+2:1] ff = '|'.join(f) sum1 = stn2[(2*ntip2-1)+1::1] sum2 = '|'.join(sum1) new_cards = ff + sum2 return new_cards #--------------------------------------- def deal_n_cards(deck, n): cid = deck.split('|') ntip3 = (2*n)+1 cards = '|'.join(cid[0:ntip3]) new_deck = '|'.join(cid[(ntip3-1):]) return cards, new_deck #--------------------------------------- def cut(deck, m): ctd = deck.split('|') ntip4 = (2*m)+1 f3 = ctd[1:ntip4:2] sum5 = '||'.join(f3) ls3 = ctd[ntip4::2] sum6 = '||'.join(ls3) new_deck = '|'+sum6+'|'+'|'+sum5+'|' return new_deck #--------------------------------------- def shuffle(deck): shf = deck.split('|') shf2 = shf[1::2] x = (len(shf2)//2) y = len(shf2)-x f4 = shf2[:y] ls4 = shf2[y:] ze = [0]*len(shf2) ze[::2] = f4 ze[1::2] = ls4 ze2 = '||'.join(ze) new_deck = '|'+ze2+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): tablc = cards.split('|') pol = tablc[1::2] ntip = m pol2 = pol[-m::] pol3 = '||'.join(pol2) pol4 = '|'+pol3+'|' l = '....' v = min(1,len(pol)-m) u = l*v Tb = 'Table'+':'+' '+u+pol4 print('-'*len(Tb)) print(Tb) print('-'*len(Tb)) #----------------------------------------- |
| # 6330518221 (20.00) 347 (2021-02-05 14:27) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): n = (len(deck)//4) a = int(round(n/2,0)) ld = deck[1:4*a-1] rd = deck[4*a+1:len(deck)-1] ld = ld.split('||') rd = rd.split('||') new_deck = list(range(n)) new_deck[::2] = ld[:] new_deck[1::2] = rd[:] new_deck = '||'.join(new_deck) new_deck = '|' + new_deck + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): c = len(cards)//4 Table = '....'*(min(abs(m-c)+(c-m), abs(abs(c-m)+(m-c))+1))+cards[-4*m:] a = 'Table: '+Table print('-'*len(a)) print(a) print('-'*len(a)) #----------------------------------------- |
| # 6330519921 (16.44) 348 (2021-02-08 21:44) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:n*4] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): gg=deck[0:m*4] new_deck=deck[m*4:]+gg return new_deck #--------------------------------------- def shuffle(deck): D = deck.strip('|').split('||') DA=len(D) DO=DA%2 DH=DA//2+DO Deck1=D[:DH] Deck2=D[DH:] D[::2]= Deck1 D[1::2]=Deck2 new_deck='|'+'||'.join(D)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): C = cards.strip('|').split('||') T = '|'.join(C[-m:]) if len(C) <= m: T = 'Table: |' + T + '|' else: T = 'Table: ....|' + T+ '|' print('-' * len(T)) print(T) print('-' * len(T)) #----------------------------------------- |
| # 6330520421 (15.11) 349 (2021-02-08 02:20) def peek_kth_card(cards, k): the_kth_card=cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[:4*(k-1)]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:4*n] new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): a=deck[1:-1] b=a.split('||') n=len(b) h=int(n/2) c=b*(h+1) d=c[:-h:h+1] e='||'.join(d) new_deck='|'+e+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): n=int(len(cards)/4) z=int((n-m)/abs(n-m)) a=z*'....'+cards[-4*m:] b=len(a) c='-'*b print(c) print(a) print(c) #----------------------------------------- |
| # 6330521021 (20.00) 350 (2021-02-07 13:26) def peek_kth_card(cards, k): the_kth_card = cards[(4*(k-1)):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[0:4*(k-1)]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): new_deck='' if (len(deck)/4)%2==0: mid=int(len(deck)/8) for i in range(mid): new_deck+=deck[4*i:4*(i+1)]+deck[(mid*4)+(i*4):(mid*4)+((i+1)*4)] else: mid=int(len(deck)/8) for i in range(mid): new_deck+=deck[4*i:4*(i+1)]+deck[((mid+1)*4)+(i*4):((mid+1)*4)+((i+1)*4)] new_deck+=deck[(mid*4):(mid*4)+4] return new_deck #--------------------------------------- def show_table_cards(cards, m): a=cards[-(m*4):] if m>=int(len(cards)/4): print('-'*(len(a)+7)) print('Table: '+a) print('-'*(len(a)+7)) else : print('-'*(len(a)+11)) print('Table: ....'+a) print('-'*(len(a)+11)) #----------------------------------------- |
| # 6330522721 (20.00) 351 (2021-02-08 21:01) def peek_kth_card(cards, k): a1 = cards.split('|') a1 = '|-|'.join(a1) a1 = a1.split('-') a1 = a1[1::2] a1 = a1[k-1:k] the_kth_card = ''.join(a1) return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): a1 = cards.split('|') a1 = '|-|'.join(a1) a1 = a1.split('-') a1 = a1[1::2] a1 = a1[0:k-1:] + a1[k::] new_cards = ''.join(a1) return new_cards return new_cards #--------------------------------------- def deal_n_cards(deck, n): a1 = deck.split('|') a1 = '|-|'.join(a1) a1 = a1.split('-') a1 = a1[1::2] cards , new_deck = ''.join(a1[0:n]) , ''.join(a1[n::]) return cards, new_deck #--------------------------------------- def cut(deck, m): a1 = deck.split('|') a1 = '|-|'.join(a1) a1 = a1.split('-') a1 = a1[1::2] new_deck = a1[m::]+a1[0:m] new_deck = ''.join(new_deck) return new_deck #--------------------------------------- def shuffle(deck): a1 = deck.split('|') a1 = '|-|'.join(a1) a1 = a1.split('-') a = a1[1::2] b1 = a1[1:len(a)+1:] b2 = a[int(len(a)/2+0.5)::] b1[1::2] = b2[::] new_deck = ''.join(b1) return new_deck #--------------------------------------- def show_table_cards(cards, m): a1 = cards.split('|') a1 = '|-|'.join(a1) a1 = a1.split('-') c = a1[1::2] b = c[-m::] a1 = ''.join(b) print("-------" + min(( len(c) - len(b) ),1) * '----' + (len(a1))*'-') print("Table: " + min(( len(c) - len(b) ),1) * '....' + a1) print("-------" + min(( len(c) - len(b) ),1) * '----' + (len(a1))*'-') #----------------------------------------- |
| # 6330523321 (20.00) 352 (2021-02-07 20:28) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): a = deck[1:-1].split("||") b = int(len(a)/2) c = a[:-b] d = a[-b:] e = c[:1]+d[:1]+c[1:2]+d[1:2]+c[2:3]+d[2:3]+c[3:4]+d[3:4]+c[4:5]+d[4:5]+c[5:6]+d[5:6]+c[6:7]+d[6:7]+c[7:8]+d[7:8]+c[8:9]+d[8:9]+c[9:10]+d[9:10]+c[10:11]+d[10:11]+c[11:12]+d[11:12]+c[12:13]+d[12:13]+c[13:14]+d[13:14]+c[14:15]+d[14:15]+c[15:16]+d[15:16]+c[16:17]+d[16:17]+c[17:18]+d[17:18]+c[18:19]+d[18:19]+c[19:20]+d[19:20]+c[20:21]+d[20:21]+c[21:22]+d[21:22]+c[22:23]+d[22:23]+c[23:24]+d[23:24]+c[24:25]+d[24:25]+c[25:26]+d[25:26] new_deck = '|'+'||'.join(e)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards[1:-1].split("||") b = a[-m:] c = '|'+'||'.join(b)+'|' d = min(len(a)-m,1) e = min(len(a),m+1) print("-------"+"----"*(e)) print("Table:","...."*d+c) print("-------"+"----"*(e)) #----------------------------------------- |
| # 6330524021 (19.11) 353 (2021-02-07 15:30) def peek_kth_card(cards, k): c = cards.split('|') the_kth_card = "|"+c[2*k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards = cards.split('|') cards.remove(cards[2*k-1]) cards = cards[:2*k-1]+cards[2*k:] new_cards = '|'.join(cards) return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck = deck.split('|') cards = deck[:n*2]+[''] cards = "|".join(cards) new_deck = deck[n*2:] new_deck = "|".join(new_deck) return cards, new_deck #--------------------------------------- def cut(deck, m): deck = deck.split('|') new_deck = ['']+deck[m*2+1:]+deck[1:m*2+1] new_deck = "|".join(new_deck) return new_deck #--------------------------------------- def shuffle(deck): deck = deck.split("|") mid = ((len(deck)//2)+1)//2 l = deck[:mid*2]+[''] l = '|'.join(l) r = deck[mid*2:] r = '|'.join(r) new_deck = l[0:4]+r[0:4]+l[4:8]+r[4:8]+l[8:12]+r[8:12]+l[12:16]+r[12:16]+l[16:20]+r[16:20]+l[20:24]+r[20:24]+l[24:28]+r[24:28]+l[28:32]+r[28:32]+l[32:36]+r[32:36]+l[36:40]+r[36:40]+l[40:44]+r[40:44]+l[44:48]+r[44:48]+l[48:52]+r[48:52]+l[52:56]+r[52:56]+l[56:60]+r[56:60]+l[60:64]+r[60:64]+l[64:68]+r[64:68]+l[68:72]+r[68:72]+l[72:76]+r[72:76]+l[76:80]+r[76:80]+l[80:84]+r[80:84]+l[84:88]+r[84:88]+l[88:92]+r[88:92]+l[92:96]+r[92:96]+l[96:100]+r[96:100]+l[100:104]+r[100:104] return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards.split("|") c = len(cards)//2 x = min(c,m) cards = "|".join(cards[-(x*2+1):]) print('-'*7+'-'*4*c) print('Table: '+'....'*(c-x)+cards) print('-'*7+'-'*4*c) #----------------------------------------- |
| # 6330525621 (19.11) 354 (2021-02-08 13:58) def peek_kth_card(cards, k): the_kth_card=cards[4*(k-1):4*(k-1)+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[0:4*(k-1)]+cards[4*(k):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:4*n] new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[(4*m):]+deck[:(4*m)] return new_deck #--------------------------------------- def shuffle(deck): s=deck.split("||") d=s[-1] e=d[0:2] m=int((len(s)+1)/2) a=(s[1:-1]+[e])*m*((len(s)+1)%2) f=(s[0:-1]+[e])*m*(len(s)%2) b=s[0] c=[b]*((len(s)+1)%2)+a[m-1::m]+f[::m] new_deck='||'.join(c)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a=len(cards) c=min(m+1,int(a/4)) d=min(1,int(a/4)-m) print("--------"+("-"*4*c)) b=max(0,a-(4*m)) print("Table = "+("...."*d)+cards[b:]) print("--------"+"-"*4*c) #----------------------------------------- |
| # 6330526221 (20.00) 355 (2021-02-05 10:43) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[(0):(k-1)*4]+cards[(k*4):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): split_card = deal_n_cards(deck,(((len(deck)//4)+1)//2)) a = split_card[0] b = split_card[1] new_deck = ["|"]*(len(deck)) new_deck[1::8] = a[1::4] new_deck[2::8] = a[2::4] new_deck[5::8] = b[1::4] new_deck[6::8] = b[2::4] new_deck = "".join(new_deck) return new_deck #--------------------------------------- def show_table_cards(cards, m): split_card = deal_n_cards(cards, max(0,(len(cards)//4)-m)) a = split_card[0] b = split_card[1] point = '....'*(int(len(cards)//4>m)) c = 'Table:' + ' ' + point + b d = '-'*len(c) print(d) print(c) print(d) #----------------------------------------- |
| # 6330527921 (19.50) 356 (2021-02-07 02:17) def peek_kth_card(cards, k): A = cards.split('|') B = '|'+'|*|'.join(A[1::2])+'|' C = B.split('*') the_kth_card = C[k-1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): A = cards.split('|') B = '|'+'|*|'.join(A[1::2])+'|' C = B.split('*') D = C[0:k-1]+C[k:] new_cards =''.join(D) return new_cards return new_cards #--------------------------------------- def deal_n_cards(deck, n): A = deck.split('|') B = '|'+'|*|'.join(A[1::2])+'|' C = B.split('*') cards = ''.join(C[0:n]) new_deck = ''.join(C[n:-1]) return cards, new_deck #--------------------------------------- def cut(deck, m): A = deck.split('|') B = '|'+'|*|'.join(A[1::2])+'|' C = B.split('*') new_deck = ''.join(C[m:])+''.join(C[0:m]) return new_deck #--------------------------------------- def shuffle(deck): m = int((len(deck)/4+1)//2) n = int((len(deck)/4)%2) A = deck.split('|') B = '|'+'|*|'.join(A[1::2])+'|' C = B.split('*') D = C+(['']*n+C[1:])*(m-1) new_deck = ''.join(D[::m]) return new_deck #--------------------------------------- def show_table_cards(cards, m): n = int(len(cards)/4) k = max(n-m,0)//max(n-m,1) cards = k*'....'+cards[-4*m:] print('-------'+'----'*k+'----'*min(m,n)) print('Table: '+cards) print('-------'+'----'*k+'----'*min(m,n)) #----------------------------------------- |
| # 6330528521 (15.56) 357 (2021-02-08 13:01) def peek_kth_card(cards, k): the_kth_card=cards[(k-1)*4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[:((k-1)*4)]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:4*n] new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): import itertools s=deck[1:-1].split("||") m=(len(s)+1)//2 a=s[:m] b=s[m:] c=list(itertools.chain.from_iterable(zip(b,a))) new_deck='|'+'||'.join(c)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a=len(cards)/4-m b=int(int((a+1/(abs(a)+1)))-1) k='table: '+'....'*b+cards[-4*m::1] q=len(k) print('-'*q) print("table: "+"...."*b+cards[-4*m::]) print('-'*q) #----------------------------------------- |
| # 6330529121 (19.50) 358 (2021-02-08 14:59) def peek_kth_card(cards, k): shuffle = cards[1:-1] shambles = shuffle.split('||') the_kth_card = '|'+shambles[k-1]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x1 = cards[1:-1] x2 = x1.split('||') y = x2[0:k-1] + x2[k:] new_cards = '|'*min(len(y),1)+'||'.join(y)+'|'*min(len(y),1) return new_cards #--------------------------------------- def deal_n_cards(deck, n): d1 = deck[1:-1] d2 = d1.split('||') cards = '|' + '||'.join(d2[0:n]) + '|' new_deck = '|' + '||'.join(d2[n:]) + '|' return cards, new_deck #--------------------------------------- def cut(deck, m): d1 = deck[1:-1] d2 = d1.split('||') new_deck = '|' + '||'.join(d2[m:]+d2[0:m]) + '|' return new_deck #--------------------------------------- def shuffle(deck): d1 = deck[1:-1] d2 = d1.split('||') x = d2[0:(len(d2)+1)//2] y = d2[((len(d2)+1)//2):] z = [0]*len(d2) z[0::2] = x z[1::2] = y new_deck = '|' + '||'.join(z) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): d1 = cards[1:-1] d2 = d1.split('||') DD = min(m, len(d2)) DDD = d2[-DD:] YEET = "Table: "+'....'*(min(len(d2)-DD,1))+'|' + '||'.join(DDD) + '|' print('-'*len(YEET)) print(YEET) print('-'*len(YEET)) #----------------------------------------- |
| # 6330530721 (19.56) 359 (2021-02-08 21:51) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = (cards.replace(cards[4*k-4:4*k], "")) return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0 : 4*n] new_deck = deck[4*n::1] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m::1] + deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1] deck = deck.split("||") new_deck = deck[(len(deck)//2 + len(deck)%2):] left = deck[:(len(deck)//2 + len(deck)%2)] x = ["0"]*len(deck) x[0::2] = left x[1::2] = new_deck new_deck = "|"+("||").join(x)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): q = str("Table:") + "...."*min(int(1), int((len(cards)/4)-m)) + cards[-(4*m):] upper = str("-")*len(q) lower = str("-")*len(q) print(upper) print(q) print(lower) #----------------------------------------- |
| # 6330531321 (20.00) 360 (2021-02-06 15:47) def peek_kth_card(cards, k): the_kth_card = cards[1:-1] the_kth_card = the_kth_card.split("||") the_kth_card = the_kth_card[k-1] the_kth_card = "|"+str(the_kth_card)+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[1:-1] new_cards = new_cards.split("||") new_cards = new_cards[:k-1]+new_cards[k:] new_cards = "|"*min(len(new_cards),1) +("||").join(new_cards)+"|"*min(len(new_cards),1) return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck = deck[1:-1] x = deck.split("||") cards = x[:n] new_deck = x[n:] cards = "|"*min(len(cards),1) +("||").join(cards)+"|"*min(len(cards),1) new_deck = "|"*min(len(new_deck),1) +("||").join(new_deck)+"|"*min(len(new_deck),1) return cards, new_deck #--------------------------------------- def cut(deck, m): deck = deck[1:-1] deck = deck.split("||") new_deck = deck[m:] deck = deck[:m] new_deck = new_deck + deck new_deck = "|" +("||").join(new_deck)+"|" return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1] deck = deck.split("||") new_deck = deck[(len(deck)//2 + len(deck)%2):] leftdeck = deck[:(len(deck)//2 + len(deck)%2)] x = ["0"]*len(deck) x[0::2] = leftdeck x[1::2] = new_deck new_deck = "|" +("||").join(x)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards[1:-1] x = cards.split("||") cards = x[-m:] cards = "|" +("||").join(cards)+"|" cards = "Table: "+"...."*(min(1,(len(x))-m)) + cards print("-"*len(cards)) print(cards) print("-"*len(cards)) #----------------------------------------- |
| # 6330532021 (20.00) 361 (2021-02-08 04:53) def peek_kth_card(cards, k): x = cards.replace('||',',') y = x.replace('|','') z = y.split(',') q = k-1 j = z[q] the_kth_card = '|'+j+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x = cards.replace('||',',') y = x.replace('|','') t = y.split(',') i = k-1 del t[i] q = len(t) w = t[0:q] p = len(w) q = min(p,1) u = '||'.join(w) new_cards = '|'*q+u+'|'*q return new_cards #--------------------------------------- def deal_n_cards(deck, n): x = deck.replace('||',',') y = x.replace('|','') z = y.split(',') f = z[0:n] i = len(z) o = z[n:i] o2 = len(o) o1 = min(o2,1) t = '||'.join(o) y = '||'.join(f) cards = '|'+y+'|' new_deck = '|'*o1+t+'|'*o1 return cards, new_deck #--------------------------------------- def cut(deck, m): x = deck.replace('||',',') y = x.replace('|','') z = y.split(',') e = len(z) j = z[0:m] o1 = min(m,1) i = '||'.join(j) o = '|'*o1+i+'|'*o1 q = z[m:e] q2 = len(q) q1 = min(q2,1) h = '||'.join(q) u = '|'*q1+h+'|'*q1 new_deck = u+o return new_deck #--------------------------------------- def shuffle(deck): x = deck.replace('||',',') y = x.replace('|','') z = y.split(',') q = len(z) s = deck[-3:-1] s1 = s.split() w = (q+1)%2 d = z[0:q-w] k = (q)%2 v = q//2 e = q%2+v p = (q)%2 r = d*e t = r[::e] t.extend(s1*w) y1 = len(y) q1 = min(y1,1) u1 = '||'.join(t) new_deck = '|'*q1+u1+'|'*q1 return new_deck #--------------------------------------- def show_table_cards(cards, m): x = cards.replace('||',',') y = x.replace('|','') z = y.split(',') e = len(z) o = e-m p = min(e,m) i = min(o,1) o = e-p u = z[o:e] r = len(u) h = '||'.join(u) s = '|'+h+'|' print('-------'+'----'*i+'----'*r) print('Table: '+'....'*i+s) print('-------'+'----'*i+'----'*r) #----------------------------------------- |
| # 6330533621 (16.67) 362 (2021-02-07 02:34) def peek_kth_card(cards, k): c=cards.split('|') D=c[1::2] the_kth_card = '|'+D[k-1]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): c=cards.split('|') D=c[1::2] del D[k-1] new_cards = ('|{}|'.format('||'.join(D)))*(min(1,len(D))) return new_cards #--------------------------------------- def deal_n_cards(deck, n): d1=deck.split('|') D1=d1[1::2] del D1[n::] cards='|{}|'.format('||'.join(D1)) d2=deck.split('|') D2=d2[1::2] del D2[0:n] new_deck='|{}|'.format('||'.join(D2)) return cards, new_deck #--------------------------------------- def cut(deck, m): d=deck.split('|') D=d[1::2] C=D[0:m] del D[0:m] new_deck= '|{}|'.format('||'.join(D+C)) return new_deck #--------------------------------------- def shuffle(deck): d1=deck.split('|') D1=d1[1::2] L=(len(D1)+1)//2 P1=D1 del D1[L::] d2=deck.split('|') D2=d2[1::2] P2=D2 del D2[0:L] sh=(P1[0],P2[0],P1[1],P2[1],P1[2],P2[2],P1[3],P2[3],P1[4],P2[4],P1[5],P2[5],P1[6],P2[6],P1[7],P2[7],P1[8],P2[8],P1[9],P2[9],P1[10],P2[10],P1[11],P2[11],P1[12],P2[12],P1[13],P2[13],P1[14],P2[14],P1[15],P2[15],P1[16],P2[16],P1[17],P2[17],P1[18],P2[18],P1[19],P2[19],P1[20],P2[20],P1[21],P2[21],P1[22],P2[22],P1[23],P2[23],P1[24],P2[24],P1[25],P2[25]) new_deck='|{}|'.format('||'.join(sh)) return new_deck #--------------------------------------- def show_table_cards(cards, m): c1=cards.split('|') C1=c1[1::2] n=min(len(C1),m) del C1[0:(len(C1)-n)] c2=cards.split('|') C2=c2[1::2] N=len(C2)-len(C1) x='----'*(min(n+1,len(C2))) z='....'*(min(N,1)) show_table_cards='|{}|'.format('||'.join(C1)) print('-------'+x) print('Table: '+z+show_table_cards) print('-------'+x) #----------------------------------------- |
| # 6330534221 (20.00) 363 (2021-02-08 13:29) def peek_kth_card(cards, k): the_kth_card=cards[(k-1)*4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[:(k-1)*4]+cards[k*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:n*4] new_deck=deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[m*4:]+deck[:m*4] return new_deck #--------------------------------------- def shuffle(deck): count=(len(deck)/4) Miss =deck[-4:] deck =deck[:int(-4*max(1/4,0**(min(1/4,min(1,(len(deck)/4)%2)))))] deck=deck.split("|") deck=deck[1::2] A=math.ceil(len(deck)/2) deck=deck*A new_deck=deck[::A] new_deck="|"+"||".join(new_deck)+"|"+int(0**max(0,count%2))*Miss return new_deck #--------------------------------------- def show_table_cards(cards, m): print("-"*7+("-")*min(len(cards),(m+1)*4)) print("Table: "+"...."*min(max(-1,(len(cards)-m*4)),1)+(cards[-(m*4):])) print("-"*7+("-")*min(len(cards),(m+1)*4)) #----------------------------------------- |
| # 6330535921 (20.00) 364 (2021-02-06 22:29) def peek_kth_card(cards, k): a = (k-1)*4 the_kth_card = cards[a:a+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards.replace(peek_kth_card(cards, k),'') return new_cards #--------------------------------------- def deal_n_cards(deck, n): a = (n)*4 cards = deck[:a] new_deck = deck[a:] return cards, new_deck #--------------------------------------- def cut(deck, m): a = m*4 d1 = deck[:a] d2 = deck[a:] new_deck = d2 +d1 return new_deck #--------------------------------------- def shuffle(deck): import math import itertools from itertools import zip_longest deck0 = deck[1:-1] deck1 = deck0.split('||') a = len(deck1)/2 x = math.ceil(a) d1 = deck1[:x] d2 = deck1[x:] d_new = list(itertools.chain.from_iterable(zip_longest(d1,d2,fillvalue=None))) new_deck0 = list(filter(None, d_new)) new_deck1 = '||'.join(new_deck0) new_deck = '|' + new_deck1 + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a = int(len(cards)/4) x = a - m y = int((x*2)//((x*2)-0.1)) c1 = cards[m*(-4):] lc = int(len(c1)/4) + y print('-------'+'----'*lc) print('Table: '+'....'*y + c1 ) print('-------'+'----'*lc) #----------------------------------------- |
| # 6330536521 (18.89) 365 (2021-02-06 09:52) def peek_kth_card(cards, k): the_kth_card=cards[4*(k-1):4 *(k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[0:4*(k-1)]+cards[4*k::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[slice(4*(n))] new_deck=deck[4*n::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[4*m::]+deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): x=int(len(deck))/4 h=int(round(x/2)+(x%2)) g=int(x-h) new1=deck[0:(h*4)] new2=deck[-(g*4)::] new_deck=new1[0:4]+new2[0:4]+new1[4:8]+new2[4:8]+new1[8:12]+new2[8:12]+new1[12:16]+new2[12:16]+new1[16:20]+new2[16:20]+new1[20:24]+new2[20:24]+new1[24:28]+new2[24:28]+new1[28:32]+new2[28:32]+new1[32:36]+new2[32:36]+new1[36:40]+new2[36:40]+new1[40:44]+new2[40:44]+new1[48:52]+new2[48:52]+new1[52:56]+new2[52:56]+new1[56:60]+new2[56:60]+new1[60:64]+new2[60:64]+new1[64:68]+new2[64:68]+new1[68:72]+new2[68:72]+new1[72:76]+new2[72:76]+new1[76:80]+new2[76:80]+new1[80:84]+new2[80:84]+new1[84:88]+new2[84:88]+new1[88:92]+new2[88:92]+new1[92:96]+new2[92:96]+new1[96:100]+new2[96:100]+new1[100:104]+new2[100:104]+new1[104:108]+new2[104:108]+new1[108:12]+new2[108:112] return new_deck #--------------------------------------- def show_table_cards(cards, m): x=cards[-(4*m)::] y=len(cards) n=int(min((int(y)/4)-m,1)) print("-"*7+"-"*(n*4)+"-"*(int(len(x)))) print("Table: "+"...."*n + x) print("-"*7+"-"*(n*4)+"-"*(int(len(x)))) #----------------------------------------- |
| # 6330537121 (19.56) 366 (2021-02-07 22:55) def peek_kth_card(cards, k): the_kth_card =cards[((k-1)*4):(k+3)+(k-1)*3] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards.replace(cards[((k-1)*4):(k+3)+(k-1)*3],'') return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:(n+3)+(n-1)*3] new_deck = deck[(n+3)+(n-1)*3:] return cards, new_deck #--------------------------------------- def cut(deck, m): x = deck[:4*m] new_deck = deck[4*m:] + x return new_deck #--------------------------------------- def shuffle(deck): decklist = deck[1:-1].split("||") number = int(len(decklist) / 2) + int(len(decklist) % 2) firsthalf = decklist[:number] secondhalf = decklist[number:] x = len(decklist) * [0] x[0::2] = firsthalf x[1::2] = secondhalf new_deck = '|' + '||'.join(x) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): z = str('Table:')+'....'*min(int(len(cards)/4-m),1)+cards[-4*m:] print('-'*len(z)) print(z) print('-'*len(z)) #----------------------------------------- |
| # 6330538821 (18.89) 367 (2021-02-06 20:31) def peek_kth_card(cards, k): the_kth_card=cards[4*(k-1):(4*(k-1))+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): the_kth_card=cards[4*(k-1):(4*(k-1))+4] new_cards=cards.replace(the_kth_card,'') return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:(4*(n-1))+4] new_deck=deck.replace(cards,'') return cards, new_deck #--------------------------------------- def cut(deck, m): a=deck[:(4*(m-1))+4] new_deck=deck.replace(a,'')+a return new_deck #--------------------------------------- def shuffle(deck): y=deck[1:-1] a=y.split("||") cc=a[:(len(a)//2)+1] dd=a[(len(a)//2)+1:] q='qi'*100 qq=q.split("i") c=cc.extend(qq) d=dd.extend(qq) new=cc[0]+dd[0]+cc[1]+dd[1]+cc[2]+dd[2]+cc[3]+dd[3]+cc[4]+dd[4]+cc[5]+dd[5]+cc[6]+dd[6]+cc[7]+dd[7]+cc[8]+dd[8]+cc[9]+dd[9]+cc[10]+dd[10]+cc[11]+dd[11]+cc[12]+dd[12]+cc[13]+dd[13]+cc[14]+dd[14]+cc[15]+dd[15]+cc[16]+dd[16]+cc[17]+dd[17]+cc[18]+dd[18]+cc[19]+dd[19]+cc[20]+dd[20]+cc[21]+dd[21]+cc[22]+dd[22]+cc[23]+dd[23]+cc[24]+dd[24]+cc[25]+dd[25]+cc[26]+dd[26] b='||'.join(new) bb=b.split("||") bbb=[bb[0]+bb[1],bb[2]+bb[3],bb[4]+bb[5],bb[6]+bb[7],bb[8]+bb[9],bb[10]+bb[11],bb[12]+bb[13],bb[14]+bb[15],bb[16]+bb[17],bb[18]+bb[19],bb[20]+bb[21],bb[22]+bb[23],bb[24]+bb[25],bb[26]+bb[27],bb[28]+bb[29],bb[30]+bb[31],bb[32]+bb[33],bb[34]+bb[35],bb[36]+bb[37],bb[38]+bb[39],bb[40]+bb[41],bb[42]+bb[43]] main='||'.join(bbb) newww=main.replace("|q|",'') newdeck="|"+newww+"|" new_deck=newdeck.replace('|qq|','') return new_deck #--------------------------------------- def show_table_cards(cards, m): a=cards.split('|') aa=a[1::2] aaa=aa[::-1] n=len(aaa) w=min(m,n) b=aaa[:w] bb=b[::-1] bbb='|'+'||'.join(bb)+'|' x=min(1,max(4*m,len(cards))-4*m) p=x*('.'*4)+bbb print('-'*(len(p))+('-'*7)) print("Table:",p) print('-'*(len(p))+('-'*7)) #----------------------------------------- |
| # 6330539421 (18.17) 368 (2021-02-08 18:20) def peek_kth_card(cards, k): a = cards[1:-1] a = a.split('||') the_kth_card = '|'+a[k-1]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): a = cards[1:-1] a = a.split('||') b = a[0:k-1]+a[k:] b = '||'.join(b) new_cards = '|'*min(len(b),1)+b+'|'*min(len(b),1) return new_cards #--------------------------------------- def deal_n_cards(deck, n): a = deck[1:-1] a = a.split('||') b = '||'.join(a[0:n]) c = '||'.join(a[n:]) cards = '|'+b+'|' new_deck = '|'+c+'|' return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck[1:-1] a = a.split('||') b = '||'.join(a[0:m]) c = '||'.join(a[m:]) new_deck = '|'+c+'||'+b+'|' return new_deck #--------------------------------------- def shuffle(deck): a = deck[1:-1] a = a.split('||') prob = len(a)//2 b = len(a)-prob settwo = a[:b] settre = a[b:] d = ['0']*len(a) d[0::2] = settwo d[1::2] = settre d = '||'.join(d) new_deck = '|'+d+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards[1:-1] a = a.split('||') b = len(a) c = 'Table: '+'....'*min((b-m),1)+'|'+'||'.join(a[-min(b,m):])+'|' print('-'*len(c)) print(c) print('-'*len(c)) #----------------------------------------- |
| # 6330540021 (20.00) 369 (2021-02-07 22:47) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1)]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): n=int(len(deck)/4) num=int((n//2)+(n%2)) d=deck.replace('||','|-|') d=d.split('-') L=d[:num] R=d[num:] newdeck=L+['']*len(R) newdeck[0:len(newdeck):2] = L newdeck[1:len(newdeck):2] = R new_deck=''.join(newdeck) return new_deck #--------------------------------------- def show_table_cards(cards, m): m = min(len(cards)//4,m) point = "...."*(min((len(cards)//4 -m),1)) print("-"*(7+4*m + len(point))) print("Table"+":", point +cards[len(cards)-4*m:]) print("-"*(7+4*m + len(point))) #----------------------------------------- |
| # 6330541621 (19.11) 370 (2021-02-08 18:13) def peek_kth_card(cards, k): x = cards[0:] the_kth_card = x[(k-1)*4:((k-1)*4)+4:1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): y = cards[0:] new_cards1 = y[:((k-1)*4):1] new_cards2 = y[((k-1)*4)+4::1] new_cards = new_cards1+new_cards2 return new_cards #--------------------------------------- def deal_n_cards(deck, n): z = deck[0:] cards = z[:(n*4):1] new_deck = z[(n*4)::1] return cards, new_deck #--------------------------------------- def cut(deck, m): g = deck[0:] g1 = g[:(m*4):1] g2 = g[(m*4)::1] new_deck = g2+g1 return new_deck #--------------------------------------- def shuffle(deck): w = (len(deck)//4)//2 e = (len(deck)//4)-w half1 = deck[:e*4:1] half2 = deck[e*4::1] new_deck0 = half1[1:-1].split('|') t = half2[1:-1].split('|') new_deck0 = new_deck0 + ['']*((len(deck)//4+1)%2) n = t[::2] new_deck0[1::2] = n q = '||'.join(new_deck0) new_deck = '|'+q+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): t1 = cards[-4*m:] t2 = '....'*min(int(len(cards)/4-m),1) t3 = 'table: '+t2+t1 print('-'*len(t3)) print(t3) print('-'*len(t3)) #----------------------------------------- |
| # 6330542221 (20.00) 371 (2021-02-08 00:15) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1)]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): d = deck[1:len(deck)-1] a = d.split('||') n = (len(a)+1)//2 x = a[:n] y = a[n:] b = [' ']*len(a) b[::2] = x b[1::2] = y t = '||'.join(b) new_deck = '|'+t+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): L = (len(cards))//4 d = min(L,m) r=1-(d//L) a = 'Table:'+'.'*r*4+cards[-d*4:] print('-'*(len(a)+1)) print('Table:','.'*r*4+cards[-d*4:]) print('-'*(len(a)+1)) #----------------------------------------- |
| # 6330543921 (18.00) 372 (2021-02-07 00:47) def peek_kth_card(cards, k): the_kth_card = cards[(k*4)-4:k*4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k*4)-4]+cards[(k*4):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:(n-1)*4+4] new_deck = deck[(n-1)*4+4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(m-1)*4+4:]+deck[:(m-1)*4+4] return new_deck #--------------------------------------- def shuffle(deck): Left = deck[1:-1].split('|') deckL = Left[:len(Left) // 2 + 1] Right = deck[1:-1].split('||') deckR = Right[((len(Right) // 2 + 1) * (len(deckL) % 2)) + ((len(deckL) // 2) * ((len(deckL) + 1) % 2))::1] deckL[1:len(deckL):2] = deckR new_deck = "|" + "||".join(deckL) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): n = int(len(cards)/4)-m b = int('0' + str(n).split('-')[0]) table = "Table: " + cards[(b-1)*4+4:] print("-" * len(table) + "-") print("Table: ", cards[(b-1)*4+4:]) print("-" * len(table) + "-") #----------------------------------------- |
| # 6330544521 (20.00) 373 (2021-02-07 00:44) def peek_kth_card(cards, k): the_kth_card = cards[((k-1)*4):(4*k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): remove_card = cards[((k-1)*4):(4*k)] c = cards.split(remove_card) new_cards = c[0]+c[1] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): start_cards = deck[:4*m] end_cards = deck[4*m:] new_deck = end_cards + start_cards return new_deck #--------------------------------------- def shuffle(deck): deck_L = deck[1:-1].split('|') deckL = deck_L[:len(deck_L) // 2 + 1] deck_R = deck[1:-1].split('||') deckR = deck_R[((len(deck_R) // 2 + 1) * (len(deckL) % 2)) + ((len(deckL) // 2) * ((len(deckL) + 1) % 2))::1] deckL[1:len(deckL):2] = deckR new_deck = "|" + "||".join(deckL) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): n = int(len(cards)/4)-m c = int('0' + str(n).split('-')[0]) table = "Table: " + "." * 4 * int(c//(c-0.01)) + cards[c*4:] print("-" * len(table)) print(table) print("-" * len(table)) #----------------------------------------- |
| # 6330545121 (20.00) 374 (2021-02-06 17:32) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] #cards เป็นสตริงเก็บไพ่หลายใบ (อาจจะใบเดียวก็ได้) เช่น "|2H||4S||TD||AC|" # k เป็นจำนวนเต็ม ระบุตำแหน่งไพ่ที่สนใจใน cards (ใบซ้ายสุดคือตำแหน่งที่ 1) # ต้องทำ: ตั้งค่าให้ตัวแปร the_kth_card เก็บสตริงที่แทนไพ่ใบที่ k ใน cards # ตัวอย่าง: cards เก็บ "|2H||4S||TD||AC|", k เก็บ 2 # ได้ the_kth_card เก็บ "|4S|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4]+cards[4*k:] #ไพ่ใบเอาออก # cards เป็นสตริงเก็บไพ่หลายใบ (อาจจะใบเดียวก็ได้) เช่น "|2H||4S||TD||AC|" # k เป็นจำนวนเต็ม ระบุตำแหน่งไพ่ที่สนใจใน cards (ใบซ้ายสุดคือตำแหน่งที่ 1) # ต้องทำ: ตั้งค่าให้ตัวแปร new_cards ให้เหมือน cards แต่ไพ่ใบที่ k เดิมของ cards ถูกลบทิ้ง # ตัวอย่าง: cards เก็บ "|2H||4S||TD||AC|", k เก็บ 2 # ได้ new_cards เก็บ "|2H||TD||AC|" return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] # deck เป็นสตริงเก็บไพ่หลายใบ (อาจจะใบเดียวก็ได้) เช่น "|2H||4S||TD||AC||AD||AS|" # n เป็นจำนวนเต็ม ระบุจำนวนไพ่ที่ต้องการแจกออกจาก deck (n ใบซ้าย) # ต้องทำ: ตั้งค่าให้ตัวแปร cards เก็บสตริงที่แทนไพ่จำนวน n ใบทางซ้ายของ deck (ในลำดับเดิมที่อยู่ใน deck) # ตั้งค่าให้ตัวแปร new_deck ให้เหมือน deck แต่ไพ่จำนวน n ใบทางซ้ายที่ k เดิมของ deck ถูกลบทิ้ง # หมายเหตุ: ไม่ต้องสนใจกรณีที่ n มีค่ามากกว่าจำนวนไพ่ใน deck # ตัวอย่าง: deck เก็บ "|2H||4S||TD||AC||AD||AS|", n เก็บ 4 # ได้ cards เก็บ "|2H||4S||TD||AC|" และ new_deck เก็บ "|AD||AS|" return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[:4*m] # deck เป็นสตริงเก็บไพ่หลายใบ เช่น "|2H||4S||TD||AC||3H||4H||5H||6H||7H||8H|" # m เป็นจำนวนเต็ม ระบุจำนวนไพ่ที่สนใจทางซ้ายของ deck (m มีค่าได้ตั้งแต่ 0 ถึงจำนวนไพ่ใน deck) # ต้องทำ: ตั้งค่าให้ตัวแปร new_deck เก็บสตริงจากการย้ายไพ่ m ใบทางซ้ายของ deck มาต่อท้ายทางขวาของ deck # ตัวอย่าง: deck เก็บ "|2H||4S||TD||AC||3H||4H||5H||6H||7H||8H|", m เก็บ 4 # ได้ new_deck เก็บ "|3H||4H||5H||6H||7H||8H||2H||4S||TD||AC|" return new_deck #--------------------------------------- def shuffle(deck): deck0 = deck[1:-1].split('|') deck0 = deck0[:len(deck0)//2 +1] deckDR = deck[1:-1].split('||') deckR = deckDR[((len(deckDR)//2 +1)*(len(deck0)%2))+ ((len(deck0)//2)*((len(deck0)+1)%2))::1] deck0[1:len(deck0):2] = deckR new_deck = '|'+ "||".join(deck0) + '|' # deck เป็นสตริงเก็บไพ่หลายใบ เช่น "|2H||3H||4H||5H||6H||7H||8H||9H||TH||JH||QH||KH||AH|" # ต้องทำ: ตั้งค่าให้ตัวแปร new_deck เก็บสตริงจากการนำไพ่ครึ่งซ้ายและครึ่งขวาของ deck มาวางสลับกันทีละใบ # ตัวอย่าง: deck เก็บ "|2H||3H||4H||5H||6H||7H||8H||9H||TH||JH||QH||KH||AH|" # ได้ new_deck เก็บ "|2H||9H||3H||TH||4H||JH||5H||QH||6H||KH||7H||AH||8H|" # หมายเหตุ: ในกรณีที่จำนวนไพ่ใน deck เป็นจำนวนคี่ ให้ครึ่งซ้ายมีจำนวนมากกว่าครึ่งขวา (ดูตัวอย่าง) return new_deck #--------------------------------------- def show_table_cards(cards, m): h = min(len(cards)//4,m) dot = '....'*(min((len(cards)//4 -m),1)) print('-'*(7+4*h + len(dot))) print('Table'+':', dot +cards[len(cards)-(4 *h):]) print('-'*(7+4*h + len(dot))) # cards เป็นสตริงเก็บไพ่หลายใบ (อาจจะใบเดยวก็ได้) เช่น "|2H||4S||TD||AC|" # m เป็นจำนวนเต็ม ระบุจำนวนไพ่ที่สนใจทางขวาของ cards ที่จะนำมาแสดง # ต้องทำ: นำไพ่ใน cards ทางขวา m ใบมาแสดง (ถ้ามีน้อยกว่าก็แสดงเท่าที่มี) #ในกรณีที่มีมากกว่า m ใบ ต้องแสดง .... ทางซ้ายด้วย ดูรายละเอียดของรูปแบบการแสดงในตัวอย่างฟังก์ชันนี้ไม่มีการคืนค่าใด ๆ #----------------------------------------- |
| # 6330547421 (18.89) 375 (2021-02-08 02:13) def peek_kth_card(cards, k): the_kth_card = cards[(4*(k-1)):(4*k)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(4*(k-1))] + cards[((4*(k-1))+4):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:(4*n)] new_deck = deck[(4*n):] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[(4*m):] + deck[:(4*m)] return new_deck #--------------------------------------- def shuffle(deck): n = int(len(deck)/4) hn = n//2 fh = deck[:(4*(hn+(max(0,(n%2)))))] sh = deck[(4*(hn)):] FH = fh[1:-1].split('||') SH = sh[1:-1].split('||') i = [0]*(n) i[0::2] = FH i[1::2] = SH new_deck = '|'+'||'.join(i)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): n = int(len(cards)/4) c = cards[(4*(max(0,(n-m)))):] print(('-------')+('-'*(int(len(c))))+('----'*(min(1,(n-m))))) print(('Table: ')+('....'*(min(1,(n-m)))) + c) print(('-------')+('-'*(int(len(c))))+('----'*(min(1,(n-m))))) #----------------------------------------- |
| # 6330548021 (19.50) 376 (2021-02-06 21:23) def peek_kth_card(cards, k): a = cards.split('|') b = a[1::2] the_kth_card = cards[0] + b[k-1] + cards[-1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): a = cards.split("|") b = a[1::2] c = "|" + b[k-1] + "|" d = cards.find(c) new_cards = cards[:d] + cards[(d+4)::] return new_cards #--------------------------------------- def deal_n_cards(deck, n): a = deck.split('|') b = a[1::2] pre_cards = b[:n:] pre_cards = " ".join(pre_cards) pre_cards = pre_cards.split(" ") cards = "|" + "|".join(pre_cards) + "|" pre_new_deck = b[n::] pre_new_deck = " ".join(pre_new_deck) pre_new_deck = pre_new_deck.split(" ") new_deck = "|" + "|".join(pre_new_deck) + "|" return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck.split('|') b = a[1::2] new_deck = b[m::] + b[:m:] new_deck = " ".join(new_deck) new_deck = new_deck.split(" ") new_deck = "|" + "|".join(new_deck) + "|" return new_deck #--------------------------------------- def shuffle(deck): a = deck.split('|') b = a[1::2] c = b[:int(len(b)//2 + ((len(b)/2)%1)*2):] d = b[int(len(b)//2 + ((len(b)/2)%1)*2)::] A = ['t'] * len(b) A[::2] = c A[1::2] = d new_deck = A new_deck = " ".join(new_deck) new_deck = new_deck.split(" ") new_deck = "|" + "|".join(new_deck) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards.split('|') b = a[1::2] A = b[len(b) - min(len(b),m)::] c = " ".join(A) d = c.split(" ") e = "|" + "|".join(d) + "|" f = "...." * min(abs(min((min(len(b),m)-len(b)),0)),1) print("-------" + (4*"-")*len(A) + (4*"-")*min(abs(min((min(len(b),m)-len(b)),0)),1)) print("Table:",f + e) print("-------" + (4*"-")*len(A) + (4*"-")*min(abs(min((min(len(b),m)-len(b)),0)),1)) #----------------------------------------- |
| # 6330549721 (20.00) 377 (2021-02-08 22:35) def peek_kth_card(cards, k): cards=cards.split("|") #print(cards) #k=int(input()) the_kth_card='|'+cards[2*k-1]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards=cards.split('|') #print(cards) #k=int(input()) new_cards=cards[1:2*k-1:2]+cards[2*k+1::2] new_cards='|'*min(1,len(new_cards))+'||'.join(new_cards)+'|'*min(1,len(new_cards)) return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:4*n] new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): deck=deck.split('|') #print(deck) #m=int(input()) new_deck=deck[2*m+1::2]+deck[1:2*m:2] new_deck='|'+'||'.join(new_deck)+'|' return new_deck #--------------------------------------- def shuffle(deck): deck=deck.split('|') n=deck[1::2] l=n[:int(len(n)/2+0.5):] r=n[int(len(n)/2+0.5):] o=('j ')*len(n) p=o.split() p[::2]=l[:] p[1::2]=r[:] new_deck='||'.join(p) new_deck='|'+new_deck+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cards=cards.split('|') #print(cards) #m=int(input()) x=cards[1::2] l=len(x) k=cards[2*max(l-m,0)+1::2] #print(k) new_cards=('Table: '+'....'*min(l-m,1)+'|'*min(m,1)+'||'.join(k)+'|'*min(m,1)) print("-"*len(new_cards)) print(new_cards) print('-'*len(new_cards)) #----------------------------------------- |
| # 6330550221 (20.00) 378 (2021-02-07 22:49) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards.replace(cards[4*k-4:4*k],'') return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck.replace(deck[:4*m],'')+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): b = len(deck) g = (b//4)//2 v = b//4-g back = deck[4*v:] front = deck[:4*v] q_new = back[1:-1].split('|') new_deckk = front[1:-1].split('|') new_deckk = new_deckk + ['']*((b//4+1)%2) w = q_new[::2] new_deckk[1::2] = w e = '||'.join(new_deckk) new_deck = '|'+e+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): c = min(int(len(cards)/4),m) j = cards[-4*m:] w = '....'*min(int(len(cards)/4-m),1) e = 'Table: '+w+j print('-'*len(e)) print(e) print('-'*len(e)) #----------------------------------------- |
| # 6330551921 (20.00) 379 (2021-02-07 12:23) def peek_kth_card(cards, k): k = int(k) the_kth_card = cards[4*(k-1):4*(k-1)+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): k = int(k) the_kth_card = cards[4*(k-1):4*(k-1)+4] x = cards.split(the_kth_card) new_cards = x[0] + x[-1] return new_cards #--------------------------------------- def deal_n_cards(deck, n): n = int(n) cards = deck[:4*(n-1)+4] new_deck = deck[4*(n-1)+4::] return cards, new_deck #--------------------------------------- def cut(deck, m): m = int(m) deck = deck.split("||") deck = "|,|".join(deck) deck = deck.split(",") popo = deck[m::]+deck[0:m] new_deck = "".join(popo) return new_deck #--------------------------------------- def shuffle(deck): deck = deck.split("||") deck = "|,|".join(deck) deck = deck.split(",") m = len(deck) nright = len(deck)//2 nleft = len(deck)-nright left = deck[:nleft] right = deck[nleft::] new_deck = [] new_deck+= [""]*m new_deck[::2] = left new_deck[1::2] = right new_deck = "".join(new_deck) return new_deck #--------------------------------------- def show_table_cards(cards, m): m = int(m) cardsgg= cards.split("||") cardsgg = "|,|".join(cardsgg) cardsgg = cardsgg.split(",") table = cardsgg[-1:-m-1:-1] table.reverse() table = "".join(table) countdot = min(len(cards)-len(table),4) print("-"*(7+len(table)+countdot)) print("Table: "+"."*countdot+table) print("-"*(7+len(table)+countdot)) #----------------------------------------- |
| # 6330552521 (20.00) 380 (2021-02-08 18:45) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:(k*4)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards.replace(cards[(k-1)*4:(k*4)], '') return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:(n*4)] new_deck = deck.replace(deck[0:(n*4)], '') return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4:] + deck[0:m*4] return new_deck #--------------------------------------- def shuffle(deck): deck_without = deck[1:-1] deck_prime = deck_without.split("||") x = (len(deck_prime)%2) != 0 sdl1 = deck_prime[:len(deck_prime)//2 + x] sdl2 = deck_prime[len(deck_prime)//2 + x:] sdl3 = ['']*(len(deck_prime)) sdl3[::2] = sdl1 sdl3[1::2] = sdl2 new_deck = '|' + "||".join(sdl3) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a = (len(cards) / 4) > m b = len(cards[(4*((len(cards) % 4) - m)):]) print("-"*7 + "-"*4*a + "-"*b) print("Table: " + "...."*(a) + cards[(4*((len(cards) % 4) - m)):]) print("-"*7 + "-"*4*a + "-"*b) #----------------------------------------- |
| # 6330553121 (20.00) 381 (2021-02-08 22:21) def peek_kth_card(cards, k): a = cards.replace("|"," ") b = a.split() c = b[k-1] the_kth_card = '|'+c+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): import math a = cards.replace("|"," ") b = a.split() len_b = len(b) mult_v = math.ceil((max(len_b+k,2)-2)/1000) ind = k-1 new_list = b[:ind]+b[k:] new_str = '||'.join(new_list) new_cards = '|'*mult_v+new_str+'|'*mult_v return new_cards #--------------------------------------- def deal_n_cards(deck, n): import math a = deck.replace("|"," ") b = a.split() k = int(len(b)) mult_v = math.ceil(abs(k-n)/1000) list_cards = b[:n] list_new_deck = b[n:] w_cards = '||'.join(list_cards) w_new_deck = '||'.join(list_new_deck) cards = '|'+w_cards+'|' new_deck = '|'*mult_v+w_new_deck+'|'*mult_v return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck.replace('|',' ') b = a.split() list_left = b[:m] list_right = b[m:] num_list_right =len(list_right) num = len(b) void_list = ['']*num void_list[:num_list_right] = list_right void_list[num_list_right:] = list_left filled_list = '||'.join(void_list) new_deck = '|'+filled_list+'|' return new_deck #--------------------------------------- def shuffle(deck): a = deck.replace('|',' ') b = a.split() len_deck = len(b) right = int(len_deck // 2) left = int(len_deck - right) list_left = b[:left] list_right = b[left:] void_list = ['']*len(b) void_list[::2] = list_left void_list[1::2] = list_right filled_str = '||'.join(void_list) new_deck = '|'+filled_str+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): import math a = cards.replace('|',' ') b = a.split() num = len(b) #------------------ # .... dot_mult = math.ceil((max(num,m) - m)/1000) #-------------------- # ---- k = num - 1 dash_mult = (min(k,m))*4 #--------------------- # card_left rev_b = b[::-1] cut_rev_b = rev_b[:m] rev_cut_rev_b = cut_rev_b[::-1] betw = '||'.join(rev_cut_rev_b) final_cards = '|'+betw+'|' #---------------- # assemble print('-'*11+'-'*dash_mult) print('Table:','....'*dot_mult+final_cards) print('-'*11+'-'*dash_mult) #----------------------------------------- |
| # 6330554821 (14.67) 382 (2021-02-06 23:03) def peek_kth_card(cards, k): x = cards.split('|') e = x[(2*k)-1] d = str('|'+e+'|') the_kth_card = d return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x = cards.split('|') e = x[abs((2*k)-((2*k)-1)):((2*k)-1):2]+x[((2*k)+1)::2] if e ==[]: return '' else: r = '||'.join(e) q = str('|'+r+'|') new_cards = q return new_cards #--------------------------------------- def deal_n_cards(deck, n): x = deck.split('|') e = x[abs((2*n)-((2*n)-1)):(2*n)+1:2] r = '||'.join(e) q = str('|'+r+'|') cards = q w = x[((2*n)+1)::2] if w == []: return cards, None else: t = '||'.join(w) y = str('|'+t+'|') new_deck = y return cards, new_deck #--------------------------------------- def cut(deck, m): x = deck.split('|') e = x[((2*m)+1)::2]+x[((2*m)-((2*m)-1)):((2*m)+1):2] r = '||'.join(e) q = '|'+r+'|' new_deck = q return new_deck #--------------------------------------- def shuffle(deck): deck2 = [] new_deck = [] for i in range(0,len(deck),4): deck2.append(deck[i:i+4]) for i in range(len(deck2)): new_deck.append(deck2[i]) if i+int(len(deck2)/2)<len(deck2): new_deck.append(deck2[i+int(len(deck2)/2)]) else: break new_deck= ''.join(new_deck) return new_deck #--------------------------------------- def show_table_cards(cards, m): if m*4<len(cards): x = cards.split('|') w = x[-(2*m)::2] e = '||'.join(w) q = str('|'+e+'|') r = ' '+'...'+ q else: r = cards print('-'*len('Table:'+r)) print('Table:'+r) print('-'*len('Table:'+r)) #----------------------------------------- |
| # 6330555421 (20.00) 383 (2021-02-08 10:24) def peek_kth_card(cards, k): a = cards[1:-1] a = a.split('||') the_kth_card = '|'+a[k-1]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): a = cards[1:-1] a = a.split('||') b = a[:k-1] c = a[k:] new_cards = '|'*min(len(b+c),1) + '||'.join(b+c) + '|'*min(len(b+c),1) return new_cards #--------------------------------------- def deal_n_cards(deck, n): a = deck[1:-1] a = a.split('||') cards = a[:n] cards = '|'*min(len(cards),1)+'||'.join(cards)+'|'*min(len(cards),1) deck=len(a[n:]) new_deck = '|'*min(deck,1)+'||'.join(a[n:])+'|'*min(deck,1) return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck[1:-1] a = a.split('||') new_deck = '|'+'||'.join(a[m:]+a[:m])+'|' return new_deck #--------------------------------------- def shuffle(deck): a = len(deck) left = deck[:((a//2+a%8)+((-1)**(a//4)))-1] right = deck[((a//2+a%8)+((-1)**(a//4)))-1:] z = [3]*(a//4) s = left[1:-1] s = s.split('||') t = right[1:-1] t = t.split('||') z[0::2]=s z[1::2]=t new_deck = '|'+'||'.join(z)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards[1:-1] a = a.split('||') x = len(a) e = min(x,m) f = a[-e:] g = '....'*min(1,x-m)+'|'+'||'.join(f)+'|' print('-'*(7+len(g))) print('Table:',g) print('-'*(7+len(g))) #----------------------------------------- |
| # 6330556021 (20.00) 384 (2021-02-05 13:26) def peek_kth_card(cards, k): cards_split = cards.split("|") the_kth_card = "|"+cards_split[2*k-1]+"|" #answer return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards_split = cards.split("|") cards_out = "|"+cards_split[(k*2)-1]+"|" position = cards.find(cards_out) new_cards = cards[:position]+cards[position+4:] #answer return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck_split = deck.split("|") cards = "|".join(deck_split[:n*2+1]) #answer new_deck = "|".join(deck_split[n*2:]) #answer return cards, new_deck #--------------------------------------- def cut(deck, m): deck_split = deck.split("|") new_deck = "|".join(deck_split[m*2:]) + "|".join(deck_split[:2*m+1]) #answer return new_deck #--------------------------------------- def shuffle(deck): deck_split = deck.split("|") deck_split = deck_split[1::2] m = (len(deck_split)+1)%2 n = (len(deck_split)+1)//2 new_deck = ("|"+"||".join(deck_split[::n])+"|")*m deck_split = deck_split[m:]*(n-m) new_deck += "|"+"||".join(deck_split[::n])+"|" #answer return new_deck #--------------------------------------- def show_table_cards(cards, m): cards_split = cards.split("|") cards_split = cards_split[1::2] cards_split = cards_split[::-1] n = len(cards_split) maximum = max(m, n) minimum = min(m, n) cards_keep = cards_split[:minimum] cards_keep = cards_keep[::-1] cards_keep = "|"+"||".join(cards_keep)+"|" x = min(1, max(4*m, len(cards))-4*m) show = x*"...."+cards_keep print("-"*7+"-"*len(show)) print("Table: "+show) print("-"*7+"-"*len(show)) #----------------------------------------- |
| # 6330557721 (18.89) 385 (2021-02-08 03:00) def peek_kth_card(cards, k): cards = cards.split("|") the_kth_card = "|"+cards[2*k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards = cards.split("|") new_cards = cards[:2*k-1] + cards[2*k+1:] new_cards = "|".join(new_cards) return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): a = deck x = (len(a)//2)+(len(a)%2) x1 = a[:x] x2 = a[x:] nd1 = x1[0:4]+x2[0:4]+x1[4:8]+x2[4:8]+x1[8:12]+x2[8:12] nd2 = x1[12:16]+x2[12:16]+x1[16:20]+x2[16:20]+x1[20:24]+x2[20:24] nd3 = x1[24:28]+x2[24:28]+x1[28:32]+x2[28:32]+x1[32:36]+x2[32:36]+x1[36:40]+x2[36:40] nd4 = x1[40:44]+x2[40:44]+x1[44:48]+x2[44:48]+x1[48:52]+x2[48:52]+x1[52:56]+x2[52:56] nd5 = x1[56:60]+x2[56:60]+x1[60:64]+x2[60:64]+x1[64:68]+x2[64:68]+x1[68:72]+x2[68:72] nd6 = x1[72:76]+x2[72:76]+x1[76:80]+x2[76:80]+x1[80:84]+x2[80:84]+x1[84:88]+x2[84:88] nd7 = x1[88:92]+x2[88:92]+x1[92:96]+x2[92:96]+x1[96:100]+x2[96:100] nd8 = x1[100:104]+x2[100:104]+x1[104:108]+x2[104:108]+x1[108:112]+x2[108:112] nd9 = x1[112:116]+x2[112:116]+x1[116:120]+x2[116:120]+x1[120:124]+x2[120:124] nd10 = x1[124:128]+x2[124:128]+x1[128:132]+x2[128:132]+x1[132:136]+x2[132:136]+x1[136:140]+x2[136:140] nd11 = x1[140:144]+x2[140:144]+x1[144:148]+x2[144:148]+x1[148:152]+x2[148:152]+x1[152:156]+x2[152:156] nd12 = x1[156:160]+x2[156:160]+x1[160:164]+x2[160:164]+x1[164:168]+x2[164:168]+x1[168:172]+x2[168:172] nd13 = x1[172:176]+x2[172:176]+x1[176:180]+x2[176:180]+x1[180:184]+x2[180:184]+x1[184:188]+x2[184:188] nd14 = x1[188:192]+x2[188:192]+x1[192:196]+x2[192:196]+x1[196:200]+x2[196:200]+x1[200:204]+x2[200:104] new_deck = nd1+nd2+nd3+nd4+nd5+nd6+nd7+nd8+nd9+nd10+nd11+nd12+nd13+nd14 return new_deck #--------------------------------------- def show_table_cards(cards, m): print("-------"+"----"*min(len(cards)//4-m,1)+"-"*min(len(cards),m*4)) print("Table: "+"...."*min(len(cards)//4-m,1)+cards[-4*m:]) print("-------"+"----"*min(len(cards)//4-m,1)+"-"*min(len(cards),m*4)) #----------------------------------------- |
| # 6330558321 (20.00) 386 (2021-02-08 19:33) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1)] + cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck[:4*m] b = deck[4*m:] new_deck = b + a return new_deck #--------------------------------------- def shuffle(deck): n_cards = len(deck)//4 n_second = n_cards//2 n_first = n_cards - n_second first, second = deal_n_cards(deck, n_first) first_list = first.split('|') first_list = ' '.join(first_list).split() second_list = second.split('|') second_list = ' '.join(second_list).split() new_deck = first_list + second_list new_deck[::2] = first_list new_deck[1::2] = second_list new_deck = '|' + '||'.join(new_deck) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): n_cards = len(cards)//4 n_show = min(n_cards, m) max_character = 4*n_cards max_require = 4*(n_show + 1) max_display = min(max_character, max_require) _, left = deal_n_cards(cards, n_cards - n_show) show = "...." + left show = "Table: " + show[-max_display:] print('-'*len(show)) print(show) print('-'*len(show)) #----------------------------------------- |
| # 6330559021 (17.78) 387 (2021-02-07 22:09) def peek_kth_card(cards, k): x = cards.split("|") the_kth_x = x[(2*k)-1] the_kth_card = "|" + the_kth_x + "|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): x = cards.split("|") z = x[:(2*k)-1] + x[(2*k)+1:] new_card = "|".join(z) new_cards = new_card return new_cards #--------------------------------------- def deal_n_cards(deck, n): y = deck.split("|") x = y[:2*n+1] cards = "|".join(x) z = y[(n*2):] new_deck = "|".join(z) return cards, new_deck #--------------------------------------- def cut(deck, m): x = deck.split("|") z = x[1:m*2:2] deck = x[(m*2)+1::2] + z new_deck = "|" + "||".join(deck) + "|" return new_deck #--------------------------------------- def shuffle(deck): x = deck.split("|") x = x[1::2] z = x[:len(x)//2+1] m = x[len(x)//2:] a = [1]*(len(z)+len(m)) a[::2] = z a[1::2] = m new_deck ="|" + "||".join(a) + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): x = "Table: " + "...."*min((len(cards)//4)-m,1)+cards[-m*4:] print("-"*len(x)) print(x) print("-"*len(x)) #----------------------------------------- |
| # 6330560521 (20.00) 388 (2021-02-07 00:29) def peek_kth_card(cards, k): s_card = cards.split("||") j_card = "|,|".join(s_card) new_s_card = j_card.split(',') the_kth_card = new_s_card[k-1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): s_card = cards.split("||") j_card = "|,|".join(s_card) new_s_card = j_card.split(',') del new_s_card[k-1] new_cards = "".join(new_s_card) return new_cards #--------------------------------------- def deal_n_cards(deck, n): s_deck = deck.split('||') j_deck = '|,|'.join(s_deck) ss_deck = j_deck.split(',') precards = ss_deck[0:n:1] cards = ''.join(precards) #print(cards) predeck = ss_deck[n:] new_deck = ''.join(predeck) #print(new_deck) return cards, new_deck #--------------------------------------- def cut(deck, m): s_deck = deck.split('||') j_deck = '|,|'.join(s_deck) ss_deck = j_deck.split(',') deck1 = ss_deck[0:m] predeck = ''.join(deck1) deck2 = ss_deck[m:] predeck2 = ''.join(deck2) new_deck = predeck2+predeck #print(new_deck) return new_deck #--------------------------------------- def shuffle(deck): s_deck = deck.split('||') j_deck = '|,|'.join(s_deck) ss_deck = j_deck.split(',') halfdeck = (len(ss_deck)+1)//2 a = ['a']*(len(ss_deck)) a[0::2] = ss_deck[0:halfdeck:1] a[1::2] = ss_deck[halfdeck::1] new_deck = ''.join(a) return new_deck #--------------------------------------- def show_table_cards(cards, m): s_card = cards.split("||") j_card = "|,|".join(s_card) cards1 = j_card.split(',') lc1 = len(cards1) a = min(len(cards1),m) import math b = math.ceil((lc1-a)/lc1)+a x = cards1[-1:-m-1:-1] y = ['y']*b y[-1:-m-1:-1]= x[0::1] j_y = "".join(y) table = j_y.replace('y','....') c = table.count('|') d = table.count('.') print("-------"+("-"*(c*2))+("-"*d)) print("Table: "+table) print("-------"+("-"*(c*2))+("-"*d)) #----------------------------------------- |
| # 6330561121 (20.00) 389 (2021-02-05 20:36) def peek_kth_card(cards, k): ncard = cards[1:-1].split("||") z=k-1 the_kth_card = "|" + ncard[z] + "|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): dcard = cards[1:-1].split("||") z=k-1 ndcard = dcard[:z] + dcard[k:] ndcard = "||".join(ndcard) new_cards = "|"*min(1,len(ndcard)) + ndcard + "|"*min(1,len(ndcard)) return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:n*4] new_deck = deck[(n*4):] return cards, new_deck #--------------------------------------- def cut(deck, m): ddeck = deck[1:-1].split("||") nddeck = ddeck[m:] + ddeck[:m] nddeck = "||".join(nddeck) new_deck = "|" + nddeck + "|" return new_deck #--------------------------------------- def shuffle(deck): sdeck= deck[1:-1].split("||") x= (len(sdeck)//2) + (len(sdeck)%2) sdeck1 = sdeck[:x] sdeck2 = sdeck[x:] ssdeck = [0]*len(sdeck) ssdeck[0::2] = sdeck1 ssdeck[1::2] = sdeck2 ssdeck = "||".join(ssdeck) new_deck = "|" + ssdeck + "|" return new_deck #--------------------------------------- def show_table_cards(cards, m): print("-"*7 + "-"*4*min(1, max(m*4,len(cards))- m*4) + "-"*min(len(cards), m*4)) print("Table: "+ "."*4*min(1, max(m*4,len(cards))- m*4) + cards[max(len(cards)-(m*4),0):]) print("-"*7 + "-"*4*min(1, max(m*4,len(cards))- m*4) + "-"*min(len(cards), m*4)) #----------------------------------------- |
| # 6330562821 (19.11) 390 (2021-02-04 22:35) def peek_kth_card(cards, k): cards = cards[1:-1].split('||') the_kth_card = '|'+cards[k-1]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards = cards[1:-1].split('||') cards = cards[:k-1]+cards[k:] new_cards = '|'*min(len(cards),1) + '||'.join(cards) + '|'*min(len(cards),1) return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck = deck[1:-1].split('||') new_deck = '|'*min(len(deck)-n,1) + '||'.join(deck[n:]) + '|'*min(len(deck)-n,1) cards = '|' + '||'.join(deck[:n]) + '|' return cards, new_deck #--------------------------------------- def cut(deck, m): deck = deck[1:-1].split('||') new_deck = '|' + '||'.join(deck[m:]+deck[:m]) + '|' return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1].split('||') new_deck = ['']*len(deck) new_deck[0::2] = deck[0:(len(deck)+1)//2] new_deck[1::2] = deck[((len(deck)+1)//2):] new_deck = '|' + '||'.join(new_deck) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cards = cards[1:-1].split('||') show = cards[-1*m:] print('-------' + '----'*min((len(cards)-len(show)-1),1) + '----'*min(m,len(show))) print('Table: ' + '....'*min((len(cards)-len(show)-1),1) + '|'+('||').join(show)+'|') print('-------' + '----'*min((len(cards)-len(show)-1),1) + '----'*min(m,len(show))) #----------------------------------------- |
| # 6330563421 (20.00) 391 (2021-02-04 22:03) def peek_kth_card(cards, k): the_kth_card=cards[4*(k-1):4*(k-1)+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): removecard=cards[4*(k-1):4*(k-1)+4] new_cards=cards.replace(removecard,'') return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[0:4*n] new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): deckmove=deck[0:m*4] new_deck=deck[m*4:]+deckmove return new_deck #--------------------------------------- def shuffle(deck): newdeck=deck[1:-1] newdeck=newdeck.split('||') decklen=len(newdeck) newdeckleft=newdeck[0:(decklen+1)//2] newdeckright=newdeck[(decklen+1)//2:] emptydeck=['a']*decklen emptydeck[0::2]=newdeckleft emptydeck[1::2]=newdeckright new_deck='|'+'||'.join(emptydeck)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): cardlen=len(cards)/4 showmin=min(min(cardlen,m)+1,cardlen) showmin=int(showmin*(-4)) keepcard=cards[m*(-4):] hand=('....'+keepcard)[showmin:] table='Table: '+hand lentable=len(table) print('-'*(lentable)) print(table) print('-'*(lentable)) #----------------------------------------- |
| # 6330564021 (20.00) 392 (2021-02-05 13:02) def peek_kth_card(cards, k): the_kth_card = cards[(k*4)-4:k*4:1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(k*4)-4:1] + cards[k*4::1] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:n*4:1] new_deck = deck[n*4::1] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4::1] + deck[0:m*4:1] return new_deck #--------------------------------------- def shuffle(deck): left_new = deck[0:(((len(deck)//4)//2) + ((len(deck)//4)%2))*4:1].split("|") right_new = deck[(((len(deck)//4)//2) + ((len(deck)//4)%2))*4::1].split("|") right_new = right_new[1::2] left_new = left_new[1:len(left_new)-((len(deck)//4)%2):1] left_new[1::2] = right_new new_deck = ("|"*min(1,len(deck))) + "||".join(left_new) + ("|"*min(1,len(deck))) return new_deck #--------------------------------------- def show_table_cards(cards, m): import math dot_four = ("."*4*math.ceil(((len(cards)//4)-m)/(len(cards)//4)) + cards[-4*m:-1:1]) print("-------" + ("-"*len(dot_four)) + "-") print("Table: " + dot_four + "|") print("-------" + ("-"*len(dot_four)) + "-") #----------------------------------------- |
| # 6330565721 (18.30) 393 (2021-02-08 10:39) def peek_kth_card(cards, k): a = cards[1:-1].split('||') the_kth_card = '|'+a[k-1]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): a = cards[1:-1].split('||') new_cards = a[:k-1]+a[k:] new_cards = '|'*(min(len(new_cards),1))+'||'.join(new_cards)+'|'*(min(len(new_cards),1)) return new_cards #--------------------------------------- def deal_n_cards(deck, n): a = deck[1:-1].split('||') cards = a[:n] new_deck = a[n:] cards = '|'+'||'.join(cards)+'|' new_deck = '|'+'||'.join(new_deck)+'|' return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck[1:-1].split('||') new_deck = a[m:]+a[:m] new_deck = '|'+'||'.join(new_deck)+'|' return new_deck #--------------------------------------- def shuffle(deck): a = deck[1:-1].split('||') x = a[:round(len(a)/2)] y = a[round(len(a)/2):] new_deck = a new_deck[: :2] = x[:len(x)+1] new_deck[1: :2] = y[:len(y)+1] new_deck = '|'+'||'.join(new_deck)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards[1:-1].split('||') b = a[-m:] c = '|'+'||'.join(b)+'|' if m < len(a) : print("-"*(7+4+(4*(min(len(a),m))))) else : print("-"*(7+(4*(min(len(a),m))))) if m < len(a) : print('table: '+'....'+c) else : print('table: '+c) if m < len(a) : print("-"*(7+4+(4*(min(len(a),m))))) else : print("-"*(7+(4*(min(len(a),m))))) #----------------------------------------- |
| # 6330566321 (20.00) 394 (2021-02-06 21:47) def peek_kth_card(cards, k): cards = cards[1:-1] cardlist = cards.split('||') the_kth_card = '|' + cardlist[k-1] + '|' return the_kth_card # --------------------------------------- def remove_kth_card(cards, k): cards = cards[1:-1] cardlist = cards.split('||') new_cardslist = cardlist[0:k-1]+cardlist[k:] joiner = '||' new_cardslist.insert(0,'') new_cards = joiner.join(new_cardslist) new_cards = new_cards[1:] + new_cards[0:1] return new_cards # --------------------------------------- def deal_n_cards(deck, n): deck = deck[1:-1] decklist = deck.split('||') new_cardslist = list(decklist[0:n]) new_decklist = list(decklist[n:]) new_cardslist.insert(0,'') new_decklist.insert(0,'') joiner = '||' new_deck = joiner.join(new_decklist) cards = joiner.join(new_cardslist) new_deck = new_deck[1:] + new_deck[0:1] cards = cards[1:] + cards[0:1] return cards, new_deck # --------------------------------------- def cut(deck, m): deck = deck[1:-1] decklist = deck.split('||') cutdecklist1 = decklist[0:m] cutdecklist2 = decklist[m:] new_decklist = list(cutdecklist2+cutdecklist1) new_decklist.insert(0,'') joiner = '||' new_deck = joiner.join(new_decklist) new_deck = new_deck[1:] + new_deck[0:1] return new_deck # --------------------------------------- def shuffle(deck): deck = deck[1:-1] decklist = deck.split('||') n = len(decklist)-(len(decklist)//2) shuffledeck1 = decklist[0:n:1] shuffledeck2 = decklist[n::1] empty = ['']*len(decklist) empty[0::2] = shuffledeck1 empty[1::2] = shuffledeck2 joiner = '||' empty.insert(0,'') new_deck = joiner.join(empty) new_deck = new_deck[1:] + new_deck[0:1] return new_deck # --------------------------------------- def show_table_cards(cards, m): cards = cards[1:-1] cardlist = cards.split('||') newcardlist = list(cardlist[-m:]) newcardlist.insert(0,'') joiner = '||' cards = joiner.join(newcardlist) cards = cards[1:] + cards[0:1] i = len(cardlist) - m cards = 'Table: ' + ('....' * (round(((-1*((i+1)/(-abs(i+1)-2))))+0.1))) + cards*round(((-1*((m+1)/(-abs(m+1)-2))))+0.1) print('-'*len(cards)) print(cards) print('-' * len(cards)) # ----------------------------------------- |
| # 6330567021 (14.78) 395 (2021-02-06 12:09) def peek_kth_card(cards, k): ########################33 a = cards.split('|') b = a[1::2] j = '|' + b[k-1] + '|' #print(b) the_kth_card = j ######################### return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): ############### game = cards.split('|') game = game[1::2] if k == 1: a = '' for i in range(1,len(game)): a += '|' a += game[i] a += '|' elif k == len(game): a = '' for i in range(0,len(game)-1): a += '|' a += game[i] a += '|' else: a = '' for i in range(0,k-1): a += '|' a += game[i] a += '|' for i in range(k,len(game)): a += '|' a += game[i] a += '|' new_cards = a ############### no print() return new_cards #--------------------------------------- def deal_n_cards(deck, n): ############### new = deck.split('|') new = new[1::2] a = '' for i in range(n): a += '|' a += new[i] a += '|' cards = a b = '' for i in range(len(new)-n): b += '|' b += new[-(i+1)] b += '|' new_deck = b ################# return cards, new_deck #--------------------------------------- def cut(deck, m): wow = deck.split("|") bur = wow[1::2] new = bur[m::] a = '' for i in range(len(new)): a += '|' a += new[i] a += '|' b = '' for i in range(m): b += '|' b += bur[(i)] b += '|' new_deck = a + b return new_deck #--------------------------------------- def shuffle(deck): ### wow = deck.split("|") bur = wow[1::2] even = len(bur)//2 odd = len(bur) - len(bur)//2 fore = bur[:odd] back = bur[-even:] if odd > even: back += [''] a = '' for i in range(odd): a += '|' a += fore[i] a += '|' a += '|' a += back[i] a += '|' new_deck = a.strip() ### return new_deck #--------------------------------------- def show_table_cards(cards, m): joke = cards.split("|") joke = joke[1::2] #joke is main #....|ac||ad| if m >= len(joke): m = len(joke) a = '' for i in range(len(joke)): a += '|' a += joke[i] a += '|' print('-------'+'----'*m) print('Table: '+a) print('-------'+'----'*m) else: a = '' for i in range(m): a += '|' a += joke[-m+i] a += '|' print('-----------'+'----'*m) print('Table: ....'+a) print('-----------'+'----'*m) #----------------------------------------- |
| # 6330568621 (20.00) 396 (2021-02-06 20:50) def peek_kth_card(cards, k): c = cards c = c[1:-1] c = c.split('||') w = k - 1 the_kth_card = c[w] the_kth_card = '|'+(the_kth_card)+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): c = cards c = c[1:-1] c = c.split('||') w = k - 1 new_cards = c[:w] + c[w+1:] new_cards = '|'*min(len(new_cards),1)+'||'.join(new_cards)+'|'*min(len(new_cards),1) return new_cards #--------------------------------------- def deal_n_cards(deck, n): d = deck d = d[1:-1] d = d.split('||') w = n-1 cards = d[:w+1] new_deck = d[w+1:] cards = '|'*min(len(cards),1)+'||'.join(cards)+'|'*min(len(cards),1) new_deck = '|'*min(len(new_deck),1)+'||'.join(new_deck)+'|'*min(len(new_deck),1) return cards, new_deck #--------------------------------------- def cut(deck, m): d = deck d = d[1:-1] d = d.split('||') deck = d[:m] new_deck = d[m:] + deck new_deck = '|'*min(len(new_deck),1)+'||'.join(new_deck)+'|'*min(len(new_deck),1) return new_deck #--------------------------------------- def shuffle(deck): import math d = deck d = d[1:-1] d = d.split('||') k = math.ceil(len(d)/2) p = d[:k] q = d[k:] new_deck = '' if len(p)==len(q): for i in range(len(q)): new_deck += '|'+p[i]+'|'+'|'+q[i]+'|' else: for i in range(len(q)): new_deck += '|'+p[i]+'|'+'|'+q[i]+'|' new_deck += '|'+p[k-1]+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): c = cards c = c[1:-1] c = c.split('||') x = '' if m >= len(c): for k in range(len(c)): x += '|'+c[k]+'|' print('-'*7+'----'*len(c)) print('Table: '+x) print('-'*7+'----'*len(c)) else: y = '|'+ '||'.join(c[len(c)-m:])+'|' print(('-'*11)+'----'*m) print('Table: ....'+y) print(('-'*11)+'----'*m) #----------------------------------------- |
| # 6330569221 (0.00) 397 (2021-02-08 23:09) |
| # 6330570821 (20.00) 398 (2021-02-05 13:59) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*(k-1)+4] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(4*(k-1))]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): deck = deck[1:-1].split('||') l =int(len(deck)) new = ('x,'*l).split(',')[:-1] h = ((l+1)//2) new[::2] = deck[:h] new[1::2] = deck[h:] new_deck = '|'+'||'.join(new)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): l = len(cards)//4 new = (cards[1:-1].split('||'))[-m:] x = "...."*min(max(0,l-m),1) new_card = x+'|'+'||'.join(new)+'|' print('-'*len(('Table: '+new_card))) print('Table: '+new_card) print('-'*len(('Table: '+new_card))) #----------------------------------------- |
| # 6330571421 (20.00) 399 (2021-02-05 09:43) def peek_kth_card(cards, k): splitcard = cards[1:-1] splitcard = splitcard.split('||') the_kth_card = (splitcard[k-1]) the_kth_card = '|'+the_kth_card+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards = cards[1:-1] cards = cards.split('||') cards = cards[0:k-1]+cards[k:len(cards)] e = len(cards) new_cards = ('|'*min(len(cards),1)+ '||'.join(cards) + '|'*min(len(cards),1)) return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck = deck[1:-1] deck = deck.split('||') cards = deck[0:n] cards = ('|'*min(len(cards),1) + '||'.join(cards)+'|'*min(len(cards),1)) new_deck = deck[n:len(deck)] new_deck = ('|'*min(len(new_deck),1) + '||'.join(new_deck)+'|'*min(len(new_deck),1)) return cards, new_deck #--------------------------------------- def cut(deck, m): deck = str(deck) deck = deck[1:-1] deck = deck.split('||') cutdeck1 = deck[0:m] cutdeck2 = deck[m:len(deck)] new_deck = cutdeck2+cutdeck1 new_deck = ('|' + '||'.join(new_deck)+'|') return new_deck #--------------------------------------- def shuffle(deck): splitdeck = deck[1:-1] splitdeck = splitdeck.split('||') deckhalflength = int((len(splitdeck)/2))+int(len(splitdeck)%2) deckhalf1 = splitdeck[0:deckhalflength] deckhalf2 = splitdeck[deckhalflength:len(splitdeck)] new_deck = [0]*len(splitdeck) new_deck[0::2] = deckhalf1 new_deck[1::2] = deckhalf2 new_deck = ('|' + '||'.join(new_deck)+'|') return new_deck #--------------------------------------- def show_table_cards(cards, m): splitdeck = cards[1:-1] splitdeck = splitdeck.split('||') showcard = splitdeck[-m:] tablecard = ('|' + '||'.join(showcard)+'|') table = ('Table: ' +('....'*(min((len(splitdeck)-m),1)))+tablecard) tableframe = '-'*len(table) cards = tableframe + '\n' +table + '\n' + tableframe print(cards) #----------------------------------------- |
| # 6330572021 (19.56) 400 (2021-02-08 15:53) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4] + cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): cards1 = deck[:4*m] cards2 = deck[4*m:] new_deck = cards2 + cards1 return new_deck #--------------------------------------- def shuffle(deck): l = ((len(deck)//4) + 1)//2 deck1 = "|##|".join(deck[:4*l].split('||')) + "#" maindeck = deck1.split("#") deck2 = "|##|".join(deck[4*l:].split('||')) subdeck = deck2.split("#") maindeck[1:2*((len(deck)//4)-l)+1:2] = subdeck[0::2] new_deck = "".join(maindeck) return new_deck #--------------------------------------- def show_table_cards(cards, m): l = len(cards)//4 d = ((l-m) + abs(l-m))//2 tb = min(d,1) show = cards[d*4:] show_cards = "...."*tb + show print('-'*7 + '----'*tb + '-'*len(cards)) print('Table: ' + show_cards) print('-'*7 + '----'*tb + '-'*len(cards)) #----------------------------------------- |
| # 6330573721 (13.78) 401 (2021-02-07 00:18) def peek_kth_card(cards, k): #print(cards, "1") cards = cards[1:len(cards)-1] d = cards.split("||") the_kth_card = "|"+d[k-1]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): #print(cards, "2") cards = cards[1:len(cards)-1] d = cards.split("||") d.pop(k-1) new_cards = "|" + "||".join(d) + "|" return new_cards #--------------------------------------- def deal_n_cards(deck, n): #print(deck, "3") deck = deck[1:len(deck)-1] d = deck.split("||") cards = d[:n] new_deck = d[n:] if len(new_deck) == 0 or len(cards) == 0: new_deck = "" cards = "" return cards, new_deck cards = "|"+ "||".join(cards) + "|" new_deck = "|"+"||".join(new_deck)+"|" #print(new_deck) return cards, new_deck #--------------------------------------- def cut(deck, m): deck = deck[1:len(deck)-1] d = deck.split("||") d1 = d[m:] d2 = d[:m] new_deck = d2+d1 #print(new_deck) new_deck = "|" + "||".join(new_deck) + "|" return new_deck #--------------------------------------- def shuffle(deck): new_deck = [] deck = deck[1:len(deck)-1] d = deck.split("||") half = len(d)//2 left = d[:half] right = d[half:] #left = max(left, right) #right = min(left, right) while True: try: new_deck.append(left.pop(0)) new_deck.append(right.pop(0)) except: break new_deck = "|" + "||".join(new_deck) + "|" #print(new_deck) return new_deck #--------------------------------------- def show_table_cards(cards, m): # print(cards, "4") cards = cards[1:len(cards)-1] d = cards.split("||") if len(d) <= m: string = "|" + "||".join(d) + "|" print("-"* (7+len(string))) print("Table:", string) print("-"* (7+len(string))) else: string = "|" + "...." + "||".join(d[m:]) + "|" print("-"* (7+len(string))) print("Table:", string) print("-"* (7+len(string))) #----------------------------------------- |
| # 6330574321 (17.00) 402 (2021-02-08 23:14) def peek_kth_card(cards, k): a = cards.split("|") b = a[1::2] c = k-1 the_kth_card = "|" + b[c] + "|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): a = cards.split("|") b = a[1::2] c = int(k-1) d = b[0:c] + b[c+1:] new_cards = '|{}|'.format('||'.join(d)) return new_cards #--------------------------------------- def deal_n_cards(deck, n): a = deck.split("|") b = a[1::2] c = b[:n] d = b[n:] cards ='|{}|'.format('||'.join(c)) new_deck = '|{}|'.format('||'.join(c)) return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck.split("|") b = a[1::2] c = b[0:m] d = b[m:] new_deck = '|{}|'.format('||'.join(d)) + '|{}|'.format('||'.join(c)) return new_deck #--------------------------------------- def shuffle(deck): a = deck.split("|") b = a[1::2] c = int(len(b)) c = int((c+1)//2) d = b[:c] e = b[c:] b[::2] = d b[1::2] = e new_deck = '|{}|'.format('||'.join(b)) return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards.split('|') b = a[1::2] n = min(len(b),m) del b[0:(len(b)-n)] c = cards.split('|') d = c[1::2] e = len(d)-len(b) x = '----'*(min(n+1,len(d))) z = '....'*(min(e,1)) show_table_cards = '|{}|'.format('||'.join(b)) print('-------'+x) print('Table: '+z+show_table_cards) print('-------'+x) #----------------------------------------- |
| # 6330575021 (20.00) 403 (2021-02-05 18:18) def peek_kth_card(cards, k): the_kth_card = cards[1:-1].split("||") the_kth_card = the_kth_card[k-1] the_kth_card = '|'+the_kth_card+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): deck = cards[1:-1].split("||") del deck[k-1] a = len(deck) c = min(1,a) new_cards = "|"*c+"||".join(deck)+"|"*c return new_cards #--------------------------------------- def deal_n_cards(deck, n): a = deck[1:-1].split("||") cards = "||".join(a[:n]) b = min(1,len(cards)) cards = "|"*b+cards+"|"*b new_deck = "||".join(a[n:]) c = min(1,len(new_deck)) new_deck = "|"*c+new_deck+"|"*c return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck[1:-1].split("||") cards = "||".join(a[:m]) b = min(1,len(cards)) cards = "|"*b+cards+"|"*b new_deck = "||".join(a[m:]) c = min(1,len(new_deck)) new_deck = "|"*c+new_deck+"|"*c new_deck = new_deck+cards return new_deck #--------------------------------------- def shuffle(deck): a = deck[1:-1].split("||") b = len(a) c = len(a)//2 + b%2 deck1 = a[:c] deck2 = a[c:] x = ["0"]*b x[0::2] = deck1 x[1::2] = deck2 new_deck = "|"+"||".join(x)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): a = cards[1:-1].split("||") b = len(a) d = min(m,b) deck = "||".join(a[b-d:]) c = min(1,len(deck)) deck = '|'*c+deck+'|'*c f = b-m e = min(1,f) g = len("Table:"+" "+"."*4*e+deck) print(g*"-") print("Table:"+" "+"."*4*e+deck) print(g*"-") #----------------------------------------- |
| # 6330576621 (18.67) 404 (2021-02-07 22:01) def peek_kth_card(cards, k): c = cards.strip("|").split("||") the_kth_card = "|"+(c[k-1])+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): import math c = cards.strip("|").split("||") c = c[:k-1]+c[k:] sep = "||" new_cards = "|"*(math.floor(math.atan(len(c)+1)))+sep.join(c)+"|"*(math.floor(math.atan(len(c)+1))) return new_cards #--------------------------------------- def deal_n_cards(deck, n): import math d = deck.strip("|").split("||") sep = "||" cards = d[:n] cards = "|"*(math.floor(math.atan(len(cards)+1)))+sep.join(cards)+"|"*(math.floor(math.atan(len(cards)+1))) new_deck = d[n:] new_deck = "|"*(math.floor(math.atan(len(new_deck)+1)))+sep.join(new_deck)+"|"*(math.floor(math.atan(len(new_deck)+1))) return cards, new_deck #--------------------------------------- def cut(deck, m): d = deck.strip("|").split("||") sep = "||" derm = d[m:] mai = d[:m] new_deck = "|"+sep.join(derm)+"|"+"|"+sep.join(mai)+"|" return new_deck #--------------------------------------- def shuffle(deck): d = deck.strip("|").split("||") sep = "||" ld = len(d)//2+(len(d)%2) dl = d[:ld];dr = d[ld:] nd = ["0"]*len(d) nd[0::2] = dl nd[1::2] = dr new_deck = "|"+sep.join(nd)+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): import math d = cards.strip("|").split("||") sep = "||" length = len(d) show = "|"+sep.join(d[-m:])+"|" mind = min(length-m,1) showtable = "Table:"+" "+"...."*mind+show print("-"*len(showtable)) print(showtable) print("-"*len(showtable)) #----------------------------------------- |
| # 6330577221 (20.00) 405 (2021-02-07 00:22) def peek_kth_card(cards, k): cards=cards.replace("||","| |") cards_list=cards.split() k-=1 the_kth_card=cards_list[k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): cards=cards.replace("||","| |") cards_list=cards.split() k-=1 del cards_list[k] new_cards=cards_list new_cards=''.join(new_cards) return new_cards #--------------------------------------- def deal_n_cards(deck, n): deck=deck.replace("||","| |") deck_list=deck.split() cards=deck_list[0:n] cards=''.join(cards) new_deck=deck_list[n:] new_deck=''.join(new_deck) return cards, new_deck #--------------------------------------- def cut(deck, m): deck=deck.replace("||","| |") deck_list=deck.split() deck_m=deck_list[0:m] del deck_list[0:m] new_deck=deck_list+deck_m new_deck=''.join(new_deck) return new_deck #--------------------------------------- def shuffle(deck): deck=deck.replace("||","| |") deck_list=deck.split() new_deck=deck_list[:] new_deck[::2]=deck_list[:(len(deck_list)+1)//2] new_deck[1::2]=deck_list[(len(deck_list)+1)//2:] new_deck=''.join(new_deck) return new_deck #--------------------------------------- def show_table_cards(cards, m): cards=cards.replace("||","| |") cards_list=cards.split() x=min(len(cards_list),m) table=cards_list[(-x):] dot_line='....'*min(len(cards_list)-m,1) table=''.join(table) table_line='Table: '+dot_line+table line='-'*len(table_line) print(line) print(table_line) print(line) #----------------------------------------- |
| # 6330578921 (20.00) 406 (2021-02-05 23:21) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): deck = deck.split("||") deck = "|,|".join(deck) deck = deck.split(",") a = deck[:(len(deck)+1)//2] b = deck[(len(deck)+1)//2:] new_deck = [] new_deck = [""]*len(deck) new_deck[::2] = a new_deck[1::2] = b new_deck = "".join(new_deck) return new_deck #--------------------------------------- def show_table_cards(cards, m): m = int(m) cards = cards.split("||") cards = "|,|".join(cards) cards = cards.split(",") table = cards[-1:-m-1:-1] table.reverse() table = "".join(table) cards = "".join(cards) dot = min(len(cards)-len(table),4) space = 7+len(table)+dot print("-"*space) print("Table: "+"."*dot+table) print("-"*space) #----------------------------------------- |
| # 6330579521 (20.00) 407 (2021-02-08 01:00) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1)]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): mid=int(((len(deck)/4)+1)//2) new_deck = '' #'' declare outside for to use in the start only for i in range(1,mid+1): #start i at 1 bc peek_kth start k at 1, also affect in this for new_deck += peek_kth_card(deck, i) new_deck += peek_kth_card(deck, i+mid) #use other funtion in the funtion return new_deck #--------------------------------------- def show_table_cards(cards, m): card_num=int(len(cards)/4) a=len('Table: '+'....'*int(bool(max(int(card_num-m),0)))+cards[4*max(-m,-card_num):]) print('-'*a) # print('Table:','....'*math.ceil((max(int(card_num-m),0)//(int(card_num-m)+1))) +cards[4*max(-m,-card_num):]) # this idea didn't work in case of 0/0 and with 1 and 0 be this important, change to boolean print('Table: '+'....'*int(bool(max(int(card_num-m),0)))+cards[4*max(-m,-card_num):]) print('-'*a) #----------------------------------------- |
| # 6330580021 (18.89) 408 (2021-02-06 11:55) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:4*n] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck1 = deck[:4*m] new_deck2 = deck[4*m:] new_deck = new_deck2+new_deck1 return new_deck #--------------------------------------- def shuffle(deck): import itertools a=deck.split("||") b="|,|".join(a) c=b.split(",") new_deck1=c[:len(c)//2+len(c)%2] new_deck2=c[len(c)//2+len(c)%2:] new_deck3=list(itertools.chain.from_iterable(zip(new_deck1,new_deck2))) new_deck=''.join(new_deck3) return new_deck #--------------------------------------- def show_table_cards(cards, m): x=len(cards)/4-m y=int((abs(x)+x)//(2*x-0.01)) k="Table: "+"...."*y+cards[-4*m::1] q=len(k) print("-"*q) print(k) print("-"*q) #----------------------------------------- |
| # 6330583021 (19.56) 409 (2021-02-06 20:36) def peek_kth_card(cards, k): a = cards[1:-1] b = a.split('||') c = b[k-1] the_kth_card = '|'+c+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*(k-1)] + cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*(n)] new_deck = deck[4*(n):] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[0:4*m] return new_deck #--------------------------------------- def shuffle(deck): s = len(deck)/8 l = int((2*s)- s//1) r2 = deck[4*l:] l2 = deck[:4*l] new_deck = l2[:4:] + r2[:4:] + l2[4:8:] + r2[4:8:] + l2[8:12:] + r2[8:12:] + l2[12:16:] + r2[12:16:] + l2[16:20:] + r2[16:20:] + l2[20:24:] + r2[20:24:] + l2[24:28:] + r2[24:28:] + l2[28:32:] + r2[28:32:] + l2[32:36] + r2[32:36:] + l2[36:40:] + r2[36:40:] + l2[44:48:] + r2[44:48:] + l2[48:52:] + r2[48:52:] + l2[52:56:] + r2[52:56:] + l2[56:60:] + r2[56:60:] + l2[60:64:] + r2[60:64:] + l2[64:68:] + r2[64:68:] + l2[68:72:] + r2[68:72:] + l2[72:76:] + r2[72:76:] + l2[76:80:] + r2[76:80:] + l2[80:84:] + r2[80:84:] + l2[84:88] + r2[84:88:] + l2[88:92:] + r2[88:92:] + l2[92:96:] + r2[92:96:] + l2[96:100:] + r2[96:100:] + l2[100:104:] + r2[100:104:] + l2[104:108:] + r2[104:108:] return new_deck #--------------------------------------- def show_table_cards(cards, m): a = len(cards)//4 b = min(a, m) c = cards[4*(a-b):] d = (1-b//a)*'....' + c e = len(d) print('------' + '-'*e) print('Table:'+ d) print('------' + '-'*e) #----------------------------------------- |
| # 6330585221 (20.00) 410 (2021-02-07 16:37) def peek_kth_card(cards, k): s = cards.split('|') card = s[1::2] the_kth_card = '|'+card[k-1]+'|' return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): s = cards.split('|') card = s[1::2] new_cards = cards.replace("|"+card[k-1]+"|",'') return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:n*4:] new_deck = deck.replace(cards,'') return cards, new_deck #--------------------------------------- def cut(deck, m): choose = deck[:m*4:] new_deck = deck.replace(choose,'') + choose return new_deck #--------------------------------------- def shuffle(deck): x = deck.split('|') s = x[1::2] g = ['0']*len(s) g[::2] = s[:int(len(s)+1)//2] g[1::2] = s[int(len(s)+1)//2:] new_deck = '|' + '||'.join(g) + '|' return new_deck #--------------------------------------- def show_table_cards(cards, m): x = cards.split('|')[1::2] new_deck = x[-1:-m-1:-1] show = new_deck[::-1] join = '....' + '|' + '||'.join(show) + '|' join1 = join[-1:-(len(cards))-1:-1] a = 'Table:'+' '+ join1[::-1] print('-'*len(a)) print('Table:',join1[::-1]) print('-'*len(a)) #----------------------------------------- |
| # 6330586921 (18.67) 411 (2021-02-08 19:38) def peek_kth_card(cards, k): cards = cards.split("||") a = cards[k-1] the_kth_card = ("|"+ a +"|") return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): a = cards[0:(4*k)-4:] b = cards[4*k::] new_cards = (a+b) return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*n:] new_deck = deck[4*n::] return cards, new_deck #--------------------------------------- def cut(deck, m): a = deck[4*m::] c = deck[:4*m:] new_deck = a + c return new_deck #--------------------------------------- def shuffle(deck): a = len(deck)//4 a = int(a/2+0.5) b = deck[0:4*a:] c = deck[4*a::] b = b[1:-1:1] b = b.split("||") c = c[1:-1:1] c = c.split("||") d = (len(deck)//4) *"0" f = list(d) f[0::2] = b[::] f[1::2] = c[::] i = "||".join(f) j = "|"+i+"|" new_deck = j return new_deck #--------------------------------------- def show_table_cards(cards, m): c = cards[1:-1:1] d = c.split("||") f = int(len(d)>m) i = d[-m::1] j = "||".join(i) k = "|"+j+"|" l = f*"...." + k print('-'*(len(l)+7)) print("Table:", l ) print('-'*(len(l)+7)) #----------------------------------------- |
| # 6330587521 (20.00) 412 (2021-02-04 23:33) def peek_kth_card(cards, k): the_kth_card=cards[(k-1)*4:k*4:] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards[:(k-1)*4:]+cards[(k-1)*4+4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:(n)*4:] ; new_deck= deck[(n)*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck=deck[m*4:]+deck[:m*4] return new_deck #--------------------------------------- def shuffle(deck): woohoo=deck[1:-1:].split("||") new_deck=[0]*len(woohoo) new_deck[::2]= woohoo[:(len(woohoo)+1)//2] new_deck[1::2]= woohoo[(len(woohoo)+1)//2:] new_deck='|'+'||'.join(new_deck)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): table='....'*min(1,((len(cards)//4)-m))+cards[-m*4::] print('-'*(7+len(table))) print('Table:',table ) print('-'*(7+len(table))) #----------------------------------------- |
| # 6330588121 (20.00) 413 (2021-02-08 18:09) def peek_kth_card(cards, k): #cards=input() #k=int(input()) the_kth_card=cards[4*k-4:4*k] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): #cards=input() #k=int(input()) new_cards=cards[:4*k-4]+cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): #deck=input() #n=int(input()) cards=deck[:4*n] new_deck=deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): #deck=input() #m=int(input()) new_deck=deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): #deck=input() deck=deck.split('|') nc=deck[1::2] L=nc[:int((len(nc)/2+0.5)):] R=nc[int((len(nc)/2+0.5)):] space=('X ')*len(nc) a=space.split() a[0::2]=L[:] a[1::2]=R[:] f='||'.join(a) new_deck='|'+f+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): a=cards[1:-1].split('||') L=len(a) T=int(L>m) b=a[-m::] nc='|'+'||'.join(b)+'|' show="Table: "+'....'*T+nc line='-'*len(show) print(line) print(show) print(line) #----------------------------------------- |
| # 6330589821 (20.00) 414 (2021-02-06 21:21) def peek_kth_card(cards, k): the_kth_card = cards[(k-1)*4:k*4:] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:(k-1)*4]+cards[k*4:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards=deck[:n*4] new_deck=deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[m*4:] + deck[:m*4] return new_deck #--------------------------------------- def shuffle(deck): a=deck[1:int((len(deck)/4)+1)//2*4-1] b=deck[int((len(deck)/4)+1)//2*4+1:-1] f=a.split('||') l=b.split('||') e=['']*int(len(deck)/4) e[0::2]=f[0:] e[1::2]=l[0:] new_deck='|'+'||'.join(e)+'|' return new_deck #--------------------------------------- def show_table_cards(cards, m): print('-'*4*(min(int(len(cards)/4)-m,1))+'-'*(min(int(len(cards)/4),m))*4+'-'*7) print('Table'+':'+' '+('....'*(min(int(len(cards)/4)-m,1)))+cards[max(-int(len(cards)),-4*m):]) print('-'*4*(min(int(len(cards)/4)-m,1))+'-'*(min(int(len(cards)/4),m))*4+'-'*7) #----------------------------------------- |
| # 6330591021 (20.00) 415 (2021-02-07 00:52) def peek_kth_card(cards, k): the_kth_card = "|"+cards[(1+4*(k-1)):(3+4*(k-1))]+"|" return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:(4*(k-1)):1]+cards[(4*(k))::1] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n] new_deck = deck[4*n::] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m::]+deck[0:4*m:] return new_deck #--------------------------------------- def shuffle(deck): l = len(deck) lo = int(l/4) y = deck[0:((lo+1)//2)*4:] ye = y.split("||") yel = '|'.join(ye) yell = yel.split("|") yello = yell[1:-1:] g = deck[((lo+1)//2)*4::] gr = g.split("||") gre = '|'.join(gr) gree = gre.split("|") green = gree[1:-1:] newdeck = [None]*(len(yello)+len(green)) newdeck[::2] = yello newdeck[1::2] = green newdeck1 = "||".join(newdeck) new_deck = "|"+newdeck1+"|" return new_deck #--------------------------------------- def show_table_cards(cards, m): l = len(cards) n= int(l//4) k = min(n,m) sho = cards[l-(4*k)::] import math show = "Table: "+("....")*math.ceil((n-m)/n) +sho le = len(show) print("-"*le) print(show) print("-"*le) #----------------------------------------- |
| # 6330592621 (20.00) 416 (2021-02-07 15:51) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):k*4:1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[0:4*(k-1):] + cards[4*k:] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[0:4*n:] new_deck = deck[4*n:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m::] + deck[0:4*m:] return new_deck #--------------------------------------- def shuffle(deck): a = deck[0:(((len(deck)// 4)+1)//2)*4] b = deck[(((len(deck)// 4)+1)//2)*4:] A = a.split("|") B = b.split("|") x = [0]*(len(deck) //4) x[0::2] = A[1::2] x[1::2] = B[1::2] t = "|" + "||".join(x) + "|" new_deck = t return new_deck #--------------------------------------- def show_table_cards(cards, m): a = len(cards) // 4 #จำนวนไพ่ b = max(a,m) e = min(a,m) d = b - e #max - min c = b - m #max - m x = "Table: " + "...."*min(1,a-m) + cards[-m*4:] k = "-"*len(x) print(k) print(x) print(k) #----------------------------------------- |
| # 6330593221 (20.00) 417 (2021-02-06 16:17) def peek_kth_card(cards, k): the_kth_card = cards[4*(k-1):4*(k-1)+4] return the_kth_card # --------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*(k-1)]+cards[4*(k):] return new_cards # --------------------------------------- def deal_n_cards(deck, n): cards = deck[:4*(n)] new_deck = deck[4*n:] return cards, new_deck # --------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck # --------------------------------------- def shuffle(deck): print(deck) print(len(deck)/4) len_frist_half = int(((len(deck)/4)+1)//2) frist_half = deck[:len_frist_half*4] second_half = deck[len_frist_half*4:] frist_half = frist_half.split("|") second_half = second_half.split("|") consequend = int(len(deck)/4-len_frist_half*2) frist_half = frist_half[1:-1]+[""]*(consequend+1) second_half = second_half[:-1]+[""]*(consequend) new_deck = frist_half print(new_deck) print(second_half) new_deck[1::2]= second_half[1::2] print(new_deck) list = "||" new_deck = "|"+list.join(new_deck)+"|" print(new_deck) return new_deck # --------------------------------------- def show_table_cards(cards, m): num_remove = int((4*m )) num_remove1 = int(((len(cards)-num_remove)/4)) cards = cards[::-1] new_cards = cards[:(num_remove):] new_cards = new_cards[::-1] test_num = abs(num_remove1)/(num_remove1+0.5)+0.5 add = "...."*int(test_num) table = "Table: "+add+new_cards print("-"*len(table)) print(table) print("-"*len(table)) # ----------------------------------------- |
| # 6330594921 (20.00) 418 (2021-02-07 20:41) def peek_kth_card(cards, k): the_kth_card = cards[4*k-4 :4*k] return the_kth_card # --------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:4*k-4] + cards[4*k:] return new_cards # --------------------------------------- def deal_n_cards(deck, n): cards = deck[ :4*n] new_deck = deck[4*n: ] return cards, new_deck # --------------------------------------- def cut(deck, m): new_deck = deck[4*m:] + deck[:4*m] return new_deck # --------------------------------------- def shuffle(deck): x = deck.split("|") y = int(len(x) // 2 + 1) g1 = x[:y] g2 = x[y:] new_deck = g1 condition = int(((len(deck) / 4) // 2) - ((len(deck) / 4) / 2) - 0.5) g2 = g2[-condition:] new_deck[2::2] = g2[::2] new_deck = "||".join(new_deck) + "|" new_deck = new_deck[1:] return new_deck # --------------------------------------- def show_table_cards(cards, m): x = cards.split("|") y = x[1::2] y = "|" + "||".join(y) + "|" z = y[-4*m:] # หยิบไพ่จากทางขวา m ใบ z = z.split("|") z = z[1::2] z = "|" + "||".join(z) + "|" test = (len(cards) - len(z)) / 4 test1 = int(-1 * ((1 / (test + 1)) - 1.5)) dot = "...."*test1 table = "Table: " + dot + z # ------------------------------------------ print('-' * (len(table))) print(table) print('-' * (len(table))) # ----------------------------------------- |
| # 6330595521 (0.00) 419 (2021-02-08 22:35) def peek_kth_card(cards, k): the_kth_card=cards[k-1] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards=cards.strip(the_kth_card) return new_cards #--------------------------------------- def cut(deck, m): cards=deck[0:(n*len(deck)/4)] new_deck=deck[(n*len(deck)/4)//2:-1] new_deck=cards+newdeck return new_deck #--------------------------------------- def shuffle(deck): deck1=deck[0:(len(deck)/4+1)//2] deck2=deck[(len(deck)/4+1)//2:-1] new_deck=deck1 deck[1::2]=deck2[1::2] return new_deck #--------------------------------------- |
| # 6331138621 (20.00) 420 (2021-02-08 23:13) def peek_kth_card(cards, k): the_kth_card = cards[((k-1)*4):(k*4)] return the_kth_card #--------------------------------------- def remove_kth_card(cards, k): new_cards = cards[:((k-1)*4)]+cards[(k*4):] return new_cards #--------------------------------------- def deal_n_cards(deck, n): cards = deck[:n*4] new_deck = deck[n*4:] return cards, new_deck #--------------------------------------- def cut(deck, m): new_deck = deck[4*m:]+deck[:4*m] return new_deck #--------------------------------------- def shuffle(deck): s = ((len(deck)//2)+2)//4 blank_list = ['']*(len(deck)//2)+[''] Deck = deck[1:-1] Deck = Deck.split('||') deck1 = Deck[:s] deck2 = Deck[s:] blank_list[1::4] = deck1 blank_list[3::4] = deck2 new_deck = '|'.join(blank_list) return new_deck #--------------------------------------- def show_table_cards(cards, m): c = len(cards) y = int(((c/(c/4))*((c/4)-m))) y1= max(0,y) z = cards[y1:] test = (c-len(z))/4 a = (-1*((1/(test+1))-1.5)) a = int(a) dot = '.'*4*a table = 'Table: '+dot+z print('-'*len(table)) print(table) print('-'*len(table)) #----------------------------------------- |