Cómo evitar los caracteres repetitivos de una cadena

Por O (1) complejidad espacial, supongo que te refieres a O (1) espacio adicional.

Esta solución parece un poco extraña, pero debería funcionar de todos modos.

  • Por simplicidad, voy a suponer que todos los caracteres están en minúsculas
  • Asigna cada uno de los 26 caracteres a un booleano. Inicialmente, todos están configurados en falso. (Use una matriz 2D o una tabla hash.
  • Iterar a través de cada personaje en la cadena
    • Busca el personaje. Si el valor correspondiente es falso , establezca el valor en verdadero . Luego, imprima el carácter sin espacio o carácter de nueva línea
    • Si el valor correspondiente es verdadero, bueno, hemos visto el personaje, así que no hacemos nada.

En pseudocódigo:

map = {‘a’: falso, ‘b’: falso, ‘c’: falso …}
str = “mississippi”

para personaje en str:
if map [character] == false:
printf (“% c”, caracter) // Sin nueva línea o espacio
mapa [caracter] = verdadero

Un pseudoanálisis le indicaría que estamos iterando sobre elementos de longitud (str) . Llamemos length (str), N por simplicidad. En otras palabras, tenemos iteraciones Ө (N) .

En cada iteración, estamos haciendo una búsqueda de tabla hash o matriz, lo que debería llevar tiempo Ө (1) . Por lo tanto, es justo decir que el tiempo total de ejecución es Ө (N) • Ө (1). Que es igual a Ө (N) .

En lo que respecta a la complejidad espacial, el mapa o la matriz 2D ocupará dos unidades de espacio para cada uno de los 26 caracteres (52 si está haciendo mayúsculas por separado o lo que sea del tamaño de su conjunto de caracteres). Como el tamaño del juego de caracteres es constante y el número de unidades de espacio es constante, la memoria que consumen estos es Ө (1)

Por lo tanto, nuestra complejidad espacial es Ө (1).

En Python puro,

inicio = 65 # El carácter inicial es ‘A’
end = 122 # El carácter final es ‘z’

map = {char (i): falso para i en rango (inicio, (final + 1))}
str = ‘mississipi’

para personaje en str:
if map [character] == False:
print (caracter, final = ”)
mapa [personaje] = Verdadero

EDITAR 1:

Aquí hay un código C ++ para lo mismo:

#include
#include
#include

usando el espacio de nombres estándar;

int main () {

int inicio = 65;
int end = 122;

char str [11] = “mississippi”;
unordered_map map;

for (int i = start; i <= end; i ++) {

mapa [i] = falso;

}

para (int i = 0; i <11; i ++) {

if (mapa [str [i]] == falso) {
printf (“% c”, str [i]);
mapa [str [i]] = verdadero;
}

}

devuelve 0;

}

Puede usar un número entero como hashmap aquí mediante la manipulación de bits.

Y use bits del entero para corresponder a una letra en particular.

Por ejemplo, el bit 0 es a, el bit 1 es by etc.

Una implementación en C ++: –

a = 0;

cin >> s;

para (int i = 0; i <= s.size (); i ++)

{

if ((a & (1 << (s [i] - 'a'))) == 0)

{

cout << s [i];

a = a | 1 << (s [i] - 'a');

}

}

Como solo hay 26 alfabetos en minúsculas, esto estará dentro de los límites del número entero.

Si también se permiten mayúsculas, podemos usar int largo, el código debe modificarse solo un poco.

Espero que esto ayude :).

Se equivoca si supone que la complejidad espacial de su código es O (n). Por cierto, supongo que n es el tamaño de la cadena

Su complejidad espacial adicional es de hecho O (1). Por “adicional” me refiero al espacio requerido, excluyendo el espacio para almacenar la cadena.

¿Qué necesita para probar que una función [matemáticas] g [/ matemáticas] es [matemáticas] O (f). [/ Matemáticas]

Se dice que una función [matemática] g (n) [/ matemática] es [matemática] “de orden f (n)” [/ matemática] es decir [matemática] g (n) = O (f (n)) [/ matemática] si existen constantes [matemática] C [/ matemática] y [matemática] N [/ matemática] ambas mayores que 0 tales que [matemática] g (n) <= Cf (n) [/ matemática] para todas [matemática] ] n> = N. [/ math]

En su caso, está utilizando una matriz de tamaño fijo [matemática] 26 [/ matemática] (dejando de lado esas variables char y char *). Por lo tanto, [matemática] g (n) = 26 [/ matemática] que es una función constante. Entonces, puedo seleccionar constantes [matemáticas] C = 2 [/ matemáticas] y [matemáticas] N = 1 [/ matemáticas] y [matemáticas] f (n) = 1 [/ matemáticas].

Entonces sucede que [matemática] 0 <= g (n) <= Cf (n) [/ matemática] para todo n> 1.

(¡Recuerde! Todo lo que necesitamos es la existencia de constantes [matemáticas] C [/ matemáticas] y [matemáticas] N [/ matemáticas])

Por lo tanto, su [matemática] g (n [/ matemática]) (= espacio requerido por el programa) es del orden [matemática] f (n) [/ matemática] (= 1).

Entonces, su complejidad espacial es O (1).

Regla general: si siempre usa el espacio o el tiempo no más que una constante fija como 100, 1000, 25846, la complejidad correspondiente es siempre O (1).

Por favor comente si no entiende. Debe ser claro acerca de la definición “del orden f (n)” y tales preguntas simples y difíciles se pueden hacer en las entrevistas.

Aquí está la respuesta:

Ideone.com

La complejidad del espacio es O (1) y la Complejidad del tiempo es O (n).

Explicación:

Toma el carácter, utiliza la función lógica “Y” bit a bit (es decir, bit a bit). Finalmente terminas con el valor deseado. Consulte el código y plantee cualquier duda en la sección de comentarios.

Deberá almacenar la cadena de entrada de todos modos para que su complejidad espacial siga siendo O (n). Solo puede reducir el factor constante y la otra respuesta muestra una forma de hacerlo.

More Interesting

¿Cuál es la complejidad temporal de la solución del problema del vendedor ambulante mediante la optimización de colonias de hormigas?

¿Qué es un algoritmo eficiente para encontrar un número mágico?

¿Cómo determino la complejidad temporal de una expresión matemática que involucra potencias, divisiones y exponenciales? Sé la complejidad temporal de las operaciones simples, pero no sé cómo se supone que las combino para encontrar la respuesta.

Sistemas distribuidos: ¿es posible utilizar el algoritmo de Paxos para generar números de secuencia (seqnums)?

Cómo mejorar mis estructuras de datos y algoritmo desde el nivel básico

¿Cuáles son algunos URI de buen código de ejemplo que utilizan algoritmos STL (aparte de la ordenación)?

¿Cuánto estrés se le da a los algoritmos y las estructuras de datos en el curso de pregrado en CMI? ¿Se enseña programación competitiva allí?

¿Explicar diferentes algoritmos de ruta más corta, sus restricciones, complejidades?

¿Cuáles son las mejores aplicaciones de algoritmos en la vida real?

¿Podemos implementar un algoritmo genético sin usar mutación?

¿Cómo podemos encontrar la aparición de una cadena dada (la secuencia no importa) en una secuencia dada en Java?

¿Cómo encontrar una ruta con la suma máxima en un BST (no BT)?

¿Dónde debo comenzar si quiero aprender estructuras de datos y algoritmos?

Cómo contar el número de enteros palindrómicos dentro de un rango [A, B] donde A y B pueden ser de hasta 10 ^ 17

¿Es este código de búsqueda binario válido? Si es así, ¿entonces cómo?