Problem:
Score: 100 points

Problem Statement

A triple of numbers is said to be poor when two of those numbers are equal but the other number is different from those two numbers.

You will be given three integers A, B, and C. If this triple is poor, print Yes; otherwise, print No.

Constraints

A, B, and C are all integers between 1 and 9 (inclusive).

Input

Input is given from Standard Input in the following format:

A B C

Output

If the given triple is poor, print Yes; otherwise, print No.

Sample Input 1

5 7 5

Sample Output 1

Yes

A and C are equal, but B is different from those two numbers, so this triple is poor.

Sample Input 2

4 4 4

Sample Output 2

No

A, B, and C are all equal, so this triple is not poor.

Sample Input 3

4 9 6

Sample Output 3

No

Sample Input 4

3 3 4

Sample Output 4

Yes

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Accepted)

import java.io.*;
import java.util.*;
import java.lang.*;

public class Main {
	int mod = 1000000007;

	static FastScanner sc = new FastScanner();
	
	public static void main(String[] args) {
		out = new PrintWriter(new BufferedOutputStream(System.out));
		int a=sc.nextInt();
		int b=sc.nextInt();
		int c=sc.nextInt();
		if(a==b&&b==c) {
			out.println("No");
		}else if((a-b)*(b-c)*(a-c)==0) {
			out.println("Yes");
		}else {
			out.println("No");
		}
		out.close();
	}

	// ----------------------------------------------------------

	static int l_min(int[] a) {
		Arrays.sort(a);
		return a[0];
	}

	static int l_max(int[] a) {
		int l = a.length;
		Arrays.sort(a);
		return a[l - 1];
	}

	static int gcd(int a, int b) {

		if (a == 0) {
			return b;
		}
		return gcd(b % a, a);

	}
	static int[] fill(int[] a){
		int n=a.length;
		for (int i = 0; i < n; i++) {
			a[i]=sc.nextInt();
		}
		return a;
	}

	public static PrintWriter out;

}

class UnionFind {
	int parent[];
	int rank[];
	int size[];

	UnionFind(int n) {
		parent = new int[n];
		rank = new int[n];
		size = new int[n];
		for (int i = 0; i < n; i++) {
			parent[i] = i;
			rank[i] = 0;
			size[i] = 1;
		}
	}

	void union(int x, int y) {
		int xRoot = find(x);
		int yRoot = find(y);

		if (xRoot != yRoot) {

			if (rank[xRoot] > rank[yRoot]) {
				parent[yRoot] = xRoot;
				size[xRoot] += size[yRoot];

			} else if (rank[xRoot] < rank[yRoot]) {
				parent[xRoot] = yRoot;
				size[yRoot] += size[xRoot];

			} else {
				parent[yRoot] = xRoot;
				rank[xRoot]++;
				size[xRoot] += size[yRoot];
			}
		}

	}

	int find(int x) {
		if (parent[x] == x) {
			return x;
		} else {
			return find(parent[x]);
		}

	}

	boolean same(int x, int y) {
		return find(x) == find(y);
	}

}

class FastScanner {
	private final InputStream in = System.in;
	private final byte[] buffer = new byte[1024];
	private int ptr = 0;
	private int buflen = 0;

	private boolean hasNextByte() {
		if (ptr < buflen) {
			return true;
		} else {
			ptr = 0;
			try {
				buflen = in.read(buffer);
			} catch (IOException e) {
				e.printStackTrace();
			}
			if (buflen <= 0) {
				return false;
			}
		}
		return true;
	}

	private int readByte() {
		if (hasNextByte())
			return buffer[ptr++];
		else
			return -1;
	}

	private static boolean isPrintableChar(int c) {
		return 33 <= c && c <= 126;
	}

	public boolean hasNext() {
		while (hasNextByte() && !isPrintableChar(buffer[ptr]))
			ptr++;
		return hasNextByte();
	}

	public String next() {
		if (!hasNext())
			throw new NoSuchElementException();
		StringBuilder sb = new StringBuilder();
		int b = readByte();
		while (isPrintableChar(b)) {
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	public long nextLong() {
		if (!hasNext())
			throw new NoSuchElementException();
		long n = 0;
		boolean minus = false;
		int b = readByte();
		if (b == '-') {
			minus = true;
			b = readByte();
		}
		if (b < '0' || '9' < b) {
			throw new NumberFormatException();
		}
		while (true) {
			if ('0' <= b && b <= '9') {
				n *= 10;
				n += b - '0';
			} else if (b == -1 || !isPrintableChar(b)) {
				return minus ? -n : n;
			} else {
				throw new NumberFormatException();
			}
			b = readByte();
		}
	}

	public int nextInt() {
		long nl = nextLong();
		if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
			throw new NumberFormatException();
		return (int) nl;
	}

	public double nextDouble() {
		return Double.parseDouble(next());
	}
}