TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S, W = map(int, input().split())
if W >= S:
    print("unsafe")
else:
    print("safe")S, W = map(int, input().split())
if W >= S:
    print("unsafe")
else:
    print("safe")

S, W = map(int, input().split())
if W >= S:
    print("unsafe")
else:
    print("safe")

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S,W = map(int,input().suplit())
if W >= S:
  print("unsafe")
else:
  print("safe")

S,W = map(int,input().split())
if W >= S:
  print("unsafe")
else:
  print("safe")

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
   s,w=input().split()
s=int(s)
w=int(w)
if s>w:
    print("safe")
else:
    print("unsafe")

s,w=input().split()
s=int(s)
w=int(w)
if s>w:
    print("safe")
else:
    print("unsafe")
    

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
N=[int(x) for x in input().split()]
if not N[2]%N[1]==0:
   c=N[2]//N[1]+1
else:
    c=N[2]//N[1]

if not N[0]%N[3]==0:
   c=N[0]//N[3]+1

   d=N[0]//N[3]+1
else:
    d=N[0]//N[3]
if d>=c:
    print("Yes")
else:
    print("No")

N=[int(x) for x in input().split()]
if not N[2]%N[1]==0:
   c=N[2]//N[1]+1
else:
    c=N[2]//N[1]
if not N[0]%N[3]==0:
   c=N[0]//N[3]+1

   d=N[0]//N[3]+1
else:
    d=N[0]//N[3]
if d>c:
    print("Yes")
else:
    print("No")

N=[int(x) for x in input().split()]
if not N[2]%N[1]==0:
   c=N[2]//N[1]+1
else:
    c=N[2]//N[1]
if not N[0]%N[3]==0:
   c=N[0]//N[3]+1

   d=N[0]//N[3]+1
else:
    d=N[0]//N[3]
if d>=c:
    print("Yes")
else:
    print("No")

N=[int(x) for x in input().split()]
if N[0]/2=>N[1]:
    print("safe")
else:
   print("unsafe")

N=[int(x) for x in input().split()]
if not N[2]%N[1]==0:
   c=N[2]//N[1]+1
else:
    c=N[2]//N[1]
if not N[0]%N[3]==0:
   d=N[0]//N[3]+1
else:
    d=N[0]//N[3]
if d>=c:
    print("Yes")
else:
    print("No")


N=[int(x) for x in input().split()]
if N[0]>N[1]:
    print("safe")
else:
   print("unsafe")

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
 s, w = (int(x) for x in input().split())
if s <= w:
    print('unsafe')
else:
    print('safe')

s, w = map(int, input().split())
if s <= w:
    print('unsafe')
else:
    print('safe')

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
a,b,c,d = map(int,input().split())
ta = 0
aok = 0
while True:
    ta = c-b
    c = ta
    if c <=0:
        print("Yes")
        break
    aok = a - d
    a = aok
    if a <=0:
        print("No")
        break

       

    



s, w = map(int, input().split())
if w >= s:
    print("unsafe")
else:
    print("safe")


Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
a, b, c ,d = map(int, input().split())
attack = True
win = True

while True:
	if attack:
		c -= b
		attack = False
		if c < 0:
			break
	else:
		a -= d
		attack = True
		if a < 0:
			win = False 
			break


print("Yes") if win else print('No')


a, b, c, d = map(int, input().split())
attack = True
win = True

while a < 0 | c < 0:
	if attack:
		c -= b
		attack = False
	else:
		a -= d
		attack = True
		if a < 0:
			win = False
            
print("Yes") if win else print('No')


a, b, c ,d = map(int, input().split())
attack = True
win = True

while True:
	if attack:
		c -= b
		attack = False
		if c < 0:
			break
	else:
		a -= d
		attack = True
		if a < 0:
			win = False 
			break


print("Yes") if win else print('No')



s, w = map(int, input().split())

print("unsafe") if (s <= w) else print("safe")

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
a, b = map(int, input().split())]
if a <= b:
  print("unsafe")
elif a > b:
  print("safe")

a, b = map(int, input().split())]
if a < b:
  print("unsafe")
else:
  print("safe")

