90.0% ≤ sim ≤ 100%

HW02

Top-Level Statements: 12 clusters, 39 submissions

>> cluster #1(7)
# 6631509021 (point = 100.0%) sim = 100%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
n = int(input())
lift = []
burden = []
for i in range(1000):
  lift.append([])
  burden.append(0)
for i in range(n):
  k,a,b = map(int,input().split())
  lift[k]=[a,b]
m = int(input())
while m>0:
  m -= 1
  mn = 2e9
  s,e = map(int,input().split())
  for i in range(1,n+1,1):
    if lift[i][0] > lift[i][1]:
      if s <= lift[i][0] and s >= lift[i][1]:
        burden[i] = abs(e-lift[i][1])
      else:
        burden[i] = abs(s-lift[i][1])+abs(e-s)
      mn = min(mn,burden[i])
    elif lift[i][0] < lift[i][1]:
      if s >= lift[i][0] and s <= lift[i][1]:
        burden[i] = abs(e-lift[i][1])
      else:
        burden[i] = abs(s-lift[i][1]) + abs(e-s)
      mn = min(mn,burden[i])
    else:
      burden[i] = abs(s-lift[i][1]) + abs(e-s)
      mn = min(mn,burden[i])
  for i in range(1,n+1,1):
    if(mn == burden[i]):
      print(f'>> {i}')
      break
# 6631133721 (point = 100.0%) sim = 100%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
n = int(input())
lift = []
burden = []
for i in range(1000):
  lift.append([])
  burden.append(0)
for i in range(n):
  k,a,b = map(int,input().split())
  lift[k]=[a,b]
m = int(input())
while m>0:
  m -= 1
  mn = 2e9
  s,e = map(int,input().split())
  for i in range(1,n+1,1):
    if lift[i][0] > lift[i][1]:
      if s <= lift[i][0] and s >= lift[i][1]:
        burden[i] = abs(e-lift[i][1])
      else:
        burden[i] = abs(s-lift[i][1])+abs(e-s)
      mn = min(mn,burden[i])
    elif lift[i][0] < lift[i][1]:
      if s >= lift[i][0] and s <= lift[i][1]:
        burden[i] = abs(e-lift[i][1])
      else:
        burden[i] = abs(s-lift[i][1]) + abs(e-s)
      mn = min(mn,burden[i])
    else:
      burden[i] = abs(s-lift[i][1]) + abs(e-s)
      mn = min(mn,burden[i])
  for i in range(1,n+1,1):
    if(mn == burden[i]):
      print(f'>> {i}')
      break
# 6631027921 (point = 100.0%) sim = 100%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
n = int(input())
Lift = []
load = []
for i in range(n+1):
  Lift.append([])
  load.append(0)
for i in range(n):
  x,y,z = map(int,input().split())
  Lift[x]=[y,z]
k = int(input())
while k>0:
  k -= 1
  a,b = map(int,input().split())
  lowest = int(3000)
  for i in range(1,n+1):
    if Lift[i][0]>Lift[i][1]:
      if a <= Lift[i][0] and a >= Lift[i][1]:
        load[i] = abs(b - Lift[i][1])
      else:
        load[i] = abs(a-Lift[i][1])+abs(a-b)
      lowest = min(lowest,load[i])
    elif Lift[i][0]<Lift[i][1]:
      if a >= Lift[i][0] and a <= Lift[i][1]:
        load[i] = abs(b - Lift[i][1])
      else:
        load[i] = abs(a-Lift[i][1])+abs(a-b)
      lowest = min(lowest,load[i])
    else:
      load[i] = abs(a-Lift[i][0])+abs(a-b)
    lowest = min(lowest,load[i])
  for i in range(1,n+1):
   if lowest == load[i]:
      print (f'>> {i}')
      break
# 6630056921 (point = 100.0%) sim = 100%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
n = int(input()) #รับค่า จำนวน ลิฟต์
Lift = []
Para = [] #ภาระ
for i in range(n+1):
  Lift.append([])
  Para.append(0)
for i in range(n):
  k,a,b = map(int,input().split())
  Lift[k]=[a,b]
m = int(input())
while m>0:
  m -= 1
  p,q = map(int,input().split())
  Ele = int(3000)
  for i in range(1,n+1):
    if Lift[i][0]>Lift[i][1]:
      if p <= Lift[i][0] and p >= Lift[i][1]:
        Para[i] = abs(q - Lift[i][1])
      else:
        Para[i] = abs(p-Lift[i][1])+abs(p-q)
      Ele = min(Ele,Para[i])
    elif Lift[i][0]<Lift[i][1]:
      if p >= Lift[i][0] and p <= Lift[i][1]:
        Para[i] = abs(q - Lift[i][1])
      else:
        Para[i] = abs(p-Lift[i][1])+abs(p-q)
      Ele = min(Ele,Para[i])
    else:
      Para[i] = abs(p-Lift[i][0])+abs(p-q)
    Ele = min(Ele,Para[i])
  for i in range(1,n+1):
   if Ele == Para[i]:
      print (f'>> {i}')
      break
# 6631501021 (point = 100.0%) sim = 99%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
n = int(input())
x = []
y = []
for i in range(100):
    x.append([])
    y.append(0)
for i in range(n):
    a,b,c = map(int,input().split())
    x[a]=[b,c]
m = int(input())
while m>0:
    m-=1
    xx= 100
    z,d = map(int,input().split())
    for i in range(1,n+1,1):
        if x[i][0] > x[i][1]:
            if z <= x[i][0] and z >= x[i][1]:
                y[i] = abs(d-x[i][1])
            else:
                y[i] = abs(z-x[i][1])+abs(d-z)
            xx = min(xx,y[i])
        else :
            if x[i][0] < x[i][1]:
                if z >= x[i][0] and z <= x[i][1]:
                    y[i] = abs(d-x[i][1])
                else:
                    y[i] = abs(z-x[i][1]) + abs(d-z)
                xx = min(xx,y[i])
            else:
                y[i] = abs(z-x[i][1]) + abs(d-z)
                xx = min(xx,y[i])
    for i in range(1,n+1,1):
        if(xx == y[i]):
            print(f'>> {i}')
            break
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
# 6631126321 (point = 100.0%) sim = 98%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
n = int(input())
lift = []
burden = []
for i in range(1000):
  lift.append([])
  burden.append(0)
for i in range(n):
   a,b,c = map(int,input().split())
   lift[a]=[b,c]
