我需要把用户输入的字符串转换成莫尔斯电码。我们的教授希望我们这样做的方式是从一个morse code.txt文件中读取，将morseCode中的字母分成两个列表，然后将每个字母转换为morse代码(有空格时插入新行)。
我有开始。它所做的是读取morseCode.txt文件并将这些字母分成一个列表[a，B。。。Z] 把代码列成一个列表['–-。–––\n'，'。– . – . –\n'…]。
我们还没学会“套路”，所以我不能用它。那我怎么把他们输入的字符串，逐字逐句地读一遍，然后把它转换成莫尔斯电码呢？我有点忙。这是我现在所拥有的(一点也不多…)
编辑：完成程序！# open morseCode.txt file to read
morseCodeFile = open('morseCode.txt', 'r') # format is :
# create an empty list for letters
letterList = []
# create an empty list for morse codes
codeList = []
# read the first line of the morseCode.txt
line = morseCodeFile.readline()
# while the line is not empty
while line != '':
# strip the \n from the end of each line
line = line.rstrip()
# append the first character of the line to the letterList
letterList.append(line[0])
# append the 3rd to last character of the line to the codeList
codeList.append(line[2:])
# read the next line
line = morseCodeFile.readline()
# close the file
morseCodeFile.close()
try:
# get user input
print("Enter a string to convert to morse code or press  to quit")
userInput = input("")
# while the user inputs something, continue
while userInput:
# strip the spaces from their input
userInput = userInput.replace(' ', '')
# convert to uppercase
userInput = userInput.upper()
# set string accumulator
accumulateLetters = ''
# go through each letter of the word
for x in userInput:
# get the index of the letterList using x
index = letterList.index(x)
# get the morse code value from the codeList using the index found above
value = codeList[index]
# accumulate the letter found above
accumulateLetters += value
# print the letters
print(accumulateLetters)
# input to try again or  to quit
print("Try again or press  to quit")
userInput = input("")
except ValueError:
print("Error in input. Only alphanumeric characters, a comma, and period allowed")
main()

读题
在扰乱这个字符串的过程中，我们可以挑选任何一个非叶节点，然后交换它的两个子节点。

说明，字符串相同时，输出true；
理解题
就是字符串分割，那么怎么分割，当然是每个字符都可以分割，分割之后可以交换判断，其实很简单，但是就是想不出来>_<

可以任意位置把字符串分成两部分。

这道题很容易想到用递归的思想去解，假如两个字符串 great 和 rgeat。考虑其中的一种切割方式。

第 1 种情况：S1 切割为两部分，然后进行若干步切割交换，最后判断两个子树分别是否能变成 S2 的两部分。


第 2 种情况：S1 切割并且交换为两部分，然后进行若干步切割交换，最后判断两个子树是否能变成 S2 的两部分。


暴力递归
启发：递归前进行一些必要的判断很需要。
public boolean isScramble(String s1, String s2) {
    if (s1.length() != s2.length()) {
        return false;
    }
    //以下代码可以不需要，但是可以经过判断之后速度运行比较快，就可以不需要进行下面的递归了。毕竟简单的递归调用过不了。
    if (s1.equals(s2)) {
        return true;
    }

    //判断两个字符串每个字母出现的次数是否一致
    int[] letters = new int[26];
    for (int i = 0; i < s1.length(); i++) {
        letters[s1.charAt(i) - 'a']++;
        letters[s2.charAt(i) - 'a']--;
    }
    //如果两个字符串的字母出现不一致直接返回 false
    for (int i = 0; i < 26; i++) {
        if (letters[i] != 0) {
            return false;
        }
    }
    
    //遍历每个切割位置
    for (int i = 1; i < s1.length(); i++) {
        //对应情况 1 ，判断 S1 的子树能否变为 S2 相应部分
        if (isScramble(s1.substring(0, i), s2.substring(0, i)) && isScramble(s1.substring(i), s2.substring(i))) {
            return true;
        }
        //对应情况 2 ，S1 两个子树先进行了交换，然后判断 S1 的子树能否变为 S2 相应部分
        if (isScramble(s1.substring(i), s2.substring(0, s2.length() - i)) &&
           isScramble(s1.substring(0, i), s2.substring(s2.length() - i)) ) {
            return true;
        }
    }
    return false;
}

