分割和包装字符串

String splitting and wrapping

本文关键字：字符串 包装 分割      更新时间：2023-10-16

假设我得到了这个字符串-

String A_Old[]="010.011.100.000.111";

每次出现"000"时，我都希望将字符串断开，并将结束部分包装到字符串的前面。结果应该是这样的-

String A_New[]="111.010.011.100";
如果能帮助我解决这个问题，我将不胜感激。此外，当多次出现"000"时，我该怎么办?
String A_Old[]="010.011.100.000.111.001.011.000.101.110";

应转换为:

String A_New[]="101.110.111.001.011.010.011.100";

理解并欣赏java或c++代码。

编辑

我认为这是可行的-

String b[]=A_Old.split(".000.",2);    //should split the string in 2 parts.
A_New=b[1].concat(b[0]);              // concatenation with a loss of a period

我被告知要避免周期的损失以及不要使用虚拟变量。这两种方法在这里都失败了。有办法解决这个问题吗?

要旋转列表，您需要分割，然后按您想要的顺序连接。您可能需要检查是否为空白/如果它是最后一个元素。

public static void main(String[] args)
{
    String inString = "010.011.100.000.111";
    String outString = "";
    String[] arr = inString.split("\.000\.");
    outString = arr[0];
    for(int i = 1; i < arr.length; i++)
    {
      outString = outString + arr[i];
    }
    System.out.println(outString);
}

在java中使用Split方法和反向forloop 

public static void main(String[] args) {
 //insert code here
     String A_Old="010.011.100.000.111.001.011.000.101.110";
     String A_new ="";
     String newe[]=A_Old.split("\.000");
     for(int i=newe.length-1;i>=0;i--){
         A_new+=newe[i];
     }
     System.out.print(A_new.replaceFirst("\.", ""));
 }

我在java中尝试过:

public static String convert(String in) {
    String[] strs = in.split("\.*000\.*");
    StringBuilder sb = new StringBuilder();
    for (int i = strs.length - 1; i >= 0; --i) {
        sb.append(strs[i]);
        if (i > 0 && strs[i - 1].length() > 0) {
            sb.append(".");
        }
    }
    return sb.toString();
}
public static void main(String[] args) {
    System.out.println(convert("010.011.100.000.111"));
    System.out.println(convert("010.011.100.000.111.001.011.000.101.110"));
    System.out.println(convert("010.011.100.111"));
    System.out.println(convert("000.010.011.100.111"));
    System.out.println(convert("010.011.100.111.000"));
    System.out.println(convert("000.010.011.100.111.000"));
}
输出:

111.010.011.100
101.110.111.001.011.010.011.100
010.011.100.111
010.011.100.111
010.011.100.111
010.011.100.111

"No dummy variables"听起来像是在寻找递归解决方案。这是Scheme类吗?

下面是一个Perl解决方案。c++ 11足够高级，可以提供这里演示的大多数功能: 
my @tests = (
    '010.011.100.000.111',
    '010.011.100.000.111.001.011.000.101.110'
);
foreach ( @tests ) {
  print "$_ => ", rotate($_), "n";  # Call our rotate routine, and show results.
}
sub rotate {
  # Split the string into components, reverse their order, join them with '.'
  return join('.', reverse split /(?:^|.)000(?:.|$)/, shift);
}

无虚拟变量。事实上，也没有显式变量。

下面是拆分正则表达式的工作原理:

(?:^|.) # Match either start of string, or a dot.
000      # Match three zeros.
(?:.|$) # Match either a dot, or the end of string.

允许000出现在字符串的任何位置(包括开头或结尾)。如果它出现在开头，就不需要一个导点。如果它出现在末尾，则不需要尾随点。在其他地方，点必须围绕000。

更新:下面是一个使用Perl的递归解决方案。从我读到的Java解决方案(我不是Java人)来看，对于有Java背景的人来说，翻译应该是直截了当地的。

my @tests = (
    '010.011.100.000.111',
    '010.011.100.000.111.001.011.000.101.110'
);
foreach ( @tests ) {
  print "($_)  =>  (", rotate($_), ")n";
}
sub rotate {
  my( $ok, $rest ) = split /(?:^|.)000(?:.|$)/, $_[0], 2;
  return $ok unless defined $rest;
  return join( '.', rotate($rest), $ok);
}

更新2:下面是另一个Perl解决方案，它消除了任何显式变量，只使用子例程参数:

my @tests = (
    '010.011.100.000.111',
    '010.011.100.000.111.001.011.000.101.110'
);
foreach ( @tests ) {
  print "($_)  =>  (", rotate($_), ")n";
}
sub rotate {
  return sub {
    return $_[0] unless defined $_[1];
    return join( '.', rotate($_[1]), $_[0]);
  }->( split /(?:^|.)000(?:.|$)/, shift, 2 );
}

我不知道如何翻译Java。我怀疑翻译会变得更加困难，尽管我相信一定存在语义上等效的c++ 11解决方案。

相关文章：