import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Q3M {
	public static void main(String[] args) throws Exception {
		compute();
	}

	private static void compute() throws Exception {
		BufferedReader br = new BufferedReader(new FileReader(new File(
				"C:\\work\\Q3\\C-small-attempt0.in")));
		String line = null;
		int i = Integer.parseInt(br.readLine());
		List l = new ArrayList();
		for (int j = 0; j < i; j++) {
			line = br.readLine();
			String[] nums = line.split(" ");
			l.add(calculate(nums));
		}
		writeOutput(l);
	}

	private static int calculate(String[] nums) {
		int min = Integer.parseInt(nums[0]);
		int max = Integer.parseInt(nums[1]);
		int count = 0;
		List l = new ArrayList();
		for (int i = min; i <= max; i++) {
			for (int times = 1; times < countDigits(i); times++) {
				int res = shiftNum(i, times);
				if (res <= max && i < res) {
					if ((!l.contains((i + ":" + res)))) {
						l.add(i + ":" + res);
						l.add(res + ":" + i);
						count++;
					}
				}
			}
		}
		return count;
	}

	private static boolean checkZeros(int temp, int res) {
		if (temp % 10 == 0 || res % 10 == 0)
			return false;
		return true;
	}

	private static int shiftNum(int n, int times) {
		int base = (int) Math.pow(10, times);
		int temp2 = n / base;
		int placeHolder = (int) Math.pow((double) 10,
				(double) countDigits(temp2));
		int res = placeHolder * (n % base) + temp2;
		if (countDigits(res) == countDigits(n)) {
			return res;
		} else {
			return 2000001;
		}
	}

	public static int countDigits(int x) {
		if (x < 10)
			return 1;
		else {
			return 1 + countDigits(x / 10);
		}
	}

	private static void writeOutput(List l) throws Exception {
		StringBuffer b = new StringBuffer();
		int i = 1;
		BufferedWriter br = new BufferedWriter(new FileWriter(new File(
				"C:\\work\\Q3\\ans.txt")));
		for (Iterator iterator = l.iterator(); iterator.hasNext();) {
			br.write("Case #" + i++ + ": " + iterator.next());
			br.newLine();
		}
		br.close();
	}

}
package com.google.cj;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.StringTokenizer;

public class Recycling {
	public static void main(String[] args) {
		List<String> fileContents = IOHandler
				.readInput("/home/wzedan/cj/input/recycling.in");

		List<String> output = getPairs(fileContents);
		IOHandler.writeOutput(output, "/home/wzedan/cj/output/recycling.out");
	}

	private static List<String> getPairs(List<String> fileContents) {
		List<String> output = new ArrayList<String>();

		for (String line : fileContents) {
			StringTokenizer st = new StringTokenizer(line);
			String lowerLimit = st.nextToken();
			String upperLimit = st.nextToken();

			if (lowerLimit.length() == 1 && upperLimit.length() == 1) {
				output.add("" + 0);
				continue;
			}
			int maxShiftFactor = upperLimit.length() - 1;
			List<String> refCharacters = new ArrayList<String>();
			buildRefCharacters(lowerLimit, upperLimit, refCharacters);
			int noOfPairs = 0;
			List<Entry> shiftedList = new ArrayList<Entry>();
			for (int distance = 1; distance <= maxShiftFactor; distance++) {
				System.out.println("Distance = [" + distance + "]");
				shiftedList.addAll(shiftList(refCharacters, distance,
						Integer.valueOf(upperLimit) , Integer.valueOf(lowerLimit)));
				Set<Entry> s = new HashSet<Entry>(shiftedList);
				shiftedList.clear();
				shiftedList.addAll(s);
				System.out.println("ShiftedList length [" + shiftedList.size() + "]");
				System.out.println(shiftedList);
				
				
			}
			System.out.println("No of pairs [" + shiftedList.size()
					+ "] for lowerLimit [" + lowerLimit
					+ "] and upperLimt [" + upperLimit + "]");

			output.add("" + shiftedList.size());
		}
		return output;
	}

	private static int findMatches(List<String> refCharacters,
			List<Entry> shiftedList) {
		int noOfPairs = 0;
//		for (int i = 0; i < shiftedList.size(); i++) {
//			if (refCharacters.contains(shiftedList.get(i).value)) {
//				noOfPairs +=1;
//			}
//		}
		return shiftedList.size();
	}

	private static void buildRefCharacters(String lowerLimit,
			String upperLimit, List<String> refCharacters) {
		for (int i = Integer.valueOf(lowerLimit); i <= Integer
				.valueOf(upperLimit); i++) {
			refCharacters.add("" + i);
		}
	}

	private static List<Entry> shiftList(List<String> refCharacters,
			int distance, int upperLimit , int lowerLimit) {
		List<Entry> shiftedList = new ArrayList<Entry>();
		for (int i = 0; i < refCharacters.size(); i++) {
			Entry entry = shift(refCharacters.get(i), i, distance, upperLimit , lowerLimit);
			if (entry != null) {
				shiftedList.add(entry);
			}
		}
		return shiftedList;
	}

	public static Entry shift(String n, int index, int distance, int upperLimit , int lowerLimit) {
		String nCopy = n;
		if (!hasAllSameDigit(n)) {
			//System.out.println("Shifting [" + n + "] distance [" + distance + "]");
			String shiftPattern = n
					.substring(n.length() - distance);
			int shiftPatternIndex = n.length() - shiftPattern.length();
					
			String modifiedN = n.substring(0, shiftPatternIndex);
			n = shiftPattern + modifiedN;
			if (n.startsWith("0")) {
				n = nCopy;
			}
			
			int nInteger = Integer.valueOf(n);
			// A <= n < m <= B
			if(nInteger < lowerLimit){
				n = nCopy;
			}
			if (nInteger > upperLimit) {
					n = nCopy;
			}
			if(Integer.valueOf(nCopy) > nInteger ){
				n = nCopy;
			}
		}
		return !n.equals(nCopy) ? new Entry(nCopy, n) : null;
	}

	private static boolean hasAllSameDigit(String n) {
		char c = n.charAt(0);
		for (int i = 0; i < n.length(); i++) {
			if (n.charAt(i) != c) {
				return false;
			}
		}
		return true;
	}
}