memoization 记忆化递归
把递归过程中的结果存储起来，如果第二次递归过来，直接返回结果即可，无需重复递归
public boolean isScramble(String s1, String s2) {
    HashMap<String, Integer> memoization = new HashMap<>();
    return isScrambleRecursion(s1, s2, memoization);
}

public boolean isScrambleRecursion(String s1, String s2, HashMap<String, Integer> memoization) {
    	//判断之前是否已经有了结果
		int ret = memoization.getOrDefault(s1 + "#" + s2, -1);
		if (ret == 1) {
			return true;
		} else if (ret == 0) {
			return false;
		}
		if (s1.length() != s2.length()) {
			memoization.put(s1 + "#" + s2, 0);
			return false;
		}
		if (s1.equals(s2)) {
			memoization.put(s1 + "#" + s2, 1);
			return true;
		}

		int[] letters = new int[26];
		for (int i = 0; i < s1.length(); i++) {
			letters[s1.charAt(i) - 'a']++;
			letters[s2.charAt(i) - 'a']--;
		}
		for (int i = 0; i < 26; i++)
			if (letters[i] != 0) {
				memoization.put(s1 + "#" + s2, 0);
				return false; 
			}

		for (int i = 1; i < s1.length(); i++) {
			if (isScramble(s1.substring(0, i), s2.substring(0, i)) && isScramble(s1.substring(i), s2.substring(i))) {
				memoization.put(s1 + "#" + s2, 1);
				return true;
			}
			if (isScramble(s1.substring(0, i), s2.substring(s2.length() - i))
					&& isScramble(s1.substring(i), s2.substring(0, s2.length() - i))) {
				memoization.put(s1 + "#" + s2, 1);
				return true;
			}
		}
		memoization.put(s1 + "#" + s2, 0);
		return false;
	}

动态规划
初步分析
给定两个字符串 T 和 S，假设 T 是由 S 变换而来

如果 T 和 S 长度不一样，必定不能变来

如果长度一样，顶层字符串 S 能够划分为 S1和 S2同样字符串 T 也能够划分为 T1和 T2

情况一：没交换，S1 ==> T1，S2 ==> T2

情况二：交换了，S1 ==> T2，S2 ==> T1
确定子问题
子问题就是分别讨论两种情况，T1是否由 S1变来，T1是否由 S2	变来，或 T1是否由 S2变来，T2  是否由 S1变来。


初始条件
对于长度是 1 的子串，只有相等才能变过去，相等为 true，不相等为 false。
得到答案
还记得我们的定义吗？dp [ len ][ i ] [ j ]  表示从字符串 S 中 i 开始长度为 len 的字符串是否能变换为从字符串 T 中 j 开始长度为 len 的字符串，所以答案是 dp [ length ][ 0] [ 0 ] 。
public boolean isScramble4(String s1, String s2) {
    if (s1.length() != s2.length()) {
        return false;
    }
    if (s1.equals(s2)) {
        return true;
    }

    int[] letters = new int[26];
    for (int i = 0; i < s1.length(); i++) {
        letters[s1.charAt(i) - 'a']++;
        letters[s2.charAt(i) - 'a']--;
    }
    for (int i = 0; i < 26; i++) {
        if (letters[i] != 0) {
            return false;
        }
    }

    int length = s1.length();
    boolean[][][] dp = new boolean[length + 1][length][length];
	//遍历所有的字符串长度
    for (int len = 1; len <= length; len++) {
        //S1 开始的地方
        for (int i = 0; i + len <= length; i++) {
            //S2 开始的地方
            for (int j = 0; j + len <= length; j++) {
                //长度是 1 无需切割
                if (len == 1) {
                    dp[len][i][j] = s1.charAt(i) == s2.charAt(j);
                } else {
                    //遍历切割后的左半部分长度
                    for (int q = 1; q < len; q++) {
                        dp[len][i][j] = dp[q][i][j] && dp[len - q][i + q][j + q]
                            || dp[q][i][j + len - q] && dp[len - q][i + q][j];
                        //如果当前是 true 就 break，防止被覆盖为 false
                        if (dp[len][i][j]) {
                            break;
                        }
                    }
                }
            }
        }
    }
    return dp[length][0][0];
}

