アナグラム生成プログラムを再帰などで汎用性を高くしたい

Question

前提・実現したいこと

以前に質問したJavaでのアナグラム・置き換え処理を改善(早く)したいでの回答プログラムを使用して、アナグラムをしていました。最近はローマ字の文をアナグラムした結果を日本語変換して遊んでいたのですが、長文（大体13文字以上）をアナグラムしようとすると処理に半日以上かかってしまいました。
そのため、変換時の処理など考えプログラムを改良した所、処理時間が大分短くなったのですが、文字数に合わせて事前にプログラミングしないといけないような記述になってしまっているため、事前に文字数がわかっていなくても対応できる（1つのプログラムで複数の文字数に対応できる）プログラムを作る事が出来るか質問しました。
もしかしたら以前の回答プログラムで実現したい事が可能なのかもしれないですが、自分では分からなかったため、改善点を指摘していただけるとありがたいです。

発生している問題・エラーメッセージ

文字数が異なる文が複数ある場合、その文字数に合わせたプログラムを用意する必要がある

該当のソースコード

「teratail」（8文字）を対象とした例（この場合、文字数が8文字以外の文字列を扱う事が出来ない）

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Anagram{
	static Path path;
	static String sword;  //作成中のアナグラム文
	static String[] targetArray;  //アナグラムの元となる文字列を1文字ずつ配列（後の処理が簡単なためString）
	static int intA, intB, intC, intD, intE, intF, intG, intH;  //targetArrayの要素番号用
	static List<String> arrayList = new ArrayList<String>(1000000);  //作成されたアナグラム文の保管場所

	public static void main(String[] args) {
		final String targetWord = "teratail";
		path = Paths.get("C:\programming\anagram_teratail.txt");
		createFile();
		targetArray = targetWord.split("");
		Arrays.sort(targetArray);
		one();
	}

	static void one() {
		List<String> oneList = new ArrayList<String>(10);  //作成中のアナグラム文の保管場所（eightListまで同様）
		for(int ai=0; ai<targetArray.length; ai++) {
			intA = ai;
			sword = targetArray[ai];
			if(notListed(oneList)) {  //oneListにswordが無いかチェック（既に作成されていないか確認）
				oneList.add(sword);
				two();  //進む
			}  //ある場合、保存時に重複してしまうためそれ以降の文字を追加せずにスキップ
			sword = sword.substring(0, sword.length()-1);  //swordの末尾を削除（次の先頭文字に進むため）
		}
	}

	static void two() {
		List<String> twoList = new ArrayList<String>(10);
		for(int bi=0; bi<targetArray.length; bi++) {
			intB = bi;
			if(intA!=intB) {  //targetArrayの要素番号が被っていないかチェック（被る=アナグラムでは無くなるため）
				sword += targetArray[bi];
				if(notListed(twoList)){
					twoList.add(sword);
					three();
				}
				sword = sword.substring(0, sword.length()-1);
			}
		}
	}

	static void three() {
		List<String> threeList = new ArrayList<String>(10);
		for(int ci=0; ci<targetArray.length; ci++) {
			intC = ci;
			if(intA!=intC && intB!=intC) {
				sword += targetArray[ci];
				if(notListed(threeList) && canString(sword)) {
					threeList.add(sword);
					four();
				}
				sword = sword.substring(0, sword.length()-1);
			}
		}
	}

	static void four() {
		List<String> fourList = new ArrayList<String>(10);
		for(int di=0; di<targetArray.length; di++) {
			intD = di;
			if(intA!=intD && intB!=intD && intC!=intD) {
				sword += targetArray[di];
				if(notListed(fourList) && canString(sword)) {
					fourList.add(sword);
					five();
				}
				sword = sword.substring(0, sword.length()-1);
			}
		}
	}

	static void five() {
		List<String> fiveList = new ArrayList<String>(10);
		for(int ei=0; ei<targetArray.length; ei++) {
			intE = ei;
			if(intA!=intE && intB!=intE && intC!=intE && intD!=intE) {
				sword += targetArray[ei];
				if(notListed(fiveList) && canString(sword)) {
					fiveList.add(sword);
					six();
				}
				sword = sword.substring(0, sword.length()-1);
			}
		}
	}

	static void six() {
		List<String> sixList = new ArrayList<String>(10);
		for(int fi=0; fi<targetArray.length; fi++) {
			intF = fi;
			if(intA!=intF && intB!=intF && intC!=intF && intD!=intF && intE!=intF) {
				sword += targetArray[fi];
				if(notListed(sixList) && canString(sword)) {
					sixList.add(sword);
					seven();
				}
				sword = sword.substring(0, sword.length()-1);
			}
		}
	}

	static void seven() {
		List<String> sevenList = new ArrayList<String>(10);
		for(int gi=0; gi<targetArray.length; gi++) {
			intG = gi;
			if(intA!=intG && intB!=intG && intC!=intG && intD!=intG && intE!=intG && intF!=intG) {
				sword += targetArray[gi];
				if(notListed(sevenList) && canString(sword)) {
					sevenList.add(sword);
					eight();
				}
				sword = sword.substring(0, sword.length()-1);
			}
		}
	}

	static void eight() {
		List<String> eightList = new ArrayList<String>(10);
		for(int hi=0; hi<targetArray.length; hi++) {
			intH = hi;
			if(intA!=intH && intB!=intH && intC!=intH && intD!=intH && intE!=intH && intF!=intH && intG!=intH) {
				sword += targetArray[hi];
				if(notListed(eightList)){
					if(canString(sword)){
						eightList.add(sword);
						arrayList.add(sword);
						System.out.println(sword);
						if(arrayList.size() == 1000000) {
							fileWriting();
							arrayList.clear();
						}
					}
				}
				sword = sword.substring(0, sword.length()-1);
			}
			if(intA==7 && intB==6 && intC==5 && intD==4 && intE==3 && intF==2 && intG==1 && intH==0) {  //targetWordで作成出来るアナグラムを最後まで作成したかチェック
				fileWriting();
				arrayList.clear();
			}
		}
	}

	static boolean notListed(final List<String> list) {  //リストにswordがないかチェック（ある場合→既に作成されている）
		if(!(list.contains(sword))){
			return true;
		}else {
			return false;
		}
	}

	static boolean canString(final String Sword) {  //日本語に変換されない箇所があるかチェック（実際には複数対応へ）
		final Pattern patternTwo = Pattern.compile("l[rt]|r[lt]|t[lr]");  //日本語に変換できない文字列（2文字）
		final Pattern patternThree = Pattern.compile("tt[lr]");  //日本語に変換できない文字列（3文字）
		final Pattern patternEnd = Pattern.compile("[lrt]$");
		Matcher matcherTwo = patternTwo.matcher(Sword);
		Matcher matcherThree = patternThree.matcher(Sword);
		Matcher matcherEnd = patternEnd.matcher(Sword);
		if(!(matcherTwo.find()) && !(matcherThree.find()) && !(matcherEnd.find())) {
			return true;
		}else {
			return false;
		}
	}

	public static void createFile(){  //書き込み先のファイルがあるか確認（ある→削除し作成、ない→作成）
		try {
			if(Files.exists(path)){
				Files.delete(path);
			}
			Files.createFile(path);
		}catch(IOException e) {
			System.out.println(e);
		}
	}


	public static void fileWriting(){  //ファイルにリストを追記で書き込み
		try {
			Files.write(path, arrayList, StandardOpenOption.APPEND);
		}catch(IOException e) {
			System.out.println(e);
		}
	}
}