a, b = map(int, input().split())
if a <= b:
  print("unsafe")
else:
  print("safe")

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
sheep_number=int(10)
wolf_number=int(2)
if sheep_number<=wolf_number:
    print('unsafe')
else:
    print('safe')

sheep_number=S
wolf_number=W
if sheep_number<=wolf_number:
    print('unsafe')
else:
    print('safe')

t,k,a,o = map(int,input().split())
taka=int(a//k)
aoki=int(t//o)
if taka<=aoki:
    print('Yes')
else:
    print('No')

sheep_number=int(input())
wolf_number=int(input())
if sheep_number<=wolf_number:
    print('unsafe')
else:
    print('safe')

x,y = map(int,input().split())
if x<=y:
    print('unsafe')
else:
    print('safe')

Verdicts: Wrong Answer

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
s,w = input().split()
print(type(s))
if 2*int(w) > int(s):
  print('unsafe')
else:
  print('safe')

# -*- encode utf-8 -*-

S,W = int(input())
狼の数が羊の数以上のとき、羊は狼に襲われてしまいます。
if 2W >= S:
	print(unsafe)
else:
	print(safe)


s,w = input().split()
if int(w) >= int(s):
  print('unsafe')
else:
  print('safe')

Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S = int(input())
W = int(input())
if W >= S:
    print('unsafe')
else:
    print('safe')

S =  int(input('How many sheep'))
W =  int(input('How many wolf'))
if W >= S:
    print('unsafe')
else:
    print('safe')

S,W = input().split()
if int(W) >= int(S):
    print('unsafe')
else:
    print('safe')

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
a,b=map(int,input().split(" ")
if a>b:
	print("safe")
else:
    print("unsafe")
    


a,b=map(int,input().split(" "))
if a>b:
    print("safe")
else:
    print("unsafe")

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
import sys

def main():
    args = sys.argv
    if int(args[1]) <= int(args[2]):
        print("unsafe")
    else:
        print("safe")

if __name__ == "__main__":
    main()

import sys

def main():
    args = sys.argv
    if int(args[0]) <= int(args[1]):
        print("unsafe")
    else:
        print("safe")

if __name__ == "__main__":
    main()

def main():
    num = input().split()
    if int(num[0]) <= int(num[1]):
        print("unsafe")
    else:
        print("safe")

if __name__ == "__main__":
    main()

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S=input(sheeps:)
W=input(wolfs:)

if S>W:
  print("safe")
else:
  print("unsafe")

s,w=map(int,input().split())

if s>w:
  print("safe")
else:
  print("unsafe")

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S = int(input())
W = int(input())
if W >= S :
    print('unsafe')
else :
    print('safe')

S,W = map(int,input().split(' '))
if W >= S :
    print('unsafe')
else :
    print('safe')

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
a , b = map(int,input().split())
if b>= a:
  print("safe")
elif :
  print("unsafe")

s,w = map(int,input().split())
if w >= s :
  print("unsafe")
else:
  print("safe")

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
def sheep_wolf (S,W):
    if 1 < (S or W) <100:
        
        if S > W :
            print("safe")
        else :
            print("unsafe")
        
    else :
        print("Error! You should specify the value between 1 and 100")

S,W = map(int, input.split())

        if S > W :
            print("safe")
        else :
            print("unsafe")





def wolfgame(S,W):
    if 1 <= S <= W <= 100:
        print("unsafe")
    elif 1 <= W < S <= 100:
        print("safe")
    else :
        print("invalid")

S,W = map(int, input().split())

if S > W :
    print("safe")
else :
    print("unsafe")

Verdicts: Wrong Answer

Runtime Error

Wrong Answer

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S,W = map(int,input().split())
print("unsafe" if S>=W else "safe")

S,W = map(int,input().split())
print("unsafe" if S<=W else "safe")

Verdicts: Wrong Answer

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
from sys import stdin,stdout
s,w=stdin.readline().strip().split()
s=int(s)
w=int(w)
if(s>=w):
    print("unsafe")
else:
    print("safe")


for i in range(2):
    S, W = [int(x) for x in input().split()]
if W >= S:
    print('unsafe')
else:
    print('safe')

a, b=[int(yy) for yy in input().split()]
if b>=a:
	print('unsafe')
else:
	print("safe")


Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
A,B,C,D= map(int, input().split())
while (True):
    C = C - B
    if ( C <= 0 ):
        result = "Yes"
        break
    A = A - D
    if ( A <= 0 ) :
        result = "No"
        break
print ( result )


s,w  = map(int, input().split())

if w >= s:
    print("unsafe")
else:
    print("safe")


Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
import numpy as np
from collections import defaultdict
from math import gcd
import time
import sys
from collections import Counter
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
start = time.time()
N, M = map(int, input().split(' '))
if N < M:
    print('safe')
else:
    print('unsafe')


import numpy as np
from collections import defaultdict
from math import gcd
import time
import sys
from collections import Counter
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
start = time.time()
N, M = map(int, input().split(' '))
if N > M:
    print('safe')
else:
    print('unsafe')


Verdicts: Wrong Answer

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S = [int(a) for a in input()[::-1]]
m = 2019
N = len(S)
s = 0
p = 1
X = [0] * 2019
X[0] = 1
ans = 0


for a in S:

    s = (s + a * p) % m
    ans += X[s]
    X[s] += 1
    p = p * 10 % m
 
print(ans)

# N = int(input())
A,B = list(map(int, input().split()))

if A<=B:
    print("unsafe")
else:
    print("safe")


Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
s,w=map(int, input().split())
if w>=s:
  pritn('unsafe')
else:
  print('safe')

s,w=map(int, input().split())
if w>=s:
  print('unsafe')
else:
  print('safe')

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S=input()
mem_mod = [0 for i in range(0,2019,1)]
N = len(S)
counter = 0
S_num_tmp = list(S)
S_num = list(map(int, S_num_tmp))
tmp=10

e = list(map(int,input().split(sep=" ")))
if e[0]<=e[1]:
    print("unsafe")
else:
    print("safe")

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S,W = int(input().split())
if S <= W:
    print('unsafe')
print('safe')

S,W = map(int,input().split())
if S <= W:
    print('unsafe')
print('safe')


S,W = map(int,input().split())
if S <= W:
    print('unsafe')
else:
    print('safe')

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
s=input().split()
print(s)
sheep=int(s[0])
wolf=int(s[1])
if wolf>sheep:
  print('unsafe')
else:
  print('safe')

s,w = map(int,input().split())	
if s>w:
  print("safa")
else:
  print("unsafa")

s=input().split()
sheep=int(s[0])
wolf=int(s[1])
if wolf>=sheep:
  print('unsafe')
else:
  print('safe')

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
s,w = map(int,input().split())
if w <= s:
    print("unsafe")
else:
    print("safe")

s,w = map(int,input().split())
if w >= s:
    print("unsafe")
else:
    print("safe")


Verdicts: Wrong Answer

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
N,M=map(int,input().split())
if(N>M):
    print("safe")
else if(N<=M):
    print("unsafe")

N,M=map(int,input().split())
if(N>M):
    print("safe")
elif(N<=M):
    print("unsafe")

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
A,B,C,D=input().split()
num = 0
while(int(A)>=0 and int(C)>=0):
    if int(A)<= 100 and 0 <= int(B)<= 100 and int(C)<= 100 and 0 <= int(D)<= 100:
        if num %2 ==0:
            C = int(C)-int(B)
            if int(C)<=0:
                print("Yes")
                break
            num += 1
        elif num %2 !=0:
            A = int(A)-int(D)
            if int(A)<=0:
                print("No")
                break
            num += 1
    else:
        break


S,W = input().split()

if 0 <= int(S) <= 100 and 0 <= int(W) <= 100:
    if int(S) <= int(W):
        print("unsafe")
    else:
        print("safe")

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S, W = map(int, input().split())

print(S)
print(W)

if S <= W :
  print('unsafe')
else:
  print('safe')

S, W = map(int, input().split())

if S <= W :
  print('unsafe')
else:
  print('safe')

Verdicts: Wrong Answer

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S = input()

result = []

for i in range(len(S) - 3):
    for j in range(i + 3, len(S)):
        if int(S[i:j+1]) % 2019 == 0:
            result.append([i + 1, j + 1])

print(len(result))


S = input()

result = []

for i in range(len(S) - 3):
    for j in range(i + 3, len(S)):
        if int(S[i:j+1]) % 2019 == 0:
            result.append([i + 1, j + 1])

print(len(result))


S, W = map(int, input().split())

if S > W:
    print("safe")
else:
    print("unsafe")


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S, W  = map(int, input().split())

print("safe" if S > W else"unsefe")

S, W  = map(int, input().split())

print("safe" if S > W else "unsafe")

Verdicts: Wrong Answer

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
A = input()

S = 0
lis = [0] * 2019
lis[0] += 1
l = len(A)+1
d = 1

for n in reversed(A):
    S += int(n)*d
    sm = S % 2019
    lis[sm] += 1
    d *= 10

result = 0

for n in lis:
    result += (n*(n-1)/2)


print(int(result))


S, W = map(int,input().split())

if W >= S:
    print('unsafe')
else:
    print('safe')


Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
a,b,c,d = (int(x) for x in input().split())

x=int(a/d)+1
y=int(b/c)+1

if x>=y:
    print("Yes")
else:
    print("No")

s,w = (int(x) for x in input().split())
if s<=w:
  print("unsafe")
else:
  print("safe")

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
SW = input()
SW = [int(i) for i in list(SW.split())]

if SW[0]<=SW[1]:
  print('unsage')
else:
  print('safe')

SW = input()
SW = [int(i) for i in list(SW.split())]

if SW[0]<=SW[1]:
  print('unsafe')
else:
  print('safe')

Verdicts: Wrong Answer

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
N = input()
count=0
for i in range(len(N)+1):
  for j in range(i+1,len(N)+1):
    if(int(N[i:j])%3!=0):
      continue
    if(int(N[i:j])%673==0):
      count+=1

print(count)


S, W = map(int,(input().split()))
if(S>W):
  print("safe")
else:
  print("unsafe")

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
s,w = map(int, input().split())
if s =< w:
  print("unsafe")
else:
  print("safe")

s,w = map(int, input().split())
if s <= w:
  print("unsafe")
else:
  print("safe")

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
a,b=map(int,input().split())

if a>b
	print("safe")

else:
	print("unsafe")

a,b=map(int,input().split())
 
if a>b:
	print("safe")
 
else:
	print("unsafe")

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
w, s = map(int, input().split(' '))
if w>=s:
  print('unsafe')
else:
  print('safe')

s, w = map(int, input().split(' '))
if w>=s:
  print('unsafe')
else:
  print('safe')

Verdicts: Wrong Answer

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
s, w = map(int, input().split())

if s > w:
  "safe"
else:
  "unsafe"

s, w = map(int, input().split())

if s > w:
  print("safe")
else:
  print("unsafe")

Verdicts: Wrong Answer

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S = input()
count = 0

if len(S)<=200000:
    for i in range(len(S)-4):
        for j in range(i+5, len(S)+1):
            tmp = int(S[i:j])
            if tmp%2019==0:
                count += 1

print(count)

S = input()
count = 0

for i in range(len(S)-3):
    for j in range(i+3, len(S)+1):
        tmp = int(S[i:j])
        if tmp%2019==0:
            print(i, j)
            count += 1

print(count)

S, W = map(int, input().split())

if S>W:
    print('safe')
else:
    print('unsafe')

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S, W = map(int, input().split())
if W >= S:
    print('unsafe')
else:
    print('safe'

S, W = map(int, input().split())
if W >= S:
    print('unsafe')
else:
    print('safe')

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
seep, wolf = map(int, input().rstrip())

if seep > wolf:
  print('safe')
else:
  print('unsafe')

seep, wolf = map(int, input().rstrip().split())
 
if seep > wolf:
  print('safe')
else:
  print('unsafe')

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
s,w = map(int, input().split())

print('unsafe' if s=<w else 'safe')

s,w = map(int, input().split())
print('unsafe' if s<=w else 'safe')

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
s, w = map(int, input().split())
if (s <= w):
  print('unsafe')
 else:
  print('safe')

s, w = map(int, input().split())
if (s <= w):
  print('unsafe')
else:
  print('safe')

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
lis =[]
abc =[]
count = 0

N = int(input())
lis =[lis.append(input()) for _ in range(N)]

for i in lis:
    if any(i == j for j in abc):
        pass
    else:
        abc.append(i)
        count += 1

print(count)
    

S,W = map(int,input().split())

if S > W:
    print('safe')
else:
    print('unsafe')

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S=int(input())
W=int(input())
if S>W:
  print("safe")
else:
  print("unsafe")

S,W=map(int,input().split())
if S>W:
  print("safe")
else:
  print("unsafe")


Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
s = int(input())
w = int(input())
if s < w :
    print("unsafe")
else :
    print("safe")

s, w = map(int, (input().split()))

if s > w :
    print("safe")
else :
    print("unsafe")

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S, W = map(int, input().split())
if S =< W:
  print("unsafe")
else:
  print("safe")

S, W = map(int, input().split())
if S <= W:
  print("unsafe")
else:
  print("safe")

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
s, w = int(input().split())
if w >= s:
    print("unsafe")
else:
    print("safe")

s, w = map(int,input().split())
if w >= s:
    print("unsafe")
else:
    print("safe")

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
s, w = input().split(' ')
s = int(s)
w = int(w)
 
if s > w :
  print('safe')
else:
  pritn('unsafe')

s, w = input()
s = int(s)
w = int(w)

if s > w :
  print('safe')
else:
  pritn('unsafe')

s, w = input().split(' ')
s = int(s)
w = int(w)
 
if s > w :
  print('safe')
else:
  print('unsafe')

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
import itertools
s = input()
count = 0

for i,j in itertools.combinations(range(0,len(str(s))+1),2):
    if int(s[i:j]) % 2019 ==0:
        count +=1
    print(s[i:j])
print(count)
    

S, W =map(int,input().split())
if W>=S:
    print("unsafe")
else:
    print("safe")

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
s = input()
a = [int(c) for c in s]

b=""
count=0

for i in range(len(a)):
    for j in range(i,len(a)):
        for k in range(i,j+1):
            b += str(a[k])
        #print(b)
        if int(b)%2019 == 0:
            count+=1
        b=""

print(count)


n=int(input())

mydic={"",0}

for i in range(n):
    a=input()
    mydic.update(a)

#print(mydic)
print(len(mydic)-2)

a = list(map(int,input().split()))
s=a[0]
w=a[1]

if s<=w:
    print("unsafe")
else:
    print("safe")

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
s=input();c=0
for i in range(len(s)):
    for j in range(1,len(s)+1):
        if s[i:j]:
            if int(s[i:j])%2019==0:
                c+=1
print(c)

s,w=map(int,input().split())
print(("un"if w>=s else "")+"safe")

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
if W >= S:print('unsafe')
else: print('safe')

W,S = list(map(int,input().split()))
if W >= S:print('unsafe')
else: print('safe')

n = int(input())
d = []
for i in range(n):
    s = input()
    if not(s in d): d.append(s)

print(len(d))



S,W = list(map(int,input().split()))
if W >= S:print('unsafe')
else: print('safe')

Verdicts: Runtime Error

Wrong Answer

Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
print('unsafe') if int(input()) <= int(input()) else print('safe')

S, W = input().split(' ')
print('unsafe') if int(S) <= int(W) else print('safe')

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S = int(input())
W = int(input())
if W >= S:
    print("unsafe")
else:
    print("safe")



S, W = map(int(input().split()))
if W >= S:
    print("unsafe")
else:
    print("safe")

S, W = map(int, input().split())
if W >= S:
    print("unsafe")
else:
    print("safe")

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
s = int(input())
w = int(input())
if w >= s:
  print("unsafe")
else:
  print('safe')

s = input()
w = input()
if w >= s:
  print("unsafe")
else:
  print('safe')

s, w = map(int, input().split())
if w >= s:
  print('unsafe')
else:
  print("safe")

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
s = input()

n = len(s)

k = 0

for i in range(n - 4):
    for j in range(i+4, n+1):
        if int(s[i:j]) % 2019 == 0:
            k = k+1
            
print(k)

a, b = map(int, input().split())

if a > b :
    print('safe')
else:
    print('unsafe')

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S, W = map(int,input(.split()))
if W >= S:
    print('unsafe')
else:
    print('safe')

S, W = map(int,input().split())
if W >= S:
    print('unsafe')
else:
    print('safe')

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S.W=map(int,input().split())
if W>=S:
    print("unsafe")
else:
    print("safe")

S,W=map(int,input().split())
if W>=S:
    print("unsafe")
else:
    print("safe")

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
if S<W:
  print("unsafe")
else:
  print("safe")

S=100
W=10

if S <= W:
  print("unsafe")
else:
  print("safe")

if S <= W:
  print("unsafe")
else:
  print("safe")

S, W = map(int, input().split())

if S <= W:
  print("unsafe")
else:
  print("safe")

Verdicts: Runtime Error

Wrong Answer

Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S, W = map(int, input().split(' '))
print('safe' if S <= W else 'unsafe')

S, W = map(int, input().split(' '))
print('unsafe' if S <= W else 'safe')

Verdicts: Wrong Answer

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S, W = list(map(int, input().split()))
if S < W :
    print(unsafe)
if S > W :
    print(safe)

S, W = list(map(int, input().split()))
if S <= W :
    print("unsafe")
if S > W :
    print("safe")

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S, W = (int(x) for in input().split())
if W>=S:
  print("unsafe")
else:
  print("safe")

S, W = (int(x) for x in input().split())
if W>=S:
  print("unsafe")
else:
  print("safe")


Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S,W = map(int, input().split())
if S > W:
  print(safe)
else :
  print(unsafe)


S,W = map(int, input().split())
if S > W:
  print(safe)
 else :
  print(unsafe)

S,W = map(int, input().split())
if S > W:
  print('safe')
else :
  print('unsafe')


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
A, B, C, D = map(int, input().split())
count = 0
while True:
    if count % 2 == 0:
        C -= B
    else:
        A -= D
    count += 1
    if A <= 0:
        print("No")
        break
    elif C <= 0:
        print("Yes")
        break


a, b = map(int, input().split())
if a <= b:
    print("unsafe")
else:
    print("safe")


Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
s,w = map(int,input())
print("unsafe" if s <= w else "safe")

s,w = map(int,input().split())
print("unsafe" if s <= w else "safe")

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
s=input()
w=input()
ss=int(s)
ww=int(w)
if ww>=ss:
  print("unsafe")
else:
  print("safe")

if W>=S:
  print("unsafe")
else:
  print("safe")

s,w=int(input()),int(input())
if w>=s:
  print("unsafe")
else:
  print("safe")

s,w=map(int,input().split())
if w>=s:
  print("unsafe")
else:
  print("safe")

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
a,b = map(int,input().split())
if b > a:
    priant("unsafe")
elif a > b:
    print("safe")

a,b = map(int,input().split())
if b >= a:
    print("unsafe")
elif a > b:
    print("safe")

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
s, w = input()
if s <= w:
  print('unsafe')
else:
  print('safe')

S, W = map(int, input().split())
if S <= W:
    print('unsafe')
else:
    print('safe')

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
A=list(map(int,input.split()))
s=A[0]
w=A[1]

if s>w:
    return safe
else:
    return unsafe


A=list(map(int,input.split()))
s=A[0]
w=A[1]

if s>w:
    print(safe)
else:
    print(unsafe)


s,w=map(int,input().split())


if s>w:
    print(safe)
else:
    print(unsafe)


s,w=map(int,input.split())


if s>w:
    print(safe)
else:
    print(unsafe)


s,w=map(int,input().split())


if s>w:
    print("safe")
else:
    print("unsafe")

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S,W=map(int,input().split())
if W>=s:
  print("unsafe")
else:
  print("safe")

S,W=map(int,input().split())
if W>=S:
  print("unsafe")
else:
  print("safe")

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):

S = input()
W = input()

if S <= W:
    print('unsafe')
else:
    print('safe')

S = input()
W = input()

def sheep_wold(S=S, W=W):
    if S <= W:
        print('unsafe')
    else:
        print('safe')

s, w =  map(int, input().split())
if s <= w:
    print('unsafe')
else:
    print('safe')

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
s,w=[int(i) for i in input().split()]
print(["unsefe","safe"][s>w])

s,w=[int(i) for i in input().split()]
print(["unsefe","safe"][s>w])

s,w=[int(i) for i in input().split()]
print("unsafe" if w>=s else "safe")

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
def main():
  St = input()
  Va = St.split()
  S = Va[0]
  W = Va[1]
  if S>W:
    print("safe")
  else:
    print("unsafe")

St = input()
Va = St.split()
S = int(Va[0])
W = int(Va[1])
if S>W:
  print("safe")
else:
  print("unsafe")

Verdicts: Wrong Answer

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
a,b,c,d=map(int, input().split())
while True:
	b -= c
	if c<=0:
      print"Yes"
      break
	a -=d
	if a<=0:
      print"No"
      break


S,W=map(int, input().split())
print("safe" if S>W else "unsafe")

Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
s,w = map(int,input().split())

if s >= w :
  print(safe)
else:
  print(unsafe)

s,w = map(int,input().split())

if s > w :
  print("safe")
else:
  print("unsafe")


Verdicts: Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
if 1 <= W <= 100 and 1 <= S <= 100 and W >= S :
  print ("unsafe")
if 1 <= W <= 100 and 1 <= S <= 100 and W < S :
  print("safe")

if W >= S :
  print ("unsafe")
if W < S :
  print("safe")

S, W = map(int, input().split())
if 1 <= W <= 100 and 1 <= S <= 100 and W >= S :
  print ("unsafe")
if 1 <= W <= 100 and 1 <= S <= 100 and W < S :
  print("safe")

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
s = int(input())
w = int(input())
if ( w >= s )
	print("unsafe")
else
	print("safe")

A, B, C, D = map(int, input().split())
while (A>0 and C > 0):
    C = C - B
    if C <= 0:
        break
    A = A - D
print("Yes" if C<=0 else "No")

s = int(input())
w = int(input())
if w > s
	print("unsafe")
else
	print("safe")

s = int(input())
w = int(input())
if ( w >= s ):
	print("unsafe")
else:
	print("safe")

s, w = map(int, input().split())
if ( w >= s )
	print("unsafe")
else
	print("safe")

s, w = map(int, input().split())
if ( w >= s ):
    print("unsafe")
else:
    print("safe")

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
list = map(int, input().split())
S = list[0]
W = list[1]
if W >= S: print("unsafe")
else: print("safe")

list = map(int, input().split())
S = list[0]
W = list[1]
if W => S: print("unsafe")
else: print("safe")

list = map(int, input().split())
S = list[0]
W = list[1]
if W >= S: print("unsafe")
else: print("safe")

S = input()
L = len(S)
N = 0

for i in range(L - 3):
    for j in range(4,L - i+1):
        P = int(S[i:i + j])
        if P % 3 == 0:
            if P % 2019 == 0: N += 1

print(N)

list = list(map(int, input().split()))
S = list[0]
W = list[1]
if W >= S: print("unsafe")
else: print("safe")


Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
S, W = map(int, input().split())

if W &gt;= S:
  print("unsafe")
else:
  print("safe")

S, W = map(int, input().split())
if W >= S:
  print(“unsafe”)
else:
  print(“safe”)

S, W = map(int, input().split())if W >= S:  print("unsafe")else:  print("safe")


S, W = map(int, input().split())


if W >= S:
  print("unsafe")
else:
  print("safe")

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: There are S sheep and W wolves.  If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.  If the wolves will attack the sheep, print `unsafe`; otherwise, print `safe`.

Submission attempts (in order):
a, b, c, d = list(map(int, input().split()))
A = a - d
B = c - b
if A>=B:
  print('Yes')
else:
  print('No')

w, s = input().split()
if w>=s:
	print('unsafe')
else:
	print('safe')

s, w = map(int, input().split())
if w>=s:
	print('unsafe')
else:
	print('safe')
          

Verdicts: Runtime Error

Wrong Answer

Accepted