import java.util.Scanner;

/**
 * ZAKIREN第5章
 *
 * @author K.Yamauchi
 *
 */
public class Main {

	/**
	 *
	 * @param args
	 */
	public static void main(String[] args) {

		Scanner scan = new Scanner(System.in); // 入力
		int n = Integer.parseInt(scan.nextLine()); // 要素数

		// ソート対象配列の読み込み
		String[] targetArrayStr = scan.nextLine().split(" ");
		int[] targetArray = new int[targetArrayStr.length];
		for (int i = 0; i < targetArrayStr.length; i++) {
			targetArray[i] = Integer.parseInt(targetArrayStr[i]);
		}

		// 読み込み終了
		scan.close();

		// ソート
		int exchangingCount = selectionSort(n, targetArray);

		// 結果出力
		for (int i = 0; i < targetArray.length; i++) {
			if (i < targetArray.length - 1) {
				System.out.print(targetArray[i] + " ");
			} else {
				System.out.println(targetArray[i]);
			}
		}
		System.out.println(exchangingCount);
		;

	}

	/**
	 * 指定された整数配列を選択ソートする。
	 *
	 * @param n 要素数
	 * @param targetArray 選択ソートしたい整数配列
	 * @return 入れ替え回数
	 */
	private static int selectionSort(int n, int[] targetArray) {

		int exchangingCount = 0; // 入れ替え回数
		for (int i = 0; i < n; i++) {
			int minIndex = i; // 最小値の要素番号
			for (int j = i; j < n; j++) {
				// 最小値より低い値があったら
				if (targetArray[j] < targetArray[minIndex]) {
					// 最小値の要素番号を更新
					minIndex = j;
				}
			}
			// 最小値の値と左端を入れ替える
			if (i != minIndex) {
				exchangeArrayValue(targetArray, minIndex, i);
				exchangingCount++;
			}
		}

		return exchangingCount;
	}