补充
// 上述代码只是考虑了16个英文字母，可以用hashmap来代替
        int n = s1.length();
        HashMap<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < n; i++) {
            char c1 = s1.charAt(i);
            char c2 = s2.charAt(i);
            map.put(c1, map.getOrDefault(c1, 0) + 1);
            map.put(c2, map.getOrDefault(c2, 0) - 1);
        }
        for (Character key : map.keySet()) {
            if (map.get(key) != 0) {
                return false;
            }
        }

​

很多朋友在开发过程中都会遇到把一个大大的字符串中分成若干个小的字符串，然后判断小字符串是否是由字字组成。在这里我给大家提供几个简单的方法。
第一种：
     try catch方法
      例：
      try
      {
        Convert.ToInt32("123"):
        Console.Write("是数字");
      }
      catch(Exception ex)
      {
        Console.Write("非数字");
      }
     注：如果有很多字符串要求判断，此方法需要大量的try catch  以及finally来处理后续的程序.不建议使用此方法。

第二种：
     正则表达式方法
      例：
      //引用正则表达式类
      using    System.Text.RegularExpressions;  
      Regex     reg=new    Regex("^[0-9]+$");  
      Match    ma=reg.Match(text);  
       if(ma.Success)  
      {  
       //是数字  
      }  
       else  
      {  
      //不是数字  
      }
     注：此方法快捷，但不太容易掌握，尤其是正则表达式公式，如果有兴趣的朋友可以好好研究，这东西很好用的，建议使用。

第三种：
      Double.TryParse方法
      例：
      bool isNum=System.Double.TryParse("所要判断的字符串"    ,System.Globalization.NumberStyles.Integer,null,out );
     注：此方法快捷,方便，很容易被掌握，但是参数很多，有兴趣的朋友可以研究一下，建议使用。
 

全字符排列
求出整个字符串的排列以及字典序排列。第一步找出所有的，第二步排序。

可以利用递归的思想，分成第一个字符和后面字符的全排列。求整个字符串的排列，第一步就是把第一个字符和后面的所有字符交换一次，第二步是递归求解后面字符串的全排列。

拿到一个字符串，首先将第一个与第二个交换，然后将交换后的传入继续交换接下来的，也就是此时第一个已经固定了，求的是剩下的字符串的全排列，需要知道一个起始点。递归回来之后再将这个换回来，继续令第一个字符和第三个字符交换。。。

怎么判断是否重复，那就要在交换前判断这个字符是否已经出现过了，如果出现过了则不进行下面的操作。可以用一个set来保存。记得交换要从第一个和第一个开始交换，把第一个字符也算进set里。
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Collections;
public class Solution {
    ArrayList<String> res=new ArrayList<String>();
    public ArrayList<String> Permutation(String str) {
        if(str==null || str.length()==0){
            return res;
        }
        char[] s=str.toCharArray();
        core(s,0);
        Collections.sort(res);
        return res;
    }
     public void core(char[] str,int i){
         if(i==str.length-1){
             res.add(String.valueOf(str));
             return;
         }
       HashSet<Character> set=new HashSet<Character>();
       for(int j=i;j<str.length;j++){
           if(j==i || !set.contains(str[j])){
               swap(str,i,j);
               core(str,i+1);
               swap(str,i,j);
               set.add(str[j]);
           }
       }
     }
    public void swap(char[] str,int i,int j){
        char temp=str[i];
        str[i]=str[j];
        str[j]=temp;
    }
}

全字符组合
如果求的不是全排列而是所有字母的组合，也就是组合不限字符个数。但ab和ba算同一个组合这也是一个排列组合的问题

首先这个问题可以分解为求长度为n的字符串有多少个m长度的字符组合，m可以为1到n。如果m为n则就一种。如果m为n-1那就有n种。

把n个字符分为第一个字符和后面的字符两部分，如果就这两部分，则后面的字符组合可以用递归来求，如果组合里包括第一个字符则在剩下的部分中选m-1个字符，如果组合里不包括则在剩下的组合里选m个字符，这样就把问题分解为f（n，m）=f（n-1，m）+f（n-1，m-1）

循环m从1到n，然后里面的每个m是递归求。当到达最后一个时判断这个字符是否在set里出现如果不出现则添加，出现则返回。