PleiadesによりEclipseを日本語化する手順(Windows 64bit OS)

備忘録 Eclipse Pleiades 環境構築

Pleiadesプラグインの公式ページ

になぜか掲題の作業手順が記載されていなかったため(私が見落としているだけだったらごめんなさい)備忘録として残しておきます(EclipseとPleiadesはインストール済みの前提です)

※ディレクトリ構造やワークスペースの名前は各自の環境に読み替えてください

 

 

  1. pleiades-winディレクトリのsetup.exeを起動

  2. Pleiades 日本語化プラグインのセットアップ画面で「選択…」を押す

  3. インストール済みのeclipse.exeを指定して「日本語化する」を押す

  4. 「OK」を押して「日本語化が完了しました。他の（以下略）」ダイアログを消し、「終了」を押してsetup.exeを完了

  5. pleiades-winディレクトリにあるeclipse.exe -clean.cmdを、インストール済みのeclipse.exeがあるディレクトリにコピーする(もうpleiades-winディレクトリのファイルは用済みなので削除してもOK)

  6. eclipse.exe -clean.cmdを実行してeclipseを起動し、実際に日本語化されていることを確認

    ※基本的に日本語化実行後初回起動のみの手順という認識でよいが、Pleiades・他のプラグインを追加あるいは更新したタイミングでも必要

以上で完了

Java向け競プロライブラリ(素数)

Java 競プロライブラリ

素数が絡んでくる問題向けのライブラリです。

問題の制約に合わせて適宜sieveSizeの値を変更して使用します。

例えば以下の問題で役に立ちます。

AtCoder Beginner Contest 250 D - 250-like Number

AtCoder Beginner Contest 254 D - Together Square

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

final class PrimeNumber {

	private static int sieveSize = 2 * 100000;
	private static boolean[] isPrime = new boolean[sieveSize + 10];
	private static long[] cnt = new long[sieveSize + 10];

	static {
		Arrays.fill(isPrime, 2, isPrime.length, true);
		for (int i = 2; i * i <= sieveSize; ++i) {
			if (!isPrime[i]) {
				continue;
			}

			for (int j = i * i; j <= sieveSize; j += i) {
				isPrime[j] = false;
			}
		}

		for (int i = 2; i <= sieveSize; ++i) {
			cnt[i] = (isPrime[i]) ? cnt[i - 1] + 1 : cnt[i - 1];
		}
	}

	/**
	 * 与えた整数が素数ならばtrue、素数でなければfalseを返す
	 * @param n 判定対象の整数
	 * @return nが素数ならtrue、合成数ならfalse
	 */
	public static boolean isPrimeNumber(int n) {
		return isPrime[n];
	}

	/**
	 * デフォルトで指定された範囲の素数の個数を取得する
	 * @return 素数の個数
	 */
	public static long countPrimeNumbers() {
		return countPrimeNumbersLessThanOrEqualTo(sieveSize);
	}

	/**
	 * 与えた整数以下の素数の個数を取得する
	 * @param n 上限の整数
	 * @return n以下の素数の個数
	 */
	public static long countPrimeNumbersLessThanOrEqualTo(int n) {
		return cnt[n];
	}

	/**
	 * デフォルトで指定された範囲の素数を要素とする配列を取得する
	 * @return 素数を要素とする配列
	 */
	public static int[] getPrimeNumbers() {
		return getPrimeNumbersLessThanOrEqualTo(sieveSize);
	}

	/**
	 * 与えた整数以下の素数を要素とする配列を取得する
	 * @param n 上限の整数
	 * @return n以下の素数を要素とする配列
	 */
	public static int[] getPrimeNumbersLessThanOrEqualTo(int n) {
		List<Integer> p = new ArrayList<Integer>();
		for (int i = 2; i <= n; ++i) {
			if (isPrime[i]) {
				p.add(i);
			}
		}
		return p.stream().mapToInt(i -> i).toArray();
	}

	/**
	 * 与えた整数の素因数分解を実行し結果を返す
	 * @param n 素因数分解の対象となる整数
	 * @return 素因数分解の結果を格納したマップ
	 */
	public static Map<Integer, Integer> factorize(long n) {
		Map<Integer, Integer> res = new TreeMap<Integer, Integer>();
		for (int d = 2; 1l * d * d <= n; d += (d == 2) ? 1 : 2) {
			if (!isPrime[d]) {
				continue;
			}

			int cnt = 0;
			while (n % d == 0) {
				++cnt;
				n /= d;
			}

			if (cnt > 0) {
				res.put(d, cnt);
			}
		}

		if (n > 1) {
			res.put((int) n, 1);
		}
		return res;
	}

