Problem:


Score : 300 points

Problem Statement

Does \sqrt{a} + \sqrt{b} < \sqrt{c} hold?

Constraints

1 \leq a, b, c \leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

a \ b \ c

Output

If \sqrt{a} + \sqrt{b} < \sqrt{c}, print Yes; otherwise, print No.

Sample Input 1

2 3 9

Sample Output 1

No

\sqrt{2} + \sqrt{3} < \sqrt{9} does not hold.

Sample Input 2

2 3 10

Sample Output 2

Yes

\sqrt{2} + \sqrt{3} < \sqrt{10} holds.



Sample input:
2 3 9


Sample output:
No

Submission status: Wrong Answer

Solution code:
a, b, c = (int(x) for x in input().split())
if a**0.5 + b**0.5 < c**0.5:
    print("Yes")
else:
    print("No")

Submission status: Wrong Answer

Solution code:
a,b,c=map(int,input().split())
if a+b+2*((a*b)**0.5)<c:
  print('Yes')
else:
  print('No')

Submission status: Wrong Answer

Solution code:
import math

a,b,c = input().split()
a = math.sqrt(int(a))
b = math.sqrt(int(b))
c = math.sqrt(int(c))

ans = ""

if((a + b) < c):
    ans = "Yes"
else:
    ans = "No"

print(ans)

Submission status: Wrong Answer

Solution code:
import numpy as np
a = list(map(int, input().split()))
if np.sqrt(a[0]) + np.sqrt(a[1]) < np.sqrt(a[2]):
  print('Yes')
else:
  print('No')

Submission status: Wrong Answer

Solution code:
import numpy

rt = numpy.sqrt([int(x) for x in input().split(" ")])
if (rt[0] + rt[1]) < rt[2]:
    print("Yes")
else:
    print("No")

Submission status: Wrong Answer

Solution code:
import math
a,b,c = map(int,input().split())
if 2*(math.sqrt(a)*math.sqrt(b))+a+b < c:
    print("Yes")
else:
    print("No")

Submission status: Wrong Answer

Solution code:
'''
Fuad Ashraful Mehmet
University of Asia Pacific,Bangladesh
Date:15th March 2020
'''


import math

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


f=a*a+b*b+c*c+2*a*b-2*b*c-2*c*a
s=4*a*b


if f>s:
    print('Yes')
else:
    print('No')

Submission status: Wrong Answer

Solution code:
l=[int(e) for e in input().split(' ')]
a=l.pop(0)
b=l.pop(0)
c=l.pop(0)

lt=4*a*b + 2*(a+b)*c
rt=c**2 + (a+b)**2

if lt < rt:
    print('Yes')
else:
    print('No')

Submission status: Wrong Answer

Solution code:
# from fractions import gcd
# from datetime import date, timedelta
# from heapq import *
# import heapq
# import math
# from collections import defaultdict, Counter, deque
# from bisect import *
# import itertools
# import fractions
# # import sys
# sys.setrecursionlimit(10 ** 7)
# MOD = 10 ** 9 + 7
# input = sys.stdin.readline


# def lcm(a, b):
#     return a * b / fractions.gcd(a, b)


# def make_divisors(n):
#     divisors = []
#     for i in range(1, int(n**0.5)+1):
#         if n % i == 0:
#             divisors.append(i)
#             if i != n // i:
#                 divisors.append(n//i)

#     # divisors.sort()
#     return divisors


# def factorize(n):
#     fct = []  # prime factor
#     b, e = 2, 0  # base, exponent
#     while b * b <= n:
#         while n % b == 0:
#             n = n // b
#             e = e + 1
#         if e > 0:
#             fct.append((b, e))
#         b, e = b + 1, 0
#     if n > 1:
#         fct.append((n, 1))
#     return fct


# def is_prime(n):
#     if n == 1:
#         return False

#     for k in range(2, int(math.sqrt(n)) + 1):
#         if n % k == 0:
#             return False

#     return True


