Java — расщепление строк и упаковка
Предположим, мне дали эту строку
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);
}
Другие решения
Используя метод Split и обратный forloop в Java
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
«Без фиктивных переменных» звучит как поиск рекурсивного решения. Это класс 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);
}
Update2:
А вот еще одно решение 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.