m = int(input())
while m>0:
  m -= 1
  mn = 2e9
  x,y = map(int,input().split())
  for i in range(1,n+1,1):
    if lift[i][0] > lift[i][1]:
      if x <= lift[i][0] and x >= lift[i][1]:
        burden[i] = abs(y-lift[i][1])
      else:
        burden[i] = abs(x-lift[i][1])+abs(x-y)
      mn = min(mn,burden[i])
    elif lift[i][0] < lift[i][1]:
      if x >= lift[i][0] and x <= lift[i][1]:
        burden[i] = abs(y-lift[i][1])
      else:
        burden[i] = abs(x-lift[i][1]) + abs(x-y)
      mn = min(mn,burden[i])
    else:
      burden[i] = abs(x-lift[i][1]) + abs(x-y)
      mn = min(mn,burden[i])
  for i in range(1,n+1,1):
    if(mn == burden[i]):
      print(f'>> {i}')
      break
# 6630063221 (point = 100.0%) sim = 93%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
n=int(input())
b =[]
l =[]
for i in range(10000):
  b.append(0)
  l.append([])
for i in range(n):
  k,a,bb = map(int,input().split())
  l[k]=[a,bb]
m=int(input())
for i in range(m):
  mn=2e9
  s,e=map(int,input().split())
  for k in range(1,n+1):
    if l[k][0]>l[k][1]:
      if s<=l[k][0]and s >=l[k][1]:
        b[k]=abs(e-l[k][1])
      else:
        b[k]=abs(s-l[k][1])+abs(e-s)
      mn=min(mn,b[k])
    elif l[k][0]<l[k][1]:
      if s>=l[k][0]and s<=l[k][1]:
        b[k]=abs(e-l[k][1])
      else:
        b[k]=abs(s-l[k][1])+abs(e-s)
      mn=min(mn,b[k])
    else:
      b[k]=abs(s-l[k][1])+abs(e-s)
      mn=min(mn,b[k])
  for k in range(1,n+1):
     if(mn==b[k]):
      print(f'>> {k}')
      break

>> cluster #2(5)
# 6631139521 (point = 100.0%) sim = 100%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
number=int(input())
a=[0]*number
b=[0]*number
c=[0]*number
for i in range(number):
            x,y,z=input().split()
            a[i]=int(x)
            b[i]=int(y)
            c[i]=int(z)
step_lift=int(input())
d=[0]*step_lift
e=[0]*step_lift
for i in range(step_lift):
            r,n=input().split()
            d[i]=int(r)
            e[i]=int(n)
        #test case math
cal1=[0]*number
for i in range(step_lift):
            for j in range(number):
                if b[j]<=d[i] and c[j]>=d[i]:
                    cal=abs(c[j]-e[i])
                elif b[j]>=d[i] and c[j]<=d[i]:
                    cal=abs(c[j]-e[i])
                elif d[i]<=b[j] and d[i]>=c[j] and e[i]<=b[j] and e[i]>=c[j]:
                    cal=0
                elif d[i]>=b[j] and d[i]<=c[j] and e[i]>=b[j] and e[i]<=c[j]:
                    cal=0
                else :
                    cal=abs(abs(d[i]-c[j])+abs(e[i]-d[i]))
                cal1[j]=cal
            x=number
            for j in range(number):
                if min(cal1)==cal1[j]:
                    if a[j]<=x:
                        x=a[j]
            print(">>",x)
# 6631007321 (point = 100.0%) sim = 100%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
n = int(input())
u = [0]*n
v = [0]*n
w = [0]*n
for i in range(n):
  f,g,h = input().split()
  u[i] = int(f)
  v[i] = int(g)
  w[i] = int(h)
m = int(input())
s = [0]*m
t = [0]*m
for i in range(m):
  p,q = input().split()
  s[i] = int(p)
  t[i] = int(q)
sleep = [0]*n
for i in range(m):
  for j in range(n):
      if v[j]<=s[i] and w[j]>=s[i]:
          KNK = abs(w[j]-t[i])
      elif v[j]>=s[i] and w[j]<=s[i]:
          KNK = abs(w[j]-t[i])
      elif s[i]<=v[j] and s[i]>=w[j] and t[i]<=v[j] and t[i]>=w[j]:
          KNK = 0
      elif s[i]>=v[j] and s[i]<=w[j] and t[i]>=v[j] and t[i]<=w[j]:
          KNK = 0
      else :
          KNK = abs(abs(s[i]-w[j])+abs(t[i]-s[i]))
      sleep[j] = KNK
  NK = n
  for j in range(n):
      if min(sleep) == sleep[j]:
          if u[j]<=NK:
              NK = u[j]
  print('>>',NK)
# 6630089621 (point = 100.0%) sim = 100%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
l=int(input())
a=[0]*l
b=[0]*l
c=[0]*l
for i in range(l):
  d,e,f=input().split()
  a[i]=int(d)
  b[i]=int(e)
  c[i]=int(f)
q=int(input())
g=[0]*q
h=[0]*q
for i in range(q):
  k,m=input().split()
  g[i]=int(k)
  h[i]=int(m)
loadall=[0]*l
for i in range(q):
    for j in range(l):
        if b[j]<=g[i] and c[j]>=g[i]:
            load=abs(c[j]-h[i])
        elif b[j]>=g[i] and c[j]<=g[i]:
            load=abs(c[j]-h[i])
        elif g[i]<=b[j] and g[i]>=c[j] and h[i]<=b[j] and h[i]>=c[j]:
            load=0
        elif g[i]>=b[j] and g[i]<=c[j] and h[i]>=b[j] and h[i]<=c[j]:
            load=0
        else :
            load=abs(abs(g[i]-c[j])+abs(h[i]-g[i]))
        loadall[j]=load
    x=l
    for j in range(l):
       if min(loadall)==loadall[j]:
              if a[j]<=x:
                   x=a[j]
    print(">>",x)
# 6630088021 (point = 100.0%) sim = 100%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
number=int(input())
a=[0]*number
b=[0]*number
c=[0]*number
for i in range(number):
    x,y,z=input().split()
    a[i]=int(x)
    b[i]=int(y)
    c[i]=int(z)
jumnungchan=int(input())
d=[0]*jumnungchan
e=[0]*jumnungchan
for i in range(jumnungchan):
    r,n=input().split()
    d[i]=int(r)
    e[i]=int(n)
#test case math
cal1=[0]*number
for i in range(jumnungchan):
    for j in range(number):
        if b[j]<=d[i] and c[j]>=d[i]:
            cal=abs(c[j]-e[i])
        elif b[j]>=d[i] and c[j]<=d[i]:
            cal=abs(c[j]-e[i])
        elif d[i]<=b[j] and d[i]>=c[j] and e[i]<=b[j] and e[i]>=c[j]:
            cal=0
        elif d[i]>=b[j] and d[i]<=c[j] and e[i]>=b[j] and e[i]<=c[j]:
            cal=0
        else :
            cal=abs(abs(d[i]-c[j])+abs(e[i]-d[i]))
        cal1[j]=cal
    x=number
    for j in range(number):
        if min(cal1)==cal1[j]:
            if a[j]<=x:
                x=a[j]
    print(">>",x)