# def primes(n):
#     is_prime = [True] * (n + 1)
#     is_prime[0] = False
#     is_prime[1] = False
#     for i in range(2, int(n**0.5) + 1):
#         if not is_prime[i]:
#             continue
#         for j in range(i * 2, n + 1, i):
#             is_prime[j] = False
#     return [i for i in range(n + 1) if is_prime[i]]

# def modpow(a, n, mod):
#     res = 1
#     while n > 0:
#         if n & 1:
#             res = res * a % mod
#         a = a * a % mod
#         n >>= 1
#     return res


# def modinv(a, mod):
#     return modpow(a, mod - 2, mod)


# def cnk(a, b):
#     MOD = 10**9+7
#     ret = 1
#     for i in range(b):
#         ret *= (a-i)
#         ret %= MOD
#         ret = ret * modinv(i+1, MOD) % MOD
#     return ret


# class UnionFind:
#     def __init__(self, n):
#         self.sz = [-1 for i in range(n)]

#     # 検索
#     def find(self, x):
#         if self.sz[x] < 0:
#             return x
#         else:
#             self.sz[x] = self.find(self.sz[x])
#             return self.sz[x]

#     # 併合
#     def union(self, x, y):
#         x = self.find(x)
#         y = self.find(y)
#         if x == y:
#             return False
#         if self.sz[x] > self.sz[y]:
#             x, y = y, x
#         self.sz[x] += self.sz[y]
#         self.sz[y] = x

#     # 同じ集合に属するか判定
#     def same(self, x, y):
#         return self.find(x) == self.find(y)

#     # xが含まれている集合のサイズを求める
#     def size(self, x):
#         return -self.sz[self.find(x)]

# class WeightedUnionFind:
#     def __init__(self, n):
#         self.par = [i for i in range(n+1)]
#         self.rank = [0] * (n+1)
#         # 根への距離を管理
#         self.weight = [0] * (n+1)

#     # 検索
#     def find(self, x):
#         if self.par[x] == x:
#             return x
#         else:
#             y = self.find(self.par[x])
#             # 親への重みを追加しながら根まで走査
#             self.weight[x] += self.weight[self.par[x]]
#             self.par[x] = y
#             return y

#     # 併合
#     def union(self, x, y, w):
#         rx = self.find(x)
#         ry = self.find(y)
#         # xの木の高さ < yの木の高さ
#         if self.rank[rx] < self.rank[ry]:
#             self.par[rx] = ry
#             self.weight[rx] = w - self.weight[x] + self.weight[y]
#         # xの木の高さ ≧ yの木の高さ
#         else:
#             self.par[ry] = rx
#             self.weight[ry] = -w - self.weight[y] + self.weight[x]
#             # 木の高さが同じだった場合の処理
#             if self.rank[rx] == self.rank[ry]:
#                 self.rank[rx] += 1

#     # 同じ集合に属するか
#     def same(self, x, y):
#         return self.find(x) == self.find(y)

#     # xからyへのコスト
#     def diff(self, x, y):
#         return self.weight[x] - self.weight[y]


class manacher:

    def __init__(self, l):
        self.n = len(l)
        self.m = 2*self.n+1
        self.d = ['&']*self.m
        self.r = [0]*self.m
        for i in range(self.n):
            self.d[2*i+1] = l[i]
        self.make_r()

    def make_r(self):
        i, j = 0, 0
        while i < self.m:
            while j <= i < self.m-j and self.d[i-j] == self.d[i+j]:
                j += 1
            self.r[i] = j
            k = 1
            while k <= i < self.m-k and k+self.r[i-k] < j:
                self.r[i+k] = self.r[i-k]
                k += 1
            i += k
            j -= k

    def judge(self, start, end):
        center = start+end
        return 2 * end - 1 < center + self.r[center]


def main():
    a, b, c = map(int, input().split())

    # if a + b == c:
    #     if a ** 0.5 + b ** 0.5 < c ** 0.5:
    #         print("Yes")
    #     else:
    #         print("No")
    #     exit()

    left = 4 * a * b
    right = (c - a - b)** 2
    left=(a ** 0.5 + b ** 0.5)**2
    right = c
    if left < right:
        print("Yes")
    else:
        print("No")


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
a,b,c = map(int,input().split())
"""
if a**0.5 + b**0.5 < c**0.5:
    print("Yes")
else:
    print("No")

print(a**0.5)
print(b**0.5)
print(a**0.5+b**0.5,c**0.5)
"""

