Вы можете преобразовать строку в массив и проверить, является ли каждый элемент строки (разделенный пробелом) цифрой, протестировав метод Integer.parseInt () для каждого элемента строки. Вот пример ниже:
public static boolean isDig(String theString) {
String[] theStringArray = theString.split(" ");
ArrayList<Integer> nums = new ArrayList<Integer>();
for(int x = 0; x < theStringArray.length; x++) {
String thisString = theStringArray[x];
try {
int num = Integer.parseInt(thisString);
nums.add(num);
}catch(NumberFormatException e) {
continue;
}
}
int total = 0;
for(int num: nums) {
total += num;
}
if(total >= 80 && total <= 95) {
return true;
}
else {
System.out.println(total);
return false;
}
}
Сначала мы разбиваем исходную строку на массив, основанный на пустых местах. Затем мы создаем ArrayList, который добавит к нему каждую цифру в строке. Затем мы создаем цикл for для просмотра каждой отдельной строки в массиве и устанавливаем блок try-catch. Если мы можем преобразовать цифру в int с помощью метода Integer.parseInt (), мы добавим ее в ArrayList. Если нет, мы перехватим исключение и продолжим цикл с помощью оператора continue. Как только мы вырвемся из цикла, мы можем создать переменную под названием «total» и создать еще одну для цикла, чтобы добавить каждую цифру в ArrayList к общей сумме. Если сумма больше / равна 80 и меньше / равна 95, мы вернем True, иначе вернем false. Давайте проверим код:
String digitTest = "There is a digit here: 50 and a digit here 45";
System.out.println(isDig(digitTest));
Числа 50 и 45 должны быть равны 95, и наш результат:
true
Рекурсивные, алгоритмы делить-и-побеждать часто O (logN). Алгоритм, что циклы по делить-и-побеждать были бы O (NlogN).
Вот сообщение в блоге, которое могло бы помочь:
Стоимость разрушения вещей и откладывания их вместе
То сообщение объясняет "основную теорему" для работы с большими-O заказами.
O (LG (n)): Если Ваша проблема становится меньшей некоторой пропорцией n (часто n/2) на каждом шаге Вашего алгоритма, и каждый шаг делает постоянный объем работы. Двоичный поиск является хорошим примером, так как каждый шаг сокращает Ваш проблемный размер в половине путем выполнения постоянного объема работы (вычислите среднюю точку и сделайте одно сравнение).
Обратите внимание, что n находится на вершине той пропорции. Это не то же как Ваше сокращение размера задач 1/n на каждом шаге.:)
При поиске быстрого способа оценить время выполнения алгоритма другие ответы хороши. Если Вы хотите более тщательно продуманный ответ, я предлагаю, чтобы Вы посмотрели на "Основную теорему". В немецкой статье существует хорошая таблица к этому.
Править: John D. Cook сделал хорошее резюме к основной теореме, см. Ссылку его ответ.
Статья Wikipedia о Большой Нотации O имеет хорошую диаграмму заказов общих функций.
асимптотическая сложность алгоритмов важна на практике и здесь является некоторыми эмпирическими правилами, которые я использую, когда я рассматриваю мой или чужой код. Обычно практические компьютерные алгоритмы являются функциями многих переменных и нетривиальных структур данных, но позволяют нам принять (только для иллюстрации), что наш алгоритм f берет в основном единственное целое число X как его аргумент, и мы хотим найти асимптотическую сложность f с точки зрения X. Предположим, что f (0) тривиален. Затем в целом:
Некоторые особые случаи:
Алгоритмы, которые выращивают строки или области памяти путем добавления им, делают на многих языках, подвергаются O (X ** 2) наверху, такой как
for (i = 0; i < X; i++) { s += "foo"; } // quadratic
Этот типичный вложенный цикл имеет также X ** 2 наверху:
for (i = 0; i < X; i++) { for (j = 0; j < i; j++) { ... } } // quadratic
C++ контейнеры STL как станд.:: набор и станд.:: карта имеет O (зарегистрируйтесь X), издержки почти для всех операций
Просто мои 2 цента!Надеюсь, это поможет!
Usually something like O(logN) comes about because the data is size N, but it is organized e.g. in a tree where the depth of the tree is logN. If the typical search involves going from the root to the leaf (in worse case) then it is easy to see that the algorithm will be O(logN).
There are no hard and fast rules - you just have to look at each case, figure out the worse case scenario, and calculate what the cost of that would be.