# 6630067821 (point = 100.0%) sim = 100%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
number=int(input())
a=[0]*number
b=[0]*number
c=[0]*number
for i in range(number):
    x,y,z=input().split()
    a[i]=int(x)
    b[i]=int(y)
    c[i]=int(z)
zen=int(input())
d=[0]*zen
e=[0]*zen
for i in range(zen):
    r,n=input().split()
    d[i]=int(r)
    e[i]=int(n)
#test case math
cal1=[0]*number
for i in range(zen):
    for j in range(number):
        if b[j]<=d[i] and c[j]>=d[i]:
            cal=abs(c[j]-e[i])
        elif b[j]>=d[i] and c[j]<=d[i]:
            cal=abs(c[j]-e[i])
        elif d[i]<=b[j] and d[i]>=c[j] and e[i]<=b[j] and e[i]>=c[j]:
            cal=0
        elif d[i]>=b[j] and d[i]<=c[j] and e[i]>=b[j] and e[i]<=c[j]:
            cal=0
        else :
            cal=abs(abs(d[i]-c[j])+abs(e[i]-d[i]))
        cal1[j]=cal
    x=number
    for j in range(number):
        if min(cal1)==cal1[j]:
            if a[j]<=x:
                x=a[j]
    print(">>",x)

>> cluster #3(4)
# 6632078021 (point = 100.0%) sim = 100%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
n=int(input())
number=[0]*n
numnow=[0]*n
numlast=[0]*n
for u in range(n):
    x = input().split()
    number[u]=int(x[0])
    numnow[u]=int(x[1])
    numlast[u]=int(x[2])
m=int(input())
kodlift=[0]*m
wantgo=[0]*m
for me in range(m):
    x=input().split()
    kodlift[me]=int(x[0])
    wantgo[me]=int(x[1])
for me in range(m) :
    distance = 0
    ans1 = 0
    ans2 = 0
    for u in range (n) :
        if (numnow[u] <=  kodlift[me] <= wantgo[me] <= numlast[u]) or (numnow[u] >=  kodlift[me] >= wantgo[me] >= numlast[u])  :
            distance = 0
        elif (numnow[u] <=  kodlift[me] <= numlast[u] <= wantgo[me]) or (numnow[u] >=  kodlift[me] >= numlast[u] >= wantgo[me]) :
            distance = abs(wantgo[me]-numlast[u])
        else :
            distance = abs(numlast[u]-kodlift[me]) + abs(kodlift[me]-wantgo[me])
        if u == 0 or distance < ans1:
            ans1 = distance
            ans2 = number[u]
    print('>>',ans2)
# 6631229321 (point = 100.0%) sim = 100%
2 # HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
n = int(input())
lift = [0]*n
bl = [0]*n
stopl = [0]*n
for i in range(n) :
    a = input().split()
    lift[i]=int(a[0])
    bl[i]=int(a[1])
    stopl[i]=int(a[2])
m = int(input())
bu = [0]*m
stopu = [0]*m
for j in range(m) :
    a = input().split()
    bu[j]=int(a[0])
    stopu[j]=int(a[1])
for j in range(m) :
    dist = 0
    min_d = 0
    min_l = 0
    for i in range(n) :
        if (bl[i] <= bu[j] <= stopu[j] <= stopl[i]) or (bl[i] >= bu[j] >= stopu[j] >= stopl[i]) :
            dist = 0
        elif (bl[i] <= bu[j] <= stopl[i] <= stopu[j]) or (bl[i] >= bu[j] >= stopl[i] >= stopu[j]):
            dist = abs(stopu[j]-stopl[i])
        else :
            dist = abs(stopl[i]-bu[j])+ abs(bu[j]-stopu[j])
        if i == 0 or dist < min_d :
            min_d = dist
            min_l = lift[i]
    print('>>',min_l)
# 6630002021 (point = 100.0%) sim = 100%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
n = int(input())
num_ele = [0]*n
elenow = [0]*n
elegoto = [0]*n
for i in range(n) :
    e = input().split()
    num_ele[i] = int(e[0])
    elenow[i] = int(e[1])
    elegoto[i] = int(e[2])
m = int(input())
floor = [0]*m
st_floor = [0]*m
for k in range(m) :
    e = input().split()
    floor[k] = int(e[0])
    st_floor[k] = int(e[1])
for k in range(m) :
    work = 0
    delt_1 = 0
    delt_2 = 0
    for i in range (n) :
        if (elenow[i] <= floor[k] <= st_floor[k] <= elegoto[i]) or (elenow[i] >= floor[k] >= st_floor[k] >= elegoto[i]) :
            work = 0
        elif (elenow[i] <= floor[k] <= elegoto[i] <= st_floor[k]) or (elenow[i] >= floor[k] >= elegoto[i] >= st_floor[k]) :
            work = abs(st_floor[k]-elegoto[i])
        else :
            work = abs(elegoto[i]-floor[k]) + abs(floor[k]-st_floor[k])
        if i == 0 or work < delt_1 :
            delt_1 = work
            delt_2 = num_ele[i]
    print('>>',delt_2)
# 6630024821 (point = 100.0%) sim = 91%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
n = int(input()) ; lift_n = [0]*n ; start = [0]*n ; stop = [0]*n
for i in range(n) :
    m = input().split()
    lift_n[i]=int(m[0]) ; start[i]=int(m[1]) ; stop[i]=int(m[2])
N = int(input())
stay = [0]*N
go = [0]*N
for I in range(N) :
    M = input().split()
    stay[I]=int(M[0]) ; go[I]=int(M[1])
    #endinput
for e in range(N) :
    delta = 0 ; d = 0 ;l = 0
    for i in range(n) :
        if (start[i] <= stay[e] <= go[e] <= stop[i]) or             (start[i] >= stay[e] >= go[e] >= stop[i]) :
            delta = 0
        elif (start[i] <= stay[e] <= stop[i] <= go[e]) or               (start[i] >= stay[e] >= stop[i] >= go[e]):
            delta = abs(go[e]-stop[i])
        else :
            delta = abs(stop[i]-stay[e]) + abs(stay[e]-go[e])
        if i == 0 or delta < d :
            d = delta
            l = lift_n[i]
    print('>>',l)

>> cluster #4(4)
# 6631532421 (point = 100.0%) sim = 100%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
#จำนวนลิฟต์ที่มี
n = int(input())
elevator = []
start_elevator = []
end_elevator = []
for i in range(n):
    elevator_data = input().split()
    elevator.append(int(elevator_data[0]))
    start_elevator.append(int(elevator_data[1]))
    end_elevator.append(int(elevator_data[2]))
#จำนวนคำถามที่มี
m = int(input())
current_floor = []
target_floor = []
for i in range(m):
    my_data = input().split()
    current_floor.append(int(my_data[0]))
    target_floor.append(int(my_data[1]))
