Блог

Возможно ли сопоставить следующее в одном регулярном выражении, чтобы получить первое слово, а затем список чисел?

 this 10 12 3 44 5 66 7 8    # should return "this", "10", "12", ...
another 1 2 3               # should return "another", "1", "2", "3"
 

EDIT1: мои фактические данные не так просты, цифры на самом деле представляют собой более сложные шаблоны, но для иллюстрации я сократил проблему до простых цифр, поэтому мне требуется ответ с регулярным выражением.

Длина чисел в каждой строке неизвестна, но все они соответствуют простому шаблону.

Следующее соответствует только «this» и «10»:

 ([p{Alpha}]  )(d  ?) ?
 

Удаление окончательных ? совпадений «this» и «8».

Я думал, что последняя группа (d ?) будет выполнять сопоставление цифр несколько раз, но это не так, и я не могу найти синтаксис для этого, если это возможно.

Я могу сделать это за несколько проходов, только выполняя поиск имени и последних чисел отдельно, но мне было интересно, возможно ли это в одном выражении? (А если нет, есть ли причина?)

EDIT2: Как я упоминал в некоторых комментариях, это был вопрос в Advent of Code (день 7, 2020). Я искал самое чистое решение (кто не любит немного полировать?)

Вот мое окончательное решение (kotlin) Я использовал, но потратил слишком много времени, пытаясь сделать это в 1 регулярном выражении, поэтому я опубликовал этот вопрос.

 val bagExtractor = Regex("""^([p{Alpha} ] ) bags contain""")
val rulesExtractor = Regex("""([d] ) ([p{Alpha} ] ) bag""")

// bagRule is a line from the input
val bag = bagExtractor.find(bagRule)?.destructured!!.let { (n) -> Bag(name = n) }
val contains = rulesExtractor.findAll(bagRule).map { it.destructured.let { (num, bagName) -> Contain(num = num.toInt(), bag = Bag(bagName)) } }.toList()
Rule(bag = bag, contains = contains)
 

Несмотря на то, что теперь я знаю, что это можно сделать в 1 строке, я не реализовал это, так как считаю, что в 2 это чище.

Я думаю, что то, что вы ищете, может быть достигнуто путем разделения строки s , если я чего-то не упустил.

 import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        String str = "this 10 12 3 44 5 66 7 8";
        String[] parts = str.split("\s ");
        System.out.println(Arrays.toString(parts));
    }
}
 

Вывод:

 [this, 10, 12, 3, 44, 5, 66, 7, 8]
 

Если вы хотите выбрать только алфавитный текст и целочисленный текст из строки, вы можете сделать это следующим образом

 import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        String str = "this 10 12 3 44 5 66 7 8";
        Matcher matcher = Pattern.compile("(\b\p{Alpha} \b)|(\b\d \b)").matcher(str);
        while (matcher.find()) {
            System.out.println(matcher.group());
        }
    }
}
 

Вывод:

 this
10
12
3
44
5
66
7
8
 

или как

 import java.util.List;
import java.util.regex.MatchResu<
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        String str = "this 10 12 3 44 5 66 7 8";

        List<String> list = Pattern.compile("(\b\p{Alpha} \b)|(\b\d \b)")
                            .matcher(str)
                            .results()
                            .map(MatchResult::group)                                                        
                            .collect(Collectors.toList());

        System.out.println(list);
    }
}
 

Вывод:

 [this, 10, 12, 3, 44, 5, 66, 7, 8]
 

Нет. Понятие «найди мне все определенное регулярное выражение» просто не выполняется с увеличением групп. Вы действительно спрашиваете, почему регулярное выражение такое, какое оно есть? Это… эпический тезис, который углубляется в какую-то древнюю историю вычислений и множество интервью Ларри Уолла (автора Perl, из которого более или менее пришли регулярные выражения), который кажется немного выходящим за рамки SO. Они работают таким образом, потому что регулярные выражения работают именно так, а те работают именно так, потому что они работали так десятилетиями, и их изменение нарушило бы ожидания людей; давайте не будем углубляться в это.