試したこと

以前の回答案からの変更点として

1. 生成済みのアナグラム文を再度生成しない
2. 日本語に変換後にローマ字が残る箇所が出来た時点で、その箇所に続く処理をスキップする（一般的なローマ字入力で変換）

例 「teratail」をアナグラム
アナグラム後の文の先頭2文字が「tr」の文→3文字目以降を追加せずに、2文字目を変更する

補足情報（FW/ツールのバージョンなど）

Eclipse IDE
・Version: 2021-03 (4.19.0)
・Java version: 11.0.9
・JavaコンパイラーはJavaSE-15

アナグラム生成箇所についての質問のため、日本語に変換する所など、生成の動作に支障が無い程度に省略している箇所があります。
個人で遊ぶ用のプログラムのため、Javaの作法から逸脱していたり、適切ではないメソッドを使用している可能性があります。

Comments

[dodox86]

コードを動かして完全に追っている訳ではないので確信は無いのですが、
[Javaでのアナグラム・置き換え処理を改善(早く)したい] https://teratail.com/questions/282663
の質問文中のご提示のコードで、Permutation()メソッドやgen()メソッドが自らを呼び出す再帰/再帰呼び出し（recursion/recursive call)を使っていて、もともと複数の文字列を扱うことができる汎用的なかたちになっていたように思えます。