#เงื่อนไข
for i in range(m):
    elevator_list = []
    for j in range(n):
        my_target = target_floor[i] - current_floor[i]
        elevator_target = end_elevator[j] - start_elevator[j]
        if elevator_target < 0 and my_target < 0:
            if end_elevator[j] <= target_floor[i]              <= current_floor[i] <= start_elevator[j]:
                elevator_list.append(0)
            elif end_elevator[j] <= current_floor[i]              <= start_elevator[j]:
                elevator_list.append(abs(target_floor[i] - end_elevator[j]))
            else:
                elevator_list.append(abs(end_elevator[j] - current_floor[i])                              + abs(current_floor[i] - target_floor[i]))
        elif elevator_target > 0 and my_target > 0:
            if start_elevator[j] <= current_floor[i]              <= target_floor[i] <= end_elevator[j]:
                elevator_list.append(0)
            elif start_elevator[j] <= current_floor[i]              <= end_elevator[j]:
                elevator_list.append(abs(target_floor[i] - end_elevator[j]))
            else:
                elevator_list.append(abs(end_elevator[j] - current_floor[i])                              + abs(current_floor[i] - target_floor[i]))
        else:
            elevator_list.append(abs(end_elevator[j] - current_floor[i])                          + abs(current_floor[i] - target_floor[i]))
    min_workload = min(elevator_list)
    best_elevator = elevator[elevator_list.index(min_workload)]
    print(">>", best_elevator)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
# 6630220421 (point = 100.0%) sim = 100%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
n = int(input())
num_lift = []
start_lift = []
end_lift = []
for i in range(n) :
    a1 = input().split()
    num_lift.append(int(a1[0]))
    start_lift.append(int(a1[1]))
    end_lift.append(int(a1[2]))
m =int(input())
start_me = []
end_me = []
for i in range(m) :
    a2 = input().split()
    start_me.append(int(a2[0]))
    end_me.append(int(a2[1]))
for i in range(m) :
    para = []
    for p in range(n) :
        direc_me = end_me[i] - start_me[i]
        direc_lift = end_lift[p] - start_lift[p]
        if direc_lift < 0 and direc_me < 0 :
            if end_lift[p] <=end_me[i] <= start_me[i] <=start_lift[p] :
                para.append(0)
            elif end_lift[p] <= start_me[i] <=start_lift[p] :
                para.append(abs(end_me[i] - end_lift[p]))
            else :
                para.append(abs(end_lift[p] - start_me[i]) + abs(start_me[i] - end_me[i]))
        elif direc_lift > 0 and direc_me > 0 :
            if start_lift[p]<= start_me[i] <= end_me[i] <= end_lift[p] :
                para.append(0)
            elif start_lift[p] <= start_me[i] <= end_lift[p] :
                para.append(abs(end_me[i] - end_lift[p]))
            else :
                para.append(abs(end_lift[p] -start_me[i]) + abs(start_me[i] - end_me[i]))
        else :
            para.append(abs(end_lift[p] - start_me[i]) + abs(start_me[i] - end_me[i]))
    min_para = min(para)
    ans = num_lift[para.index(min_para)]
    print('>>', ans )
# 6630072921 (point = 100.0%) sim = 100%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
n = int(input())
num_lift = []
start_lift = []
end_lift = []
for i in range(n):
    d1 = input().split()
    num_lift.append(int(d1[0]))
    start_lift.append(int(d1[1]))
    end_lift.append(int(d1[2]))
m = int(input())
start_me = []
end_me = []
for i in range(m):
    d2 = input().split()
    start_me.append(int(d2[0]))
    end_me.append(int(d2[1]))
for i in range(m):
    para = []
    for k in range(n):
        direc_me = end_me[i] - start_me[i]
        direc_lift = end_lift[k] - start_lift[k]
        if direc_lift < 0 and direc_me < 0:
            if end_lift[k] <= end_me[i] <= start_me[i] <= start_lift[k]:
                para.append(0)
            elif end_lift[k] <= start_me[i] <= start_lift[k]:
                para.append(abs(end_me[i] - end_lift[k]))
            else:
                para.append(abs(end_lift[k] - start_me[i]) + abs(start_me[i] - end_me[i]))
        elif direc_lift > 0 and direc_me > 0:
            if start_lift[k] <= start_me[i] <= end_me[i] <= end_lift[k]:
                para.append(0)
            elif start_lift[k] <= start_me[i] <= end_lift[k]:
                para.append(abs(end_me[i] - end_lift[k]))
            else:
                para.append(abs(end_lift[k] - start_me[i]) + abs(start_me[i] - end_me[i]))
        else:
            para.append(abs(end_lift[k] - start_me[i]) + abs(start_me[i] - end_me[i]))
    min_para = min(para)
    ans = num_lift[para.index(min_para)]
    print('>>', ans)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
# 6630044321 (point = 100.0%) sim = 91%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
n = int(input())
x = []
y = []
num_elevator = []
elevator_start = []
elevator_end = []
human_start = []
human_end = []
for i in range(n) :
  x = input().split()
  num_elevator.append(int(x[0]))
  elevator_start.append(int(x[1]))
  elevator_end.append(int(x[2]))
m = int(input())
for i in range(m) :
  y = input().split()
  human_start.append(int(y[0]))
  human_end.append(int(y[1]))
for i in range(m) :
  lift = []
  for j in range(n) :
    drh = human_end[i] - human_start[i]
    dre = elevator_end[j] - elevator_start[j]
    if dre < 0 and drh < 0 :
      if elevator_end[j] <= human_end[i] <= human_start[i] <= elevator_start[j] :
        lift.append(0)
      elif elevator_end[j] <= human_start[i] <= elevator_start[j] :
        lift.append(abs(human_end[i] - elevator_end[j]))
      else:
        lift.append(abs(elevator_end[j] - human_start[i]) + abs(human_start[i] - human_end[i]))
    elif dre > 0 and drh > 0:
      if elevator_start[j] <= human_start[i] <= human_end[i] <= elevator_end[j]:
        lift.append(0)
      elif elevator_start[j] <= human_start[i] <= elevator_end[j]:
        lift.append(abs(human_end[i] - elevator_end[j]))
      else :
        lift.append(abs(elevator_end[j] - human_start[i]) + abs(human_start[i] - human_end[i]))
    else:
      lift.append(abs(elevator_end[j] - human_start[i]) + abs(human_start[i] - human_end[i]))
  lift_chosen = num_elevator[lift.index(min(lift))]
  print('>>', lift_chosen)

