No sé pero se me fue la cabeza al poner [FILA][COLUM] en lugar de [j]
Saludos
Observa que no aparece el corchete con la i y el de la j sale en cursiva.
Si no se usan las etiquetas "code" no salen bien los índices de las matrices:
Código
[i][j]
El problema radica en que la expresión [ i], sin el espacio en blanco que pongo para que salgan los corchetes con la i, como decía el problema está en que dichos corchetes con la i se usan como prefijo de la letra en cursiva, de ahí que el corchete con la j salga en cursiva.
Hola. ............................. ¿tiene sentido hacer este mismo código con punteros? .............................................................
Como apunto rir3760 ya lo estas haciendo.
Pero para que quede todo como punteros en lugar de declarar la variable copia como un array, tal vez sería más propio, que no obligatorio, declarala como como puntero directamente.
Hola muy buenas. He estado buscando por la web algún tutorial de manejo de carpetas en C pero no encontré nada. Si alguien conoce de página me sería de gran ayuda.
Una simple opción es usar el system con dir y sus acólitos.
Por ejemplo si quieres ver el contenido de la carpeta C bastaría:
..................................... Por cierto, @vangodp evita publicar tanto post en un tema y más si son totalmente inutiles y ni siquiera se sabe lo que se esta hablando.
* Lo de los archivos prefiero pasarlo por alto.
* Lo de tanto post te doy la razón en parte. Siempre se puede reeditar el post anterior si no hay nuevas contestaciones. A no ser que se vaya a hacer una aportación nueva y/o distinta.
* Si no sabe de que habla y tú si, aclarase lo y así ayudas. Porque la culpa nace del post original:
Hola comunidad, hoy me dejaron un proyecto en TC20. El proyecto se basa en abrir ficheros y modo grafico.. ....................
* Habla de modo gráfico y eso es lo que ha llevado a confusión al amigo vangodp, al no haberse fijado en lo que dice anteriormente que trabaja, si se puede llamar así al uso de ese programa, con Turbo C y que éste incluye de forma nativa modo gráfico, por lo que no le es necesario el uso de librerías externas, como se imaginaba vangodp. Al menos intento alguna solución a lo que entendió y eso siempre es de agradecer.
Como ves, cuesta poco aclara el malentendido y se evitan malos rolllos.
..................................... Creo que el que deberia aprender a leer bien los temas eres tu y evitar de publicar tanta basura. .........................................................
P.D:Habría que repasar tus post a ver donde encontramos más basura. Creo que te has pasado un pelín.
Lo que quiere decir es que no encuentra el archivo studio.h.
Por si acaso existiese dicha librería he mirado en la carpeta include del Code::Blocks, pero no, no existe, con lo que me reafirmo en tu afirmación de que está mal escrito y en realidad se refería a stdio:
Por cierto, ¿haciéndome la competencia con los emoticones?. ¡¡¡Que cunda el ejemplo!!!, es una forma como otra cualquiera de darle gracia y vistosidad a esto.
¡¡¡Pedazo de código amchacon!!!!. Está visto que te lo has currado de lo lindo.
Antes que nada GRACIAS. Es un código muy pero que muy interesante, al menos para mí. Me recuerda que tengo que ponerme las pilas en el tema de estructuras, listas y muy especialmente en arboles, facilita mucho las cosas.
Como comprobarás por mi código final, yo me apaño, creo que bastante bien, con los arrays. Y es que el mundo de donde vengo se pierde en el tiempo. Era una época en que lo más que habían para estas cosas eran los arrays y, en todo caso, los famosos sprites. Eso sí, tenían capacidades gráficas y de sonido de forma nativa, nada de librerías externas ni cosas por el estilo. Sin duda era mucho más fácil programar un ping-pong o un break. La verdad que en ese sentido el C me decepciona ya que las librerías gráficas, al menos las que he ojeado, son todo un *oñazo y poco intuitivas. Pero en fin, es lo que hay.
Y vamos a lo que vamos, a comentar y realizar observaciones, que no críticas -no entra en mi ánimo ni mucho menos- sobre los códigos y métodos usados en vuestros códigos.
Repito querido amigo Mikel Angelo, son sólo observaciones, no quiero que te lo tomes o mal ni las veas como críticas.
Los colores los he copiado totalmente del código de Leo, es un artista.
No es para tanto. Además lo explique, creo que meridianamente clarito, en el tema de GAMA DE COLORES, tema que aconsejo a todo el que quiera darle un poco de vidilla a sus códigos.
La verdad es que el tema de grafos es, como diría, espeso, eso es. Lo tuve que dominar en profundidad en su momento, tanto por haberlo dado en la asignatura correspodiente de Álgebra como por las múltiples aplicaciones en otras asignaturas, como Regulación Automática, Administración de Empresas,Procesos químicos, Economía,etc.
Pero siempre me dejo un mal regusto, me parece primitivo en los tiempos que corren con el uso de los ordenadores. Así que me voy a poner a ello y voy a desarrollar mi propio sistema para determinar el camino más corto entre dos puntos, que se note que soy Ingeniero y que hacemos honor al nombre: ingeniar, innovar.
No es moco de pavo el problemita pero si pillo un par de días, la familia ocupa casi todo el tiempo, pero el problema tiene unas implicaciones la mar de interesantes, como la búsqueda del camino más corto entre dos puntos en un viaje en coche, o la mejor ruta para el reparto de mercancías entre dos puntos/ciudades, entre otros muchos casos.
Y respecto al uso del DFS (Depth First Search)
comentar que el problema que nos traemos entre manos, que no es baladí, es algo más complejo ya que implica que el árbol cierre y/o conecte buena parte de las subramas de las ramas principales y que el origen y fin sean los nodos extremos, es decir que se cierren las ramas por abajo en un punto final, amén de las comentadas interconexciones entre subramas. Vamos que es bastante más complejo que un simple árbol como el que muestra la figura y las modificaciones que abría que hacer al susodicho método DFS son de tal envergadura que yo me pondría, y me voy a poner, a desarrollar un nuevo método.
Lo de pintar el camino hacia atrás ni me molesto porque es como algo obvio.
................................................................. Funciona de perfectamente y es capaz de hacer el personaje volver por todo el camino. ......................................... hay unos bugcitos jaja .................................................................
A veces se queda un rato parado en una intercesión, eso lo hace hasta que obtiene un numero aleatorio correcto. Podía mejorarlo pero bua lo dejo así que soy mu vaguito XD ............................................................................. Como diga que no anda os grabo un video jajaj Otra cosa que tengo problemas es con la declaracion de las tablas. .............................................. La cosa es que veo vuestro código funcionar y el mio pues no anda. es raro pero me esta pasando pffff
Por vídeos que no quede esta vez.
* Por un lado debes dejar un espacio en blanco al lado de %c del printf que te dibuja el laberinto. Tal como lo tienes sale demasiado pegado en horizontal y no se ve bien.
* ¿Intentas provocar un ataque de epilepsia a los usuarios?. Es insufrible el que cada vez que camines por el laberinto se redibuje toda la matriz, eso trae como consecuencia un parpadeo incesante de la imagen que hace difícil seguir el movimiento de la casilla en cuestión. Observa si no:
SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
}
** ¿Y como evitas el parpadeo?. Sencillo, dibujas una sola vez la matriz y ya no refrescas más la pantalla con el system("pause") cada vez que haces un movimiento. Lo que haces es aprovechar que la matriz está dibujada y sobre esa misma matriz mueves la casilla.
** ¿Y cómo diablos consigues que se mueva la casilla sin cambiar la matriz?. Sencillo, con una función de las API de Windows que permite situar el cursor en cualquier posición de la pantalla y escribir, e incluso sobrescribir, en un punto determinado. La función que realiza tal cometido es "goto", así como la función "color" es la encargada de dar color. Te pongo un vídeo de muestra, no te preocupes que todos duran menos de un minuto- y el código que te muestra cómo hacer lo que te comento:
Código
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#define FIL 7
#define COL 8
void color (int n);
int gotoxy(int x, int y);
int main (){
int i=0,j=0,k=0,fil=1,col=1;
char a[7][8];
system("pause");
system("cls");
for(i=0;i<15;i++){
gotoxy (10+2*i,10);
printf("*");
}
Sleep (2000);
for(i=0;i<15;i++){
Sleep (250);
gotoxy (10+2*i,10);
printf("X");
}
puts("\n\n");
system("pause");
system("cls");
for(i=0;i<27;i++)
printf("* ");
putchar('\n');
for(i=0;i<27;i++){
Sleep(150);
gotoxy (2*i,0);
printf("X ");
}
for(i=0;i<27;i++){
Sleep(100);
gotoxy (2*i,4);
printf("X");
}
for(i=0;i<6;i++){
for(j=0;j<6;j++){
gotoxy (2*j+6,i+6);
printf("* ");
}
}
for(i=0;i<6;i++){
for(j=0;j<6;j++){
Sleep(250);
gotoxy (2*j+6,i+6);
printf("X");
}
}
putchar('\n');
system("pause");
system("cls");
for(i=0;i<7;i++){
a[i][7]='\0';
for(j=0;j<7;j++){
if(j>=i-1&& j<i+1&& j>0&& j<6&& i<6)
a[i][j]='X';
elseif(i==0|| j==0|| i==6|| j==6)
a[i][j]='*';
else
a[i][j]='0';
}
}
putchar('\n');
for(i=0;i<7;i++){
a[i][7]='\0';
for(j=0;j<7;j++){
if((i==j || j==i-1)&& i>0&& j<6&& j>0&& i<6)
a[i][j]='X';
elseif(i==0|| j==0|| i==6|| j==6)
a[i][j]='*';
else
a[i][j]='0';
}
}
gotoxy (0,10);
for(i=0;i<7;i++){
for(j=0;j<7;j++){
printf("%c ",a[i][j]);
}
putchar('\n');
}
system("pause");
/*for (i=0;i<7;i++){
a[i][7]='\0';
for (j=0;j<7;j++){
if (i==0 || j==0 || i==6 || j==6 )
a[i][j]='*';
else if (i>=j)
a[i][j]='X';
else
a[i][j]='0';
}
}*/
for(i=0;i<7;i++)
printf("%s\n",a[i]);
system("pause");
gotoxy (0,0);
for(i=0;i<7;i++){
for(j=0;j<7;j++){
printf("%c ",a[i][j]);
}
putchar('\n');
}
fil=1,col=1;
while(1){
Sleep(1000);
if(fil==FIL-2&& col==COL-3){
gotoxy (2*col,fil);
printf("%c ",'F');
break;
}
elseif(a[fil+1][col]=='X'&& fil<FIL){
color(215);
gotoxy (2*col,fil);
printf("%c ",'F');fil++;
}
elseif(a[fil][col+1]=='X'&& col<COL){
color(215);
gotoxy (2*(col),fil);
printf("%c ",'F');col++;
}
elseif(a[fil-1][col]=='X'&& fil>0){
color(215);
gotoxy (2*(col),fil);
printf("%c ",'F');fil--;
}
elseif(a[fil][col-1]=='X'&& col>0){
color(215);
gotoxy (2*col,fil);
printf(" %c ",'F');col--;
}
}
color(7);
gotoxy (0,30);
printf("Final!");
putchar('\n');
return0;
}
void color (int n)
{
SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
Como ves es sencillo pero muy efectivo, Todo es jugar con las coordenadas de goto(x,y). Y al respecto te hago una observación, el ordenador usa como ejes coordenados el horizontal superior como eje OX y el vertical izquierdo como eje OY, de forma que el origen de coordenada está en el vértice superior izquierdo de la pantalla, como ya imagino sabrás. Eso provoca una pequeña distorsión y/o problema a la hora de escribir en pantalla con la mencionada función goto(x,y) y es que las coordenadas x,y se corresponden con los índices i,j o, como en tu caso, x,y. Observa que en la matriz normalmente al poner (i,j) la i es para las filas y la y para las columnas. Ahí es donde tienes que tener cuidado ya que las filas, osea la i, se corresponde en pantalla con la Y del goto(x,y), mientras la j se corresponde con la x.
* En cuanto a la declaración de las tablas mencionarte que tenías un problema al indicar la fila y columna final. por eso tenías que sobredimensionarlas. En los códigos que te paso ya he corregido ese problema.
* Efectivamente tienes un pequeño bug principal. Si te fijas en la imagen y vídeo siguientes quedan unos "1" sin "pintar":
Eso que a primera vista parece un problema nimio resulta que es un problema realmente vital. Se pone de manifiesto al aplicarle yo el que la pantalla no parpadee con el uso del goyo(x,y). Observa el vídeo:
y mira como se "pega" en la rama horizontal. No puede retroceder como sería lo normal y es por lo que te comenté, ese "1" no lo has cambiado al hacer el recorrido y la casilla que se mueve la detecta como errónea:
¿Y yo?.
La verdad es que poca cosa, aunque interesantes, es que con tanta fiestas y familia alrededor no he tenido tiempo pá ná.
Pero bueno, algo si que he adelantado.
La principal novedad que he introducido es el hecho de no trabajar ya con una matriz predefinida en el código, eso era como demasiado fácil. Ahora la matriz se genera de forma aleatoria.
Para hacer el código más rico, introduzco una variables, de nombres peso, c_peso y peso_i, que permiten jugar a poner más o menos 2=camino o 0=pared. Además aseguro que la matriz generada tenga al menos una solución, cosa que si la genero aleatoriamente de forma total no ocurriría la mayor parte de las veces. Y la salida que busco es "UNA", dejo para un posterior código, como ya comenté más arriba, el desarrollo de un método que me permita elegir el camino con menor coste.
Sí, digo bien, con menor coste ya que pueden haber varias soluciones que del principio al final recorran el mismo número de casillas pero con distinto coste. ¿Que qué es eso del coste?. Ni más ni menos que el número de cambios de dirección en el camino. Imaginaos que vais de una ciudad a otra, el camino óptimo será el que tenga menos "curvas", que en este caso se traduce por el menor número de cambios de dirección. No vale eso de abajo. derecha una y otra vez si puedes ir recto hacia abajo y luego directo a la derecha sin tomar curvas en medio.
Y un vídeo de un minutito que muestra el código en acción y después el código:
No eh probado lo de las divisiones. ¿Cuantas la puede abrir?
Yo suelo tener nueve ventanitas con tropecientas pestañitas, lo que me permite comparar códigos o recordar comandos básicos de una manera rápida.
Luego amplio la ventana de trabajo actual y automáticamente se ajusta el tamaño de las demás.
Siento que las imágenes no sean muy buenas peo estoy en el portátil, en el monitor grande lo tienen ocupado en este momento. Pero bueno, como prueba de lo que digo creo que vale.
Se consigue abriendo varios ficheros a la vez y arrastrando pestañas hacia los lados. Simple pero muy eficiente:
Y respecto a NOB2014 recordarle que se tienen que introducir un máximo de 4 caracteres (9 9 9 9 ). El problema surge al declarar el array con tamaño 5 ya que si se introducen más cifras no caben en el array y toman valores basura. La solución es declarar, como has hecho tú, el array con más cifras por precaución, no sea que se introduzcan más de cuatro y empiece el buffer a llenarse de basura. Ya luego sólo queda limitar el tamaño de la cadena con la introducción del caracter nulo,
Te dejo una muestra:
Citar
Ingrese un entero (maximo 9999)....:123
Ingresaste..: 123
0 para continuar otro para salir....:0
Ingrese un entero (maximo 9999)....:123456789
Ingresaste..: 1234
0 para continuar otro para salir....:0
Ingrese un entero (maximo 9999)....:12
Ingresaste..: 12
0 para continuar otro para salir....:0
Ingrese un entero (maximo 9999)....:12345
Ingresaste..: 1234
0 para continuar otro para salir....:
Código
#include <stdio.h>
#include <stdlib.h>
#define N 5
int main(void){
unsignedint ok=0, longitud=0, i=0, ch=0;
char numeroChar[100]="";
do{
//system("cls");
printf("\n\n Ingrese un entero (maximo 9999)....:");
fgets(numeroChar, 100, stdin);
numeroChar[N-1]='\0';
printf("\n\n Ingresaste..: %s", numeroChar);
printf("\n\n 0 para continuar otro para salir....:");
Pues si que funciona. Fue un error mío ya que al pedirme la opción de introducir el cero introduje el número directamente y, claro como no empezaba con cero se cerro el programa. la verdad es que me extrañaba que el scanf fallara seguido del while para limpiar el buffer, ya que lo he hecho multitud de veces.
Pero al César lo que es del César, ya reedité el post anterior. ¿por qué guardas como .cpp lo que son en realidad códigos .c?. No cuesta tanto cuando te pide guardar, que por defecto sale ,cpp, quitarle las dos p y tenerlo así en c como corresponde. Claro que si es por comodidad nada que objetar.
Y lo del Code::Blocks es para hablar más despacio y con tiempo. Sólo el mero hecho de usar múltiples ventanitas dentro de la ventana del propio Code::Blocks y con múltiples pestañitas a la vez en cada ventanita me vale. Para que te hagas una idea, yo suelo tener más de 30 códigos abiertos al mismo tiempo, con la comodidad de tenerlos repartidos en ventanitas y pestañitas diferentes, lo que me facilita el acceso a cada código. Por no hablar de las interioridades que ya sería un tema más prolijo y/o extenso.
Mostrar Mensajes
