Java 解压缩包含更多嵌套字符串的字符串
赋值包括对字符串进行解压缩。特别是,代码必须适用于3个示例,如图所示 我这里的代码在前两个示例中有效。然而,我不能拿出第三个样本。可能我不理解递归的概念。你能帮我吗Java 解压缩包含更多嵌套字符串的字符串,java,string,compression,Java,String,Compression,赋值包括对字符串进行解压缩。特别是,代码必须适用于3个示例,如图所示 我这里的代码在前两个示例中有效。然而,我不能拿出第三个样本。可能我不理解递归的概念。你能帮我吗 import java.util.Scanner; public class Compression4 { public static void main(String[] args) { Scanner in = new Scanner(System.in); String input=in.next();
import java.util.Scanner;
public class Compression4 {
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
String input=in.next();
System.out.println(uncompress(input));
}
public static boolean flag = true;
public static String uncompress(String compressedText)
{
return uncompress(compressedText, "", "");
}
public static String getMultiple(String x, int N) {
if (N == 0) return "";
return ""+x+getMultiple(x,N-1);
}
public static String uncompress(String text, String count, String output)
{
if (text.equals(""))
{
return output;
}
if(text.charAt(0) == '(')
{
int FirstIndex = text.indexOf("(")+1;
String inner = text.substring(FirstIndex, text.lastIndexOf(")"));
//System.out.println(inner);
flag = false;
return uncompress (inner, count, output);
}
else if (Character.isLetter(text.charAt(0)))
{
//letter case - need to take the count we have accrued, parse it into an integer and add to output
if (flag==true)
{
//System.out.println(count);// * text.charAt(0);
String s = String.valueOf(text.charAt(0));
output += getMultiple(s,Integer.parseInt(count));
count ="1";
}
else
{
//System.out.println(count);// * text.charAt(0);
output += getMultiple(text,Integer.parseInt(count));
//System.out.println("output: "+output);
count="0";
}
}
else if(Character.isDigit(text.charAt(0)))
{
//digit case - need to add to the count but keep as a string because must be parsed later
if(flag)
count += (""+text.charAt(0));
else
{
count = "0";
count += (""+text.charAt(0));
}
}
//parse the *remainder* of the string, one character at a time, so pass in the substring(1)
return uncompress(text.substring(1), count, output);
}
}
抱歉,代码太长了,但用代码解释比用文字解释更容易 前提:
- 我认为作为一种语言的解释器来呈现字符串是一个问题
- 该语言简单实用,因此递归解释是可能的
- 第一:标记化表达式(在更高的抽象级别上工作)
- 第二:解析刚刚标记的表达式
- 基本情况和递归情况
- 单个递归所需的状态(递归的局部变量,作为参数传递给递归方法的变量)
- 所有递归的状态(递归的全局变量,在某些特定递归中读/写的变量)
import java.util.ArrayList;
import java.util.List;
public class TestStringDecompression {
// simpleExpr examples: a | b | 123a | 123b | 123(a) | 123(ab) | 123(ba) | (ab) | (ba)
// 11ab = aaaaaaaaaaab = = expression = simpleExpr simpleExpr = 11a b
// 4(ab) = abababab = expression = simpleExpr = 4(ab)
// 2(3b3(ab)) = bbbabababbbbababab = expression = compositeExpr = 2 ( simpleExpr simpleExpr ) = 2 ( 3b 3(ab) )
public static void main(String[] args) {
System.out.println(new StringInflater().inflate("11ab"));
System.out.println(new StringInflater().inflate("4(ab)"));
System.out.println(new StringInflater().inflate("2(3b3(ab))"));
}
public static class StringInflater {
// This store the position of the last parsed token
private int posLastParsedToken = 0;
public String inflate(String expression) {
return parse(tokenize(expression), 0, false);
}
/**
* Language tokens:
* <ul>
* <li>literals:
* <ul>
* <li>intLiteral = [0-9]*</li>
* <li>charLiteral = [ab]</li>
* </ul>
* </li>
* <li>separators:
* <ul>
* <li>leftParen = '('</li>
* <li>rightParen = ')'</li>
* </ul>
* </li>
* </ul>
*/
private Object[] tokenize(String expression) {
List<Object> tokens = new ArrayList<Object>();
int i = 0;
while (i < expression.length()) {
if ('0' <= expression.charAt(i) && expression.charAt(i) <= '9') {
String number = "";
while ('0' <= expression.charAt(i) && expression.charAt(i) <= '9' && i < expression.length()) {
number += expression.charAt(i++);
}
tokens.add(Integer.valueOf(number));
} else {
tokens.add(expression.charAt(i++));
}
}
return tokens.toArray(new Object[tokens.size()]);
}
/**
* Language syntax:
* <ul>
* <li>simpleExpr = [intLiteral] charLiteral | [intLiteral] leftParen charLiteral+ rightParen</li>
* <li>compositeExpr = [intLiteral] leftParen (simpleExpr | compositeExpr)+ rightParen</li>
* <li>expression = (simpleExpr | compositeExpr)+</li>
* </ul>
*/
private String parse(Object[] tokens, int pos, boolean nested) {
posLastParsedToken = pos;
String result = "";
if (tokens[pos] instanceof Integer) {
/** it's a intLiteral */
// get quantifier value
int repetition = (int) tokens[pos];
// lookahead for (
if (tokens[pos + 1].equals("(")) {
// composite repetition, it could be:
// simpleExpr: "[intLiteral] leftParen charLiteral+ rightParen"
// compositeExpr: "[intLiteral] leftParen (simpleExpr | compositeExpr)+ rightParen"
result = parse(tokens, pos + 1, true);
} else {
// simple repetition, it could be:
// simpleExpr: [intLiteral] charLiteral
result = parse(tokens, pos + 1, false);
}
result = repeat(result, repetition);
// evaluate the rest of the expression because syntax allows it
if (posLastParsedToken + 1 == tokens.length) {
// end of the expression
return result;
} else {
// there are other simpleExpr or compositeExpr to parse
return result + parse(tokens, posLastParsedToken + 1, false);
}
} else if (tokens[pos].equals('(')) {
/** it's a leftParen */
// an open paren means what follow this token is considered nested (useful for string to treat as char sequence)
return parse(tokens, pos + 1, true);
} else if (tokens[pos].equals(')')) {
/** it's a rightParen */
// a closed paren, nothing to render
return "";
} else {
/** it's a charLiteral */
if (nested) {
// it's nested between paren, so more parsing is requested to consume next charLiteral or next simpleExpr or compositeExpr
return tokens[pos] + parse(tokens, pos + 1, nested);
} else {
// it's not nested between paren, return charLiteral as is
return "" + tokens[pos];
}
}
}
private String repeat(String s, int repetition) {
StringBuilder result = new StringBuilder();
for (int i = 0; i < repetition; i++) {
result.append(s);
}
return result.toString();
}
}
}
import java.util.ArrayList;
导入java.util.List;
公共类teststring解压{
//简单的例子:a | b | 123a | 123b | 123(a)| 123(ab)| 123(ba)|(ab)
//11ab=aaaaaaaab==expression=simpleExpr simpleExpr=11a b
//4(ab)=abababab=expression=simpleExpr=4(ab)
//2(3b3(ab))=BBBABBBABBBAB=表达式=compositeExpr=2(simpleExpr simpleExpr)=2(3b3(ab))
公共静态void main(字符串[]args){
System.out.println(新的StringInflater().充气(“11ab”);
系统输出打印LN(新的StringInflater().充气(“4(ab)”);
System.out.println(新的StringInflater().充气(“2(3b3(ab))”))));
}
公共静电级充气机{
//这将存储最后解析的令牌的位置
private int poslastpassessedtoken=0;
公共字符串充气(字符串表达式){
返回解析(标记化(表达式),0,false);
}
/**
*语言标记:
*
*- 文字:
*
*- intLiteral=[0-9]*
*- charLiteral=[ab]
*
*
*- 分离器:
*
*- leftParen='('
*- rightParen=')'
*
*
*
*/
私有对象[]标记化(字符串表达式){
List tokens=new ArrayList();
int i=0;
而(i 如果('0'这是一个很好的赋值!但您仅有的规范是三个示例?我将添加更多说明。从这些示例中可以理解,我们假设字符串11ab中的数字11表示下一个符号a将重复11次。如果我们希望重复更长的模式,请使用括号:字符串4中的数字4(ab)指示子字符串ab将重复4次。所有未压缩字符串仅由两个符号a和b组成。而压缩字符串也可以包含数字和括号,如上面的示例所示。很好的Leonardo。但是现在你应该更具体地说明关于递归的不清楚之处。目前你的问题似乎有些问题ng如“这是我不工作的代码,请让它工作”。正如主持人通常建议在问题中添加您的澄清,而不是在评论中。另一个建议:这里的问题更多地与解析有关,而不是与解压缩有关。作业要求的是思考如何编写“字符串呈现语言”的执行者:.所以你必须解析。