fork download
copy 
  1. //package com.codeforces.competitions.year2016.julytoseptember.round368div2;
  2.  
  3. import java.io.*;
  4. import java.util.*;
  5.  
  6. class TaskA
  7. {
  8.     public static void main(String[] args)
  9.     {
  10.         InputReader in = new InputReader(System.in);
  11.         OutputWriter out = new OutputWriter(System.out);
  12.  
  13. 		Solver solver = new Solver(in, out);
  14. 		solver.solve();
  15.  
  16.         out.flush();
  17.  
  18.         in.close();
  19.         out.close();
  20.     }
  21.  
  22.     static class Solver
  23.     {
  24.         int n, m;
  25.         InputReader in;
  26.         OutputWriter out;
  27.  
  28. 		void solve()
  29. 		{
  30. 			n = in.nextInt();
  31. 			m = in.nextInt();
  32.  
  33. 			String[] col = new String[n];
  34.  
  35. 			for (int i = 0; i < n; i++)
  36. 				col[i] = in.nextLine();
  37.  
  38. 			boolean found = false;
  39.  
  40. 			for (int i = 0; i < n; i++)
  41. 			{
  42. 				for (int j = 0; j < 2 * m; j += 2)
  43. 				{
  44. 					char c = col[i].charAt(j);
  45.  
  46. 					if (col[i].charAt(j) == 'C' || c == 'M' || c == 'Y')
  47. 						found = true;
  48. 				}
  49. 			}
  50.  
  51. 			if (found)
  52. 				out.println("#Color");
  53. 			else
  54. 				out.println("#Black&White");
  55. 		}
  56.  
  57.         public Solver(InputReader in, OutputWriter out)
  58.         {
  59.         	this.in = in;
  60.         	this.out = out;
  61.         }
  62.  
  63. 	}
  64.  
  65.     static class InputReader
  66.     {
  67.         private InputStream stream;
  68.         private byte[] buf = new byte[1024];
  69.         private int curChar;
  70.         private int numChars;
  71.  
  72.         public InputReader(InputStream stream)
  73.         {
  74.             this.stream = stream;
  75.         }
  76.  
  77.         public int read()
  78.         {
  79.             if (numChars == -1)
  80.                 throw new InputMismatchException();
  81.  
  82.             if (curChar >= numChars)
  83.             {
  84.                 curChar = 0;
  85.                 try
  86.                 {
  87.                     numChars = stream.read(buf);
  88.                 } catch (IOException e)
  89.                 {
  90.                     throw new InputMismatchException();
  91.                 }
  92.                 if (numChars <= 0)
  93.                     return -1;
  94.             }
  95.  
  96.             return buf[curChar++];
  97.         }
  98.  
  99.         public int nextInt()
  100.         {
  101.             int c = read();
  102.  
  103.             while (isSpaceChar(c))
  104.                 c = read();
  105.  
  106.             int sgn = 1;
  107.  
  108.             if (c == '-')
  109.             {
  110.                 sgn = -1;
  111.                 c = read();
  112.             }
  113.  
  114.             int res = 0;
  115.  
  116.             do
  117.             {
  118.                 if (c < '0' || c > '9')
  119.                     throw new InputMismatchException();
  120.  
  121.                 res *= 10;
  122.                 res += c & 15;
  123.  
  124.                 c = read();
  125.             } while (!isSpaceChar(c));
  126.  
  127.             return res * sgn;
  128.         }
  129.  
  130.         public int[] nextIntArray(int arraySize)
  131.         {
  132.             int array[] = new int[arraySize];
  133.  
  134.             for (int i = 0; i < arraySize; i++)
  135.                 array[i] = nextInt();
  136.  
  137.             return array;
  138.         }
  139.  
  140.         public long nextLong()
  141.         {
  142.             int c = read();
  143.  
  144.             while (isSpaceChar(c))
  145.                 c = read();
  146.  
  147.             int sign = 1;
  148.  
  149.             if (c == '-')
  150.             {
  151.                 sign = -1;
  152.  
  153.                 c = read();
  154.             }
  155.  
  156.             long result = 0;
  157.  
  158.             do
  159.             {
  160.                 if (c < '0' || c > '9')
  161.                     throw new InputMismatchException();
  162.  
  163.                 result *= 10;
  164.                 result += c & 15;
  165.  
  166.                 c = read();
  167.             } while (!isSpaceChar(c));
  168.  
  169.             return result * sign;
  170.         }
  171.  
  172.         public long[] nextLongArray(int arraySize)
  173.         {
  174.             long array[] = new long[arraySize];
  175.  
  176.             for (int i = 0; i < arraySize; i++)
  177.                 array[i] = nextLong();
  178.  
  179.             return array;
  180.         }
  181.  
  182.         public float nextFloat() // problematic
  183.         {
  184.             float result, div;
  185.             byte c;
  186.  
  187.             result = 0;
  188.             div = 1;
  189.             c = (byte) read();
  190.  
  191.             while (c <= ' ')
  192.                 c = (byte) read();
  193.  
  194.             boolean isNegative = (c == '-');
  195.  
  196.             if (isNegative)
  197.                 c = (byte) read();
  198.  
  199.             do
  200.             {
  201.                 result = result * 10 + c - '0';
  202.             } while ((c = (byte) read()) >= '0' && c <= '9');
  203.  
  204.             if (c == '.')
  205.                 while ((c = (byte) read()) >= '0' && c <= '9')
  206.                     result += (c - '0') / (div *= 10);
  207.  
  208.             if (isNegative)
  209.                 return -result;
  210.  
  211.             return result;
  212.         }
  213.  
  214.         public double nextDouble() // not completely accurate
  215.         {
  216.             double ret = 0, div = 1;
  217.             byte c = (byte) read();
  218.  
  219.             while (c <= ' ')
  220.                 c = (byte) read();
  221.  
  222.             boolean neg = (c == '-');
  223.  
  224.             if (neg)
  225.                 c = (byte) read();
  226.  
  227.             do
  228.             {
  229.                 ret = ret * 10 + c - '0';
  230.             } while ((c = (byte) read()) >= '0' && c <= '9');
  231.  
  232.             if (c == '.')
  233.                 while ((c = (byte) read()) >= '0' && c <= '9')
  234.                     ret += (c - '0') / (div *= 10);
  235.  
  236.             if (neg)
  237.                 return -ret;
  238.  
  239.             return ret;
  240.         }
  241.  
  242.         public String next()
  243.         {
  244.             int c = read();
  245.  
  246.             while (isSpaceChar(c))
  247.                 c = read();
  248.  
  249.             StringBuilder res = new StringBuilder();
  250.  
  251.             do
  252.             {
  253.                 res.appendCodePoint(c);
  254.  
  255.                 c = read();
  256.             } while (!isSpaceChar(c));
  257.  
  258.             return res.toString();
  259.         }
  260.  
  261.         public boolean isSpaceChar(int c)
  262.         {
  263.             return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
  264.         }
  265.  
  266.         public String nextLine()
  267.         {
  268.             int c = read();
  269.  
  270.             StringBuilder result = new StringBuilder();
  271.  
  272.             do
  273.             {
  274.                 result.appendCodePoint(c);
  275.  
  276.                 c = read();
  277.             } while (!isNewLine(c));
  278.  
  279.             return result.toString();
  280.         }
  281.  
  282.         public boolean isNewLine(int c)
  283.         {
  284.             return c == '\n';
  285.         }
  286.  
  287.         public void close()
  288.         {
  289.             try
  290.             {
  291.                 stream.close();
  292.             } catch (IOException e)
  293.             {
  294.                 e.printStackTrace();
  295.             }
  296.         }
  297.  
  298.     }
  299.  
  300.     static class OutputWriter
  301.     {
  302.         private PrintWriter writer;
  303.  
  304.         public OutputWriter(OutputStream stream)
  305.         {
  306.             writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
  307.                     stream)));
  308.         }
  309.  
  310.         public OutputWriter(Writer writer)
  311.         {
  312.             this.writer = new PrintWriter(writer);
  313.         }
  314.  
  315.         public void println(int x)
  316.         {
  317.             writer.println(x);
  318.         }
  319.  
  320.         public void print(int x)
  321.         {
  322.             writer.print(x);
  323.         }
  324.  
  325. 		public void println(char x)
  326. 		{
  327. 			writer.println(x);
  328. 		}
  329.  
  330. 		public void print(char x)
  331. 		{
  332. 			writer.print(x);
  333. 		}
  334.  
  335.         public void println(int array[], int size)
  336.         {
  337.             for (int i = 0; i < size; i++)
  338.                 println(array[i]);
  339.         }
  340.  
  341.         public void print(int array[], int size)
  342.         {
  343.             for (int i = 0; i < size; i++)
  344.                 print(array[i] + " ");
  345.         }
  346.  
  347.         public void println(long x)
  348.         {
  349.             writer.println(x);
  350.         }
  351.  
  352.         public void print(long x)
  353.         {
  354.             writer.print(x);
  355.         }
  356.  
  357.         public void println(long array[], int size)
  358.         {
  359.             for (int i = 0; i < size; i++)
  360.                 println(array[i]);
  361.         }
  362.  
  363.         public void print(long array[], int size)
  364.         {
  365.             for (int i = 0; i < size; i++)
  366.                 print(array[i]);
  367.         }
  368.  
  369.         public void println(float num)
  370.         {
  371.             writer.println(num);
  372.         }
  373.  
  374.         public void print(float num)
  375.         {
  376.             writer.print(num);
  377.         }
  378.  
  379.         public void println(double num)
  380.         {
  381.             writer.println(num);
  382.         }
  383.  
  384.         public void print(double num)
  385.         {
  386.             writer.print(num);
  387.         }
  388.  
  389.         public void println(String s)
  390.         {
  391.             writer.println(s);
  392.         }
  393.  
  394.         public void print(String s)
  395.         {
  396.             writer.print(s);
  397.         }
  398.  
  399.         public void println()
  400.         {
  401.             writer.println();
  402.         }
  403.  
  404.         public void printSpace()
  405.         {
  406.             writer.print(" ");
  407.         }
  408.  
  409. 		public void printf(String format, Object args)
  410. 		{
  411. 			writer.printf(format, args);
  412. 		}
  413.  
  414.         public void flush()
  415.         {
  416.             writer.flush();
  417.         }
  418.  
  419.         public void close()
  420.         {
  421.             writer.close();
  422.         }
  423.  
  424.     }
  425.  
  426. 	static class CMath
  427. 	{
  428. 		static long power(long number, long power)
  429. 		{
  430. 			if (number == 1 || number == 0 || power == 0)
  431. 				return 1;
  432.  
  433. 			if (power == 1)
  434. 				return number;
  435.  
  436. 			if (power % 2 == 0)
  437. 				return power(number * number, power / 2);
  438. 			else
  439. 				return power(number * number, power / 2) * number;
  440. 		}
  441.  
  442. 		static long modPower(long number, long power, long mod)
  443. 		{
  444. 			if (number == 1 || number == 0 || power == 0)
  445. 				return 1;
  446.  
  447. 			number = mod(number, mod);
  448.  
  449. 			if (power == 1)
  450. 				return number;
  451.  
  452. 			long square = mod(number * number, mod);
  453.  
  454. 			if (power % 2 == 0)
  455. 				return modPower(square, power / 2, mod);
  456. 			else
  457. 				return mod(modPower(square, power / 2, mod) * number, mod);
  458. 		}
  459.  
  460. 		static long moduloInverse(long number, long mod)
  461. 		{
  462. 			return modPower(number, mod - 2, mod);
  463. 		}
  464.  
  465. 		static long mod(long number, long mod)
  466. 		{
  467. 			return number - (number / mod) * mod;
  468. 		}
  469.  
  470. 		static int gcd(int a, int b)
  471. 		{
  472. 			if (b == 0)
  473. 				return a;
  474. 			else
  475. 				return gcd(b, a % b);
  476. 		}
  477.  
  478. 	}
  479.  
  480. }
  481.  
Success #stdin #stdout 0.04s 320576KB
comments (?)
stdin
copy 
1 6
C M Y W G B
stdout
copy 
#Color
https://ideone.com/3ozYaI
language:
Java (12.0.1)
created:
8 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!