Problem:
Score : 100 points

Problem Statement

Determine if we can choose K different integers between 1 and N (inclusive) so that no two of them differ by 1.

Constraints

1\leq N,K\leq 100

N and K are integers.

Input

Input is given from Standard Input in the following format:

N K

Output

If we can choose K integers as above, print YES; otherwise, print NO.

Sample Input 1

3 2

Sample Output 1

YES

We can choose 1 and 3.

Sample Input 2

5 5

Sample Output 2

NO

Sample Input 3

31 10

Sample Output 3

YES

Sample Input 4

10 90

Sample Output 4

NO

Solution in C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.IO;
using System.Linq;
using System.Text;
using static System.Console;
using static System.Math;
using static Macro;
using static LinqExtension;
class AC {
    /*------------------------------------------------------------------*/
    int N, K;
    void Solve() {
        N = io.Int;
        K = io.Int;
        if (N.IsOdd()) {
            io.YN(N / 2 + 1 >= K);
        } else {
            io.YN(N / 2 >= K);
        }
    }
    /*------------------------------------------------------------------*/
    void Test() {
        //--- TEST ---//
    }
    public static void Main(string[] args) => new AC().Stream();
    IO io = new IO();
    private void Stream() {
        /*
        var exStdIn = new System.IO.StreamReader("stdin.txt");
        SetIn(exStdIn);
        Test();
        */
        Solve();
        io.Flush();
    }
}
class IO {
    #region INPUT
    #region FastRead
    private const int Size = 1 << 12;
    private readonly Stream _stream = OpenStandardInput();
    private readonly byte[] _buffer = new byte[Size];
    private int _ptr = 0, _buffLen = 0;
    private bool HasNextByte() {
        if (_ptr < _buffLen) return true;
        _ptr = 0;
        _buffLen = _stream.Read(_buffer, 0, Size);
        return _buffLen > 0;
    }
    private byte ReadByte() {
        if (HasNextByte()) return _buffer[_ptr++];
        else
            //inputの末尾の改行がないとerror
            throw new EndOfStreamException();
    }
    private bool IsAscii(int c) => '!' <= c && c <= '~';
    private char NextChar() {
        var b = ReadByte();
        while (!IsAscii(b)) b = ReadByte();
        return (char)b;
    }
    private string Next() {
        var sb = new StringBuilder();
        for (var b = NextChar(); IsAscii(b); b = (char)ReadByte()) sb.Append(b);
        return sb.ToString();
    }
    public string String => Next();
    public char Char => NextChar();
    public int Int => int.Parse(Next());
    public long Long => long.Parse(Next());
    public double Double => double.Parse(Next());
    #endregion
    #region LazyRead
    private void scan<T>(ref T x) {
        if (x is int) __refvalue(__makeref(x), int) = int.Parse(Next());
        else if (x is long) __refvalue(__makeref(x), long) = long.Parse(Next());
        else if (x is double) __refvalue(__makeref(x), double) = double.Parse(Next());
        else if (x is char) __refvalue(__makeref(x), char) = NextChar();
        else __refvalue(__makeref(x), string) = Next();
    }
    public void i<T>(out T t) {
        t = default(T);
        scan(ref t);
    }
    public void i<T, TU>(out T t, out TU u) {
        i(out t);
        i(out u);
    }
    public void i<T, TU, TV>(out T t, out TU u, out TV v) {
        i(out t, out u);
        i(out v);
    }
    public void i<T, TU, TV, TW>(out T t, out TU u, out TV v, out TW w) {
        i(out t, out u);
        i(out v, out w);
    }
    public void i<T, TU, TV, TW, TX>(out T t, out TU u, out TV v, out TW w, out TX x) {
        i(out t, out u, out v);
        i(out w, out x);
    }
    public void i<T, TU, TV, TW, TX, TY>(out T t, out TU u, out TV v, out TW w, out TX x, out TY y) {
        i(out t, out u, out v);
        i(out w, out x, out y);
    }
    public void ini<T>(out T[] a, int n) {
        a = new T[n];
        for (int i = 0; i < n; ++i) i<T>(out a[i]);
    }
    public void ini<T, TU>(out T[] a, out TU[] b, int n) {
        a = new T[n];
        b = new TU[n];
        for (int i = 0; i < n; ++i) i<T, TU>(out a[i], out b[i]);
    }
    public void ini<T, TU, TV>(out T[] a, out TU[] b, out TV[] c, int n) {
        a = new T[n];
        b = new TU[n];
        c = new TV[n];
        for (var i = 0; i < n; ++i) i<T, TU, TV>(out a[i], out b[i], out c[i]);
    }
    public void ini<T>(out T[,] a, int h, int w) {
        a = new T[h, w];
        for (int i = 0; i < h; ++i) for (int j = 0; j < w; ++j) i<T>(out a[i, j]);
    }
    #endregion
    #endregion
    #region OUTPUT
    private readonly StreamWriter _sw = new StreamWriter(OpenStandardOutput()) {
#if DEBUG
        AutoFlush = true
#else
        AutoFlush = false
#endif
    };
    public void Flush() => Out.Flush();
    public void YN(bool f) => yn(f, "YES", "NO");
    public void Yn(bool f) => yn(f, "Yes", "No");
    public void yn(bool f, string y = "yes", string n = "no") => WriteLine(f ? y : n);
    #endregion
    public IO() { SetOut(_sw); }
}
static class Macro {
    public static void FOR(int a, int b, int n, Action<int> f) {
        for (var i = a; i < b; i += n) {
            try {
                f(i);
            } catch (IndexOutOfRangeException e) {
#if DEBUG
                WriteLine($"IndexOutOfRange at [{i}]");
#endif
            }
        }
    }
    public static void FOR(int a, int b, Action<int> f) => FOR(a, b, 1, f);
    public static void REP(int a, Action<int> f) => FOR(0, a, 1, f);
    public static void REP(int a, int n, Action<int> f) => FOR(0, a, n, f);
    public static void FOREQ(int a, int b, Action<int> f) => FOR(a, b + 1, 1, f);
    public static void FOREQ(int a, int b, int n, Action<int> f) => FOR(a, b + 1, n, f);
    public static void REPEQ(int a, Action<int> f) => FOR(0, a + 1, 1, f);
    public static void REPEQ(int a, int n, Action<int> f) => FOR(0, a + 1, n, f);
    public static T MIN<T>(params T[] xs) => xs.Min();
    public static T MAX<T>(params T[] xs) => xs.Max();
    public static IEnumerable<Tuple<T, U>> ZIP<T, U>(IEnumerable<T> x, IEnumerable<U> y)
        => x.Zip(y, (i1, i2) => new Tuple<T, U>(i1, i2));

