Mensajes

[1. Seguir usando vectores y comprobar manualmente que no se muestren repetidos. Para ello a su vez tienes dos formas de conseguirlo, por lo pronto:]

Para que no aparezcan puntos repetidos tienes varias opciones.
1. Seguir usando vectores y comprobar manualmente que no se muestren repetidos. Para ello a su vez tienes dos formas de conseguirlo, por lo pronto:
- Cuando (operacion = operacion_max), antes de insertar los nuevos x e y, compruebas que no existen ya.

Código [Seleccionar] Expandir


SI (operacion == operacion_max) ENTONCES
  indice := 0
  MIENTRAS indice < vectorX.size() and !encontrado HACER
    SI vectorX[indice] == x ENTONCES
      encontrado = (vectorY[indice] == y)
    FIN SI
    indice := indice + 1
  FIN MIENTRAS
  SI !encontrado ENTONCES
    vectorX.push_back(x)
    vectorY.push_back(y)
  FIN SI
FIN SI

- La otra opción sería guardarlos todos y a la hora de mostrar comprobar que el elemento actual que vas a mostrar no lo has mostrado ya. La idea es la misma pero ahora tendrías que recorrer desde la actual hacia el inicio. Puedes probarlo pero es menos eficiente ya que estás gastando más memoria al guardarlos repetidos.