>> cluster #5(2)
# 6631511221 (point = 88.67%) sim = 100%
def func(now,end):
    sum = 0
    mini = 999e100
    ans = 0
    for i in range(lift):
        liftstart = liststart[i]
        liftend = listend[i]
        if now >= liftstart and now <= liftend and end >= now and liftend >= liftstart:
            if end > liftend:
                sum = end - liftend
            else:
                sum = 0
        elif now <= liftstart and now >= liftend and end <= now and liftend <= liftstart:
            if end < liftend:
                sum = liftend - end
            else:
                sum = 0
        elif now >= liftend and end >= now:
            sum = (now - liftend) + (end - now)
        elif liftstart >= end and end >= now:
            if liftend > now:
                sum = (liftend - now) + (end - now)
            elif eleend < now:
                sum = (now - liftend) + (end - now)
        elif now <= liftend and end <= now:
            sum = (liftend - now) + (now - end)
        elif liftstart <= now and now >= end:
            if liftend < now:
                sum = (now - liftend) + (now - end)
            elif liftend > now:
                sum = (liftend - now) + (now - end)
        #print(sum)
        if mini > sum:
            mini = sum
            ans = i
    return ans+1
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
lift = int(input())
liststart = [0]*lift
listend = [0]*lift
for i in range(lift):
    x = input()
    s = x.split()
    liststart[int(s[0])-1]=int(s[1])
    listend[int(s[0])-1]=int(s[2])
#print(liststart[3])
question = int(input())
listtob = []
for i in range(question):
    x = input().split()
    now = x[0]
    end = x[1]
    ans = func(int(now),int(end))
    listtob.append(ans)
for i in range(int(question)):
    print(">>", listtob[i])
# 6631115421 (point = 88.67%) sim = 100%
def func(now,end):
    sum = 0
    mini = 999e100
    ans = 0
    for i in range(lift):
        liftstart = liststart[i]
        liftend = listend[i]
        if now >= liftstart and now <= liftend and end >= now and liftend >= liftstart:
            if end > liftend:
                sum = end - liftend
            else:
                sum = 0
        elif now <= liftstart and now >= liftend and end <= now and liftend <= liftstart:
            if end < liftend:
                sum = liftend - end
            else:
                sum = 0
        elif now >= liftend and end >= now:
            sum = (now - liftend) + (end - now)
        elif liftstart >= end and end >= now:
            if liftend > now:
                sum = (liftend - now) + (end - now)
            elif eleend < now:
                sum = (now - liftend) + (end - now)
        elif now <= liftend and end <= now:
            sum = (liftend - now) + (now - end)
        elif liftstart <= now and now >= end:
            if liftend < now:
                sum = (now - liftend) + (now - end)
            elif liftend > now:
                sum = (liftend - now) + (now - end)
        #print(sum)
        if mini > sum:
            mini = sum
            ans = i
    return ans+1
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
lift = int(input())
liststart = [0]*lift
listend = [0]*lift
for i in range(lift):
    x = input()
    s = x.split()
    liststart[int(s[0])-1]=int(s[1])
    listend[int(s[0])-1]=int(s[2])
#print(liststart[3])
question = int(input())
listtob = []
for i in range(question):
    x = input().split()
    now = x[0]
    end = x[1]
    ans = func(int(now),int(end))
    listtob.append(ans)
for i in range(int(question)):
    print(">>", listtob[i])

>> cluster #6(2)
# 6632174621 (point = 71.97%) sim = 100%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
n = int(input())
lifts = []
for _ in range(n):
    lift_info = list(map(int, input().split()))
    lifts.append(lift_info)
m = int(input())
best_lifts = []
for _ in range(m):
    current_floor, target_floor = map(int, input().split())
    min_workload = float('inf')
    best_lift = None
    # หาลิฟต์ที่เหมาะสมที่สุด
    for lift_num, current, target in lifts:
        if current == target:
                workload = abs(target - current_floor )+abs(current_floor-target_floor)
        else:
         if current < target:  # ลิฟต์ขึ้น
            if current <= current_floor <= target_floor:  # ถ้าคนอยู่ระหว่างชั้นที่ลิฟต์กำลังขึ้น
                workload = target_floor - (current_floor - current)
            elif current_floor < current:  # ถ้าคนอยู่ด้านล่างของลิฟต์
                workload = current + target + abs(current - current_floor) + abs(target - target_floor)
            else:  # ถ้าคนอยู่ด้านบนของลิฟต์
                workload = current_floor + target_floor + abs(current - current_floor) + abs(target - target_floor)
         else:  # ลิฟต์ลง
            if target_floor <= current_floor <= current:  # ถ้าเราอยู่ระหว่างชั้นที่ลิฟต์กำลังลง
                workload = current_floor - target_floor
            elif current < current_floor:  # ถ้าเราอยู่ด้านบนของลิฟต์
                workload = current + target + abs(current - current_floor) + abs(target - target_floor)
            else:  # ถ้าคนอยู่ด้านล่างของลิฟต์
                workload =  abs(current - current_floor) + abs(target - target_floor)
        if workload < min_workload:
            min_workload = workload
            best_lift = lift_num
    best_lifts.append(best_lift)
for answer in best_lifts:
    print(">>", answer)
# 6631006721 (point = 71.97%) sim = 100%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
n = int(input())
lifts = []
for _ in range(n):
    lift = list(map(int, input().split()))
    lifts.append(lift)
m = int(input())
best_lifts = []
for _ in range(m):
    K1, K2 = map(int, input().split())
    min_workload = float('inf')
    best_lift = None
    for  L1, L2, L3 in lifts:
        if L2 == L3:
            workload = abs(L3 - K1) + abs(K1 - K2)
        else:
            if L2 < L3:
                if L2 <= K1 <= K2:
                    workload = K2 - (K1 - L2)
                elif K1 < L2:
                    workload = L2 + L3 + abs(L2 - K1) + abs(L3 - K2)
                else:
                    workload = K1 + K2 + abs(L2 - K1) + abs(L3 - K2)
            else:
                if K2 <= K1 <= L2:
                    workload = K1 - K2
                elif L2 < K1:
                    workload = L2 + L3 + abs(L2 - K1) + abs(L3 - K2)
                else:
                    workload = abs(L2 - K1) + abs(L3 - K2)
        if workload < min_workload:
            min_workload = workload
            best_lift = L1
    best_lifts.append(best_lift)
for answer in best_lifts:
    print(">>", answer)

>> cluster #7(2)
# 6531809221 (point = 100.0%) sim = 100%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
n=int(input())
lift=[]
for i in range(n):
  lift.append(input().split())
m=int(input())
people=[]
for i in range(m):
  people.append(input().split())
