Autor: Rukawa Maple Knock Code
Página de inicio del blog: Blog de Rukawa Kaede
Columna: Aprende java conmigo
Cita: Mantente hambriento, mantente tonto
Si quieres hacer cosas buenas, primero debes afilar tus herramientas. Permíteme presentarte una herramienta súper poderosa para ganar ofertas de grandes fabricantes: Niuke.com
Haga clic para registrarse de forma gratuita y aclarar las preguntas conmigo
Directorio de artículos
una cadena que representa un valor numérico
Número de veces que aparece un número en una matriz ascendente
una cadena que representa un valor numérico
Implemente una función para determinar si la cadena str representa un valor numérico (incluidos números en notación científica, decimales y enteros).
Los números en notación científica (en orden) se pueden dividir en las siguientes partes:
1. Algunos espacios
2. Un número entero o decimal
3. (opcional) una 'e' o 'E' seguida de un número entero (puede ser positivo o negativo)
4. Algunos espacios
Los decimales (en orden) se pueden dividir en las siguientes partes:
1. Algunos espacios
2. (opcional) un carácter de signo ('+' o '-')
3. Puede ser uno de los siguientes formatos de descripción:
3.1 Al menos un dígito seguido de un punto '.'
3.2 Al menos un dígito seguido de un punto '.' seguido de al menos un dígito
3.3 Un punto '.' seguido de al menos un dígito
4. Algunos espacios
Los números enteros (en orden) se pueden dividir en las siguientes partes:
1. Varios espacios
2. (opcional) un carácter de signo ('+' o '-')3. Al menos un dígito
4. Algunos espacios
Por ejemplo, las cadenas ["+100","5e2","-123","3.1416","-1E-16"] representan valores numéricos.
Pero ["12e","1a3.14","1.2.3","+-5","12e+4.3"] no son números.
insinuación:
1.1 <= longitud de cadena <= 25
2.str contiene solo letras en inglés (mayúsculas y minúsculas), números (0-9), signo más '+', signo menos '-', espacio ' ' o punto '.'.
3. Si tiene dudas sobre si el caso de uso puede representarse como un valor numérico, puede usar la función print(float(str)) de python para verificar
Avanzado: complejidad temporal O(n)\O(n), complejidad espacial O(n)\O(n)
Ideas:
Primero recorte, elimine los espacios al principio y al final de la cadena
.solo puede aparecer una vez, y solo puede aparecer antes de e
e solo puede aparecer una vez y debe ir precedida de un número
+ - solo puede aparecer al principio o después de una e
Espacios, procesados con recorte, si hay un espacio en el medio, regresará directamente cuando falle
Use boolean para indicar si ocurre cada situación, solo escriba situaciones exitosas
responder:
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;
}reemplazar espacios
Implemente una función que reemplace cada espacio en una cadena s con "% 20".
Por ejemplo, cuando la cadena es We Are Happy., la cadena reemplazada es We%20Are%20Happy.
Rango de datos: 0 \le len(s) \le 1000 \0≤len(s)≤1000 . Asegúrese de que los caracteres de la cadena sean letras inglesas en mayúsculas, letras inglesas en minúsculas y espacios.
método uno
Idea: primero convierta la cadena en un solo carácter
Lo que queremos aquí es reemplazar los espacios en la cadena con% 20. Una forma de lograr esto es solicitar una matriz temporal y luego recorrer cada carácter de la cadena. Si no es un espacio, agregue los caracteres recorridos a la matriz temporal. , si es un espacio, agregue 3 caracteres '%', '2', '0' a la matriz temporal respectivamente, y finalmente convierta la matriz temporal en una cadena.
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;
}Complejidad de tiempo: O(n), todos los caracteres se recorren una vez
Complejidad de espacio: O(n), se requiere una matriz de n*3
Método dos
Idea: Usar StringBuilder
Agregue cada carácter en la cadena a StringBuilder uno por uno, si encuentra un espacio, reemplácelo con% 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();
}Complejidad de tiempo: O(n), todos los caracteres se recorren una vez
Complejidad de espacio: O(n), el espacio requerido por StringBuilder
secuencia Fibonacci
Todo el mundo conoce la secuencia de Fibonacci, y ahora debe ingresar un número entero positivo n, genere el enésimo elemento de la secuencia de Fibonacci.
Una secuencia de Fibonacci es una secuencia que satisface fib(x)=\left\{ \begin{array}{rcl} 1 & {x=1,2}\\ fib(x-1)+fib(x-2) & {x>2}\\ \end{matriz} \right.fib(x)={1fib(x−1)+fib(x−2)x=1,2x>2 matriz
Rango de datos: 1\leq n\leq 401≤n≤40
Requisitos: complejidad de espacio O(1)O(1), complejidad de tiempo O(n)O(n), este problema también tiene una solución de complejidad de tiempo O(logn)O(logn)
Introduzca la descripción:
un entero positivo n
Descripción del valor de retorno:
Salida de un entero positivo.
método uno
Idea: adición iterativa (recomendado)
La idea básica del algoritmo de programación dinámica es: descomponer el problema a resolver en varios subproblemas interrelacionados, resolver primero los subproblemas y luego obtener la solución del problema original a partir de las soluciones de estos subproblemas; para los subproblemas repetidos, resuélvalos solo cuando los encuentre por primera vez y guarde la respuesta, de modo que pueda referirse directamente a la respuesta cuando los encuentre nuevamente, sin tener que resolverlos nuevamente. Los algoritmos de programación dinámica tratan la solución de un problema como el resultado de una serie de decisiones
El primer y segundo elementos de la inicialización de la secuencia de Fibonacci son ambos 1, luego, de acuerdo con la fórmula, el elemento 0 es 0, y se puede acumular hasta el elemento nnn de acuerdo con la fórmula de Fibonacci
métodos específicos:
1: Secuencia con menos de 2 elementos, devolver n directamente
2: inicializa el elemento 0 y el elemento 1 es 0, 1 respectivamente
3: comience desde el segundo elemento, acumule gradualmente de acuerdo con la fórmula y actualice el número de suma para que siempre sean los dos primeros elementos del siguiente elemento
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;
}
}
Método dos
idea: recursividad
1. Cuando n < 2, devuelve n directamente
2. Algoritmo recursivo: Fibonacci(n-1) + Fibonacci(n-2);
Ventajas, el código es simple y fácil de escribir, desventajas: lento, se agota el tiempo de espera Complejidad de tiempo : O (2 ^ n) Complejidad de espacio: espacio para la pila recursiva
public class Solution {
public int Fibonacci(int n) {
if (n < 2){
return n;
}
return Fibonacci(n-1) + Fibonacci(n-2);
}
}Número de veces que aparece un número en una matriz ascendente
Dada una matriz no descendente de longitud n y un número entero no negativo k, pida contar el número de veces que k aparece en la matriz
Rango de datos: 0 \le n \le 1000 , 0 \le k \le 1000≤n≤1000, 0≤k≤100, el valor de cada elemento en la matriz cumple con los requisitos de 0 \le val \le 1000≤val ≤100
: Complejidad espacial O(1)O(1), complejidad temporal O(logn)O(logn)
Método: Dicotomía (recomendado)
Divide y vencerás significa "divide y vencerás", "divide" se refiere a dividir un problema grande y complejo en múltiples subproblemas con la misma naturaleza pero de menor escala, y los subproblemas continúan dividiéndose de esta manera hasta que el problema puede resolverse. resolverse fácilmente” se refiere a tratar los subproblemas individualmente. Después de dividir y conquistar los subproblemas, la solución del problema original se puede obtener fusionando las soluciones, por lo que todo el proceso de dividir y conquistar a menudo se implementa por recursividad.
Ideas:
Debido a que los datos son una matriz no descendente, están ordenados.En este momento, podemos pensar en usar la búsqueda binaria. Pero una matriz puede tener más de una k, y lo que estamos buscando no es dónde aparece k en la dicotomía regular, sino el límite izquierdo donde aparece k y el límite derecho donde aparece k. Sería bueno si pudiéramos encontrar las posiciones de los números que son exactamente menores que k y las posiciones de los números que son simplemente mayores que k
Y debido a que la matriz está llena de números enteros, podemos considerar usar la búsqueda binaria para encontrar la posición donde debería aparecer k+0.5k+0.5k+0.5 y la posición donde debería aparecer k−0.5k-0.5k−0.5, y restar el dos es el número de ocurrencias de k
métodos específicos:
1: Escriba una función de búsqueda binaria para encontrar la posición de un elemento en una matriz. Compruebe el valor del punto medio del intervalo cada vez y determine el siguiente intervalo en función de la comparación con el punto medio.
2: Utilice la búsqueda binaria respectivamente para encontrar las posiciones donde deben aparecer k+0,5 y k-0,5. La parte media es todo k, y se puede restar el número de cálculos.
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);
}
}
Complejidad de tiempo: O(log2n)O(log_2n)O(log2n), donde nnn es la longitud de la matriz, dos búsquedas binarias, la complejidad de la búsqueda binaria es O(log2n)O(log_2n)O(log2n)
Complejidad del espacio: O(1)O(1)O(1), variables de nivel constante, sin espacio auxiliar adicional
"El intercambio de este problema está aquí, recuerda darle al blogger un enlace de tres, ¡tu apoyo es la mayor fuerza impulsora para mi creación!