if 2*(a*b)**0.5 < c-a-b:
    print("Yes")
else:
    print("No")

Submission status: Wrong Answer

Solution code:
import math
from decimal import Decimal

def main(): 
    a,b,c = map(Decimal,input().split())

    if math.sqrt(Decimal(a)) + math.sqrt(Decimal(b)) < math.sqrt(Decimal(c)):
        print("Yes")
    else:
        print("No")

main()

Submission status: Wrong Answer

Solution code:
a, b, c = map(int, input().split())
sosu = [2, 3, 5, 7, 11]
for i in range(5):
  while (a % sosu[i] == 0 and b % sosu[i] == 0 and c % sosu[i] == 0):
    if (a == sosu[i] or b == sosu[i] or c == sosu[i]):
      break
    a /= sosu[i]
    b /= sosu[i]
    c /= sosu[i]
left = a * b
right = (c - (a + b)) / 2
if (right < 0):
  print('No')
  exit()
right = right ** 2
if (left < right):
  print('Yes')
else:
  print('No')

Submission status: Wrong Answer

Solution code:
import math
a,b,c = map(int,input().split())


if a+b<c:
    ans = 'Yes' if 2*math.sqrt(a*b) <c-a-b else 'No'
    print(ans)
else:
    print('No')

Submission status: Wrong Answer

Solution code:
import math
l = input()
arr = l.split()
a = int(arr[0])
b = int(arr[1])
c = int(arr[2])

if 2 * math.sqrt(a + b) < c - a - b:
    print('Yes')
else:
    print('No')

Submission status: Wrong Answer

Solution code:
a, b, c = map(int, input().split())
import math

if math.sqrt(c) - math.sqrt(a) -  math.sqrt(b) > 1e-100:
    print('Yes')
else:
    print('No')

Submission status: Wrong Answer

Solution code:
[a,b,c] = [int(x) for x in input().split()]

if 2*a*c + 2*b*c + 4*(a*b) < a**2 + b**2 + c**2 + 2*a*b:
    print("Yes")
else:
    print("No")

Submission status: Wrong Answer

Solution code:
def abs(x):
    if x < 0:
        return -x
    else:
        return x

def main():
    a,b,c = list(map(lambda x:abs(int(x)),input().split(' ')))
    # if (a**0.5 + b**0.5) < (c**0.5):
    #     print('Yes')
    # else:
    #     print('No')

    if (4*a*b) < ((c-a-b)**2):
        print('Yes')
    else:
        print('No')

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import math
a, b, c = map(int, input().split())
if c > a+b and 4*a*b < math.pow(c-a-b, 2):
    print("Yes")
else:
    print("No")

Submission status: Wrong Answer

Solution code:
a, b, c = map(int, input().split())

if a * a + b * b + c * c >= 2 * (b * c + c * a - a * b) and 2 * (a * b + b * c + c * a) < a * a + b * b + c * c:
    print("Yes")
else:
    print("No")

Submission status: Wrong Answer

Solution code:
import numpy as np

a, b, c=map(int,input().split())
left = a + b + 2*np.sqrt(a)*np.sqrt(b)

if (left < c):
    print('Yes')
else:
    print('No')

Submission status: Wrong Answer

Solution code:
from decimal import *

getcontext().prec = 100
A = [int(i) for i in input().split()]
B = [Decimal(a).sqrt() for a in A]
for i in range(1, 100000):
    for j in range(3):
        if i * i == A[j]:
            B[j] = i

if B[0] + B[1] < B[2]:
    print("Yes")
else:
    print("No")

Submission status: Wrong Answer

Solution code:
A, B, C = map(float, input().split())

#if math.sqrt(A) + math.sqrt(B) < math.sqrt(C):
#    print('Yes')
#else:
#    print('No')

if 4*A*B < (C-A-B)**2:
    print('Yes')
else:
    print('No')

