所以我试图从压缩在一起的 2 个输入句子返回另一个字符串。如果 2 个句子的长度相同，它将产生实际输出。如果两个输入句子的长度不相同，那么它只会返回一个空字符串。到目前为止，这是我的代码，但我不知道如何正确压缩单词，有人可以帮助我。顺便说一句，如果您能通过递归执行此操作来帮助我，那就太好了，因为我正在尝试这样做。
前任:
Zippppp("ABC", "123") will return "A1B2C3"
Zippppp("AD", "CCC") will return “”
public class Zippppp
{
public Zippppp(String a, String s)
{
int l1 = a.length();
int l2 = s.length();
if(l1 == l2)
for(int i = 0; i > l1; i++)
System.out.print( a.substring(0, 1) + s.substring(0, 1));
}
public static void main(String args[ ])
{
Zippppp sv = new Zippppp("ABC", "123");
System.out.print(sv);
}
}
最佳答案
我喜欢你的类(class)名称。真挚地
为了真正“ return ”它，您可以实现类似于以下示例的内容。
更新/编辑:原始答案如下，因为三种新方法(不关心要压缩的字符串数量)位于顶部。
[ MultiThreaded ]
The ultimate ZIPPER
要压缩的每个单词都由一个线程处理。为什么？问问自己: 为什么不？？？
无聊使这些事情发生。
每个单词都将由它自己的线程进行可爱处理。由于 AtomicInteger ，线程自行组织以便不处理相同的单词并设置相同的位置。
String[] mix =new String[]{"AAAZZZ","100001","BBBWWW","200002","CCCYYY","300003",
"DDDXXX", "400004","EEEWWW","5000005","FFFVVV","600006"};
int strl = mix[0].length(); //entry's length
int nwords = mix.length; //number of strings
char[] zip=new char[strl*nwords]; //the result
AtomicInteger myWord = new AtomicInteger(0);
//returning boolean if want to check some future failed(not here lol)
List<Callable<Boolean>> callables = new ArrayList<>(nwords);
Callable<Boolean> zipYours =
new Callable<Boolean>()
{
public Boolean call()
{
try
{
int mine = myWord.getAndIncrement();
for (int x=0; x < strl; x++)
zip[mine+(nwords*x)]=mix[mine].charAt(x);
}catch(Exception e) {
return false;
}
return true;
}
};
for (int i=0;i<nwords;i++)
callables.add(zipYours);
//one thread - one word - true loef
ExecutorService executor = Executors.newFixedThreadPool(nwords);
executor.invokeAll(callables);
executor.shutdown();
System.out.println(new String(zip));
/*A1B2C3D4E5F6A0B0C0D0E0F0A0B0C0D0E0F0Z0W0Y0X0W0V0Z0W0Y0X0W0V0Z1W2Y3X4W0V6*/
说谎，我没有女 friend 。如果我有的话，你真的认为我会这样做吗？？
[
Zip'em all ]两种不同的方法:
1.直接移动
无论要压缩的字符串数量如何，从 2 到 n 都有效。* 这意味着这些方法也是旧方法的替代，因为您可以调用
getStringsZippedDirectMove("ABC,"123") 或 getStringsZippedDirectMove(yourArray) 。在这种方法中，每个字符串一次完全分配，因此列表中的每个元素只被访问/处理一次。主循环根据数组中的元素数进行迭代:
public static String getStringsZippedDirectMove(String... mix)
{
if (!goodMix(mix))
return "woloolooO"; //you are a blue monk now
int cn = mix[0].length(), n = mix.length; //cn = 3 | n = 6
char[] zip=new char[cn*n];
for (int i=0; i<n; i++)
for (int x=0; x<cn; x++)
zip[i+(n*x)] = mix[i].charAt(x);
return new String(zip);
}
boolean goodMix(String ... mix)
{
if (mix.length<2)
return false;
for (int i=1; i<mix.length; i++)
if (mix[i].length()!=mix[0].length())
return false;
return true;
}
AAA ”:zip[i+(n*x)]=mix[i].charAt(x); // zip[0 + (6*0)]=mix[0].charAt(0);
zip[i+(n*x)]=mix[i].charAt(x); // zip[0 + (6*1)]=mix[0].charAt(1);
zip[i+(n*x)]=mix[i].charAt(x); // zip[0 + (6*2)]=mix[0].charAt(2);
zip[0]=A zip[6]=A zip[12]=A
789 ”:zip[i+(n*x)]=mix[i].charAt(x); // zip[5 + (6*0)]=mix[5].charAt(0);
zip[i+(n*x)]=mix[i].charAt(x); // zip[5 + (6*1)]=mix[5].charAt(1);
zip[i+(n*x)]=mix[i].charAt(x); // zip[5 + (6*2)]=mix[5].charAt(2);
zip[5]=7 zip[11]=8 zip[17]=9
相同的输出:
String[] mix =new String[] { "AAA","123","BBB","456","CCC","789"};
System.out.println(getStringsZippedDirectMove(mix)); //"A1B4C7A2B5C8A3B6C9"
2. 从索引开始多次移动 - Holger 风格
受到 Holger 评论的启发
无论要压缩的字符串数量如何，这也将起作用，从 2 到 n .*
public String getStringsZippedHolger(String ... mix)
{
if (!goodMix(mix))
return "woloolooO"; //you are a red monk now
char[] zip = new char[mix[0].length()*mix.length];
for (int i=0, j=0; i<mix[0].length(); i++)
for (String s : mix)
zip[j++] = s.charAt(i);
return new String(zip);
}
i 标记的索引中的数组中的每个字符串的位置 j 附加字符。最后一个计数器在每次分配时递增。
String[] mix =new String[] { "AAA","123","BBB","456","CCC","789"};
System.out.println(getStringsZippedHolger(mix)); // "A1B4C7A2B5C8A3B6C9"
System.out.println(getStringsZippedHolger("HLE","OGR"));
System.out.println(getStringsZippedHolger("IT S","SHBS"," EO "));
原始答案块(2 个字符串)
Arrays 每次迭代的双重赋值
public String getZippppppppppppppppppppppppp(String a, String s) //a -"ABC" s -"123"
{
if (s.length()!=a.length())
return "";
char[] zip=new char[s.length()*2];
for (int i=0; i<s.length(); i++)
{
zip[i*2] = a.charAt(i);
zip[(i*2)+1] = s.charAt(i);
}
return new String(zip); /* "A1B2C3" */
}
i = 0 i = 1 i = 2
--------------------------------------------------------
zip[0] = A zip[2] = B zip[4] = C
zip[1] = 1 zip[3] = 2 zip[5] = 3
结果，我们得到了:
zip = ['A','1','B','2','C','3'] |||new String(zip) = "A1B2C3" 注意:如果你不喜欢数组，你就没有壁炉。
每次迭代的单个赋值
这对迭代逻辑使用了另一种方法，当您可以执行上一个示例所做的操作时，这似乎完全没有用。但只是为了好玩。
static String getZipppppppppppppppppppppUsingCharAtThanksElliot(String a, String s)
{ //a -"ABC" s -"123"
if (a.length()!=s.length())
return "";
char[] zip = new char[s.length()*2];
int c=0;
boolean even = false;
for(int i =0; i < (s.length()*2); i++)
{
even =!even;
if (even)
zip[i] = a.charAt(c);
else
{
zip[i] = s.charAt(c);
c++;
}
}
return new String(zip); //--> "A1B2C3"
}
String#subString :public String getZippppppppppppppppppppppppp(String a, String s) //a -"ABC" s -"123"
{
if (a.length()!=s.length())
return "";
String line="";
for(int i = 0; i < s.length(); i++)
line += ( a.substring(i*1, (i*1)+1) + s.substring(i*1, (i*1)+1) );
return line; //--> "A1B2C3"
}
String#charAt 请注意，在 Elliot 的答案中正确指出的
charAt() 不适用于此逻辑；它会给你一个数字文本，作为添加它们各自的 unicode 值的结果。它不会附加字符。使用
charAt() 的替代方法是使用 空字符串解决方法 ，或者像第二个无聊的例子一样创建 char[] 。public String getZipppppppppppppppppppppUsingCharAtThanksElliot(String a, String s)
{ //a -"ABC" s -"123"
if (a.length()!=s.length())
return "";
String line="";
for(int i = 0; i < s.length(); i++)
line += a.charAt(i) + "" + s.charAt(i) ; //note the empty string
return line; //--> "A1B2C3"
}
关于java - 来自 2 个(或更多)字符串的压缩字符串 - "AB"+ "YZ"= "AYBZ"，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/66309543/