Problem:
Score : 200 points

Problem Statement

Takahashi and Aoki will have a battle using their monsters.

The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.

The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ...
Here, an attack decreases the opponent's health by the value equal to the attacker's strength.
The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.

If Takahashi will win, print Yes; if he will lose, print No.

Constraints

1 \leq A,B,C,D \leq 100

All values in input are integers.

Input

Input is given from Standard Input in the following format:

A B C D

Output

If Takahashi will win, print Yes; if he will lose, print No.

Sample Input 1

10 9 10 10

Sample Output 1

No

First, Takahashi's monster attacks Aoki's monster, whose health is now 10-9=1.

Next, Aoki's monster attacks Takahashi's monster, whose health is now 10-10=0.

Takahashi's monster is the first to have 0 or less health, so Takahashi loses.

Sample Input 2

46 4 40 5

Sample Output 2

Yes

Solution in Kotlin (1.3.71) (judge verdict: Accepted)

import java.io.PrintWriter
import java.util.*
import java.math.*
import java.lang.*
import kotlin.comparisons.*

val pw = PrintWriter(System.out)
val MOD: Long = (1e+9 + 7).toLong()

fun main(args: Array<String>) {
    var (a, b, c, d) = readListOfInt()
    var taka = true
    while(a > 0 && c > 0) {
        if(taka) c-=b
        else a-=d
        taka = !taka
    }

    val ans = if(a > 0) "Yes" else "No"
    println(ans)
    pw.flush()
}

/****** Declared Functions and Data Structures ******/
// IO
fun read() = readLine()!!
fun readInt() = read().toInt()
fun readLong() = read().toLong()
fun readDouble() = read().toDouble()
fun readListOfString() = read().split(" ")
fun readListOfInt() = readListOfString().map { it.toInt() }
fun readListOfLong() = readListOfString().map { it.toLong() }
fun readListOfDouble() = readListOfString().map { it.toDouble() }

fun Double.format(digits: Int) = String.format("%.${digits}f", this)
fun Float.format(digits: Int) = String.format("%.${digits}f", this)

fun print(value: Any) { pw.print(value) }
fun println(value : Any) { pw.println(value) }

// Extensions
fun<T> List<T>.toBuckets(): Map<T, Int>
    = this.groupBy { it }.mapValues { it.value.size }

fun<T: Comparable<T>> List<T>.upperBound(element: T, fromIndex: Int=0, toIndex: Int=this.size): Int {
    var l = fromIndex
    var r = toIndex
    while(l < r) {
        val mid = (l+r) / 2
        if(element >= this[mid]) { 
            l = mid + 1
        } else {
            r = mid
        }
    }
    return l
}

fun<T: Comparable<T>> List<T>.lowerBound(element: T, fromIndex: Int=0, toIndex: Int=this.size): Int {
    var l = fromIndex
    var r = toIndex
    while(l < r) {
        val mid = (l+r) / 2
        if(element <= this[mid]) { 
            r = mid
        } else {
            l = mid + 1
        }
    }
    return r 
}

fun <K, V> Map<K, V>.toMutableMap(): MutableMap<K, V> = HashMap(this)

// Util Functions
fun Long.makeDivisors(): List<Long> {
    val divisors = mutableListOf<Long>()
    for(i in 1L .. Math.sqrt(this.toDouble()).toLong()+1L) {
        if(this % i == 0L) {
            divisors.add(i)
            if(i != this/i) {
                divisors.add(this/i)
            }
        }
    }
    return divisors.distinct().sorted()
}

fun Long.isPrime(): Boolean {
    if(this==1L) return false
    for(i in 2L .. Math.sqrt(this.toDouble()).toLong() + 1L) {
        if(this % i == 0L && this != i) {
            return false
        }
    }
    return true
}


fun<T> permutations(src: List<T>): List<List<T>> {
    if(src.size == 1) return listOf(src)
    val perms = mutableListOf<List<T>>()
    val insertElement = src[0]
    permutations(src.drop(1)).forEach { perm ->
        for(i in 0..perm.size) {
            val newPerm = perm.toMutableList()
            newPerm.add(i, insertElement)
            perms.add(newPerm.toList())
        }
    }
    return perms
}