Submission status: Wrong Answer

Solution code:
def main(sample_file = ''):

    """ convenient functions
    # for i, a in enumerate(iterable)
    # q, mod = divmod(a, b)
    # divmod(x, y) returns the tuple (x//y, x%y)
    # Higher-order function: reduce(operator.mul, xyz_count, 1)
    # manage median(s) using two heapq https://atcoder.jp/contests/abc127/tasks/abc127_f
    """

    """convenient decorator
    # @functools.lru_cache():
    # to facilitate use of recursive function
        # ex:
        # from functools import lru_cache
        # import sys
        # sys.setrecursionlimit(10**9)
        # @lru_cache(maxsize=None)
        # def fib(n):
        #     if n < 2:
        #         return n
        #     return fib(n-1) + fib(n-2)
        # print(fib(1000))
    """
    
    # import numpy as np
    import sys
    sys.setrecursionlimit(10**7)
    from itertools import accumulate, combinations, permutations, product # https://docs.python.org/ja/3/library/itertools.html
    # accumulate() returns iterator! to get list: list(accumulate())
    from math import factorial, ceil, floor, sqrt
    def factorize(n):
        """return the factors of the Arg and count of each factor
        
        Args:
            n (long): number to be resolved into factors
        
        Returns:
            list of tuples: factorize(220) returns [(2, 2), (5, 1), (11, 1)]
        """
        fct = []  # prime factor
        b, e = 2, 0  # base, exponent
        while b * b <= n:
            while n % b == 0:
                n = n // b
                e = e + 1
            if e > 0:
                fct.append((b, e))
            b, e = b + 1, 0
        if n > 1:
            fct.append((n, 1))
        return fct
    def combinations_count(n, r):   
        """Return the number of selecting r pieces of items from n kinds of items.
        
        Args:
            n (long): number
            r (long): number
        
        Raises:
            Exception: not defined when n or r is negative
        
        Returns:
            long: number
        """
        # TODO: How should I do when n - r is negative?
        if n < 0 or r < 0:
            raise Exception('combinations_count(n, r) not defined when n or r is negative')
        if n - r < r: r = n - r
        if r < 0: return 0
        if r == 0: return 1
        if r == 1: return n
        numerator = [n - r + k + 1 for k in range(r)]
        denominator = [k + 1 for k in range(r)]
        for p in range(2,r+1):
            pivot = denominator[p - 1]
            if pivot > 1:
                offset = (n - r) % p
                for k in range(p-1,r,p):
                    numerator[k - offset] /= pivot
                    denominator[k] /= pivot
        result = 1
        for k in range(r):
            if numerator[k] > 1:
                result *= int(numerator[k])
        return result
    def combinations_with_replacement_count(n, r):
        """Return the number of selecting r pieces of items from n kinds of items allowing individual elements to be repeated more than once.
        
        Args:
            n (long): number
            r (long): number
        
        Raises:
            Exception: not defined when n or r is negative
        
        Returns:
            long: number
        """
        if n < 0 or r < 0:
            raise Exception('combinations_with_replacement_count(n, r) not defined when n or r is negative')
        elif n == 0:
            return 1
        else:
            return combinations_count(n + r - 1, r)
    from bisect import bisect_left, bisect_right
    from collections import deque, Counter, defaultdict # https://docs.python.org/ja/3/library/collections.html#collections.deque
    from heapq import heapify, heappop, heappush, heappushpop, heapreplace,nlargest,nsmallest # https://docs.python.org/ja/3/library/heapq.html
    from copy import deepcopy, copy # https://docs.python.org/ja/3/library/copy.html
    import operator
    from operator import itemgetter #sort 
    # ex1: List.sort(key=itemgetter(1))
    # ex2: sorted(tuples, key=itemgetter(1,2))
    from functools import reduce, lru_cache
    def chmin(x, y):
        """change minimum
        if x > y, x = y and return (x, True).
        convenient when solving problems of dp[i]
        
        Args:
            x (long): current minimum value
            y (long): potential minimum value
        
        Returns:
            (x, bool): (x, True) when updated, else (x, False)
        """
        if x > y:
            x = y
            return (x, True)
        else:
            return (x, False)
    def chmax(x, y):
        """change maximum
        if x < y, x = y and return (x, True).
        convenient when solving problems of dp[i]
        
        Args:
            x (long): current maximum value
            y (long): potential maximum value
        
        Returns:
            (x, bool): (x, True) when updated, else (x, False)
        """
        if x < y:
            x = y
            return (x, True)
        else:
            return (x, False)

    from fractions import gcd # Deprecated since version 3.5: Use math.gcd() instead.
    def gcds(numbers):
        return reduce(gcd, numbers)
    def lcm(x, y):
        return (x * y) // gcd(x, y)
    def lcms(numbers):
        return reduce(lcm, numbers, 1)
    def make_divisors(n, reversed=False):
        """create list of divisors
        
        Args:
            number (int): number from which list of divisors is created
            reversed (bool, optional): ascending order if False. Defaults to False.
        
        Returns:
            list: list of divisors
        """
        divisors = set()
        for i in range(1, int(n**0.5)+1):
            if n % i == 0:
                divisors.add(i)
                divisors.add(n//i)
        return sorted(list(divisors),reverse=reversed)
    
    # first create factorial_list
    # fac_list = mod_factorial_list(n)
    INF = 10 ** 18
    MOD = 10 ** 9 + 7
    modpow = lambda a, n, p = MOD: pow(a, n, p) # Recursive function in python is slow!
    def modinv(a, p = MOD):
        # evaluate reciprocal using Fermat's little theorem:
        # a**(p-1) is identical to 1 (mod p) when a and p is coprime
        return modpow(a, p-2, p)
    def modinv_list(n, p = MOD):
        if n <= 1:
            return [0,1][:n+1]
        else:
            inv_t = [0,1]
            for i in range(2, n+1):
                inv_t += [inv_t[p % i] * (p - int(p / i)) % p]
            return inv_t
    def modfactorial_list(n, p = MOD):
        if n == 0:
            return [1]
        else:
            l = [0] * (n+1)
            tmp = 1
            for i in range(1, n+1):
                tmp = tmp * i % p
                l[i] = tmp
            return l
    def modcomb(n, k, fac_list = [], p = MOD):
        # fac_list = modfactorial_list(100)
        # print(modcomb(100, 5, modfactorial_list(100)))
        from math import factorial
        if n < 0 or k < 0 or n < k: return 0
        if n == 0 or k == 0: return 1
        if len(fac_list) <= n:
            a = factorial(n) % p
            b = factorial(k) % p
            c = factorial(n-k) % p
        else:
            a = fac_list[n]
            b = fac_list[k]
            c = fac_list[n-k]
        return (a * modpow(b, p-2, p) * modpow(c, p-2, p)) % p
    def modadd(a, b, p = MOD):
        return (a + b) % MOD
    def modsub(a, b, p = MOD):
        return (a - b) % p
    def modmul(a, b, p = MOD):
        return ((a % p) * (b % p)) % p
    def moddiv(a, b, p = MOD):
        return modmul(a, modpow(b, p-2, p))

    class UnionFindTree:
        """union find tree class
        TODO: fix this description...
        how to use (example):
        >>  uf = UnionFindTree(N) 
        >>  if uf.find_root(a) == uf.find_root(b):
        >>      do something
        >>  else:
        >>      do something
        >>      uf.unite(a, b)
        """
        def __init__(self, N):
            self.root = [-1] * (N+1)
            self.rank   = [0]  * (N+1)
            self.connected_num = [1] * (N+1)
    
        def find_root(self,x):
            root = self.root
            while root[x] != -1:
                x = root[x]
            return x
    
        def unite(self,x,y):
            root = self.root
            rank = self.rank
            connected_num = self.connected_num
            find_root = self.find_root
    
            rx = find_root(x)
            ry = find_root(y)
            if rx != ry:
                if rank[rx] < rank[ry]:
                    root[rx] = ry
                    rx,ry = ry,rx
                else:
                    if rank[rx] == rank[ry]:
                        rank[rx] += 1
                    root[ry] = rx       
                connected_num[rx] += connected_num[ry]

    # Graph: https://en.wikipedia.org/wiki/Directed_graph
    # Bellman-Ford: O(|V||E|). Use this if there exists an edge with negative length in the graph
    # After N steps, the shortest path has converded if there doesn't exist an cycle of edges with negative
    # Watch out: d[N] == d[2*N] doesn't necessarily mean the graph doesn't have negative cycle
    # ref: https://www.youtube.com/watch?v=1Z6ofKN03_Y

    def BellmanFord(N, M, ABC, vertex_start, vertex_end, value_if_inf = -1, find_shortest = False):
        """to calculate furthest or shortest length between vertex_start and vertex_end using BellmanFord algorithm
        
        Args:
            N (int): number of vertices
            M (int): number of edges
            ABC (list): [(ai, bi, ci) for _ in range(N)] where i-th edge is directed from vertex ai to vertex bi and the length is ci 
            vertex_start (int): start vertex. usually use 0.
            vertex_end (int): end vertex. usually use N-1.
            value_if_inf (int or string as you like, optional): value you want when the furthest (or shortest) distance is infinite (or -infinite). Defaults to -1.
            find_shortest (bool, optional): choose False to find furthest path. Defaults to False.
        
        Returns:
            int or string: normally int (but can be str if you set value_if_inf to str)
            
        Example:
                N, M, P = R()
                ABC = [R() for _ in range(M)]
                ABC = [(a-1, b-1, c-P) for a, b, c in ABC]
                print(BellmanFord(N, M, ABC, 0, N-1, value_if_inf = 'inf'))

        """

        def make_reachable_list(N, M, ABC, vertex_start, vertex_end):
            reachable_to_direct = defaultdict(list)
            reachable_from_direct = defaultdict(list)
            reachable_from_start = [False] * N
            reachable_to_end = [False] * N
            reachable_from_start[vertex_start] = True
            reachable_to_end[vertex_end] = True
            reachable_from_both_sides = [False] * N
            dfs_from_start = []
            dfs_to_end = []
            for a, b, c in ABC:
                reachable_to_direct[a].append(b)
                reachable_from_direct[b].append(a)
                if a == vertex_start:
                    dfs_from_start.append(b)
                    reachable_from_start[b] = True
                if b == vertex_end:
                    dfs_to_end.append(a)
                    reachable_to_end[a] = True
            while dfs_from_start:
                v = dfs_from_start.pop()
                for i in reachable_to_direct[v]:
                    if not reachable_from_start[i]:
                        reachable_from_start[i] = True
                        dfs_from_start.append(i)
            while dfs_to_end:
                v = dfs_to_end.pop()
                for i in reachable_from_direct[v]:
                    if not reachable_to_end[i]:
                        reachable_to_end[i] = True
                        dfs_to_end.append(i)
            for i in range(N):
                reachable_from_both_sides[i] = reachable_from_start[i] and reachable_to_end[i]
            return reachable_from_both_sides
        
        reachable_from_both_sides = make_reachable_list(N, M, ABC, vertex_start, vertex_end)
        
        if find_shortest:
            dist = [INF for i in range(N)]
        else:
            dist = [-INF for i in range(N)]
        
        dist[vertex_start] = 0
        for i in range(N):
            updated = False
            for a, b, c in ABC:
                if not reachable_from_both_sides[a]:
                    continue
                elif find_shortest:
                    update_condition = dist[a] + c < dist[b]
                else:
                    update_condition = dist[a] + c > dist[b]
                if dist[a] != INF and update_condition:
                    dist[b] = dist[a] + c
                    updated = True
                    if i == N-1:
                        return value_if_inf
            if not updated:
                break
        return dist[vertex_end]

    """ initialize variables and set inputs
    # initialize variables
        # to initialize list, use [0] * n
        # to initialize two dimentional array:
            # ex) [[0] * N for _ in range(N)]
            # ex2) dp = [[0] * (N+1) for _ in range(W*2)]
    # set inputs
        # put inputs between specific values (almost as quickly)
        # ex) S = [-INF] + [int(r()) for _ in range(A)] + [INF]
        # open(0).read() is sometimes useful:
        # ex) n, m, *x = map(int, open(0).read().split())
        #     min(x[::2]) - max(x[1::2])
        # ex2) *x, = map(int, open(0).read().split())
        #     don't forget to add comma after *x if only one variable is used
    # preprocessing
        # transpose = [x for x in zip(*data)]
        # ex) [[1, 2, 3], [4, 5, 6], [7, 8, 9]] => [(1, 4, 7), (2, 5, 8), (3, 6, 9)]
        # flat = [flatten for inner in data for flatten in inner]
        # ex) [[1, 2, 3], [4, 5, 6], [7, 8, 9]] => [1, 2, 3, 4, 5, 6, 7, 8, 9]
    # calculate and output
        # output pattern
        # ex1) print(*l) => when l = [2, 5, 6], printed 2 5 6
    """

    # functions to read input
    r = lambda: sys.stdin.readline().strip()
    r_int = lambda: int(r())
    r_float = lambda: float(r())
    R = lambda: list(map(int, r().split()))
    R_str = lambda: r().split()
    R_map = lambda: map(int, r().split())
    R_float = lambda: list(map(float, r().split()))
    R_tuple = lambda: tuple(map(int, r().split()))

    """ how to treat input
    # single int: int(r())
    # single string: r()
    # single float: float(r())
    # line int: R()
    # line string: r().split()
    # line (str, int, int): [j if i == 0 else int(j) for i, j in enumerate(r().split())]
    # lines int: [R() for _ in range(n)]
    """

    # for test
    if sample_file:
        sys.stdin = open(sample_file)
        
    # ----------------------------------
    # main
    a, b, c = R()
    if (c - a - b)**2 > 4*a*b:
        print('Yes')
    else:
        print('No')
    
    # end of main
    # ----------------------------------

    """memo: how to use defaultdict of list
    # initialize
    Dic = defaultdict(list)
    # append / extend
    Dic[x].append(y)
    # three methods for loop: keys(), values(), items()
    for k, v in Dic.items():
    """
    
    """memo: how to solve binary problems
    # to make binary digits text
    >>> a = 5
    >>> bin_str_a = format(a, '#06b')
    >>> print(bin_str_a)
    0b0101 # first 2 strings (='0b') indicates it is binary
    """
    
    """memo: how to solve the problem
    creating simple test/answer
    greed
    simple dp
    graph
    """

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import math
a, b, c = map(int, input().split())
#sqa = math.floor(math.sqrt(a)*10**(1000))/10**(1000)
#sqb = math.floor(math.sqrt(b)*10**(1000))/10**(1000)
#sqc = math.floor(math.sqrt(c)*10**(1000))/10**(1000)

sqa = float(str(math.sqrt(a)))
sqb = float(str(math.sqrt(b)))
sqc = float(str(math.sqrt(c)))

#s = c - (a + b)
#t = 2 * sqa * sqb
#if t < s:
#  print("Yes")
#else:
#  print("No")
#sqc = math.sqrt(c)
if sqa + sqb < sqc:
  print("Yes")
else:
  print("No")

Submission status: Wrong Answer

Solution code:

import sys
import math
import fractions
import bisect
import queue
import heapq
import collections
import itertools
sys.setrecursionlimit(4100000)

MOD = int(1e9+7)
PI = 3.14159265358979323846264338327950288
INF = 1e18

'''
1行のint=====================================
N, K = map(int, input().split())
N, M = map(int, input().split())
A, B = map(int, input().split())

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

L, R = map(int, input().split())

1行のstring=================================
S, T = input().split()

1行の整数配列================================
P = list(map(int,input().split()))

A = list(map(int,input().split()))
B = list(map(int,input().split()))
C = list(map(int,input().split()))
D = list(map(int,input().split()))

L = list(map(int,input().split()))
R = list(map(int,input().split()))

T = list(map(int,input().split()))

改行あり整数==================================
X = []
Y = []
for i in range(N):
    x1,y1=[int(i) for i in input().split()]
    X.append(x1)
    Y.append(y1)

A = []
for i in range(N):
    a=int(input())
    A.append(a)

Pair = []
for i in range(N):
    x1,y1=[int(i) for i in input().split()]
    Pair.append((x1, y1))
    
2次元整数配列=====================================
A = []
for i in range(N):
    tmp = list(map(int,input().split()))
    A.append(tmp)


N行M列の初期化====================================
dp = [[VAL] * RETU for i in range(GYO)]

'''


A, B, C = map(float, input().split())

eps = 0.0000000001

if(A + B - C + 2* math.sqrt(A*B) < - eps):
    print("Yes")
else:
    print("No")

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
from collections import deque, Counter
def getN():
    return int(input())
def getList():
    return list(map(int, input().split()))
import math
from decimal import *
INF = 10 ** 20

def main():
    a,b,c = getList()
    k = max([a,b,c])
    getcontext().prec = 20  # デフォルト28桁のところを20桁にする
    a = int(Decimal(a).sqrt())
    b = int(Decimal(b).sqrt())
    c = int(Decimal(c).sqrt())
    # if math.sqrt(a/k) + math.sqrt(b/k)  < math.sqrt(c/k):
    if a + b < c:
        print("Yes")
    else:
        print("No")

    # print(math.sqrt(2000000000))
if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
import math
s=list(map(int,input().split()))
a=4*s[0]
b=a*s[1]
d=s[2]-s[1]-s[0]
e=d*d
if b<e:
  print('Yes')
else:
  print('No')

Submission status: Wrong Answer

Solution code:
import math

i = list(map(int, input().split()))
a = i[0]
b = i[1]
c = i[2]

#left = a + b + 2 * math.sqrt(a*b)
#right = c
left = 2 * a * b
right = (a-c)**2 + b*(b-2*c)

if (left < right):
    print ('Yes')
else:
    print ('No')

Submission status: Wrong Answer

Solution code:
a, b, c = map(int, input().split())
l = (a ** 2) + (b ** 2) + (c ** 2)
r = 2 * (a * b + b * c + c * a)
if (c ** 2 > 16 * a * b): print('Yes')
elif(l > r): print('Yes')
else: print('No')

Submission status: Wrong Answer

Solution code:
import math
x = input()

a, b, c = x.split(' ')

d = math.sqrt(int(a)) + math.sqrt(int(b)) - math.sqrt(int(c))

if d < 0:
    print("Yes")
else:
    print("No")

Submission status: Wrong Answer

Solution code:
a, b, c = list(map(int, input().split(' ')))
# left = 2 * (a * b + b * c + c * a)
# right = a**2 + b**2 + c**2
left = 0
right = a*(a - 2*c) + b*(b - 2*c) + c*(c - 2*a)
if left < right:
    print('Yes')
else:
    print('No')

Submission status: Wrong Answer

Solution code:
def mi():return map(str,input().split())
from decimal import *
from math import *

a,b,c=mi()
getcontext().prec=1000
a=Decimal(a)**Decimal("0.5")
b=Decimal(b)**Decimal("0.5")
c=Decimal(c)**Decimal("0.5")
f=(Decimal(c)-Decimal(a)-Decimal(b)>0)

if f:
    print("Yes")
else:
    print("No")

Submission status: Wrong Answer

Solution code:
import math

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

if (2*math.sqrt(a)*math.sqrt(b)) < (c-a-b):
    print('Yes')
else:
    print('No')

Submission status: Wrong Answer

Solution code:
import math

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

#s=a+b+2*math.sqrt(a*b)
#t=c
#s=math.sqrt(a) + math.sqrt(b)
#t=math.sqrt(c)
#s=math.sqrt(a) + math.sqrt(b) - math.sqrt(c)
#t=0
s=a + b - c + 2*math.sqrt(a*b)
t=0


#print(s,t)

if s < t:
  ans="Yes"
else:
  ans="No"

print(ans)

Submission status: Wrong Answer

Solution code:
a, b, c = map(int, input().split())

if c-a-b>=0:
    if 4*a*b<(c-a-b):
        print('Yes')
    else:
        print('No')
else:
    print('No')