Mensajes

[YreX-DwX]

Hmm... Veo demasiada similitud con el otro tema. Esto me da que pensar si será tan simple o hay alguna otra forma escondida. Le he dado muchas vueltas a ver si encontraba una alternativa como ir reduciendo la matriz por recursividad, pero no es posible (o eso me ha parecido, tengo un poco olvidado el trabajo directo con memoria...) al no ser una matriz como tal contigua en memoria.

Así que aprovecharé para sacarme la espinita que se me quedó con el otro tema...

Ojo , YreX-DwX, no se te olivde que tienen que valer para matrices N>=1 columnas....

Y tranquilo, ya no me olvidaré de las matrices de orden 1

Código (c) [Seleccionar] Expandir


int lowerTriangleDesc(const int **A, const int N){
    int i, j = N;
    for(i = 0; i < N-1 && j == N; ++i)
        for(j = i+1; j < N && !A[i][j]; ++j);
    return j == N;
}

PD: Sigo pensando que hay alguna solución oculta sorprendente. No dormiré tranquilo hasta ver la solución.

Todo depende de lo que quieras/necesites guardar y cómo quieras hacerlo. Para tu ejercicio lo único que necesitas guardar es n y los puntos que alcanzan el valor máximo. Si quieres ahorrar en operaciones aritméticas puedes guardar el resultado de (n*(x+y)) en otra variable. La idea del struct sería:

Código (c) [Seleccionar] Expandir


struct Elemento {
  int x;
  int y;
};
Y utilizar un array de struct para guardar los máximos.
No sé dónde tienes el problema exactamente. Tampoco sé si estás usando C o C++ para decirte algunas estructuras de la STL que puedes aprovechar en caso de usar C++.

Hola

Pues con un puntero ya tendrias suficiente desde mi punto de vista. En este caso con el 1 2 3 4 5, con un puntero de 5 elementos int, y en cada ciclo del for se guarde el valor.

Saludos.

Aunque la idea se entiende, no es del todo correcta tal y como está explicada. Un puntero es eso, un puntero, apunta a una variable, no a 2, ni 3, ni 5,...
Lo que se ve que has querido decir es un array. Y el nombre del array funciona como un puntero que apunta al elemento 0 del array.

Código (cpp) [Seleccionar] Expandir


const int SIZE = 10;

int main(){
  int arrayEstatico[SIZE]; // array creado con memoria estatica
  int *arrayDinamico = new int [SIZE]; // puntero que apunta a un array dinamico
  // Una vez creados ambos arrays funcionan igual
  for(int i = 0; i < SIZE; ++i){
    arrayEstatico[i] = i;
    arrayDinamico[i] = i;
  }
  // Un array reservado con memoria dinamica tiene que ser liberado:
  delete [] arrayDinamico;
}



Otra opción que tienes es usar un string (que no deja de ser un array de char) y en este caso los valores se guardarían como caracteres, no como enteros:

Código (cpp) [Seleccionar] Expandir


const int SIZE = 10;
int main(){
  string resultado = "";
  for(int i = 0; i < SIZE; ++i){
    resultado += i + " "; // concatena cada valor de i seguido de un espacio
  }
}

Como ya te he dicho, una forma fácil aunque poco eficiente es que uses una estructura como la siguiente:

Código (c) [Seleccionar] Expandir


struct Elemento {
  char valor;
  int repeticiones;
};

El algoritmo sería el siguiente. Ahora es trabajo tuyo entenderlo y traducirlo al lenguaje que quieras ya sea C o C++.

Código [Seleccionar] Expandir


caracteres : array de char
elementos : array de Elemento

PARA i := 0 HASTA length(caracteres)-1 INCREMENTO 2 HACER
  indice = buscar(caracteres[i], elementos)
  SI indice < 0 ENTONCES
    agregar(caracteres[i], elementos)
  SINO
    incrementar(elementos[indice])
  FIN SI
FIN PARA

ordenar(elementos) // en base al numero de repeticiones

PARA i := 0 HASTA length(elementos) - 1 INCREMENTO 1 HACER
  PARA j := 1 HASTA elementos[i].repeticiones INCREMENTO 1 HACER
    insertar(caracteres, elementos[i].valor)
  FIN PARA
FIN PARA