    public static IEnumerable<Tuple<T, U, V>> ZIP<T, U, V>(
        IEnumerable<T> xs,
        IEnumerable<U> ys,
        IEnumerable<V> zs) {
        using (var eX = xs.GetEnumerator())
        using (var eY = ys.GetEnumerator())
        using (var eZ = zs.GetEnumerator()) {
            while (eX.MoveNext() && eY.MoveNext() && eZ.MoveNext()) {
                yield return new Tuple<T, U, V>(eX.Current, eY.Current, eZ.Current);
            }
        }
    }
}
static class Extension {
    public static void Rep(this int a, Action<int> f) => FOR(0, a, 1, f);
    public static void Rep(this int a, int n, Action<int> f) => FOR(0, a, n, f);
    public static void RepEQ(this int a, Action<int> f) => FOR(0, a + 1, 1, f);
    public static void RepEQ(this int a, int n, Action<int> f) => FOR(0, a + 1, n, f);
    public static void Prt<T>(this T x) => WriteLine(x);
    public static void Prt<T>(this IEnumerable<T> xs) => xs.Iter(x => WriteLine(x));
    public static void Prt_<T>(this IEnumerable<T> xs) {
        xs.Iter(x => Write($"{x} "));
        WriteLine();
    }
    public static bool IsOdd(this int x) => x % 2 != 0;
    public static bool IsOdd(this long x) => x % 2 != 0;
}
static class LinqExtension {
    public struct IndexedValue<T> {
        public int Index;
        public T Value;
        public IndexedValue(int index, T value) {
            this.Index = index;
            this.Value = value;
        }
        public override string ToString() {
            return string.Format("Index: {0}, Value: {1}", Index, Value);
        }
    }
    public static IEnumerable<IndexedValue<T>> Indexed<T>(this IEnumerable<T> source) {
        return source.Select((value, index) => new IndexedValue<T>(index, value));
    }
    public static void Iter<T>(this IEnumerable<T> source, Action<T> action) {
        foreach (var s in source) action(s);
    }
    private static IEnumerable<T> Init<T>(int size, Func<int, T> f) {
        for (var i = 0; i < size; ++i) yield return f(i);
    }
    public static IEnumerable<IEnumerable<T>> Windowed<T>(this IEnumerable<T> source, int size) {
        var tmpArr = new T[size];
        var r = size - 1;
        var i = 0;
        using (var e = source.GetEnumerator()) {
            while (e.MoveNext()) {
                tmpArr[i] = e.Current;
                i = (i + 1) % size;
                if (r == 0) yield return Init<T>(size, j => tmpArr[(i + j) % size]);
                else r--;
            }
        }
    }
    public static IEnumerable<T> Sort<T>(this IEnumerable<T> source) => source.OrderBy(x => x);
    public static IEnumerable<T> Rev<T>(this IEnumerable<T> source) => Sort(source).Reverse();
    public static IEnumerable<T> DistinctBy<T, U>(this IEnumerable<T> source, Func<T, U> groupBy, Func<IGrouping<U, T>, T> selectBy)
        => source.GroupBy(groupBy).Select(selectBy);
    public static IEnumerable<T> DistinctBy<T, U>(this IEnumerable<T> source, Func<T, U> groupBy) => source.DistinctBy(groupBy, x => x.First());

}