字符串拆分和包装

Question

假设给我这个字符串-

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

我被告知要避免丢失期间以及不使用虚拟变量。两者都在这里失败。关于如何解决这个问题的任何想法？

Answer 1

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

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);
}

Answer 2

通过在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("\\.", ""));
 }

Answer 3

我在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

Answer 4

“没有虚拟变量”听起来像是在寻求递归解决方案。这是一个 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 解决方案。