Problem:
Score : 100 points

Problem Statement

You are given three integers A, B and C.
Determine whether C is not less than A and not greater than B.

Constraints

-100≤A,B,C≤100

A, B and C are all integers.

Input

Input is given from Standard Input in the following format:

A B C

Output

If the condition is satisfied, print Yes; otherwise, print No.

Sample Input 1

1 3 2

Sample Output 1

Yes

C=2 is not less than A=1 and not greater than B=3, and thus the output should be Yes.

Sample Input 2

6 5 4

Sample Output 2

No

C=4 is less than A=6, and thus the output should be No.

Sample Input 3

2 2 2

Sample Output 3

Yes

Solution in C# (Mono-csc 3.5.0) (judge verdict: Wrong Answer)

using System;
using System.Linq;
using System.Collections.Generic;

namespace Contest
{
  class Program
  {
    static void Main(string[] args)
    {
      ABC057.A();
    }
    class ABC057
    {
      public static void A()
      {
        var A = Read.Int();
        var B = Read.Int();
        Console.WriteLine((A + B) % 24);
      }
      public static void B()
      {
        var N = Read.Int();
        var M = Read.Int();
        var AB = Read.TupleInt(N);
        var CD = Read.TupleInt(M);
        var ans = new List<int>();
        foreach(var ab in AB)
        {
          int idx = -1;
          int min = Int32.MaxValue;
          for(int i = 0; i < M; ++i)
          {
            var d = Math.Abs(CD[i].Item1 - ab.Item1) + Math.Abs(CD[i].Item2 - ab.Item2);
            if (d < min)
            {
              idx = i + 1;
              min = d;
            }
          }
          ans.Add(idx);
        }
        Console.WriteLine(String.Join(Environment.NewLine, ans));
      }
      public static void C()
      {
        var N = Read.Long();
        var div = Util.Divisor(N);
        int min = Int32.MaxValue;
        foreach(var d in div)
        {
          min = Math.Min(min, Math.Max(d.ToString().Length, (N / d).ToString().Length));
        }
        Console.WriteLine(min);
      }
      public static void D()
      {
        var N = Read.Int();
        var A = Read.Int();
        var B = Read.Int();
        var V = Read.LongN().OrderBy(x => -x).ToArray();

        Func<int, int, long> comb = (n, m) =>
        {
          if (n < 0 || m < 0 || n < m) { return 0; }
          var dict = new Dictionary<long, int>();
          for (int i = 1; i <= n; ++i)
          {
            foreach (var kvp in Util.Factorize(i))
            {
              if (!dict.ContainsKey(kvp.Key))
              {
                dict.Add(kvp.Key, 0);
              }
              dict[kvp.Key] += kvp.Value;
            }
          }
          for (int i = 1; i <= m; ++i)
          {
            foreach (var kvp in Util.Factorize(i))
            {
              dict[kvp.Key] -= kvp.Value;
            }
          }
          for (int i = 1; i <= n - m; ++i)
          {
            foreach (var kvp in Util.Factorize(i))
            {
              dict[kvp.Key] -= kvp.Value;
            }
          }
          long r = 1;
          foreach (var kvp in dict)
          {
            for (int i = 0; i < kvp.Value; ++i)
            {
              r *= kvp.Key;
            }
          }
          return r;
        };

        Console.WriteLine(V.Take(A).Select(x => x * 1.0).Average());
        if (V[0] > V[A - 1])
        {
          var n = V.Count(x => x == V[A - 1]);
          var m = A - V.Count(x => x > V[A - 1]);
          Console.WriteLine(comb(n, m));
        }
        else
        {
          var n = V.Count(x => x == V[A - 1]);
          long ans = 0;
          for (int i = A; i <= B; ++i)
          {
            ans += comb(n, i);
          }
          Console.WriteLine(ans);
        }
      }
    }
    class Util
    {
      public static T[,] Gen<T>(int r, int c, T v)
      {
        var matrix = new T[r, c];
        for (int i = 0; i < r; ++i)
        {
          for (int j = 0; j < c; ++j)
          {
            matrix[i, j] = v;
          }
        }
        return matrix;
      }
      public static long[] ASum(long[] array)
      {
        var res = new long[array.Length + 1];
        for (int i = 0; i < array.Length; ++i)
        {
          res[i + 1] = res[i] + array[i];
        }
        return res;
      }
      public static long[,] ASum(long[,] matrix)
      {
        var N = matrix.GetLength(0);
        var M = matrix.GetLength(1);
        var res = new long[N + 1, M + 1];
        for(int i = 0; i < N; ++i)
        {
          for(int j = 0; j < M; ++j)
          {
            res[i + 1, j + 1] = res[i, j + 1] + res[i + 1, j] - res[i, j] + matrix[i, j];
          }
        }
        return res;
      }
      public static Dictionary<T, long> Frequency<T>(T[] array)
      {
        var dict = new Dictionary<T, long>();
        foreach (var a in array)
        {
          if (!dict.ContainsKey(a)) { dict.Add(a, 0); }
          dict[a]++;
        }
        return dict;
      }
      public static long GCD(long a, long b)
      {
        while (b > 0)
        {
          var c = a % b;
          a = b;
          b = c;
        }
        return a;
      }
      public static HashSet<long> Divisor(long x)
      {
        var div = new HashSet<long>(); for (long p = 1; p * p <= x; ++p) { if (x % p == 0) { div.Add(p); } }
        foreach (var d in div.ToArray())
        {
          if (!div.Contains(x / d)) { div.Add(x / d); }
        }
        return div;
      }
      public static Dictionary<long, int> Factorize(long x)
      {
        var dict = new Dictionary<long, int>();
        long minp = 2;
        while (x > 1)
        {
          bool ok = false;
          for (long p = minp; p * p <= x; ++p)
          {
            if (x % p == 0)
            {
              if (!dict.ContainsKey(p))
              {
                dict.Add(p, 0);
              }
              dict[p]++;
              minp = p;
              x /= p;
              ok = true;
              break;
            }
          }
          if (!ok)
          {
            if (!dict.ContainsKey(x)) { dict.Add(x, 0); }
            dict[x]++;
            break;
          }
        }
        return dict;
      }


    }