	/**
	 * 配列内の2つの要素を入れ替える。
	 *
	 * @param array
	 *            入れ替えたい要素を含む配列
	 * @param a
	 *            入れ替えたい要素のindex
	 * @param b
	 *            入れ替えたい要素のindex
	 */
	private static void exchangeArrayValue(int[] array, int a, int b) {
		int temp = array[a];
		array[a] = array[b];
		array[b] = temp;
	}

}
 import java.util.Scanner; Scanner java.util public class Main {

	/**
	 *
	 * @param args
	 */
	public static void main(String[] args) {

		Scanner scan = new Scanner(System.in); // 入力
		int n = Integer.parseInt(scan.nextLine()); // 要素数

		// ソート対象配列の読み込み
		String[] targetArrayStr = scan.nextLine().split(" ");
		int[] targetArray = new int[targetArrayStr.length];
		for (int i = 0; i < targetArrayStr.length; i++) {
			targetArray[i] = Integer.parseInt(targetArrayStr[i]);
		}

		// 読み込み終了
		scan.close();

		// ソート
		int exchangingCount = selectionSort(n, targetArray);

		// 結果出力
		for (int i = 0; i < targetArray.length; i++) {
			if (i < targetArray.length - 1) {
				System.out.print(targetArray[i] + " ");
			} else {
				System.out.println(targetArray[i]);
			}
		}
		System.out.println(exchangingCount);
		;

	}

	/**
	 * 指定された整数配列を選択ソートする。
	 *
	 * @param n 要素数
	 * @param targetArray 選択ソートしたい整数配列
	 * @return 入れ替え回数
	 */
	private static int selectionSort(int n, int[] targetArray) {

		int exchangingCount = 0; // 入れ替え回数
		for (int i = 0; i < n; i++) {
			int minIndex = i; // 最小値の要素番号
			for (int j = i; j < n; j++) {
				// 最小値より低い値があったら
				if (targetArray[j] < targetArray[minIndex]) {
					// 最小値の要素番号を更新
					minIndex = j;
				}
			}
			// 最小値の値と左端を入れ替える
			if (i != minIndex) {
				exchangeArrayValue(targetArray, minIndex, i);
				exchangingCount++;
			}
		}

		return exchangingCount;
	}

	/**
	 * 配列内の2つの要素を入れ替える。
	 *
	 * @param array
	 *            入れ替えたい要素を含む配列
	 * @param a
	 *            入れ替えたい要素のindex
	 * @param b
	 *            入れ替えたい要素のindex
	 */
	private static void exchangeArrayValue(int[] array, int a, int b) {
		int temp = array[a];
		array[a] = array[b];
		array[b] = temp;
	}

} Main /**
	 *
	 * @param args
	 */
	public static void main(String[] args) {

		Scanner scan = new Scanner(System.in); // 入力
		int n = Integer.parseInt(scan.nextLine()); // 要素数

		// ソート対象配列の読み込み
		String[] targetArrayStr = scan.nextLine().split(" ");
		int[] targetArray = new int[targetArrayStr.length];
		for (int i = 0; i < targetArrayStr.length; i++) {
			targetArray[i] = Integer.parseInt(targetArrayStr[i]);
		}

		// 読み込み終了
		scan.close();

		// ソート
		int exchangingCount = selectionSort(n, targetArray);

		// 結果出力
		for (int i = 0; i < targetArray.length; i++) {
			if (i < targetArray.length - 1) {
				System.out.print(targetArray[i] + " ");
			} else {
				System.out.println(targetArray[i]);
			}
		}
		System.out.println(exchangingCount);
		;

	} main {

		Scanner scan = new Scanner(System.in); // 入力
		int n = Integer.parseInt(scan.nextLine()); // 要素数

		// ソート対象配列の読み込み
		String[] targetArrayStr = scan.nextLine().split(" ");
		int[] targetArray = new int[targetArrayStr.length];
		for (int i = 0; i < targetArrayStr.length; i++) {
			targetArray[i] = Integer.parseInt(targetArrayStr[i]);
		}

		// 読み込み終了
		scan.close();

		// ソート
		int exchangingCount = selectionSort(n, targetArray);

		// 結果出力
		for (int i = 0; i < targetArray.length; i++) {
			if (i < targetArray.length - 1) {
				System.out.print(targetArray[i] + " ");
			} else {
				System.out.println(targetArray[i]);
			}
		}
		System.out.println(exchangingCount);
		;

	} Scanner scan = new Scanner(System.in); scan new Scanner(System.in) int n = Integer.parseInt(scan.nextLine()); n Integer.parseInt(scan.nextLine()) Integer.parseInt Integer scan.nextLine() scan.nextLine scan String[] targetArrayStr = scan.nextLine().split(" "); targetArrayStr scan.nextLine().split(" ") scan.nextLine().split scan.nextLine() scan.nextLine scan " " int[] targetArray = new int[targetArrayStr.length]; targetArray new int[targetArrayStr.length] targetArrayStr.length targetArrayStr targetArrayStr.length for (int i = 0; i < targetArrayStr.length; i++) {
			targetArray[i] = Integer.parseInt(targetArrayStr[i]);
		} int i = 0; int i = 0; i 0 i < targetArrayStr.length i targetArrayStr.length targetArrayStr targetArrayStr.length i++ i++ i {
			targetArray[i] = Integer.parseInt(targetArrayStr[i]);
		} {
			targetArray[i] = Integer.parseInt(targetArrayStr[i]);
		} targetArray[i] = Integer.parseInt(targetArrayStr[i]) targetArray[i] targetArray i Integer.parseInt(targetArrayStr[i]) Integer.parseInt Integer targetArrayStr[i] targetArrayStr i scan.close() scan.close scan int exchangingCount = selectionSort(n, targetArray); exchangingCount selectionSort(n, targetArray) selectionSort n targetArray for (int i = 0; i < targetArray.length; i++) {
			if (i < targetArray.length - 1) {
				System.out.print(targetArray[i] + " ");
			} else {
				System.out.println(targetArray[i]);
			}
		} int i = 0; int i = 0; i 0 i < targetArray.length i targetArray.length targetArray targetArray.length i++ i++ i {
			if (i < targetArray.length - 1) {
				System.out.print(targetArray[i] + " ");
			} else {
				System.out.println(targetArray[i]);
			}
		} {
			if (i < targetArray.length - 1) {
				System.out.print(targetArray[i] + " ");
			} else {
				System.out.println(targetArray[i]);
			}
		} if (i < targetArray.length - 1) {
				System.out.print(targetArray[i] + " ");
			} else {
				System.out.println(targetArray[i]);
			} i < targetArray.length - 1 i targetArray.length - 1 targetArray.length targetArray targetArray.length 1 {
				System.out.print(targetArray[i] + " ");
			} System.out.print(targetArray[i] + " ") System.out.print System.out System System.out targetArray[i] + " " targetArray[i] targetArray i " " {
				System.out.println(targetArray[i]);
			} System.out.println(targetArray[i]) System.out.println System.out System System.out targetArray[i] targetArray i System.out.println(exchangingCount) System.out.println System.out System System.out exchangingCount String[] args args /**
	 * 指定された整数配列を選択ソートする。
	 *
	 * @param n 要素数
	 * @param targetArray 選択ソートしたい整数配列
	 * @return 入れ替え回数
	 */
	private static int selectionSort(int n, int[] targetArray) {

		int exchangingCount = 0; // 入れ替え回数
		for (int i = 0; i < n; i++) {
			int minIndex = i; // 最小値の要素番号
			for (int j = i; j < n; j++) {
				// 最小値より低い値があったら
				if (targetArray[j] < targetArray[minIndex]) {
					// 最小値の要素番号を更新
					minIndex = j;
				}
			}
			// 最小値の値と左端を入れ替える
			if (i != minIndex) {
				exchangeArrayValue(targetArray, minIndex, i);
				exchangingCount++;
			}
		}

		return exchangingCount;
	} selectionSort {

		int exchangingCount = 0; // 入れ替え回数
		for (int i = 0; i < n; i++) {
			int minIndex = i; // 最小値の要素番号
			for (int j = i; j < n; j++) {
				// 最小値より低い値があったら
				if (targetArray[j] < targetArray[minIndex]) {
					// 最小値の要素番号を更新
					minIndex = j;
				}
			}
			// 最小値の値と左端を入れ替える
			if (i != minIndex) {
				exchangeArrayValue(targetArray, minIndex, i);
				exchangingCount++;
			}
		}

		return exchangingCount;
	} int exchangingCount = 0; exchangingCount 0 for (int i = 0; i < n; i++) {
			int minIndex = i; // 最小値の要素番号
			for (int j = i; j < n; j++) {
				// 最小値より低い値があったら
				if (targetArray[j] < targetArray[minIndex]) {
					// 最小値の要素番号を更新
					minIndex = j;
				}
			}
			// 最小値の値と左端を入れ替える
			if (i != minIndex) {
				exchangeArrayValue(targetArray, minIndex, i);
				exchangingCount++;
			}
		} int i = 0; int i = 0; i 0 i < n i n i++ i++ i {
			int minIndex = i; // 最小値の要素番号
			for (int j = i; j < n; j++) {
				// 最小値より低い値があったら
				if (targetArray[j] < targetArray[minIndex]) {
					// 最小値の要素番号を更新
					minIndex = j;
				}
			}
			// 最小値の値と左端を入れ替える
			if (i != minIndex) {
				exchangeArrayValue(targetArray, minIndex, i);
				exchangingCount++;
			}
		} {
			int minIndex = i; // 最小値の要素番号
			for (int j = i; j < n; j++) {
				// 最小値より低い値があったら
				if (targetArray[j] < targetArray[minIndex]) {
					// 最小値の要素番号を更新
					minIndex = j;
				}
			}
			// 最小値の値と左端を入れ替える
			if (i != minIndex) {
				exchangeArrayValue(targetArray, minIndex, i);
				exchangingCount++;
			}
		} int minIndex = i; minIndex i for (int j = i; j < n; j++) {
				// 最小値より低い値があったら
				if (targetArray[j] < targetArray[minIndex]) {
					// 最小値の要素番号を更新
					minIndex = j;
				}
			} int j = i; int j = i; j i j < n j n j++ j++ j {
				// 最小値より低い値があったら
				if (targetArray[j] < targetArray[minIndex]) {
					// 最小値の要素番号を更新
					minIndex = j;
				}
			} {
				// 最小値より低い値があったら
				if (targetArray[j] < targetArray[minIndex]) {
					// 最小値の要素番号を更新
					minIndex = j;
				}
			} if (targetArray[j] < targetArray[minIndex]) {
					// 最小値の要素番号を更新
					minIndex = j;
				} targetArray[j] < targetArray[minIndex] targetArray[j] targetArray j targetArray[minIndex] targetArray minIndex {
					// 最小値の要素番号を更新
					minIndex = j;
				} minIndex = j minIndex j if (i != minIndex) {
				exchangeArrayValue(targetArray, minIndex, i);
				exchangingCount++;
			} i != minIndex i minIndex {
				exchangeArrayValue(targetArray, minIndex, i);
				exchangingCount++;
			} exchangeArrayValue(targetArray, minIndex, i) exchangeArrayValue targetArray minIndex i exchangingCount++ exchangingCount return exchangingCount; exchangingCount int n n int[] targetArray targetArray /**
	 * 配列内の2つの要素を入れ替える。
	 *
	 * @param array
	 *            入れ替えたい要素を含む配列
	 * @param a
	 *            入れ替えたい要素のindex
	 * @param b
	 *            入れ替えたい要素のindex
	 */
	private static void exchangeArrayValue(int[] array, int a, int b) {
		int temp = array[a];
		array[a] = array[b];
		array[b] = temp;
	} exchangeArrayValue {
		int temp = array[a];
		array[a] = array[b];
		array[b] = temp;
	} int temp = array[a]; temp array[a] array a array[a] = array[b] array[a] array a array[b] array b array[b] = temp array[b] array b temp int[] array array int a a int b b public class Main {

	/**
	 *
	 * @param args
	 */
	public static void main(String[] args) {

		Scanner scan = new Scanner(System.in); // 入力
		int n = Integer.parseInt(scan.nextLine()); // 要素数

		// ソート対象配列の読み込み
		String[] targetArrayStr = scan.nextLine().split(" ");
		int[] targetArray = new int[targetArrayStr.length];
		for (int i = 0; i < targetArrayStr.length; i++) {
			targetArray[i] = Integer.parseInt(targetArrayStr[i]);
		}

		// 読み込み終了
		scan.close();

		// ソート
		int exchangingCount = selectionSort(n, targetArray);

		// 結果出力
		for (int i = 0; i < targetArray.length; i++) {
			if (i < targetArray.length - 1) {
				System.out.print(targetArray[i] + " ");
			} else {
				System.out.println(targetArray[i]);
			}
		}
		System.out.println(exchangingCount);
		;

	}

	/**
	 * 指定された整数配列を選択ソートする。
	 *
	 * @param n 要素数
	 * @param targetArray 選択ソートしたい整数配列
	 * @return 入れ替え回数
	 */
	private static int selectionSort(int n, int[] targetArray) {

		int exchangingCount = 0; // 入れ替え回数
		for (int i = 0; i < n; i++) {
			int minIndex = i; // 最小値の要素番号
			for (int j = i; j < n; j++) {
				// 最小値より低い値があったら
				if (targetArray[j] < targetArray[minIndex]) {
					// 最小値の要素番号を更新
					minIndex = j;
				}
			}
			// 最小値の値と左端を入れ替える
			if (i != minIndex) {
				exchangeArrayValue(targetArray, minIndex, i);
				exchangingCount++;
			}
		}

		return exchangingCount;
	}

	/**
	 * 配列内の2つの要素を入れ替える。
	 *
	 * @param array
	 *            入れ替えたい要素を含む配列
	 * @param a
	 *            入れ替えたい要素のindex
	 * @param b
	 *            入れ替えたい要素のindex
	 */
	private static void exchangeArrayValue(int[] array, int a, int b) {
		int temp = array[a];
		array[a] = array[b];
		array[b] = temp;
	}

} public class Main {

	/**
	 *
	 * @param args
	 */
	public static void main(String[] args) {

		Scanner scan = new Scanner(System.in); // 入力
		int n = Integer.parseInt(scan.nextLine()); // 要素数

		// ソート対象配列の読み込み
		String[] targetArrayStr = scan.nextLine().split(" ");
		int[] targetArray = new int[targetArrayStr.length];
		for (int i = 0; i < targetArrayStr.length; i++) {
			targetArray[i] = Integer.parseInt(targetArrayStr[i]);
		}

		// 読み込み終了
		scan.close();

		// ソート
		int exchangingCount = selectionSort(n, targetArray);

		// 結果出力
		for (int i = 0; i < targetArray.length; i++) {
			if (i < targetArray.length - 1) {
				System.out.print(targetArray[i] + " ");
			} else {
				System.out.println(targetArray[i]);
			}
		}
		System.out.println(exchangingCount);
		;

	}

	/**
	 * 指定された整数配列を選択ソートする。
	 *
	 * @param n 要素数
	 * @param targetArray 選択ソートしたい整数配列
	 * @return 入れ替え回数
	 */
	private static int selectionSort(int n, int[] targetArray) {

		int exchangingCount = 0; // 入れ替え回数
		for (int i = 0; i < n; i++) {
			int minIndex = i; // 最小値の要素番号
			for (int j = i; j < n; j++) {
				// 最小値より低い値があったら
				if (targetArray[j] < targetArray[minIndex]) {
					// 最小値の要素番号を更新
					minIndex = j;
				}
			}
			// 最小値の値と左端を入れ替える
			if (i != minIndex) {
				exchangeArrayValue(targetArray, minIndex, i);
				exchangingCount++;
			}
		}

		return exchangingCount;
	}

	/**
	 * 配列内の2つの要素を入れ替える。
	 *
	 * @param array
	 *            入れ替えたい要素を含む配列
	 * @param a
	 *            入れ替えたい要素のindex
	 * @param b
	 *            入れ替えたい要素のindex
	 */
	private static void exchangeArrayValue(int[] array, int a, int b) {
		int temp = array[a];
		array[a] = array[b];
		array[b] = temp;
	}

} Main
import java.util.Scanner;

