Mensajes

[O(n)]

La solución que te propuse es bastante eficiente. El primer bucle for tiene un orden de complejidad de O(n). Luego a la hora de insertar en el mapa no tengo ni idea de que orden de complejidad ofrecerá, pero me imagino que será el más eficiente posible.

Quizás podría incrementarse un poco la eficiencia del código que te propuse de esta forma:

Código (java) [Seleccionar] Expandir


for (int i = 0; i < palabras.length; i++) {
Integer aux = resultados.get(palabras[i]);
if (aux != null) {
aux++;
resultados.put(palabras[i], aux);
} else {
resultados.put(palabras[i], 1);
}
}

Nos aprovecharíamos de que si el elemento no está almacenado en el mapa el método get() devuelve un valor nulo, y por tanto no tendríamos que realizar primero la comprobación de "ifresultados.contains()" para luego realizar el get() y posteriormente el put().

El último bucle es totalmente necesario, ya que debes recorrer todo el mapa para saber la solución, también tiene orden de complejidad O(n) en el peor caso.

Sí lo que quieres son optimizaciones sobre tu código, con lo que te he comentado tienes de sobra para pensar sobre que podrías hacer.

Saludos.

pero si quiero sustituir por todo un arreglo con otro arreglo???

por ejemplo
aabc

[a,a,b,c,f,g]    por [asd,a,r,d]
a sustituir por a
a sustituir por r
b sustituir por d
c sustituir por asd
salida:
ardasdfg

Es un poco lioso como lo has explicado. Sí te explicas un poco mejor intentaré ayudarte, sí es que puedo claro xD.

Saludos.

Yo en java lo realicé y no era muy complicado. En el caso que yo lo hice de primeras te decía un número y entonces te pedía decir cuantos había hasta llegar a ese número.

Hazte una función que te compruebe si un número es OMIRP y para no tener que hacer la comprobación dos veces (es decir, sí un número es OMIRP su reverso también lo es, por tanto cuando llegues al reverso tendrías que volver a comprobar sí es) lleva un array de booleanos por ejemplo. Sí un número es OMIRP marcas a true su posición y la de su reverso. A la hora de comprobar si un número es OMIRP primero miras en dicho array, si está a true no haces nada, si está a false compruebas si lo es.

Saludos y ya sabes, hazlo tu que aquí no se escriben los códigos a los demás.

[replaceFirst]

Para hacer trabajos de sustitución de cadenas en Java es recomendable el uso de las clases Pattern y Matcher, pero sí lo que vas a hacer es algo tan sencillo como lo que expones, la propia clase String proporciona métodos de busqueda y sustitución.

Por ejemplo, sí tu quisieses sustituir una S (tal y como dices), en esta cadena: "aaaSbc" tendrías que hacer esto:

Código (java) [Seleccionar] Expandir


String cadena = new String("aaaSbc"); //Declaración de la cadena
cadena = cadena.replaceFirst("S", "bcd"); //Método que reemplaza la primera ocurrencia

El método replaceFirst tiene como primer parámetro una expresión regular (si no conoces lo que es, busca por Internet porque la verdad es interesante), el segundo parámetro es la cadena que va a sustituir a la ocurrencia.

Existe otro método, replaceAll, que, como su propio nombre indica, reemplaza todas las ocurrencias que hay en la cadena.

De esta forma no tendrías que andar pensando en como realizarlo, ya que la propia clase te ofrece esta funcionalidad. Sí quisieses implementarlo por ti mismo, supongo que no tendría mucha complejidad en los casos más simples.

Saludos y si hay alguna duda, comenta  .

Sí ni si quiera dices que error te da...mal vamos. ¿Has importado la librería correctamente a tu proyecto?

Ya propuse en otro post una respuesta a este problema.

Yo suponiendo que cada palabra esté separada por uno o más espacio haría lo siguiente:

Código (java) [Seleccionar] Expandir


public static void main(String[] args) throws IOException {

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] palabras = br.readLine().split(" +");
HashMap<String, Integer> resultados = new HashMap<String, Integer>();
for(int i = 0; i < palabras.length; i++){
        if(resultados.containsKey(palabras[i])){
                int aux = resultados.get(palabras[i]);
                aux++;
                resultados.put(palabras[i], aux);
        }
        else{
                resultados.put(palabras[i], 1);
        }
}