	/**
	 * 既知の素因数分解の情報をもとに約数を洗い出す
	 * @param pfs 素因数を要素とする配列
	 * @param maxPows 各素因数の個数を要素とする配列
	 * @return 約数一覧の配列
	 */
	public static long[] getDivisorsUsingFactorization(int[] pfs, int[] maxPows) {
		int[] pows = new int[pfs.length];
		List<Long> l = new ArrayList<Long>();
		findDivisorsByDfs(0, pfs, maxPows, pows, l);
		return l.stream().mapToLong(i -> i).toArray();
	}

	private static void findDivisorsByDfs(int depth, int[] pfs, int[] maxPows, int[] pows, List<Long> divDest) {
		if (depth == maxPows.length) {
			long d = 1;
			for (int i = 0, f = pfs.length; i < f; ++i) {
				for (int j = 0, fj = pows[i]; j < fj; ++j) {
					d *= 1l * pfs[i];
				}
			}
			divDest.add(d);
			return;
		}

		for (int i = 0, f = maxPows[depth]; i <= f; ++i) {
			pows[depth] = i;
			findDivisorsByDfs(depth + 1, pfs, maxPows, pows, divDest);
		}
	}

}

Java向け競プロライブラリ(最大公約数・最小公倍数・約数洗い出し)

Java 競プロライブラリ

最大公約数・最小公倍数が絡んでくる問題向けライブラリです

例えば以下の問題で役に立ちます

AtCoder Beginner Contest 162 C - Sum of gcd of Tuples (Easy)

AtCoder Beginner Contest 253 D - FizzBuzz Sum Hard

final class GcdLcmCalculator {

	/**
	 * ユークリッドの互除法を利用して2整数の最大公約数を取得する
	 * @param a 整数
	 * @param b 整数
	 * @return aとbの最大公約数
	 */
	public static final long calculateGcd(long a, long b) {
		if (b == 0) {
			return a;
		}

		return calculateGcd(b, a % b);
	}

	/**
	 * 2整数の最小公倍数を取得する
	 * @param a 整数
	 * @param b 整数
	 * @return aとbの最小公倍数
	 */
	public static final long calculateLcm(long a, long b) {
		return a / calculateGcd(a, b) * b;
	}

}

 

整数の約数一覧を取得するライブラリです

例えば以下の問題で役に立ちます

AtCoder Beginner Contest 249 D - Index Trio

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.List;

final class DivisorHelper {

	/**
	 * 整数の約数一覧を取得する
	 * @param n 対象の整数
	 * @return nの約数リスト
	 */
	public static final List<Long> getDivisorsOf(long n) {
		Deque<Long> less = new ArrayDeque<Long>();
		Deque<Long> greater = new ArrayDeque<Long>();
		for (long d = 1; d * d <= n; ++d) {
			if (n % d != 0) {
				continue;
			}

			less.addLast(d);

			long q = n / d;
			if (d != q) {
				greater.addLast(q);
			}
		}

		List<Long> res = new ArrayList<Long>();
		while (!less.isEmpty()) {
			res.add(less.pollFirst());
		}

		while (!greater.isEmpty()) {
			res.add(greater.pollLast());
		}
		return res;
	}

}

Java向け競プロライブラリ(Bit全探索)

Java 競プロライブラリ

要素数が20以下程度の配列で入力される場合に思い浮かべておくと得につながりがちな気がします。

例えば以下の問題で使用するとよいです。

AtCoder Beginner Contest 249 C - Just K

final class BitWholeSearchHelper {

	public static String getBinaryString(int width, int src) {
		StringBuilder sb = new StringBuilder();
		for (int divCnt = 0; divCnt < width; ++divCnt) {
			sb.append(src % 2);
			src /= 2;
		}
		sb.reverse();
		return sb.toString();
	}

}

Java向け競プロライブラリ(幅優先探索)

Java 競プロライブラリ

幅優先探索を使用する問題向けのライブラリです。例えば以下のような問題に対して使用すると有用です。

