Auteur: Rukawa Maple Knock Code
Page d' accueil du blog : Blog de Rukawa Kaede
Chronique : Apprendre java avec moi
Citation : Restez affamé, restez stupide
Si vous voulez faire de bonnes choses, vous devez d'abord affûter vos outils. Laissez-moi vous présenter un outil super puissant pour gagner des offres de grands fabricants - Niuke.com
Cliquez pour vous inscrire gratuitement et effleurez les questions avec moi
Annuaire d'articles
une chaîne représentant une valeur numérique
Nombre de fois qu'un nombre apparaît dans un tableau croissant
une chaîne représentant une valeur numérique
Veuillez implémenter une fonction pour déterminer si la chaîne str représente une valeur numérique (y compris les nombres en notation scientifique, les décimales et les nombres entiers).
Les nombres en notation scientifique (dans l'ordre) peuvent être divisés en les parties suivantes :
1. Quelques espaces
2. Un entier ou un décimal
3. (facultatif) un 'e' ou 'E' suivi d'un nombre entier (peut être positif ou négatif)
4. Quelques espaces
Les décimales (dans l'ordre) peuvent être divisées en les parties suivantes :
1. Quelques espaces
2. (optionnel) un signe ('+' ou '-')
3. Peut être l'un des formats de description suivants :
3.1 Au moins un chiffre suivi d'un point '.'
3.2 Au moins un chiffre suivi d'un point '.' suivi d'au moins un chiffre
3.3 Un point '.' suivi d'au moins un chiffre
4. Quelques espaces
Les nombres entiers (dans l'ordre) peuvent être divisés en les parties suivantes :
1. Plusieurs espaces
2. (facultatif) un signe ('+' ou '-')3. Au moins un chiffre
4. Quelques espaces
Par exemple, les chaînes ["+100","5e2","-123","3.1416","-1E-16"] représentent toutes des valeurs numériques.
Mais ["12e","1a3.14","1.2.3","+-5","12e+4.3"] ne sont pas des nombres.
indice:
1.1 <= longueur de chaîne <= 25
2.str ne contient que des lettres anglaises (majuscules et minuscules), des chiffres (0-9), le signe plus '+' , le signe moins '-' , l'espace ' ' ou le point '.' .
3. Si vous doutez que le cas d'utilisation puisse être représenté par une valeur numérique, vous pouvez utiliser print(float(str)) de python pour vérifier
Avancé : complexité temporelle O(n)\O(n), complexité spatiale O(n)\O(n)
Idées :
Commencez par couper, supprimez les espaces au début et à la fin de la chaîne
. ne peut apparaître qu'une seule fois et ne peut apparaître qu'avant e
e ne peut apparaître qu'une seule fois et doit être précédé d'un chiffre
+ - ne peut apparaître qu'au début ou après un e
Espaces, traités avec garniture, s'il y a un espace au milieu, il reviendra directement en cas d'échec
Utilisez un booléen pour indiquer si chaque situation se produit, n'écrivez que des situations réussies
réponse:
public boolean isNumeric (String str) {
str = str.trim();
//用boolean来表示每一个情况是否出现，是否出现一次（用!XXX来判断）
boolean numFlag = false, dotFlag = false, eFlag = false, plusFlag = false;
//只写成功的情况
for(int i = 0; i < str.length(); i++){
if(str.charAt(i) >= '0' && str.charAt(i) <= '9'){
numFlag = true;
}else if(str.charAt(i) == '.' && !dotFlag && !eFlag){
dotFlag = true;
}else if((str.charAt(i) == 'e' || str.charAt(i) == 'E') &&
!eFlag && numFlag){
eFlag = true;
//处理132e这种情况
numFlag = false;
}else if((str.charAt(i) == '+' || str.charAt(i) == '-') &&
(i == 0 || str.charAt(i-1) == 'e' || str.charAt(i-1) == 'E')){
//什么也不干
}else {
return false;
}
}
return numFlag;
}remplacer les espaces
Veuillez implémenter une fonction qui remplace chaque espace dans une chaîne s par "%20".
Par exemple, lorsque la chaîne est We Are Happy., la chaîne remplacée est We%20Are%20Happy.
Plage de données : 0 \le len(s) \le 1000 \0≤len(s)≤1000 . Assurez-vous que les caractères de la chaîne sont des lettres anglaises majuscules, des lettres anglaises minuscules et des espaces.
première méthode
Idée : convertissez d'abord la chaîne en un seul caractère
Ce que nous voulons ici est de remplacer les espaces dans la chaîne par %20. Une façon d'y parvenir est de demander un tableau temporaire, puis de parcourir chaque caractère de la chaîne. Si ce n'est pas un espace, ajoutez les caractères traversés à le tableau temporaire. , s'il s'agit d'un espace, ajoutez respectivement 3 caractères '%', '2', '0' au tableau temporaire, et enfin convertissez le tableau temporaire en chaîne.
public String replaceSpace(String s) {
int length = s.length();
char[] array = new char[length * 3];
int index = 0;
for (int i = 0; i < length; i++) {
char c = s.charAt(i);
if (c == ' ') {
array[index++] = '%';
array[index++] = '2';
array[index++] = '0';
} else {
array[index++] = c;
}
}
String newStr = new String(array, 0, index);
return newStr;
}Complexité temporelle : O(n), tous les caractères sont traversés une fois
Complexité spatiale : O(n), un tableau de n*3 est requis
Deuxième méthode
Idée : utiliser StringBuilder
Ajoutez chaque caractère de la chaîne à StringBuilder un par un, si vous rencontrez un espace, remplacez-le par %20
public String replaceSpace(String s) {
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) == ' ')
stringBuilder.append("%20");
else
stringBuilder.append(s.charAt(i));
}
return stringBuilder.toString();
}Complexité temporelle : O(n), tous les caractères sont traversés une fois
Complexité spatiale : O(n), l'espace requis par StringBuilder
Suite de Fibonacci
Tout le monde connaît la séquence de Fibonacci, et maintenant vous devez entrer un entier positif n, veuillez sortir le nième élément de la séquence de Fibonacci.
Une suite de Fibonacci est une suite qui satisfait fib(x)=\left\{ \begin{array}{rcl} 1 & {x=1,2}\\ fib(x-1)+fib(x-2) & {x>2}\\ \end{tableau} \right.fib(x)={1fib(x−1)+fib(x−2)x=1,2x>2 tableau
Plage de données : 1\leq n\leq 401≤n≤40
Exigences : complexité en espace O(1)O(1), complexité en temps O(n)O(n) , ce problème a aussi une solution en complexité en temps O(logn)O(logn)
Saisissez la description :
un entier positif n
Description de la valeur de retour :
Sort un entier positif.
première méthode
Idée : ajout itératif (recommandé)
L'idée de base de l'algorithme de programmation dynamique est la suivante : décomposer le problème à résoudre en plusieurs sous-problèmes interdépendants, résoudre d'abord les sous-problèmes, puis obtenir la solution du problème initial à partir des solutions de ces sous-problèmes ; pour les sous-problèmes répétés, résolvez-le uniquement lorsque vous le rencontrez pour la première fois, et enregistrez la réponse, afin de pouvoir vous référer directement à la réponse lorsque vous la rencontrerez à nouveau, sans avoir à la résoudre à nouveau. Les algorithmes de programmation dynamique traitent la solution d'un problème comme le résultat d'une série de décisions
Les premier et deuxième éléments de l'initialisation de la séquence de Fibonacci sont tous deux 1, puis selon la formule, le 0ème élément est 0, et il peut être accumulé jusqu'au nnnème élément selon la formule de Fibonacci
méthodes spécifiques :
1 : Séquence avec moins de 2 éléments, renvoie n directement
2 : Initialiser l'élément 0, et l'élément 1 est 0, 1 respectivement
3 : Commencez à partir du deuxième élément, accumulez progressivement selon la formule et mettez à jour le numéro de sommation pour qu'il soit toujours les deux premiers éléments de l'élément suivant.
public class Solution {
public int Fibonacci(int n) {
//从0开始，第0项是0，第一项是1
if(n <= 1)
return n;
int res = 0;
int a = 0;
int b = 1;
//因n=2时也为1，初始化的时候把a=0，b=1
for (int i = 2; i <= n; i++){
//第三项开始是前两项的和,然后保留最新的两项，更新数据相加
res = (a + b);
a = b;
b = res;
}
return res;
}
}
Deuxième méthode
idée: récursivité
1. Lorsque n < 2, renvoie n directement
2. Algorithme récursif : Fibonacci(n-1) + Fibonacci(n-2) ;
Avantages, le code est simple et facile à écrire, inconvénients : lent, temps mort Complexité temporelle : O(2^n) Complexité spatiale : espace pour la pile récursive
public class Solution {
public int Fibonacci(int n) {
if (n < 2){
return n;
}
return Fibonacci(n-1) + Fibonacci(n-2);
}
}Nombre de fois qu'un nombre apparaît dans un tableau croissant
Étant donné un tableau non décroissant de longueur n et un entier non négatif k, demander de compter le nombre de fois où k apparaît dans le tableau
Plage de données : 0 \le n \le 1000 , 0 \le k \le 1000≤n≤1000, 0≤k≤100, la valeur de chaque élément du tableau répond aux exigences de 0 \le val \le 1000≤val ≤100
: complexité spatiale O(1)O(1), complexité temporelle O(logn)O(logn)
Méthode : Dichotomie (recommandée)
Diviser pour régner signifie "diviser pour régner", "diviser" fait référence à la division d'un problème vaste et complexe en plusieurs sous-problèmes de même nature mais à plus petite échelle, et les sous-problèmes continuent d'être divisés de cette manière jusqu'à ce que le problème puisse être résolu. être facilement résolu ; » fait référence au traitement individuel des sous-problèmes. Après avoir divisé et conquis les sous-problèmes, la solution du problème original peut être obtenue en fusionnant les solutions, de sorte que l'ensemble du processus de division et de conquête est souvent mis en œuvre par récursivité.
Idées :
Étant donné que les données sont un tableau non descendant, elles sont ordonnées. À ce stade, nous pouvons penser à utiliser la recherche binaire. Mais un tableau peut avoir plus d'un k, et ce que nous recherchons n'est pas où k apparaît dans la dichotomie régulière, mais la borne gauche où k apparaît et la borne droite où k apparaît. Ce serait bien si nous pouvions simplement trouver les positions des nombres qui sont exactement inférieurs à k et les positions des nombres qui sont juste supérieurs à k
Et parce que le tableau est plein d'entiers, nous pouvons envisager d'utiliser la recherche binaire pour trouver la position où k+0.5k+0.5k+0.5 devrait apparaître et la position où k−0.5k-0.5k−0.5 devrait apparaître, et soustraire le deux est le nombre d'occurrences de k
méthodes spécifiques :
1 : Écrire une fonction de recherche binaire pour trouver la position d'un élément dans un tableau. Vérifiez à chaque fois la valeur médiane de l'intervalle et déterminez l'intervalle suivant en fonction de la comparaison avec le point médian.
2 : Utilisez la recherche binaire respectivement pour trouver les positions où k+0,5 et k-0,5 doivent apparaître. La partie médiane est tout en k, et le nombre de calculs peut être soustrait.
public class Solution {
//二分查找
private int bisearch(int[] data, double k){
int left = 0;
int right = data.length - 1;
//二分左右界
while(left <= right){
int mid = (left + right) / 2;
if(data[mid] < k)
left = mid + 1;
else if(data[mid] > k)
right = mid - 1;
}
return left;
}
public int GetNumberOfK(int [] array , int k) {
//分别查找k+0.5和k-0.5应该出现的位置，中间的部分就全是k
return bisearch(array, k + 0.5) - bisearch(array, k - 0.5);
}
}
Complexité temporelle : O(log2n)O(log_2n)O(log2n), où nnn est la longueur du tableau, deux recherches binaires, la complexité de la recherche binaire est O(log2n)O(log_2n)O(log2n)
Complexité spatiale : O(1)O(1)O(1), variables de niveau constant, pas d'espace auxiliaire supplémentaire
« Le partage de ce numéro est là, pensez à donner un trois-lien au blogueur, votre soutien est le plus grand moteur de ma création !