for p in people:
  sp=int(p[0])
  ep=int(p[1])
  ans=[]
  for l in lift:
    sl=int(l[1])
    el=int(l[2])
    if min(sl,el)<=sp<=max(sl,el):
      if min(sl,el)<=ep<=max(sl,el):
        if (sp>ep and sl>el)or(sp<ep and sl<el):
          ans.append([0,l[0]])
        else:
          ans.append([abs(el-ep),l[0]])
      else:
        ans.append([abs(el-ep),l[0]])
    else:
      ans.append([abs(sp-el)+(abs(ep-sp)),l[0]])
  ans.sort()
  print('>>',str(ans[0][1]))
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
# 6530403921 (point = 100.0%) sim = 100%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
n = int(input())
l = []
for i in range(n):
  l.append(input().split())
m = int(input())
p = []
for i in range(m):
  p.append(input().split())
for q in p:
  x = int(q[0])
  y = int(q[1])
  z = []
  for t in l:
    a = int(t[1])
    b = int(t[2])
    if min(a,b) <= x <= max(a,b):
      if min(a,b) <= y <= max(a,b):
        if (x>y and a>b) or (x<y and a<b):
          z.append([0,t[0]])
        else:
          z.append([abs(b-y),t[0]])
      else:
        z.append([abs(b-y),t[0]])
    else:
      z.append([abs(x-b)+(abs(y-x)),t[0]])
  z.sort()
  print('>>',str(z[0][1]))
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้

>> cluster #8(4)
# 6631451221 (point = 61.27%) sim = 98%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
n = int(input())
x = []
for a in range(n) :
  m = input().split(' ')
  x.append(m)
k = int(input())
y = []
for a in range(k) :
  m = input().split(' ')
  y.append(m)
for i in range(0,len(y)) :
  w = y[i]
  q = []
  for j in range(0,len(x)) :
    r = x[j]
    if int( x[j][1] )>=int( x[j][2] ) and int( y[i][0] )>=int( y[i][1] ):
      if int( x[j][1] )>=int( y[i][0] ) and int( x[j][2] )>=int( y[i][1] ):
        b = abs( int( x[j][2] ) - int( y[i][1] ) )
        q.append(b)
      if int( x[j][1] )>=int( y[i][0] ) and int( x[j][2] )<=int( y[i][1] ):
        q.append(0)
    if int( x[j][1] )<=int( x[j][2] ) and int( y[i][0] )<=int( y[i][1] ):
      if int( x[j][1] )<=int( y[i][0] ) and int( x[j][2] )<=int( y[i][1] ):
        b = abs( int( x[j][2] ) - int( y[i][1] ) )
        q.append(b)
      if int( x[j][1] )<=int( y[i][0] ) and int( x[j][2] )>=int( y[i][1] ):
        q.append(0)
    else :
        b = abs( int( y[i][0] ) - int( x[j][2] ) ) + abs( int( y[i][1])  - int( y[i][0]) )
        q.append(b)
  print( '>>' , q.index(min(q)) + 1 )
# 6631221221 (point = 64.39%) sim = 98%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
L = int(input())
M=[]
for K in range(L):
  A = input().split(' ')
  M.append(A)
D = int(input())
S=[]
for T in range(D):
  U =input().split(' ')
  S.append(U)
for j in range(0,len(S)):
  q = S[j]
  D = []
  for i in range(0,len(M)):
    l = M[i]
    if int(M[i][1]) > int(M[i][2]) and int(S[j][0]) > int(S[j][1]):
       if int(M[i][1])>=int(S[j][0]) and int(M[i][2])>=int(S[j][1]):
           C=abs(int(M[i][2])-int(S[j][1]))
           D.append(C)
       if int(M[i][1])>=int(S[j][0])  and int(M[i][2])<=int(S[j][1]):
           D.append(0)
    if int(M[i][1])<=int(M[i][2])    and int(S[j][0])<=int(S[j][1]):
       if int(M[i][1])<=int(S[j][0]) and int(M[i][2])<=int(S[j][1]):
           C=abs(int(M[i][2])-int(S[j][1]))
           D.append(C)
       if int(M[i][1])<=int(S[j][0]) and int(M[i][2])>=int(S[j][1]):
           D.append(0)
    else:
      C=abs(int(S[j][0])-int(M[i][2])) + abs(int(S[j][1])-int(S[j][0]))
      D.append(C)
  print('>>',D.index(min(D))+1)
# 6631228721 (point = 76.89%) sim = 94%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
n = int(input())
f = []
for y in range( n ) :
  A = input().split(' ')
  f.append(A)
question = int(input())
s = []
for x in range( question ) :
  B = input().split(' ')
  s.append(B)
for x in range(0,len(s)) :
  t = s[x]
  q = []
  for y in range(0,len(f)) :
    r = f[y]
    if int(f[y][1]) > int(f[y][2]) and int(s[x][0]) > int(s[x][1]) :
      if int(f[y][1]) >= int(s[x][0]) and int(f[y][2]) >= int(s[x][1]) :
        w = abs(int(f[y][2]) - int(s[x][1]))
        q.append(w)
      if int(f[y][1]) >= int(s[x][0]) and int(f[y][2]) <= int(s[x][1]) :
        q.append(0)
    if int(f[y][1]) < int(f[y][2]) and int(s[x][0]) < int(s[x][1]) :
      if int(f[y][1]) <= int(s[x][0]) and int(f[y][2]) <= int(s[x][1]) :
        w = abs(int(f[y][2]) - int(s[x][1]))
        q.append(w)
      if int(f[y][1]) <= int(s[x][0]) and int(f[y][2]) >= int(s[x][1]) :
        q.append(0)
    else :
      w = abs(int(s[x][0]) - int(f[y][2])) + abs(int(s[x][1]) - int(s[x][0]))
      q.append(w)
  print('>>' , q.index(min(q)) + 1)
# 6631218421 (point = 56.76%) sim = 94%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
ploy = int(input())
p = []
for i in range(ploy) :
  A = input().split(' ')
  p.append(A)
pee = int(input())
n = []
for i in range(pee) :
  B = input().split(' ')
  n.append(B)
for i in range(0,len(n)) :
  d = n[i]
  w = []
  for t in range(0,len(p)) :
    z = p[t]
    if int( p[t][1] ) >= int( p[t][2] ) and int( n[i][0] ) >= int( n[i][1] ) :
     if int( p[t][1] ) >= int( n[i][0] ) and int( p[t][2] ) >= int( n[i][1] ) :
        k = abs( int( p[t][2] ) - int( n[i][1] ) )
        w.append(k)
    if int( p[t][1] ) >= int( n[i][0] ) and int( p[t][2] ) <= int( n[i][1] ) :
        w.append(0)
    if int( p[t][1] ) <= int( p[t][2] ) and int( n[i][0] ) <= int( n[i][1]) :
     if int( p[t][1] ) <= int( n[i][0] ) and int( p[t][2] ) <= int( n[i][1]) :
      k = abs( int( p[t][2] ) - int( n[i][1] ))
      w.append(k)
     if int( p[t][1]) <= int( n[i][0]) and int( p[t][2] ) >= int( n[i][1] ) :
        w.append(0)
    else :
       k = abs( int( n[i][0] ) - int( p[t][2] ) ) + abs( int( n[i][1] ) - int( n[i][0] ) )
       w.append(k)
  print( '>>' , w.index(min(w)) + 1 )