    static class Read
{
static Queue<string> queue = new Queue<string>();
static void Enqueue() { var ss = Console.ReadLine().Split(' '); foreach (var s in ss) { queue.Enqueue(s); } }
public static int Int() { if (queue.Count == 0) { Enqueue(); } return Convert.ToInt32(queue.Dequeue()); }
public static long Long() { if (queue.Count == 0) { Enqueue(); } return Convert.ToInt64(queue.Dequeue()); }
public static string Str() { if (queue.Count == 0) { Enqueue(); } return queue.Dequeue(); }
public static int[] IntN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToInt32(s)).ToArray(); }
public static long[] LongN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToInt64(s)).ToArray(); }
public static ulong[] ULongN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToUInt64(s)).ToArray(); }
public static string[] StrN() { return Console.ReadLine().Split(' '); }
public static Tuple<int, int>[] TupleInt(int n) { List<Tuple<int, int>> list = new List<Tuple<int, int>>(); for (int i = 0; i < n; ++i) { var ab = Read.IntN(); list.Add(new Tuple<int, int>(ab[0], ab[1])); } return list.ToArray(); }
public static Tuple<long, long>[] TupleLong(int n) { List<Tuple<long, long>> list = new List<Tuple<long, long>>(); for (int i = 0; i < n; ++i) { var ab = Read.LongN(); list.Add(new Tuple<long, long>(ab[0], ab[1])); } return list.ToArray(); }
public static Tuple<string, string>[] TupleStr(int n) { List<Tuple<string, string>> list = new List<Tuple<string, string>>(); for (int i = 0; i < n; ++i) { var ab = Read.StrN(); list.Add(new Tuple<string, string>(ab[0], ab[1])); } return list.ToArray(); }
public static Tuple<double, double>[] TupleDouble(int n) { List<Tuple<double, double>> list = new List<Tuple<double, double>>(); for (int i = 0; i < n; ++i) { var ab = Read.LongN(); list.Add(new Tuple<double, double>(ab[0], ab[1])); } return list.ToArray(); }
public static long[,] LongMatrix(int r, int c) { var mat = new long[r, c]; for (int i = 0; i < r; ++i) { var x = Read.LongN(); for (int j = 0; j < c; ++j) { mat[i, j] = x[j]; } } return mat; }
public static Dictionary<int, HashSet<int>> AdjacencyList(int N, int M, bool isDirectional = false)
{
Dictionary<int, HashSet<int>> dict = new Dictionary<int, HashSet<int>>();
for (int i = 0; i <= N; ++i) { dict.Add(i, new HashSet<int>()); }
        for (int i = 0; i < M; ++i) { var ab = Read.IntN(); if (!dict[ab[0]].Contains(ab[1])) { dict[ab[0]].Add(ab[1]); } if (!isDirectional && !dict[ab[1]].Contains(ab[0])) { dict[ab[1]].Add(ab[0]); } }
        return dict;
}
public static Dictionary<int, Dictionary<int, long>> AdjacencyListWithWeight(int N, int M)
{
Dictionary<int, Dictionary<int, long>> dict = new Dictionary<int, Dictionary<int, long>>(); for (int i = 0; i <= N; ++i) { dict.Add(i, new Dictionary<int, long>()); }
for (int i = 0; i < M; ++i) { var ab = Read.IntN(); dict[ab[0]].Add(ab[1], ab[2]); dict[ab[1]].Add(ab[0], ab[2]); }
return dict;
}
}
    }
}