[777_superlucky]

確かにそのコードの方が汎用的な形をしているのですが、今回の条件（同じ文を再生成しない・日本語変換後にローマ字が残さない）に合うように書き換えるのが出来ず、今回の質問文にあるようなコードになってしまいました。

[dodox86]

なるほど、そう言った経緯を踏まえ、現状のコードを基に、汎用的にしたいと言う主旨ですね。(単なる確認です)

Answer 1

質問投稿後も調べたりしたところ、8クイーン問題と今回考えている事が似ていると感じ、アレンジしたコードを書いてみました。
テストとして「teratail」をアナグラムしたところ、考えていたような動作を行う事が出来ました。
ただ、実際に日本語に変換したり、複数の対象文に正規表現を対応させるなどと言った点で改善点が数多くありますが、今回の質問にて解決したかった事が出来たので、自己解決とさせていただきます。
回答やコメントしていただきありがとうございました。
また質問する機会がありましたら、その時も回答していただけるととても助かります。

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class Anagram{
	static int targetSize;
	static Path path;
	static boolean[] flag;
	static int[] targetCount;
	static String[] anagramArray,  targetArray;
	static String[] alphabetArray = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"};
	static ArrayList<Integer> aList = new ArrayList<Integer>();
	static ArrayList<Integer> bList = new ArrayList<Integer>();
	static ArrayList<Integer> cList = new ArrayList<Integer>();
	static ArrayList<Integer> dList = new ArrayList<Integer>();
	static ArrayList<Integer> eList = new ArrayList<Integer>();
	static ArrayList<Integer> fList = new ArrayList<Integer>();
	static ArrayList<Integer> gList = new ArrayList<Integer>();
	static ArrayList<Integer> hList = new ArrayList<Integer>();
	static ArrayList<Integer> iList = new ArrayList<Integer>();
	static ArrayList<Integer> jList = new ArrayList<Integer>();
	static ArrayList<Integer> kList = new ArrayList<Integer>();
	static ArrayList<Integer> lList = new ArrayList<Integer>();
	static ArrayList<Integer> mList = new ArrayList<Integer>();
	static ArrayList<Integer> nList = new ArrayList<Integer>();
	static ArrayList<Integer> oList = new ArrayList<Integer>();
	static ArrayList<Integer> pList = new ArrayList<Integer>();
	static ArrayList<Integer> qList = new ArrayList<Integer>();
	static ArrayList<Integer> rList = new ArrayList<Integer>();
	static ArrayList<Integer> sList = new ArrayList<Integer>();
	static ArrayList<Integer> tList = new ArrayList<Integer>();
	static ArrayList<Integer> uList = new ArrayList<Integer>();
	static ArrayList<Integer> vList = new ArrayList<Integer>();
	static ArrayList<Integer> wList = new ArrayList<Integer>();
	static ArrayList<Integer> xList = new ArrayList<Integer>();
	static ArrayList<Integer> yList = new ArrayList<Integer>();
	static ArrayList<Integer> zList = new ArrayList<Integer>();
	static ArrayList<ArrayList<Integer>> azList = new ArrayList<ArrayList<Integer>>(26);
	static ArrayList<String> arrayList = new ArrayList<String>(1000000);

	public static void main(String[] args) {
		preparation("teratail");
	}

	public static void preparation(final String tsc) {
		path = Paths.get("C:\programming\anagram_" + tsc + ".txt");
		createFile();
		anagramArray = new String[targetSize];
		targetArray = tsc.split("");
		Arrays.sort(targetArray);
		targetSize = tsc.length();
		int[] alphabetCount = new int[alphabetArray.length];
		for(int x=0; x<targetArray.length; x++) {
			for(int y=0; y<alphabetArray.length; y++) {
				if(targetArray[x].equals(alphabetArray[y])) {  //対象文に含まれている文字が何回目の登場なのか計算
					targetArray[x] += alphabetCount[y];  //英文字の後ろに登場回数を追加
					alphabetCount[y]++;
				}
			}
		}
		flag = new boolean[targetSize];
		for(int f=0; f<flag.length; f++) {
			flag[f] = false;
		}
		anagramArray = new String[targetSize];
		listReset();
		set(0);
		fileWriting();  //書き込めなかったarrayListを書き込み
	}

	static void set(int i) {
		for(int f=0; f<targetSize; f++) {
			if(flag[f]==false) {
				for(int a=i+1; a<targetSize; a++) {
					anagramArray[a] = null;
				}
				anagramArray[i] = targetArray[f];
				if(anagramCheck(anagramArray) && regularExpression(anagramArray)) {  //保存しない条件（日本語に変換出来ないなど）を満たすかどうか
					if(i == targetSize-1) {
						print(anagramArray);
					}else {
						flag[f] = true;
						set(i+1);
						flag[f] = false;
					}
				}
			}
		}
	}

	static void print(final String[] psa) {
		String ps = "";
		for(int i=0; i<targetSize; i++) {
			ps += psa[i].replaceAll("[0-9]",  "");
		}
		Pattern patternEnd = Pattern.compile("[lrt]$");
		Matcher matcherEnd = patternEnd.matcher(ps);
		if(!(matcherEnd.find())) {
			arrayList.add(ps);
			if(arrayList.size() == 1000000) {
				fileWriting();
				arrayList.clear();
			}
		}
	}

	static boolean anagramCheck(final String[] acsa) {
		listReset();
		for(int i=0; i<acsa.length; i++) {
			if(acsa[i]!=null) {
				final String oneCharacter = acsa[i].replaceAll("[0-9]", "");
				final int number = Integer.parseInt(acsa[i].replaceAll("[a-z]", ""));
				switch(oneCharacter) {
				case "a" -> azList.get(0).add(number);  //対象文を先頭から見ていき、どの英文字がどんな順番で含まれているかを保存
				case "b" -> azList.get(1).add(number);
				case "c" -> azList.get(2).add(number);
				case "d" -> azList.get(3).add(number);
				case "e" -> azList.get(4).add(number);
				case "f" -> azList.get(5).add(number);
				case "g" -> azList.get(6).add(number);
				case "h" -> azList.get(7).add(number);
				case "i" -> azList.get(8).add(number);
				case "j" -> azList.get(9).add(number);
				case "k" -> azList.get(10).add(number);
				case "l" -> azList.get(11).add(number);
				case "m" -> azList.get(12).add(number);
				case "n" -> azList.get(13).add(number);
				case "o" -> azList.get(14).add(number);
				case "p" -> azList.get(15).add(number);
				case "q" -> azList.get(16).add(number);
				case "r" -> azList.get(17).add(number);
				case "s" -> azList.get(18).add(number);
				case "t" -> azList.get(19).add(number);
				case "u" -> azList.get(20).add(number);
				case "v" -> azList.get(21).add(number);
				case "w" -> azList.get(22).add(number);
				case "x" -> azList.get(23).add(number);
				case "y" -> azList.get(24).add(number);
				case "z" -> azList.get(25).add(number);
				}
			}else {
				break;
			}
		}
		for(int x=0; x<azList.size(); x++) {
			if(azList.get(x).size()==1) {  //各リストの先頭の数字が0かどうか（0ではない→再生成の可能性大）
				if(azList.get(x).get(0)!=0) {
					return false;
				}
			}else if(1<azList.get(x).size()) {
				for(int y=0; y<azList.get(x).size()-1; y++) {
					if(azList.get(x).get(y+1)<azList.get(x).get(y)) {  //各リストの要素が小さい順かどうか（大きい順→再生成の可能性大）
						return false;
					}
				}
			}
		}
		return true;
	}

	static boolean regularExpression(final String[] resa) {
		String res = "";
		for(int i=0; i<resa.length-1; i++) {
			if(resa[i] == null) {
				break;
			}else {
				res += resa[i].replaceAll("[0-9]", "");
			}
		}
		Pattern patternFirst = Pattern.compile("^tt");
		Pattern patternTwo = Pattern.compile(".*l[rt]|r[lt]|t[lr].*");
		Pattern patternThree = Pattern.compile(".*tt[lr].*");
		Matcher matcherFirst = patternFirst.matcher(res);
		Matcher matcherTwo = patternTwo.matcher(res);
		Matcher matcherThree = patternThree.matcher(res);

		if(2<=resa.length) {
			if(matcherFirst.find() || matcherTwo.find()) {
				return false;
			}
		}
		if(3<=resa.length) {
			if(matcherThree.find()) {
				return false;
			}
		}
		return true;
	}

	public static void createFile(){
		try {
			if(Files.exists(path)){
				Files.delete(path);
			}
			Files.createFile(path);
		}catch(IOException e) {
			System.out.println(e);
		}
	}

	public static void fileWriting(){
		try {
			Files.write(path, arrayList, StandardOpenOption.APPEND);
		}catch(IOException e) {
			System.out.println(e);
		}
	}

	public static void listReset(){  //上手く動作するようにリセット
		aList.clear();
		bList.clear();
		cList.clear();
		dList.clear();
		eList.clear();
		fList.clear();
		gList.clear();
		hList.clear();
		iList.clear();
		jList.clear();
		kList.clear();
		lList.clear();
		mList.clear();
		nList.clear();
		oList.clear();
		pList.clear();
		qList.clear();
		rList.clear();
		sList.clear();
		tList.clear();
		uList.clear();
		vList.clear();
		wList.clear();
		xList.clear();
		yList.clear();
		zList.clear();
		azList.clear();

		azList.add(0, aList);
		azList.add(1, bList);
		azList.add(2, cList);
		azList.add(3, dList);
		azList.add(4, eList);
		azList.add(5, fList);
		azList.add(6, gList);
		azList.add(7, hList);
		azList.add(8, iList);
		azList.add(9, jList);
		azList.add(10, kList);
		azList.add(11, lList);
		azList.add(12, mList);
		azList.add(13, nList);
		azList.add(14, oList);
		azList.add(15, pList);
		azList.add(16, qList);
		azList.add(17, rList);
		azList.add(18, sList);
		azList.add(19, tList);
		azList.add(20, uList);
		azList.add(21, vList);
		azList.add(22, wList);
		azList.add(23, xList);
		azList.add(24, yList);
		azList.add(25, zList);
	}
}

Answer 2

static int intA, intB, intC, intD, intE, intF, intG, intH;  //targetArrayの要素番号用

これをリストにしてしまえばいろいろできるようになると思われますが。

Comments

[777_superlucky]

回答ありがとうございました。
今回は自己解決となりましたが、思いついていなかった解決案を頂けて嬉しかったです。