>> cluster #9(3)
# 6631541021 (point = 80.71%) sim = 98%
def func(now,end):
    sum = 0
    mini = 999
    ans = 0
    for i in range(int(elevator)):
        elestart = liststart[i]
        eleend = listend[i]
        if now >= elestart and now <= eleend and end >= now and eleend >= elestart:
            if end > eleend:
                sum = end - eleend
            else:
                sum = 0
        elif now <= elestart and now >= eleend and end <= now and eleend <= elestart:
            if end < eleend:
                sum = eleend - end
            else:
                sum = 0
        elif now >= eleend and end >= now:
            sum = (now - eleend) + (end - now)
        elif elestart >= end and end >= now:
            if eleend > now:
                sum = (eleend - now) + (end - now)
            elif eleend < now:
                sum = (now - eleend) + (end - now)
        elif now <= eleend and end <= now:
            sum = (eleend - now) + (now - end)
        elif elestart <= now and now >= end:
            if eleend < now:
                sum = (now - eleend) + (now - end)
            elif eleend > now:
                sum = (eleend - now) + (now - end)
        #print(sum)
        if mini > sum:
            mini = sum
            ans = i
    return ans+1
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
#print("love34")
elevator = input()
liststart = []
listend = []
for i in range(int(elevator)):
    x = input()
    s = x.split(" ")
    liststart.append(int(s[1]))
    listend.append(int(s[2]))
#print(liststart[3])
question = input()
listtob = []
for i in range(int(question)):
    mini = 999
    x = input()
    s = x.split(" ")
    now = s[0]
    end = s[1]
    ans = func(int(now),int(end))
    listtob.append(ans)
for i in range(int(question)):
    print(">>" + str(listtob[i]))
# 6631503221 (point = 72.64%) sim = 98%
def func(now,end):
    sum = 0
    mini = 999
    ans = 0
    for i in range(int(elevator)):
        elestart = liststart[i]
        eleend = listend[i]
        if now >= elestart and now <= eleend and end >= now and eleend >= elestart:
            if end > eleend:
                sum = end - eleend
            else:
                sum = 0
        elif now <= elestart and now >= eleend and end <= now and eleend <= elestart:
            if end < eleend:
                sum = eleend - end
            else:
                sum = 0
        elif now >= eleend and end >= now:
            sum = (now - eleend) + (end - now)
        elif elestart >= end and end >= now:
            if eleend > now:
                sum = (eleend - now) + (end - now)
            elif eleend < now:
                sum = (now - eleend) + (end - now)
        elif now <= eleend and end <= now:
            sum = (eleend - now) + (now - end)
        elif elestart <= now and now >= end:
            if eleend < now:
                sum = (now - eleend) + (now - end)
            elif eleend > now:
                sum = (eleend - now) + (now - end)
        if mini > sum:
            mini = sum
            ans = i
    return ans+1
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
elevator = input()
liststart = []
listend = []
for i in range(int(elevator)):
    x = input()
    s = x.split(" ")
    liststart.append(int(s[1]))
    listend.append(int(s[2]))
question = input()
listtob = []
for i in range(int(question)):
    mini = 999
    x = input()
    s = x.split(" ")
    now = s[0]
    end = s[1]
    ans = func(int(now),int(end))
    listtob.append(ans)
for i in range(int(question)):
    print(listtob[i])
# 6630308021 (point = 80.71%) sim = 95%
def func(now,end):
    sum = 0
    mini = 999
    ans = 0
    for i in range(elevator):
        elestart = liststart[i]
        eleend = listend[i]
        if now >= elestart and now <= eleend and end >= now and eleend >= elestart:
            if end > eleend:
                sum = end - eleend
            else:
                sum = 0
        elif now <= elestart and now >= eleend and end <= now and eleend <= elestart:
            if end < eleend:
                sum = eleend - end
            else:
                sum = 0
        elif now >= eleend and end >= now:
            sum = (now - eleend) + (end - now)
        elif elestart >= end and end >= now:
            if eleend > now:
                sum = (eleend - now) + (end - now)
            elif eleend < now:
                sum = (now - eleend) + (end - now)
        elif now <= eleend and end <= now:
            sum = (eleend - now) + (now - end)
        elif elestart <= now and now >= end:
            if eleend < now:
                sum = (now - eleend) + (now - end)
            elif eleend > now:
                sum = (eleend - now) + (now - end)
        #print(sum)
        if mini > sum:
            mini = sum
            ans = i
    return ans+1
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
elevator = int(input())
liststart = []
listend = []
for i in range(elevator):
    x = input()
    s = x.split(" ")
    liststart.append(int(s[1]))
    listend.append(int(s[2]))
#print(liststart[3])
question = int(input())
listtob = []
for i in range(question):
    mini = 999
    x = input()
    s = x.split(" ")
    now = s[0]
    end = s[1]
    ans = func(int(now), int(end))
    listtob.append(ans)
for i in range(question):
    print(">>", listtob[i])

>> cluster #10(2)
# 6631303021 (point = 82.33%) sim = 97%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
n = int(input())
i = 0
lift = []
while i < n :
    x = [int(e) for e in input().split()]
    lift.append(x)
    i += 1
m = int(input())
j = 0
while j < m :
    compar = []
    y = [int(e) for e in input().split()]
    for path in lift :
        if path[2]-path[1] >= 0 and y[1]-y[0] > 0 :
            if path[1] <= y[0] <= path[2] :
                if path[1] <= y[1] <= path[2] :
                    par = 0
                else :
                    par = y[1]-path[2]
            elif y[0] < path[1] :
                par = (path[2]-y[0])+(y[1]-y[0])
            elif path[2] < y[0] :
                par = (y[0]-path[2])+abs(y[1]-y[0])
        elif path[2]-path[1] <= 0 and y[1]-y[0] < 0 :
            if path[2] <= y[0] <= path[1] :
                if path[2] <= y[1] <= path[1] :
                    par = 0
                else :
                    par = path[2]-y[1]
            elif y[0] < path[2] :
                par = (path[2]-y[0])+(y[0]-y[1])
            elif path[1] < y[0] :
                par = (y[0]-path[2])+abs(y[1]-y[0])
        else :
            par = abs(path[2]-y[0])+abs(y[1]-y[0])
        compar.append(par)
    copy_compar = compar.copy()
    compar.sort()
    ans = compar[0]
    ans = copy_compar.index(ans)
    print(ans+1)
    j += 1