// return nCr, if you want nCr, please access v[n][r]
fun combinations(n: Long): List<List<Long>> {
    val v = (0..n).map { (0..n).map{0L}.toMutableList() }.toMutableList()
    for(i in 0 until v.size) {
        v[i][0] = 1L
        v[i][i] = 1L
    }
    for(i in 0 until v.size) {
        for(j in 1 until i) {
            v[i][j] = (v[i-1][j-1] + v[i-1][j]) % MOD
        }
    }
    return v.map { it.toList() }.toList()
}

fun repeatedModPow(a: Long, n: Long, mod: Long): Long = 
    when {
        n == 1L -> a % mod
        n % 2L == 1L -> (a * repeatedModPow(a, n-1L, mod)) % mod
        else -> {
            val tmp = repeatedModPow(a, n / 2L, mod)
            (tmp * tmp) % mod
        }
    }

// return nCr % MOD
fun modnCkWithoutArray(n: Long, k: Long, mod: Long): Long {
    var ret = 1L
    val min = Math.min(k, n-k)
    // まず分母の計算
    for(i in n downTo (n - min + 1)) {
        ret = ret * i % mod
    }
    for(i in min downTo 1) {
        ret = ret * repeatedModPow(i, (mod - 2L), mod) % mod
    }
    return ret
}

// return nCr % MOD
fun modnCk(n: Int, k: Int, mod: Long): Long {
    val factorials = Array(n+1) { 0L }.apply {
        this[0] = 1L
        if(this.size > 1) this[1] = 1L
    }
    val inverses = Array(n+1) { 0L }.apply {
        this[0] = 1L
        if(this.size > 1) this[1] = 1L
    }
    val factorialInverses = Array(n+1) { 0L }.apply {
        this[0] = 1L
        if(this.size > 1) this[1] = 1L
    }
    for(i in 2 .. n) {
        factorials[i] = (factorials[i-1] * i.toLong() % mod)
        inverses[i] = (mod - inverses[mod.toInt() % i] * (mod / i.toLong()) % mod)
        factorialInverses[i] = (factorialInverses[i-1] * inverses[i] % mod)
    }

    return factorials[n] % mod * (factorialInverses[k] * factorialInverses[n-k] % mod) % mod
}

// should be a >= b
fun gcd(a: Long, b: Long): Long = 
    if(b == 0L) a else gcd(b, a % b)

// shoud be a >= b
fun lcm(a: Long, b: Long): Long = 
    a / gcd(a, b) * b

fun sumDigits(num_: Long): Long {
    var num = num_
    var rtn: Long = 0
    while(num != 0.toLong()) {
        val tmp = num % 10
        rtn += tmp
        num /= 10
    }
    return rtn
}

fun Double.isDecimal(): Boolean = ((this - Math.floor(this)) != 0.0)

// Data Structures

class UnionFind(private val n: Int) {
    private val parent: Array<Int> = Array(n) { 0 }
    private val rank: Array<Int> = Array(n) { 0 }
    private val size: Array<Int> = Array(n) { 0 }

    init {
        for(i in 0 until n) {
            parent[i] = i
            rank[i] = 1
            size[i] = 1
        }
    }

    fun union(u: Int, v: Int) {
        var x = root(u)
        var y = root(v)
        if(x != y) {
            if(rank[y] < rank[x]) {
                val tmp = y 
                y = x
                x = tmp 
            }
            parent[x] = y
            rank[y] += rank[x]
            rank[x] = -1
            val totalSize = size[x] + size[y]
            size[x] = totalSize
            size[y] = totalSize
        }
    }

    fun root(u: Int): Int {
        var x = u
        while(parent[x] != x) {
            x = parent[x]
        }
        return x 
    }

    fun size(u: Int): Int = size[root(u)]
}