Set<String> keys = resultados.keySet();
for (String string : keys) {
System.out.println(string + ": " + resultados.get(string));
}
}


haría uso de un mapa que viene para el caso bastante bien.

Saludos.

Es bastante sencillo el código y son muy pocas lineas en comparación con la solución que propones. Sí quisieses mostrar la solución en una única linea no tendría mayor complejidad que hacer lo siguiente:

Código (java) [Seleccionar] Expandir


String[] keys = new String[resultados.size()];
resultados.keySet().toArray(keys);
if(keys.length>0){
System.out.print(keys[0] + ": " + resultados.get(keys[0]));
for(int i = 1; i < keys.length;i++)
System.out.print(" " + keys[i] + ": " + resultados.get(keys[i]));
System.out.println();


Por cierto, con split(" +") lo que hace es separar por uno o más espacios.

Saludos y espero te sirva.

La verdad que es un poco tediosa la nomenclatura, pero bueno, cada cual que programe a su gusto, eso sí, no me gustaría tener que continuar un código que tu empezaste xD y lo digo sin mala intención y sin ánimo de burla.

Saludos.

Hace casi un mes del post, pero por si un caso respondo.

La idea sería hacer un método de ordenación descendente en cada fila de la matriz.

Código (java) [Seleccionar] Expandir


for(int j = 0;j<matriz.length;j++){
    int temp;
    int t = matriz[j].length;
    for (int i = 1; i < t; i++) {
    for (int k = t- 1; k >= i; k--) {
    if(matriz[j][k] > matriz[j][k-1]){
    temp = matriz[j][k];
    matriz[j][k] = matriz[j][k-1];
    matriz[j][k-1]=  temp;
            }
         }
    }
    }


Con ese código te funcionaría. Usa el método de la burbuja para ordenarlo.

Por internet hay muchísimos métodos de ordenación, e incluso hay páginas que te los muestran ya implementados en algunos lenguajes, por ejemplo en Wikipedia está:

Código (java) [Seleccionar] Expandir

public static int[] OrdenarBurbuja(int[] n){
        int temp;
        int t = n.length;
        for (int i = 1; i < t; i++) {
            for (int k = t- 1; k >= i; k--) {
                if(n[k] < n[k-1]){
                    temp = n[k];
                    n[k] = n[k-1];
                    n[k-1]=  temp;
                }//fin if
            }// fin 2 for
        }//fin 1 for
        return n;
    }

Puesto que el método lo que ordena es un array puedes hacer dos cosas, o lo modificas para que ordene una matríz (la modificación es mínima) o en vez de usar una matriz usas un array. Para saber los números que se repiten puedes usar un HashMap<Integer, Integer>. En este post expliqué algo parecido pero con palabras: http://foro.elhacker.net/java/como_elaborar_este_programa_en_java_no_puedooiexcliexcl-t330838.0.html

Solo tendrías que modificarlo un poco, y a la hora de recorrerlo si el número solo ha aparecido una vez no lo muestras, si ha aparecido más de 1 vez entonces es porque se repite.

Saludos.

[Edu]

Como lo propone Edu creo que estaría bien, pero podría hacerse todo del tirón.

La idea es, lees una cadena de caracteres (en este caso serán dígitos) y la guardas en un String, empiezas a recorrer la cadena y en una variable vas almacenando la suma de cada dígito, además una variable para almacenar el número de dígitos pares. Mientras recorres la cadena vas incrementando un contador cada vez que avances un caracter. Por último, para averiguar el mayor de todos los números ingresados, llevas una variable, llamada por ejemplo mayor, la inicializas al comienzo del programa con un valor lo más pequeño posible, por ejemplo, -2147483647, cada vez que leas una secuencia de dígitos haces la comprobación

Código [Seleccionar] Expandir

if(numeroLeido>mayor) then mayor:=numeroLeido. Evidentemente en la explicación no te digo nada de como pasar de una cadena de caracteres a entero (integer), eso ya es cosa tuya.

Saludos.