AtCoder Beginner Contest 007 C - 幅優先探索

AtCoder Beginner Contest 204 C - Tour

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Deque;
import java.util.List;

final class BfsExecutor {

	private static final char UNREACHABLE_GRID = '#';
	private static final int INF = 1 << 30;

	/**
	 * 幅優先探索により、スタート位置からの最短距離を記録した二次元配列を取得する
	 * @param grid 横幅と高さが定まった二次元グリッド
	 * @param sx スタート位置のx座標
	 * @param sy スタート位置のy座標
	 * @return スタート位置からの最短距離を記録した二次元配列
	 */
	public static int[][] getGridDistanceMemory(char[][] grid, int sx, int sy) {
		int h = grid.length;
		int w = grid[0].length;
		int[][] distances = new int[h][w];
		for (int[] row : distances) {
			Arrays.fill(row, INF);
		}

		Deque<Integer> qx = new ArrayDeque<Integer>();
		Deque<Integer> qy = new ArrayDeque<Integer>();
		int[] dx = { 1, 0, -1, 0 };
		int[] dy = { 0, 1, 0, -1 };

		distances[sy][sx] = 0;
		qx.addLast(sx);
		qy.addLast(sy);

		while (!qx.isEmpty()) {
			int px = qx.pollFirst();
			int py = qy.pollFirst();

			for (int i = 0; i < 4; ++i) {
				int nx = px + dx[i];
				int ny = py + dy[i];

				// 範囲外ならば無視
				if (!(0 <= nx && nx <= w - 1) || !(0 <= ny && ny <= h - 1)) {
					continue;
				}

				// 行けないマスならば無視
				if (grid[ny][nx] == UNREACHABLE_GRID) {
					continue;
				}

				// 訪問済みのマスならば無視
				if (distances[ny][nx] < INF) {
					continue;
				}

				distances[ny][nx] = distances[py][px] + 1;
				qx.addLast(nx);
				qy.addLast(ny);
			}
		}

		return distances;
	}

	/**
	 * 幅優先探索を行い、頂点に隣接するノードを記録したリストを返す
	 * @param adjNodesToEach 各ノードに隣接しているノードを記録した2次元リスト
	 * @param top 頂点
	 * @param visited 訪問済みの頂点か否か判定用配列(要素数はノードの数に等しい)
	 * @return 頂点に隣接しているノード番号のリスト
	 */
	public static List<Integer> getAdjacentNodesToTop(ArrayList<Integer>[] adjNodesToEach, int top, boolean[] visited) {
		List<Integer> res = new ArrayList<Integer>();

		Deque<Integer> q = new ArrayDeque<Integer>();
		res.add(top);
		visited[top] = true;
		q.addLast(top);

		while (!q.isEmpty()) {
			int prevNode = q.pollFirst();

			for (int i = 0, f = adjNodesToEach[prevNode].size(); i < f; ++i) {
				int adjNode = adjNodesToEach[prevNode].get(i);

				if (visited[adjNode]) {
					continue;
				}

				res.add(adjNode);
				visited[adjNode] = true;
				q.addLast(adjNode);
			}
		}

		return res;
	}

}

 

※幅優先探索は以下のような疑似コードで一般的に表現できます

function bfs(top) {
	// 空のキューQを定義
	// topに訪問済みの印をつける
	// topをQに追加

	while (Qが空でない) {
		// prevNode ← Qの先頭から取り出す

		for each (prevNodeに接続しているノードadj) {
			if (adjが訪問済み) {
				continue;
			}

			// adjに訪問済みの印をつける
			// adjをQに追加
			// adjに所望の処理を行う
		}
	}
}

Java向け競プロライブラリ(二分探索)

Java 競プロライブラリ

java.util.ArraysクラスにbinarySearchメソッドは実装されていますが、「keyで指定された要素を複数持つ場合にはどれが返されるか保証されていない」という使い道に困り果てそうな実装であるため、自前でライブラリを持っておくべきかと思われます

Arrays (Java SE 11 & JDK 11 )

