Опитвам се да намаля времето на изпълнение на програма, върху която работя и искам да измисля по-прост начин да намеря индекса на знак с цяло число.
В момента функцията ми проследява всеки символ на низ и връща индекс от първото цяло число, което намери. Като пример, ако имах низ JohnCena1237728394712 (да, това е първият низ, за който се сетих),функция трябва да върне 8, тъй като първото цяло число, което се появява в низа 1, е в индекс 8. Тя трябва първо да прегледа всеки знак преди него, за да намери този индекс, но това понякога се оскъпява.
Ако помага, когато се опитвате да мислите за по-лесен начинза да направя това, мога да съм сигурен, че влизам във функцията, че форматът на низа винаги ще бъде "[букви]" + "[числа]", така че просто трябва да намеря края на (по всяка вероятност случаен) сегмент от букви за да получа това, което искам.
Това, което бих искал да направя, е да използвам indexOf (), така че няма да трябва да използвам цикъл, но не знам начин да използвам функцията, без да има десет, ако изявления (което, разбира се, би победило целта).
Има ли начин да проверите за множество цели числа наведнъж, докато използвате indexOf () или някаква друга функция?
Отговори:
2 за отговор № 1Можете да направите това с регекс матче.
Нещо като:
Pattern pattern = Pattern.compile("\d");
Matcher matcher = pattern.matcher(inputString);
if(matcher.find()) {
return matcher.first();
}
return -1;
Това е доста четимо и разширяващо се. Някои може да го смятат за излишен в сравнение с обикновен for цикъл през низа. Съставянето на генерията отнема време и имате създадени няколко обекта и всичко това струва, ако „сте фанатични по отношение на производителността.
for(int i=0; i<str.length; i++) {
char c = str.charAt(i);
if(c >="0" && c <= "9") {
return i;
}
}
return -1;
Необходимо е, нещо ще трябва да разгледа всеки знак от своя страна, така че някъде ще има цикъл, независимо дали го напишете или дали той е в библиотечния метод, който викате.
Може да успеете да изтръгнете някаква скоростмножество ядра, като разбивате струната на парчета и правите нещо, намаляващо картата. Но това би струвало само за наистина огромни струни, в които цифрите бяха рядкост.
1 за отговор № 2
Начинът е да се използва Regular Expression, който е много мощен начин за представяне на низовото съдържание.
String str = "Hello world";
str.matches("\w+ \w+"); // returns true
И примера с използването на класовете Pattern и Matcher.
String line = "Hello amazing world";
String pattern = "(\w+) \w+ (\w+)";
Pattern r = Pattern.compile(pattern);
Matcher m = r.matcher(line);
if (m.find( )) {
System.out.println(m.group(1)); // Prints "Hello"
System.out.println(m.group(2)); // Prints "world"
}
0 за отговор № 3
Можете да проверите ascii на символите, за да видите дали е цяло число или не
Забележка: Ако приемем, че interger е само 1 цифра
String str = "hello123";
for(int i=0; i < str.length(); i++) {
char c = str.charAt(i);
if(c >= "0" && c <= "9") {
// Code goes here
}
}
Алтернативни решения:
- Използвайте indexOf () за всеки целеви знак, но това ще има сложност във времето от O (n ^ 2)
- Съхранявайте набора от целеви числа в набор, след това циклете на низ и проверете дали знаците са в множеството (Това е добре, ако цяло число е повече от една цифра)
0 за отговор № 4
Можете също така да избегнете .charAt(i), въпреки че няма много значение за това ... Просто вземете масив от char от низа, и цикъл, въпреки че с индексиран FOR цикъл, който връща индекса при достигане на първата цифра:
char[] chars = string.toCharArray();
for (int i=0; i<chars.lenght; i++) {
if(chars[i] >= "0" && chars[i] <= "9")
return i; //Or whatever code you need.
}
0 за отговор № 5
Ако разбирам правилно въпроса ви, имате куп знаци, последвани от куп цели числа.
Можете да използвате модифициран двоично търсене за да намерите точката в низа, където се осъществява преходът. Това трябва да се окаже полезно, ако трябва да анализирате много големи низове. Най-лошата ефективност е O (log n).
Кодирах пример по-долу:
public class binSearch {
static int indexFinder(String s) {
// this doesn"t check for invalid inputs btw
int beg = 0;
int end = s.length() - 1;
int mid;
int iter = 0;
while (beg < end) {
System.out.println("Iteration: " + iter + " String: " + s.substring(beg, end+1));
mid = (end + beg) / 2;
System.out.println("Mid: " + mid + " char: " + s.charAt(mid));
if (Character.isDigit(s.charAt(mid))) {
if (Character.isDigit(s.charAt(beg))) {
return beg;
}
end = mid;
} else {
beg = mid + 1;
}
iter++;
}
return beg;
}
public static void main(String[] args) {
System.out.println("Running");
String[] strings = {"joohhhnnnnnCEEENNAAAAAA123829898", "efi1029082198"};
for (String s : strings) {
StringBuilder check = new StringBuilder();
for(int i = 0; i < s.length(); i++) {
check.append(i % 10);
}
System.out.println(s);
System.out.println(check.toString() + "n");
System.out.println("First int index: " + indexFinder(s) + "nn");
}
}
}
изход:
Running
joohhhnnnnnCEEENNAAAAAA123829898
01234567890123456789012345678901
Iteration: 0 String: joohhhnnnnnCEEENNAAAAAA123829898
Mid: 15 char: N
Iteration: 1 String: NAAAAAA123829898
Mid: 23 char: 1
Iteration: 2 String: NAAAAAA1
Mid: 19 char: A
Iteration: 3 String: AAA1
Mid: 21 char: A
Iteration: 4 String: A1
Mid: 22 char: A
First int index: 23
efi1029082198
0123456789012
Iteration: 0 String: efi1029082198
Mid: 6 char: 9
Iteration: 1 String: efi1029
Mid: 3 char: 1
Iteration: 2 String: efi1
Mid: 1 char: f
Iteration: 3 String: i1
Mid: 2 char: i
First int index: 3