/**
 * ZAKIREN第5章
 *
 * @author K.Yamauchi
 *
 */
public class Main {

	/**
	 *
	 * @param args
	 */
	public static void main(String[] args) {

		Scanner scan = new Scanner(System.in); // 入力
		int n = Integer.parseInt(scan.nextLine()); // 要素数

		// ソート対象配列の読み込み
		String[] targetArrayStr = scan.nextLine().split(" ");
		int[] targetArray = new int[targetArrayStr.length];
		for (int i = 0; i < targetArrayStr.length; i++) {
			targetArray[i] = Integer.parseInt(targetArrayStr[i]);
		}

		// 読み込み終了
		scan.close();

		// ソート
		int exchangingCount = selectionSort(n, targetArray);

		// 結果出力
		for (int i = 0; i < targetArray.length; i++) {
			if (i < targetArray.length - 1) {
				System.out.print(targetArray[i] + " ");
			} else {
				System.out.println(targetArray[i]);
			}
		}
		System.out.println(exchangingCount);
		;

	}

	/**
	 * 指定された整数配列を選択ソートする。
	 *
	 * @param n 要素数
	 * @param targetArray 選択ソートしたい整数配列
	 * @return 入れ替え回数
	 */
	private static int selectionSort(int n, int[] targetArray) {

		int exchangingCount = 0; // 入れ替え回数
		for (int i = 0; i < n; i++) {
			int minIndex = i; // 最小値の要素番号
			for (int j = i; j < n; j++) {
				// 最小値より低い値があったら
				if (targetArray[j] < targetArray[minIndex]) {
					// 最小値の要素番号を更新
					minIndex = j;
				}
			}
			// 最小値の値と左端を入れ替える
			if (i != minIndex) {
				exchangeArrayValue(targetArray, minIndex, i);
				exchangingCount++;
			}
		}

		return exchangingCount;
	}

	/**
	 * 配列内の2つの要素を入れ替える。
	 *
	 * @param array
	 *            入れ替えたい要素を含む配列
	 * @param a
	 *            入れ替えたい要素のindex
	 * @param b
	 *            入れ替えたい要素のindex
	 */
	private static void exchangeArrayValue(int[] array, int a, int b) {
		int temp = array[a];
		array[a] = array[b];
		array[b] = temp;
	}

}