Вместо этого вы можете сделать это с помощью сканеров:

 Scanner s = new Scanner("this 10 12 3 44 5 66 7 8");
assertEquals("this", s.next());
assertEquals(10, s.nextInt());
// etc
 

или даже:

 Scanner s = new Scanner("this 10 12 3 44 5 66 7 8");
assertEquals("this", s.next());
assertEquals(10, s.nextInt());
// etc
 

или даже:

 Scanner s = new Scanner("this 10 12 3 44 5 66 7 8");
assertEquals("this", s.next(Pattern.compile("[p{Alpha}] "));
assertEquals(10, s.nextInt());

s = new Scanner("--00invalid-- 10 12 3 44 5 66 7 8");
// the line below will throw an InputMismatchException
s.next(Pattern.compile("[p{Alpha}] "));
 

ПРИМЕЧАНИЕ: сканеры токенизируют (они разделяют входные данные на последовательность токенов, разделителей, токенов, разделителей и т. Д., Затем отбрасывают разделители и выдают вам токены). .next(Pattern) не означает: продолжайте сканирование, пока не найдете что-то подходящее. Это просто означает: возьмите следующий токен. Если оно соответствует этому регулярному выражению, отлично, верните его. В противном случае произойдет сбой.

Итак, настоящая магия заключается в том, чтобы сделать сканер токенизированным, как вы хотите. Это делается с помощью use .useDelimiter() и также основано на регулярных выражениях. Некоторая причудливая работа ногами с позитивным прогнозом и со может завести вас далеко, но это не бесконечно мощно. Вы не расширили фактическую структуру вашего ввода, поэтому я не могу сказать, будет ли этого достаточно для ваших нужд.

Предполагая, что вы говорите об этом: adventofcode, где входные данные являются правилами

 light red bags contain 1 bright white bag, 2 muted yellow bags.
dark orange bags contain 3 bright white bags, 4 muted yellow bags.
bright white bags contain 1 shiny gold bag.
muted yellow bags contain 2 shiny gold bags, 9 faded blue bags.
shiny gold bags contain 1 dark olive bag, 2 vibrant plum bags.
dark olive bags contain 3 faded blue bags, 4 dotted black bags.
vibrant plum bags contain 5 faded blue bags, 6 dotted black bags.
faded blue bags contain no other bags.
dotted black bags contain no other bags.
 

Зачем искать сложное регулярное выражение, когда вы можете легко разделить слово contain или ,

 String str1 = "light red bags contain 1 bright white bag, 2 muted yellow bags.";
String str2 = "dotted black bags contain no other bags.";
String[] split1 = str1.split("\scontain\s|,");
String[] split2 = str2.split("\scontain\s|,");

System.out.println(Arrays.toString(split1));
System.out.println(Arrays.toString(split2));

//[light red bags, 1 bright white bag,  2 muted yellow bags.]
//[dotted black bags, no other bags.]
 

Вы сказали, что вам нужно использовать регулярное выражение. Но как насчет гибридного решения. Используйте регулярное выражение для проверки формата, а затем разделите значения на пробелы или разделитель по вашему выбору. Я также вернул значение в качестве необязательного, чтобы вы могли проверить его доступность перед использованием.

 String[] data = { "this 10 12 3 44 5 66 7 8",
        "Bad Data 5 5 5",
        "another 1 2 3" };

for (String text : data) {
    Optional<List<String>> op = parseText(text);
    if (!op.isEmpty()) {
        System.out.println(op.get());
    }
}
 

С принтами

 [this, 10, 12, 3, 44, 5, 66, 7, 8]
[another, 1, 2, 3]
 

 static String pattern = "([a-zA-Z] )(\s \d ) ";
    
public static Optional<List<String>> parseText(String text) {
    if (text.matches(pattern)) {
        return Optional.of(Arrays.stream(text.split("\s "))
                .collect(Collectors.toList()));
    }
    return Optional.empty();
}