import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.StringTokenizer;

/**
 * <b> Algorithm on Codeforces. Problem C div 2 </b> </br>
 * @author Huynh Quang Thao
 *
 */
public class Main {

    public static void main(String[] args) throws Exception {
        Main main = new Main();
        main.run();
    }

    public void run() throws Exception {
         Scanner sc = null;
         PrintWriter pr = null;

         pr=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
         sc = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
     //   sc = new Scanner(new File("input.txt"));

         int n = sc.nextInt();
         n = 2*n;
         int[] arr = new int[n];
         int[] first = new int[1000];
         int[] second = new int[1000];
         Arrays.fill(first, -1);
         Arrays.fill(second, -1);

         for (int i = 0; i < n; i++) {
             arr[i] = sc.nextInt();
             if (first[arr[i]] == -1) first[arr[i]] = i;
             else if (second[arr[i]] == -1) second[arr[i]] = i;
         }

         // map contains freq of values
         Map<Integer, Integer> map = new HashMap<Integer, Integer>();
         for (int i = 0; i < n; i++) {
             if (!map.containsKey(arr[i])) {
                 map.put(arr[i], 1);
             }
             else {
                 map.put(arr[i], map.get(arr[i]) + 1);
             }
         }

         //process
         int[] T = new int[n];

         // start to fill 1 or 2
         int current = 0;
         int heap1 = n/2, heap2 = n/2;
         for (int i = 0; i < n; i++) {
             int key = arr[i];
             if (map.get(key) == 1) {
                 if (current % 2 == 0) {
                     T[i] = 1;
                     heap1--;
                 }
                 else {
                     T[i] = 2;
                     heap2--;
                 }
                 current = (current + 1) % 2;
             }
             else {
                 // >= 2 times appear
                 int loc1 = first[key];
                 int loc2 = second[key];
                // know that we have not add to heap yet
                 if (T[loc1] == 0) {
                     heap1--; heap2--;
                     T[loc1] = 1;
                     T[loc2] = 2;
                 }
             }
         }

         // process the rest
         for (int i = 0; i < n; i++) {
             if (T[i] == 0 && heap1 > 0) {
                 T[i] = 1;
                 heap1--;
             }
             else if (T[i] == 0 && heap1 == 0) T[i] = 2;
         }


         // add to list
         List<Integer> heap_1 = new ArrayList<Integer>();
         List<Integer> heap_2 = new ArrayList<Integer>();
         for (int i = 0; i < n; i++) {
             if (T[i] == 1) heap_1.add(arr[i]);
             else heap_2.add(arr[i]);
         }

         Set<Integer> set = new HashSet<Integer>();
         for (int i = 0; i < heap_1.size(); i++) {
             for (int j = 0; j < heap_2.size(); j++) {
                 int num = heap_1.get(i) * 100 + heap_2.get(j);
                 set.add(num);
             }
         }

         System.out.println(set.size());

         // print
         for (int i = 0; i < n; i++) {
             System.out.print(T[i] + " ");
         }

         pr.close();
         sc.close();
    }

    static class Point {
        double x, y;
        public Point(double x, double y) {
            this.x = x;
            this.y = y;
        }
    }

    static class InputReader {
        public BufferedReader reader;

        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                }
                catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

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

        public float nextFloat() {
            return Float.parseFloat(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public BigInteger nextBigInteger() {
            return new BigInteger(next());
        }

    }
}