※2023/09/22追記およびコード修正：型パラメータを使用して汎用性を持たせました（配列で書くことも不可能ではありませんが、T[]型を引数として渡すようにするとプリミティブ型配列を引数として与えた時にコンパイルエラーとなり、ラッパークラス型配列を渡さなければ正常実行が不可能であるのみならず、プリミティブ型配列を引数とするArrays#sortは改良版のクイックソートにより実装されており、最悪n^2に比例する実行時間を要してTLEする可能性を孕んでいるため、各データをプリミティブ型で保存する意思を最初から捨ててマージソートにより実装された並べ替え処理を確実に呼び出すためにリストで実装する方が良いと判断しました）

 

 

import java.util.List;

public final class BinarySearcher {

	/**
	 * 昇順ソート済みのリストに対して二分探索を実行し、
	 * key <= list.get(index)
	 * となるような最小のindexを返す
	 * @param <T> リストの各要素の型
	 * @param list 探索対象のリスト
	 * @param key 探索キー
	 * @return 適切な要素が存在する場合は最小のインデックス、存在しない場合は-1
	 */
	public static <T extends Comparable<T>> int findSmallestIndexGreaterThanOrEqualToKey(List<T> list, T key) {
		return findSmallestIndexGeneral(list, key, true);
	}

	/**
	 * 昇順ソート済みのリストに対して二分探索を実行し、
	 * key < list.get(index)
	 * となるような最小のindexを返す
	 * @param <T> リストの各要素の型
	 * @param list 探索対象のリスト
	 * @param key 探索キー
	 * @return 適切な要素が存在する場合は最小のインデックス、存在しない場合は-1
	 */
	public static <T extends Comparable<T>> int findSmallestIndexGreaterThanKey(List<T> list, T key) {
		return findSmallestIndexGeneral(list, key, false);
	}

	/**
	 * 昇順ソート済みのリストに対して二分探索を実行し、
	 * list.get(index) <= key
	 * となるような最大のindexを返す
	 * @param <T> リストの各要素の型
	 * @param list 探索対象のリスト
	 * @param key 探索キー
	 * @return 適切な要素が存在する場合は最大のインデックス、存在しない場合は-1
	 */
	public static <T extends Comparable<T>> int findLargestIndexLessThanOrEqualToKey(List<T> list, T key) {
		return findLargestIndexGeneral(list, key, true);
	}

	/**
	 * 昇順ソート済みのリストに対して二分探索を実行し、
	 * list.get(index) < key
	 * となるような最大のindexを返す
	 * @param <T> リストの各要素の型
	 * @param list 探索対象のリスト
	 * @param key 探索キー
	 * @return 適切な要素が存在する場合は最大のインデックス、存在しない場合は-1
	 */
	public static <T extends Comparable<T>> int findLargestIndexLessThanKey(List<T> list, T key) {
		return findLargestIndexGeneral(list, key, false);
	}

	private static <T extends Comparable<T>> int findSmallestIndexGeneral(List<T> list, T key, boolean isInclusive) {
		int left = -1, right = list.size();
		while (right - left > 1) {
			int mid = (left + right) / 2;
			if (isInclusive ? key.compareTo(list.get(mid)) <= 0 : key.compareTo(list.get(mid)) < 0) {
				right = mid;
			} else {
				left = mid;
			}
		}
		return right == list.size() ? -1 : right;
	}

	private static <T extends Comparable<T>> int findLargestIndexGeneral(List<T> list, T key, boolean isInclusive) {
		int left = -1, right = list.size();
		while (right - left > 1) {
			int mid = (left + right) / 2;
			if (isInclusive ? list.get(mid).compareTo(key) <= 0 : list.get(mid).compareTo(key) < 0) {
				left = mid;
			} else {
				right = mid;
			}
		}
		return left;
	}

}

Excelメモ：数式によりシート内の範囲を図として挿入

備忘録 Excel

※タイトルのことを実現したい時の手順を何度も忘れてしまって非生産的すぎたため備忘録として残しておきます（ほとんど自分用のメモです）

 

1)「挿入」→「図の挿入」を使い、貼り付け先のシートにダミーの図を挿入

 

2)上記手順1)でセットした図をクリックして選択した状態にし、数式ウインドウに図として挿入したいシートの範囲を数式で指定する

※元になるシートの名前を仮に「src」とした場合、「=src!$A$1:$D$25」などのように入力すればOK。以上の手順に従うと、src側の指定範囲に編集を加えた場合、貼り付けた図の方にも変更が反映されるのが便利