ollama run yi-coder:9b-base-q8_0

how many days betwen febuary 2nd 2021 and may 23, 2024?

from datetime import date

first = date(year=2021, month=2, day=2)
second = date(year=2024, month=5, day=23)
delta = second - first
print(f"{delta.days} days between {first} and
{second}")<|endoftext|>#!/usr/bin/env python3
import sys
from collections import Counter
from itertools import combinations as combi

def solve(N: int, S: "List[str]"):
ans = 0
for s in S : ans += (s.count('AB') or 0)
a_count = b_count = ab_count = 0
for s in S :
if s[-1] == 'A' and s[0] == 'B':ab_count+=1;continue
elif s[-1]=='A': a_count += 1
elif s[0] == 'B': b_count += 1
ans += max(min(a_count,b_count), ab_count-1 if ab_count > 0 else
-float('inf'))
print(int(ans))
return

Generated by 2.3.0 https://github.com/kyuridenamida/atcoder-tools

(tips: You use the default template now. You can remove this line by using
your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
S = [ next(tokens) for _ in range(N)] # type: "List[str]"
solve(N, S)

if name == 'main':
main()<|endoftext|>def dfs(t,d,n):
global ans
if t==n+1 : # 다음날로 간다는의미이기에 n 이하가아니고 n +1 이여야함.
ans = max(d, ans)
if t>n+1: # 실패한경로를 return을해서 이전 stack에 dfs가 동작하도록함
.
return ;
# 현재 탐색이 끝난 t를 기준을 다음dfs에서는 t+1, t +T[i]로 값 이동.
dfs(t+T[t-1], d+P[t-1],n) # i가 0이기때문에 -1해줘서 T[t-1] P[t-1]로표
현
dfs(t+1, d,n)# 그다음 하나를 더가면서 이동.
T = [] ;P=[] # 기간/ 수익 list
ans = -2e9
n = int(input())# N+1일 휴가.
for i in range(0, n):
t, p = map(int, input().split(' ')) #날짜 /수익.
T.append(t) ; P.append(p)
dfs(1, 0,n)# t=0이고 d=0부터 시작해서 n까지다음하나를 이동하면서 stack에
append.
print(ans)<|endoftext|>#!/usr/bin/env python3
import sys, math
sys.setrecursionlimit(10**6)
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def yes(): print("Yes")
def no(): print("No")
MOD = 1000000007
from collections import defaultdict, deque

class Edge:
slots = ('to', 'cost')

def __init__(self, to, cost):
    self.to = to
    self.cost = cost

01BFSで解く。ダイクストラの特徴と異なり、dist[i]は最短距離を意味するわけで

はない。
def bfs01(n, edges): # n:頂点数 , edges = [Edge(v,c),...]: 辺
INF = 10 ** 60 # 問題に合わせて変更すること
dist = defaultdict(lambda : INF )# dist[i] : i までの最短距離を格納した辞
書。ダイクストラ以外はこれが解になる。
prev = defaultdict(int) # 経路復元用。 prev[i]: 頂点iで前段階にどのよう
な操作を行ったか。BFSであれば、これは辿ってきた直前のnodeを表す
que = deque([]) # (現在のnode, そこまでの距離, prev node )
dist[0] = 0 # 始点。問題に変更する必要あり
prev[0] = -1 # 始点はrootとする
que.append((0, dist[0])) # (node, dist)の順で格納。0から0までの距離は0で
ある

while que:  # キューが空になるまで
    now_pos, now_cost =que.popleft() # 左から要素を一つ取り出す。FIFOで

あることを保証する。
if dist[now_pos] < now_cost: # 今見ている頂点の距離が、distに格納さ
れている値よりも小さい場合は探索しない
continue
for e in edges[now_pos]: # 現在の位置から行ける各頂点へ
if dist[e.to] > (dist[now_pos]+e.cost): # 距離の更新があれ
ば
dist[e.to] = now_cost+ e.cost # distを更新
prev[e.to] = now_pos # 経路復元用。頂点nowから遷移した
ことを記録する
if (e.cost == 0): que.appendleft((e.to, dist[e.to]))

コストが1なら先頭に、0なら末尾に追加。

                else: que.append((e.to,dist[e.to]))
    #print(now_pos)
return dist  # distを返すと各頂点までの最短距離の辞書になる。

edges = defaultdict(list) # 辺
n= I()
for _ in range(n-1):
a,b = LI()
x = Edge(to= b-1, cost=0 )# 距離が0であれば抜き出してキューの先頭に追加
することで、最小値探索を高速化する。
edges[a-1].append(x) # edges[from] = [Edge(to,cost)] の形で格納する。
y= Edge( to= a-1, cost=0 ) # 上記と同様
edges[b-1].append(y)
a = bfs01(n, edges)
ans = []
for i in range(len(a)):
if (i+1) % 2 == 1 and a[i] < len(str((int)(n/2))) : # 距離が半分未満ならば
、色を0とする。
ans.append(0)
else: ans.append(1)
print(*ans, sep=" ")<|endoftext|>def gcd(a, b):
while a % b != 0:
tmp = a%b
if tmp == 0: return min([a,b])
else: [a,b] = [min([a,b]), max([a,b])] + [tmp]
return b<|endoftext|>from math import sqrt, cos, sin, acos, pi

def solve(p1x, p2y): # 01 を解く
L = ((3*pi)/8) *
(sqrt(((cos((pi/4)+p1x)-sin((pi/4))-p2y)**2)+(sin((pi/4)+p1x)-(cos(pi/4)+p2(sqrt(((cos((pi/4)+p1x)-sin((pi/4))-p2y)**2)+(sin((pi/4)+px)-(cos(pi/4)+p2y))**2)) # 02
return L<|endoftext|>n = int(input()) # 入力される値を整数にし、変数nに代入
する。
s = input() # 入力される文字列を整数にし、変数sに代入する。
if n % 2 == 1: # もし、変数nが奇数であれば真（True）となり、「No」を出力す
る。
print('No')
else: # そうでない場合を表現する。
for i in range(int(len(s)/2)): # 文字列の半分分繰返し変数iに代入する。

    if s[0+i] == s[(n//2)+i]:   # もし、先頭から0 + i番目の文字と先頭か

ら(n // 2) + i番目の文字が等しい場合を表現する。
pass # 何もしない
else: # そうでない場合を表現する。「No」を出力する。
print('No')
break # else文は、break文が実行されるので実行されず無視される
。
else: # すべての文字列に関して、真(True)であれば以下の文を実行する。「
Yes」を出力する。
print('Yes')<|endoftext|>from math import sqrt, cos, sin, acos, pi
class Point():
def init(self, x=0.0, y=0.0):
# このコードはOK
""" 初期化 """
self.x = x # xを設定する。
self.y = y # yを設定する。
def distance_from_origin(self,):
return sqrt(self.x * self.x + self.y * self.y)
# このコードはOK
""" ２点間の距離を求める """
def distance_from_point(p1, p2): # 定義するだけで実行されない。
return sqrt((p2.x - p1.x) ** 2 + (p2.y - p1.y) ** 2) # ２点間の距離
を求める。
"""
# このコードはOK
ベクトルの大きさ(長さ)を求める。
"""
def mag(v): # ベクトルの大きさ(長さ)を求める。
return sqrt(v.x ** 2 + v.y ** 2) # ベクトルの大きさを求める。
""" 角度を求める """
def angle_to_origin(self,): # 角度を求める。
return atan2(p1.y, p1.x) # 値の角度を求める。
""" ベクトルを求める """
def heading_from_points(p0, p1): # ベクトルを求める。
xDiff = p1.getX() - p2.getX() # xの差分が求める。
yDiff = p1.getY() - p2.getY() # yの差分が求める。
return atan2(yDiff,xDiff) # 角度を求める。<|endoftext|>n=input()
n+=" "
a=[]
s=""
for i in range (len(n)-1):
if n[i]!=' ':
s+=n[i]
elif s!='':
a.append(int(s))
s=""
m=0;r=-1
for i in a:
c=0
for j in range (len(a)-1):
if i==a[j]: c+=1
if m<c : r=i ; m=c
print (int(r));<|endoftext|>def gcd(x, y): # 最大公約数を求める。
while y != 0:
x, y = y, x % y
return x<|endoftext|>#!/usr/bin/env python3.6
#-- coding: utf-8 --

#以下の二つは等価。
print(123) #123を表示します。
x = print (456) #456を表示し、xにNoneを代入します。
y= None #Noneを変数yに代入します。

#以下の二つは等価ですが、結果が異なる。
print(123, 456) #123と456を表示します。
x= print (789, 0)<|endoftext|>def factorial(n): # 階乗を求める関数の定義
if n == 1: # もし、引数が１であれば
return 1 # １を返す。
else : # そうでない場合を表現する。
return n * factorial(n - 1) # n と factorial()関数に対して引数nから
1を引いた値の積を返す。<|endoftext|>def frac(x, y):# 分数を出力する関数の定
義
m = x / gcd(x,y) # mに分子の値を代入する。
n = y / gcd(x,y) # nに分母の値を代入する。
return [int (m), int (n)] # 分数を返す。
def gcd(a, b): #最大公約数を求める関数の定義
while a % b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更す
る。
a, b = b, (a % b) # 変数の入れ替え。
return int(b)<|endoftext|>def gcd(x, y): # 最大公約数を求める。
while x%y: x, y = y, (x % y) # xが割り切れなくなるまで繰り返し変数[x]と
変数[y]の入れ替えを行う。(ユークリッド互除法)
return int (y)<|endoftext|>def frac(x, y): # 分数を出力する関数の定義
m = x / gcd(x,y) # mに分子の値を代入する。
n = y / gcd(x,y) # nに分母の値を代入する。
return [int (m), int (n)] # 分数を返す。
def gcd(a, b): #最大公約数を求める関数の定義
while a % b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更す
る。
a, b = b, (a % b) # 変数の入れ替え。
return int(b)<|endoftext|>#!/usr/bin/env python3.6
#-- coding: utf-8 --

def frac(x, y): # 分数を出力する関数の定義
m = x / gcd(x,y) # mに分子の値を代入する。
n = y / gcd(x,y) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。
def gcd(a, b): #最大公約数を求める関数の定義
while a % b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更す
る。
a, b = b, (a % b) # 変数の入れ替え。
return int(b)<|endoftext|>def frac(x, y): # 分数を出力する関数の定義
m = x / gcd(x,y) # mに分子の値を代入する。
n = y / gcd(x,y) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。
def gcd(a, b): #最大公約数を求める関数の定義
while a % b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更す
る。
a, b = b, (a % b) # 変数の入れ替え。
return int(b)<|endoftext|>def gcd(x, y): # 最大公約数を求める
while x%y: # aに対してbで割り切れない間繰返し変数[a]と変数[b]の入れ替え
。(ユークリッド互除法)
x, y = y, (x % y) # 変数の入れ替え
return int(y)<|endoftext|>def frac(x, y): # 分数を出力する関数の定義
m = x / gcd(x,y) # mに分子の値を代入する。
n = y / gcd(x,y) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。
def gcd(a, b): #最大公約数を求める関数の定義
while a % b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更す
る。
a, b = b, (a % b) # 変数の入れ替え。
return int(b)<|endoftext|>def gcd(x, y): #最大公約数を求める関数の定義
while x%y: # aに対してbで割り切れない間繰返し変数[a]と変数[b]の入れ替
え。(ユークリッド互除法)
x, y = y, (x % y) # 変数の入れ替え。
return int(y)<|endoftext|>def gcd(a, b): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
a, b = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x, y): # 分数を出力する関数の定義
m = x / gcd(x,y) # mに分子の値を代入する。
n = y / gcd(x,y) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。
def gcd(a, b): #最大公約数を求める関数の定義
while a % b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更
する。(ユークリッド互除法)
a, b = b, (a % b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x, y): # 分数を出力する関数の定義
m = x / gcd(x,y) # mに分子の値を代入する。
n = y / gcd(x,y) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。
def gcd(a, b): #最大公約数を求める関数の定義
while a % b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更
する。(ユークリッド互除法)
a, b = b, (a % b) # 変数の入れ替え。
return int(y)<|endoftext|>def gcd(x, y): #最大公約数を求める関数の定義
while x%y: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更す
る。(ユークリッド互除法)
x, y = y, (x % y) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(numerator, denominator): # 分数を出
力する関数の定義
m = numerator / gcd(numerator,denominator) # mに分子の値を代入する。
n = denominator / gcd(numerator,denominator) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。
def gcd(a, b): #最大公約数を求める関数の定義
while a % b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更す
る。(ユークリッド互除法)
a, b = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x, y): # 分数を出力する関数の定義
m = numerator / gcd(numerator,denominator) # mに分子の値を代入する。
n = denominator / gcd(numerator,denominator) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。
def gcd(a, b): #最大公約数を求める関数の定義
while a % b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更す
る。(ユークリッド互除法)
a, b = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(numerator, denominator): # 分数を出
力する関数の定義
m = numerator / gcd(numerator,denominator) # mに分子の値を代入する。
n = denominator / gcd(numerator,denominator) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。
def gcd(a, b): #最大公約数を求める関数の定義
while a % b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更す
る。(ユークリッド互除法)
a, b = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def gcd(x, y): #最大公約数を求める関数の定義
while x % y: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更す
る。(ユークリッド互除法)
x, y = y, (x % y) # 変数の入れ替え。
return int(y)<|endoftext|>def gcd(a, b): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
a, b = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def gcd(x, y): #最大公約数を求める関数の定義
while x % y: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更す
る。(ユークリッド互除法)
x, y = y, (x % y) # 変数の入れ替え。
return int(y)<|endoftext|>def gcd(a, b): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
a, b = y, (x % y) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(numerator, denominator): # 分数を出
力する関数の定義
m = numerator / gcd(a,b) # mに分子の値を代入する。
n = denominator / gcd(a, b) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。
def gcd(x, y): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def gcd(x, y): #最大公約数を求める関数の定義
while x % y: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = y, (x % y) # 変数の入れ替え。
return int(y)<|endoftext|>def gcd(a, b): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def gcd(numerator, denominator): # 分数を出力
する関数の定義
m = numerator / gcd(a,b) # mに分子の値を代入する。
n = denominator / gcd(a, b) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。
def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(numerator, denominator): # 分数を出
力する関数の定義
m = numerator / gcd(a,b) # mに分子の値を代入する。
n = denominator / gcd(a, b) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。
def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def gcd(numerator, denominator): # 分数を出力
する関数の定義
m = numerator / gcd(a,b) # mに分子の値を代入する。
n = denominator / gcd(a, b) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。<|endoftext|>def gcd(x, y):
#最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(numerator, denominator): # 分数を出
力する関数の定義
m = numerator / gcd(a,b) # mに分子の値を代入する。
n = denominator / gcd(a, b) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。<|endoftext|>def frac(x):
#最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(numerator, denominator): # 分数を出
力する関数の定義
m = numerator / gcd(a,b) # mに分子の値を代入する。
n = denominator / gcd(a, b) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。<|endoftext|>def frac(x):
#最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def gcd(numerator, denominator): # 分数を出力
する関数の定義
m = numerator / gcd(a,b) # mに分子の値を代入する。
n = denominator / gcd(a, b) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。<|endoftext|>def frac(x):
#最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(numerator, denominator): # 分数を出
力する関数の定義
m = numerator / gcd(a,b) # mに分子の値を代入する。
n = denominator / gcd(a, b) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。<|endoftext|>def frac(x):
#最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(numerator, denominator): # 分数を出
力する関数の定義
m = numerator / gcd(a,b) # mに分子の値を代入する。
n = denominator / gcd(a, b) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。<|endoftext|>def frac(x):
#最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def gcd(numerator, denominator): # 分数を出力
する関数の定義
m = numerator / gcd(a,b) # mに分子の値を代入する。
n = denominator / gcd(a, b) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。<|endoftext|>def frac(x):
#最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(numerator, denominator): # 分数を出
力する関数の定義
m = numerator / gcd(a,b) # mに分子の値を代入する。
n = denominator / gcd(a, b) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。<|endoftext|>def frac(x):
#最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(numerator, denominator): # 分数を出
力する関数の定義
m = numerator / gcd(a,b) # mに分子の値を代入する。
n = denominator / gcd(a, b) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。<|endoftext|>def frac(x):
#最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(numerator, denominator): # 分数を出
力する関数の定義
m = numerator / gcd(a,b) # mに分子の値を代入する。
n = denominator / gcd(a, b) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。<|endoftext|>def frac(x):
#最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(numerator, denominator): # 分数を出
力する関数の定義
m = numerator / gcd(a,b) # mに分子の値を代入する。
n = denominator / gcd(a, b) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。<|endoftext|>def frac(x):
#最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(numerator, denominator): # 分数を出
力する関数の定義
m = numerator / gcd(a,b) # mに分子の値を代入する。
n = denominator / gcd(a, b) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。<|endoftext|>def frac(x):
#最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(numerator, denominator): # 分数を出
力する関数の定義
m = numerator / gcd(a,b) # mに分子の値を代入する。
n = denominator / gcd(a, b) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。<|endoftext|>def frac(x):
#最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(numerator, denominator): # 分数を出
力する関数の定義
m = numerator / gcd(a,b) # mに分子の値を代入する。
n = denominator / gcd(a, b) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。<|endoftext|>def frac(x):
#最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(numerator, denominator): # 分数を出
力する関数の定義
m = numerator / gcd(a,b) # mに分子の値を代入する。
n = denominator / gcd(a, b) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。<|endoftext|>def frac(x):
#最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(numerator, denominator): # 分数を出
力する関数の定義
m = numerator / gcd(a,b) # mに分子の値を代入する。
n = denominator / gcd(a, b) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。<|endoftext|>def frac(x):
#最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(numerator, denominator): # 分数を出
力する関数の定義
m = numerator / gcd(a,b) # mに分子の値を代入する。
n = denominator / gcd(a, b) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。<|endoftext|>def frac(x):
#最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(numerator, denominator): # 分数を出
力する関数の定義
m = numerator / gcd(a,b) # mに分子の値を代入する。
n = denominator / gcd(a, b) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。<|endoftext|>def frac(x):
#最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(numerator, denominator): # 分数を出
力する関数の定義
m = numerator / gcd(a,b) # mに分子の値を代入する。
n = denominator / gcd(a, b) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。<|endoftext|>def frac(x):
#最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(numerator, denominator): # 分数を出
力する関数の定義
m = numerator / gcd(a,b) # mに分子の値を代入する。
n = denominator / gcd(a, b) # nに分母の値を代入する。
return [int (m) , int (n)] # 分数を返す。<|endoftext|>def frac(x):
#最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。
return int(y)<|endoftext|>def frac(x): #最大公約数を求める関数の定義
while a%b: # aに対してbで割り切れない間繰返し変数[a]と変数[b]を変更する
。(ユークリッド互除法)
x, y = b, (a%b) # 変数の入れ替え。^C

Send a message (/? for help)