2. Crear una class/struct que guarde x e y. Y sustituir ambos vectores por un SET de la STL (http://www.cplusplus.com/reference/set/set/?kw=set).
Desde luego, esta opción es mejor que las anteriores. Primero porque es la más eficiente y segundo porque te permite demostrar un mayor dominio del lenguaje sabiendo encapsular la información dentro de un objeto y eligiendo la mejor estructura de datos para tu propósito.
La ventaja principal del SET es que no guarda valores repetidos. Si tienes una class/struct tal que:

Código (cpp) [Seleccionar] Expandir


class Punto {
  private:
    int x;
    int y;
  //...
}
Y defines el operador de igualdad como que un Punto P1 es igual a un Punto P2 cuando ambos atributos (x e y) son iguales. Hecho esto será el SET el que se encargará cada vez que quieras meter un Punto en su interior de comprobar si ya existe un punto igual a ese. De existir, no lo meterá. Todo esto último sin que tú tengas que hacer nada más.

Te dejo que investigues por tu cuenta. Da más satisfacción si lo consigues tú que si te lo dan hecho.
Suerte.

En el segundo caso, si la operación actual es igual a la operación máxima, no tienes que vaciar los vectores usando clear() porque entonces te estarás cargando el resto de valores. El clear() es solo para cuando encuentras una operacion > operacion_max.

Además al final en vez de mostrar x_max, y_max, que son variables simples que contienen un único valor cada una (concretamente el último punto que cumpla la lógica del ejercicio), debes recorrer ambos vectores al mismo tiempo e ir mostrando cada uno de sus elementos.

Suerte.

Utiliza las etiquetas de Código GeSHi para poner tu código. Tal y como está es imposible de interpretar...

Puedo ver que estás utilizando variables que no aparecen en ningún sitio. Estás seguro de que esas variables existen, es decir, que están declaradas como atributos de la clase??
Expón cuál es la lógica del método al menos. Sino es imposible saber qué es lo que quieres hacer. Deberías detallar qué precondiciones/postcondiciones debe cumplir tu método (es algo fundamental sobre todo en proyectos desarrollados por varias personas) para que todo funcione bien al unirlo.

Para colocar códigos utiiza las etiquetas de Código GeSHi (desplegable encima del cuadro de texto)

Tu propósito es trabajar con matrices cuadradas por lo que parece. Entonces no tiene sentido que pidas filas y columnas ya que podrían ponerte números diferentes y hacer que el programa falle. Es mejor que pidas un único valor que sea el orden de la matriz, es decir, el número de filas y columnas.

Si quieres recorrer la diagonal de una matriz cuadrada verás que las casillas que quieres recorrer son: (0,0), (1,1), (2,2),...; es decir, la i y la j avanzan a la vez o lo que es lo mismo solo utilizas una variable en el bucle:

Código (c) [Seleccionar] Expandir


for(int i = 0; i < orden; ++i){
  matriz[i][i] = 1;
}

Si quieres guardar los valores en otro array, tendrás que crearlo. Y si quieres guardar los valores originales poner la instrucción antes de modificar los valores por 1s y si lo que quieres guardar son los 1s (que no tiene mucho sentido) pues después:

Código (c) [Seleccionar] Expandir


#DEFINE SIZE 100 // Usa constantes para los numeros que aparezcan sueltos. Asi puedes cambiarlos todos de una vez
//...
int main(){
  //...
  int diagonal[SIZE];
  //...
  for(int i = 0; i < orden; ++i){
    diagonal[i] = matriz[i][i];
    matriz[i][i] = 1;
  }
  //...
}

Luego recuerda usar <orden> para recorrer tanto la matriz como el array ya que son las posiciones que has ocupado realmente. El resto de posiciones desde orden hasta SIZE serán basura.

Los algoritmos de ordenación más básicos son: Burbuja, Inserción y Selección. Los tres tienen un orden de eficiencia O(n²) pero son fáciles de implementar.
Si quieres algo más eficiente busca el algoritmo Quicksort o Mergesort (entre otros).

1.Devolver la distancia de Manhattan entre dos puntos P1 y P2, siendo P1 el punto compuesto de la mayor latitud y la mayor longitud y el punto P2 compuesto por la menor latitud y la menor longitud. Redondea tu respuesta a 3 decimales. (En esta sé como obtener la mayor latitud y longitud y la menor latitud y longitud pero,  como lo uno para que se corresponda con el P1 y P2)

La distancia Manhattan entre dos puntos P1(x1, y1) y P2(x2, y2) se calcula como: dM = |x1 - x2| + |y1 - y2|
Por lo tanto, el tema de los puntos es "simbólico". Tienes que hacer esa operación y redondearla a 3 decimales usando:

Código [Seleccionar] Expandir


x1 = MAX(latitud)
y1 = MAX(longitud)
x2 = MIN(latitud)
y2 = MIN(longitud)

2.De manera análoga al punto anterior, calcula la distancia Euclídea entre ambos puntos.(Y en esta no se que significa exactamente lo que se pide)

Espero que alguien pueda ayudarme con ello, un saludo.

La distancia Euclídea entre dos puntos P1 y P2 como antes se calcula como: dE(P1, P2) = SQRT((x2 - x1)² + (y2 - y1)²)
Igual que antes el tema de los puntos P1 y P2 es para que puedas plantear el ejercicio.

Ambos son ejercicios para que uses un par de funciones matemáticas: raíz cuadrada, potencia, max/min,...
Suerte.

[me propuse a estudiar lenguaje de programación y ya se html, CSS]

en este tiempo de cuarentena fue que me propuse a estudiar lenguaje de programación y ya se html, CSS y javascript lo que claro por mi cuenta. Nadie me enseña y tengo solo PDF no vídeos. Bueno gracias

Cuidado con esas afirmaciones... He visto matar a gente por menos

Bueno, bromas aparte. No sé si la instalación de Back Box trae por defecto el compilador de C/C++. Este es gcc: https://es.wikipedia.org/wiki/GNU_Compiler_Collection.
La verdad es que para mí no hay como programar en Linux desde la Terminal. Te bastará el propio Gedit o si quieres un editor de textos más avanzado, te recomiendo Atom (SublimeText es otra buena opción)
En caso de que no esté instalado, igual puedes instalarlo tú:

Código [Seleccionar] Expandir

sudo apt-get install gcc && sudo apt-get install g++
El primero es para C y el segundo para C++.

Una vez tengas escrito tu programa en un fichero de texto con extensión .c (para C) o .cpp (para C++) por ejemplo:

Código (c) [Seleccionar] Expandir


// Hola Mundo en C. Fichero: hola_mundo.c
#include <stdio.h>

int main(){
  printf("Hola Mundo!\n");
  return 0;
}
o

Código (cpp) [Seleccionar] Expandir


// Hola Mundo en C++. Fichero: hola_mundo.cpp
#include <iostream>
using namespace std;

int main(){
  cout << "Hola Mundo!" << endl;
  return 0;
}

abres una Terminal en el mismo directorio que el fichero y escribes:

Código [Seleccionar] Expandir

gcc hola_mundo.c -o hola_mundo
o

Código [Seleccionar] Expandir

g++ hola_mundo.cpp -o hola_mundo
Para compilar el programa. Se te creará un nuevo fichero con el nombre que pongas después del -o.
Y para ejecutarlos:

Código [Seleccionar] Expandir

./hola_mundo

PD: Muchas veces, cuando se empieza con estos dos lenguajes es muy fácil mezclarlos ya que C++ acepta todo lo de C. Investiga para conocer las principales diferencias entre ambos.
Suerte.

[VAMOS A HACERLO DIFICIL, PERO DIFICILISMO !]

  VAMOS A HACERLO DIFICIL, PERO DIFICILISMO !

Todo el mundo ve que hay dos bucles y dos variables

ESTE ES EL RETO:

PROGRAMAR LA SOLUCION USANDO SOLO UN BUCLE Y UNA SOLA VARIABLE DE CONTROL, A PARTE DE LAS QUE SE DAN POR PARAMETRO

(Por supuesto, el programa sera mas dificil de legible, pero sera igualmente correcto....)

Esto sí que promete. 
Después de darle unas cuantas vueltas creo que está cerca pero no consigo sacarlo así que dejo mi razonamiento por si alguien se anima a seguir mientras yo duermo... (Espero no soñar con esto )

La idea es tratarlo algo así como un array unidimensional, es decir, un único índice que se incrementa desde 1 hasta n siendo n el número de casillas a recorrer. Resulta que n = (N*(N-1)/2). Iremos incrementando el contador en 1 a no ser que una casilla no sea nula en cuyo caso podemos concluir que esa matriz no es triangular inferior.

Código [Seleccionar] Expandir


i := 1
MIENTRAS i <= (N*(N-1)/2) and i != 0 ENTONCES
    i = (A[f(i)][g(i)] == 0) * (i+1)
FIN MIENTRAS
RETURN i
Como se puede apreciar falta definir las funciones f() y g() que determinen la fila y columna del siguiente elemento en función de i.

Parece sencillo usando los operadores de división entera y módulo pero no es tan simple. Probando con matrices de orden N >= 2 (ya que de orden 1 sería triangular sin entrar por el bucle) he encontrado lo siguiente:

Código [Seleccionar] Expandir


N = 2 -> M = (N*(N-1)/2) = 1
i    -> 1
f(i) -> 0
g(i) -> 1

N = 3 -> M = 3
i    -> 1 - 2 - 3
f(i) -> 0 - 0 - 1
g(i) -> 1 - 2 - 2

N = 4 -> M = 6
i    -> 1 - 2 - 3 - 4 - 5 - 6
f(i) -> 0 - 0 - 0 - 1 - 1 - 2
g(i) -> 1 - 2 - 3 - 2 - 3 - 3

N = 5 -> M = 10
i    -> 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - 10
f(i) -> 0 - 0 - 0 - 0 - 1 - 1 - 1 - 2 - 2 - 3
g(i) -> 1 - 2 - 3 - 4 - 2 - 3 - 4 - 3 - 4 - 4

N = 6 -> M = 15
i    -> 01 - 02 - 03 - 04 - 05 - 06 - 07 - 08 - 09 - 10 - 11 - 12 - 13 - 14 - 15
f(i) -> 00 - 00 - 00 - 00 - 00 - 01 - 01 - 01 - 01 - 02 - 02 - 02 - 03 - 03 - 04
g(i) -> 01 - 02 - 03 - 04 - 05 - 02 - 03 - 04 - 05 - 03 - 04 - 05 - 04 - 05 - 05
Y así sucesivamente. Yo creo que se ve perfectamente el patrón. El problema como ya he dicho es sacar la que sería la fórmula cerrada de f() y g().
Si alguien se quiere animar a intentar seguir o a exponer su razonamiento...

Gracias Yrex entonces empezare Python.

Prodras enviarme algún PDF o curso que tengas bien explicado para principiante que empiesen el lenguaje?
El libro que tengo no me explica bien osea no entiendo lo que me quiere decir y no me explica la sintaxis del lenguaje.

No puedo recomendarte ningún libro de Python porque no he leído ninguno. 
En cambio, puedes usar el buscador del foro (Buscar, en la parte superior) para buscar "libros python" y encontrar temas en los que otros usuarios hayan recomendado libros.

Que nesesitaria para c++

Para aprender C++ dices? Pues lo mismo que para el resto: un compilador y un editor de texto.
Para programas pequeños te será suficiente con eso. Para programas grandes siempre será mejor usar un IDE que te facilite el trabajo.
La verdad es que yo empecé con C++ también, que recuerdos...

Mi recomendación en base a tus opciones es que empieces por Python si buscas algo sencillo y potente. Es un lenguaje de muy alto nivel con una sintaxis muy sencilla. Desde mi punto de vista Python es muy superficial, no necesitas saber cómo funciona internamente la memoria.
Si quieres algo más cercano a la memoria física del ordenador te recomendaría C++. Al fin y al cabo todo lo que puedes hacer en C++, lo puedes hacer en C (ya que es como una expansión de este último). Algo similar a C++ pero de un poco más alto nivel es Java (un lenguaje muy utilizado además de ser multiplataforma).
Y por último si quieres ver en profundidad la memoria física del ordenador, el ensamblador.