# 6631022721 (point = 90.0%) sim = 97%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
n = int(input())
a = 0
lift = []
while a < n :
    x = [int(e) for e in input().split()]
    lift.append(x)
    a += 1
m = int(input())
b = 0
while b < m :
    Base = []
    y = [int(e) for e in input().split()]
    for floor in lift :
        if floor[2]-floor[1] >= 0 and y[1]-y[0] > 0 :
            if floor[1] <= y[0] <= floor[2] :
                if floor[1] <= y[1] <= floor[2] :
                    base = 0
                else :
                    base = y[1] - floor[2]
            elif y[0] < floor[1] :
                base = (floor[2]-y[0]) + (y[1]-y[0])
            elif floor[2] < y[0] :
                base = (y[0]-floor[2]) + abs(y[1]-y[0])
        elif floor[2]-floor[1] <= 0 and y[1]-y[0] < 0 :
            if floor[2] <= y[0] <= floor[1] :
                if floor[2] <= y[1] <= floor[1] :
                    base = 0
                else :
                    base = floor[2]-y[1]
            elif y[0] < floor[2] :
                base = (floor[2] - y[0]) + (y[0]-y[1])
            elif floor[1] < y[0] :
                base = (y[0]-floor[2]) + abs(y[1]-y[0])
        else :
            base = abs(floor[2]-y[0]) + abs(y[1]-y[0])
        Base.append(base)
    NewBase = Base.copy()
    Base.sort()
    answer = Base[0]
    answer = NewBase.index(answer)
    print(lift[answer][0])
    b += 1

>> cluster #11(2)
# 6632175221 (point = 100.0%) sim = 92%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
n = int(input())
a = []
s = []
e = []
for i in range(n):
    ss = input().split()
    a.append(int(ss[0]))
    s.append(int(ss[1]))
    e.append(int(ss[2]))
t = int(input())
ans = []
while(t):
    t-=1
    ss = input().split()
    mems = int(ss[0])
    meme = int(ss[1])
    minn = 2e18
    idx=0
    for i in range(n):
        if(s[i]<=mems<=e[i] or e[i]<=mems<=s[i]):
            if(minn>abs(e[i]-meme)):
                minn=abs(e[i]-meme)
                idx=i
        else:
            if(minn>abs(e[i]-mems)+abs(meme-mems)):
                minn=abs(e[i]-mems)+abs(meme-mems)
                idx=i
    ans.append(a[idx])
for k in ans: print(">>"+str(k))
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
# 6631111921 (point = 100.0%) sim = 92%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
n = int(input()) #รับจำนวนลิฟต์ที่มี
ele_num = []  # สร้างลิสต์เลขลิฟต์แต่ละตัว
ele_now = []  # สร้างลิสต์เชั้นปัจจุบันของลิฟต์
ele_to = []  # สร้างลิสต์เชั้นปลายทางของลิฟต์ที่กำลังไป
for i in range(n):
    info = input().split()
    ele_num.append(int(info[0]))
    ele_now.append(int(info[1]))
    ele_to.append(int(info[2]))
m = int(input()) #รับจำนวนคำถามที่มี
ans = [] #สร้างลิสต์คำตอบ
while(m):
    m -= 1
    que = input().split()
    now = int(que[0]) #เลขชั้นที่เราอยู่
    goal = int(que[1]) #เลขชั้นที่เราอยากไป
    minn = 2e18
    idx = 0
    for i in range(n):
        if(ele_now[i] <= now <= ele_to[i] or ele_to[i] <= now <= ele_now[i]):
            if(minn > abs(ele_to[i] - goal)):
                minn = abs(ele_to[i] - goal)
                idx = i
        else:
            if(minn > abs(ele_to[i] - now) + abs(goal - now)):
                minn = abs(ele_to[i] - now) + abs(goal - now)
                idx = i
    ans.append(ele_num[idx])
for k in ans: print(">>" + str(k))
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้

>> cluster #12(2)
# 6630226221 (point = 100.0%) sim = 91%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
n = int(input())
elevators = []
for i in range(n):
    Elevator = input().split()
    elevators.append([int(Elevator[0]), int(Elevator[1]), int(Elevator[2])])
m = int(input())
for i in range(m):
    Question = input().split()
    user_floor, user_target = int(Question[0]), int(Question[1])
    chosen_elavator = 0
    floor_work = float('inf')
    for i in range(n):
        Elevator = elevators[i]
        user = user_target - user_floor
        Elevator_move = Elevator[2] - Elevator[1]
        min_work = 0
        if user > 0 and Elevator_move > 0:
            if user_floor >= Elevator[1] and user_floor <= Elevator[2]:
                min_work = (user_target - Elevator[2])
            else:
                min_work = abs(user_floor - Elevator[2]) + abs(user_target - user_floor )
        elif user < 0 and Elevator_move < 0:
            if  user_floor <= Elevator[1] and user_floor >= Elevator[2]:
                min_work = (Elevator[2] - user_target)
            else:
                min_work = abs(user_floor - Elevator[2]) + abs(user_target - user_floor)
        else:
            min_work = abs(user_floor - Elevator[2]) + abs(user_target - user_floor)
        if min_work < floor_work:
            floor_work = min_work
            chosen_elavator = Elevator[0]
    print(">>", chosen_elavator)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
# 6630011621 (point = 100.0%) sim = 91%
# HW02 (ไม่ลบหรือแก้ไขบรรทัดนี้ หรือเพิ่มอะไรก่อนบรรทัดนี้ โดยเด็ดขาด)
# เขียนทั้งโปรแกรมใน cell นี่ cell เดียวเท่านั้น
# จะเขียนฟังก์ชันใด ๆ เพิ่ม ก็เขียนใน cell นี้
n = int(input())
Elist = []
for A in range(n):
    Elevator = input().split()
    Elist.append([ int(Elevator[0]), int(Elevator[1]), int(Elevator[2]) ])
m = int(input())
for B in range(m) :
    Question = input().split()
    first, secound =int(Question[0]), int(Question[1])
    number = 0
    work = 2e9
    for i in range(n):
        Elevator = Elist[i]
        diQ =  secound - first
        diE =  Elevator[2] - Elevator[1]
        this_work = 0
        #print(diQ, diE)
        if diQ > 0 and diE > 0:
            if first>= Elevator[1] and first <= Elevator[2]:
                this_work  = (secound - Elevator[2] )
            else:
                this_work = abs(first-Elevator[2]) + abs(secound- first)
        elif diQ < 0 and diE < 0:
            if first <= Elevator[1] and first >= Elevator[2]:
                this_work = ( Elevator[2] -secound)
            else:
                this_work = abs(first-Elevator[2]) + abs(secound- first)
        else : this_work = abs(first-Elevator[2])+abs(secound-first)
        #print(this_work)
        if this_work < work:
         work = this_work
         number = Elevator[0]
    print(">>",number)