Hay muchas formas de hacerlo y dependerán de las funciones, las estructuras,... que quieras usar. Básicamente dependerá de tu algoritmo.
También tendrás que tener en cuenta ciertas precondiciones como si conoces la cantidad de dígitos diferentes existentes o si todos los dígitos iguales aparecerán seguidos,...
Puedes usar una estructura para guardar un valor y sus repeticiones. Crear un array de esta estructura y guardar todos los valores, ordenar dicho array y después crear la nueva cadena a partir de esos resultados.
Puedes usar una cola con prioridad (puedes usar la de la STL de C++). Y es altamente recomendable no solo para esto sino para todos tus programas que tengas en claro tu lenguaje de programación. En C++ no se usa malloc/free sino new/delete. Tienes los strings para facilitarte el trabajo con cadenas y tienes las clases en vez de las estructuras.

Yo lo he probado y me ha guardado todo correctamente. El siguiente código debería funcionar:

Código (cpp) [Seleccionar] Expandir


Nodo *aux = superior;
while(aux != NULL){
  archivo << aux->indice.id << " | " << aux->indice.NumeroCompras << endl;
  aux = aux->sigue;
}
Cómo has sobrecargado el operador <<??

Primero comprueba que los datos se guardan correctamente en la pila. Si es así, ahora comprueba que no estés sobrescribiendo la primera línea de tu fichero ya que al ser una pila, se ve que solo muestra el primer valor insertado que es el último en salir.

PD: El código es bastante mejorable. Hay una mezcla de C con C++...

No se hacen tareas... Tienes que intentar hacer algo y ponerlo. El pseudocódigo es muy abierto por lo que cada quien lo escribe de una manera diferente. Al final no es más que poner los pasos que tiene que hacer tu algoritmo para obtener el resultado esperado.
Te pongo un ejemplo de pseudocódigo que muestra los números pares del 1 al 100:

Código [Seleccionar] Expandir


INICIO
  PARA i := 1 HASTA 100 INCREMENTO 1 HACER
    SI i % 2 = 0 ENTONCES
      MOSTRAR i
    FIN SI
  FIN PARA
FIN
Como ya digo hay muchas formas de escribir pseudocódigo. Lo importante es que los pasos sean correctos.
Supongo que sabes cómo se sabe si un número es primo, por si acaso, un número primo es aquel número mayor que 1 que solo es divisible por sí mismo y la unidad (1). Otra forma de pensarlo y hacerlo un poco más fácil: un número n es primo si (n > 1) y solo es divisible por un elemento del conjunto {1, 2, ..., n-1}.

El tema del diagrama de flujo es más complejo para hacerlo aquí a no ser que uses algún programa y lo exportes como imagen para poner un link a la imagen... Te recomiendo que intentes el pseudocódigo de ambos y cuando tengas el pseudocódigo del segundo, te será muy fácil pasarlo a un diagrama de flujo.
Suerte.

[Prueba a evaluar la matriz de 1 fila y 1 columna...]

Chavalote! Este no te lo puedo bendecir... Tiene un sutil fallo. Te digo cual?
Prueba a evaluar la matriz de 1 fila y 1 columna...
El resultado es indeterminado... porque entonces accedes a una posicion tal como A[0][-1]  . Si acierta, dependera del compilador, o de la conjunci'on de los astros...
Que pasa? que las matrices de 1 fila y 1 columna no son matrices???  Prueba [[1]]!  

Es cierto. No me di cuenta de eso en su momento. Habría que tratar las matrices de orden 1 como un caso aparte:

Código (c) [Seleccionar] Expandir

return (N == 1 || (i == N && !A[N-1][N-2]));
Aunque claramente no es la mejor solución...

 Bravo... Correcta... pero aun redundante... ya que en

Código (c) [Seleccionar] Expandir

j=(j<i)||A[i][j-1]
es equivalente a

Código (c) [Seleccionar] Expandir

j=(j<i)

El problema fue que me centré en usar A(i, j-1) y entonces comprobé que no era condición suficiente y le añadí el (j < i) pero no vi que ésta sí era suficiente por sí sola... 
Bueno, me quedo con que me he quedado cerca... Este era el de calentamiento, no?

De verdad piensas que llegando aquí y soltando un copia-pega de tu ejercicio, alguien te lo va a dar resuelto??
Empieza a hacer el ejercicio y saca todo lo que puedas por ti mismo. Cuando no sepas avanzar más, revisa tus apuntes u otros materiales (pdfs, vídeos,...) que puedes encontrar en Internet. Y cuando llegues a un problema que no puedas solucionar ni usando todos esos materiales de los que puedes disponer, coloca el/los fragmento/s de código necesarios (entre etiquetas de Código GeSHi) y entonces alguien te ayudará a resolver ese problema concreto; pero nadie te va a hacer el ejercicio entero...
Suerte.