精华内容
下载资源
问答
  • 这个表是一个帖子版区表,第一列是版区id,最后一列是版区负责人, 主要列有: 版区id 版区负责人id 6 150414;1115115156 7 150414;1115115157 有一个人员表,有人员id和人员姓名,和这个表联合查询 最后想...
  • 我需要用户输入的字符串转换成莫尔斯电码。...它所做的是读取morseCode.txt文件并将这些字母分成一个列表[a,B。。。Z] 代码列成一个列表['–-。–––\n','。– . – . –\n'…]。我们还没...

    我需要把用户输入的字符串转换成莫尔斯电码。我们的教授希望我们这样做的方式是从一个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()

    展开全文
  • LeetCode87扰乱字符串

    2020-10-24 09:50:44
    可以任意位置把字符串分成两部分。 这道题很容易想到用递归的思想去解,假如两字符串 great 和 rgeat。考虑其中的种切割方式。 第 1 种情况:S1 切割为两部分,然后进行若干步切割交换,最后判断两子树分别...

    读题

    在扰乱这个字符串的过程中,我们可以挑选任何一个非叶节点,然后交换它的两个子节点。
    说明,字符串相同时,输出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"):...
    很多朋友在开发过程中都会遇到把一个大大的字符串中分成若干个小的字符串,然后判断小字符串是否是由字字组成。在这里我给大家提供几个简单的方法。
    
    第一种:
         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里出现如果不出现则添加,出现则返回。

    展开全文
  • 最近在排查一个线上问题,发现redis使用了一个hash key里面存储了600w的filed,为啥这么多就是因为他把一个结构体中的字段分成了多个filed存储。下面来看看到底应该怎么设计比较合理。一、问题一种使用简单的字符串...
  • (a)把字符串分成两个部分:第部分是字符串的第一个字符,第二部分是第一个字符后面的所有字符。之后求第二部分字符的全排列。 (b)拿第一个字符和它后面的字符逐个交换。 看了这个思路之后大致可以理解一下,...
  • 不说什么上代码。慢慢理解,这样可以提高度代码的能力 我们应该向这个问题, 如果字符串的第一个是空格呢。字符串不只一个空格。... 我们想要一个字符串向前移动的话,是不是可一分成一个
  • 今天刷到一个字符串的题,卡了我好几个小时,做到后来都开始怀疑自己了,明明是道不怎么难的题怎么被我搞那么久,心痛啊! 废话不多说,下面就本次惨痛教训中学到的知识点列出来 带空格的字符串输入 在C++中,常用...
  • 由于业务需求,我们可能会一串以分割符字符串数据放到一个字段,如我们在客户端处理拆分是很简单的,不过这样做效果不太好,怎么用SQL SERVER 2008 来解决这件事件哪?方案1用SQL SERVER XML 功能来解决1 ---->...
  • KMP算法利用匹配失败后的信息,尽量减少...将要进行next计算的字符串S分成 k ,j 前后两串,k代表前串开头所在的序号,j代表后串开头所在的序号,起始的时候j=1,k=0。 我们比较一下前串 后串是否相等,要怎么比...
  • 字符串的排列,就是给定一个字符串abc,输出能排列出的所有的字符串,如:abc,acb,bac,bca,cba,cab,写这个算法主要是想练习for循环中嵌套递归是怎么执行的,其实单纯的递归算法还是相对好理解的,你想找一个问题的...
  • 在mfc中,wstring str = _T("test1\test2"),怎么它拆分开来,分成test1、test2两个字符串,那么,这就用到了本文章的主角_tcstok函数。 _tcstok 声明头文件:#include <TCHAR.H> char* _tcstok...
  • 最近在排查一个线上问题,发现redis使用了一个hash key里面存储了600w的field,为啥这么多就是因为他把一个结构体中的字段分成了多个field存储。下面来看看到底应该怎么设计比较合理。 一、问题 一种使用简单的字符...
  • 我在网上查到的都是以字节为单位读取,怎么才能以一个单独的数字为单位,每次读取25万个。还有文件这么大,怎么读入内存?求指教我瞎说一下啊。用char 和正则 提取每一个数字呢? String转换为char数组文件大的话=...
  • 去掉字符串里的空格

    2012-09-30 21:56:00
    事情的起因是这样的,我要处理段这样的程序,用户可以以任意的形式输入11位数字+空格的形式,然后我要分成434的格式。 然后想到的办法是:去掉所有空格,然后按照规则划分成数组,然后再输出。 那么怎么样...
  • 我们考虑折叠一个区间里的字符串怎么样才是最优的 1.这个区间分成几部分分别折叠 2.这个区间直接折叠 注意到后者我们还需要考虑括号和数字的长度 #include<algorithm> #include<cstring> ...
  • 最近两天在写一个脚本,学了三天时间,...这里是网上找的一个字符串处理,因为我写的脚本要读取文件的格式嘛,昨天晚上搞了好一会,不停的调不停的调,总算把一个文件的每一行读取出来了,然后分成了不同的组,现在就得
  • 事情的起因是这样的,我要处理段这样的程序,用户可以以任意的形式输入11位数字+空格的形式,然后我要分成434的格式。 然后想到的办法是: 去掉所有空格,然后按照规则划分成数组,然后再输出。 那么怎么样...
  • 1. 写在前面的 事情的起因是这样的,我要处理段这样的程序,用户可以以任意的形式输入11位数字+空格的形式,然后我要分成434的格式。 然后想到的办法是: 去掉所有空格,然后按照规则划分成数组,然后再输出。...
  • 本文转http://www.mhzg.net/a/20117/2011789260293.html ... 由于业务需求,我们可能会一串以分割符字符串数据放到一个字段,如我们在客户端处理拆分是很简单的,不过这样做效果不太好,怎么用SQL SERVER 2008 来解
  • 由于业务需求,我们可能会一串以分割符字符串数据放到一个字段,如我们在客户端处理拆分是很简单的,不过这样做效果不太好,怎么用SQL SERVER 2008 来解决这件事件哪? 方案1 用SQL SERVER XML 功能来解决 1 -...
  • 大家好,我是刘志军,名python开发者 以后决定原创文章放在csdn进行首发,争取冲上榜单 base64 是什么?...首先将字符串(图片等)转换成二进制序列,然后按每6二进制位为组,分成若干组,如果不足6位

空空如也

空空如也

1 2 3 4 5
收藏数 88
精华内容 35
关键字:

怎么把字符串分成一个个字符