Fijándome, así es, gracias por el dato. Acá pongo el link de la wikipedia: http://en.wikipedia.org/wiki/Quine_%28computing%29

Uno de los ejercicios propuestos por un profesor de programación, fue el de hacer un programa que imprima su código. (Obviamente sin leer ningún archivo)
Aquí una posible solución, se puede hacer mucho más corto, quitando las tabulaciones y los saltos de línea, pero así queda más visual de corroborar.

#include <stdio.h>
#include <string.h>
 
int main(int argc, char **argv)
{
	int i,n;
	char palabra[] = "#include <stdio.h>\n#include <string.h>\n\nint main(int argc, char **argv)\n{\n\tint i, n;\n\tchar palabra[] = \tn=strlen (palabra);\n\tpalabra[102]='\\0';\n\tprintf (\"%s \",palabra);\n\tpalabra[102]=' ';\n\tprintf (\"\\\"\");\n\tfor (i=0;i<n;i++)\n\t\tswitch (palabra[i])\n\t\t\t{\n\t\t\t\tcase '\\n':\n\t\t\t\tprintf (\"\\\\n\");\n\t\t\t\tbreak;\n\t\t\t\tcase '\\t':\n\t\t\t\tprintf (\"\\\\t\");\n\t\t\t\tbreak;\n\t\t\t\tcase '\\\\':\n\t\t\t\tprintf (\"\\\\\\\\\");\n\t\t\t\tbreak;\n\t\t\t\tcase '\\\"':\n\t\t\t\tprintf (\"\\\\\\\"\");\n\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\tprintf (\"%c\",palabar[i]);\n\t\t\t}\n\tprintf (\"\\\";\\n\");\n\tprintf (\"%s\", palabra+103);\n\treturn 0\n}";
	n=strlen (palabra);
	palabra[102]='\0';
	printf ("%s ",palabra);
	palabra[102]=' ';
	printf ("\"");
	for (i=0;i<n;i++)
		switch (palabra[i])
			{
				case '\n':
				printf ("\\n");
				break;
				case '\t':
				printf ("\\t");
				break;
				case '\\':
				printf ("\\\\");
				break;
				case '\"':
				printf ("\\\"");
				break;
				default:
				printf ("%c",palabra[i]);
			}
	printf ("\";\n");
	printf ("%s", palabra+103);
	return 0;
}
 

Miles de millones de disculpas, últimamente estuve ocupadísimo y me olvidé de ésto!!

Tengo el escaner roto y la explicación a mano (soy de los viejos, vieron?). Así que momentanemente y viendo lo muerto que está esto, posteo mi código sin la explicación. No creo que se entienda sin la misma. No sé si está bien, no he comparado con el ya posteado. Desde ya que usa mucha menos memoria y menos tiempo (eso se ve a simple vista).

#include <stdio.h>
#include <stdlib.h>
 
int main(int argc, char *argv[])
{
  int n, m, i;
  long long  a, b;
  long long c=1000000000;
  scanf ("%i", &n);
  scanf ("%i", &m);
  if (n>m)
     {
          i=m;
          m=n;
          n=i;
     }
  for (a=1,i=0;    
      i<n;
      i++)
      {
           a*=(m+i);
           a/=(i+1);
           while (a>c) a-=c;
      }
  a--;
  for (b=1,i=0;
       i<n-1;
       i++)
       {
           b*=(m+1+i);
           b/=(i+1);
           while (b>c) b-=c;
       }
  a=a+b;
      printf ("%d", a);
 
  system("PAUSE");	
  return 0;
}
 
 

Existen foros que te interpretan LaTex (creo que consultan paginas externas). Esto está genial, porque si no puedo escanear la solución lo más idóneo sería pasarla a LaTex, porque está llena de simbología...

Vuelvo a disculparme por haberme olvidado de ésto
Saludos y preocuraré darme una vuelta de forma frecuente de aquí en adelante!

Yo te sugeriría ser un poco más observador y te invito a razonar un poco:
1)Las fuentes están en el post, ¿lo leíste?. Un problema ya lo resolvieron en el foro y por ende entra en la categoría de "nuestros problemas" ¿no?
2)El post está en chincheta y yo no soy administrador, eso implica que esto ha sido muy planeado con los admines, los cuales, seguramente tendrán criterio para ponerme en chincheta, de acuerdo a mi participación asidua (ahora no tanto) en esta sección.
3) Yo mismo dije que iba a poner mis resoluciones, ahora he estado un poquito ocupado, pero si quieres espera hasta que yo responda para confirmarlo. Espero poder escanear y subir las respuestas de al menos el primero para mañana...
4) Me tomé el trabajo de hacer las normas yo mismo, ¿haría tanto esfuerzo por una tarea?

Sé que aquí suelen haber personas que quieren la tarea hecha, yo mismo he prejuzgado a muchos. Pero antes me fijo:
a) La cantidad de mensajes.
b) La calidad de sus respuestas, usando el buscador.

Además, he creado este post porque los ejercicios que conmumente se proponen aquí no tienen el nievel y el estilo que tiene estos, admitiendo soluciones realmente originales, y no simplemente se limite la competencia a optimizar algo en un bucle, en una anidación, o convertir una recursividad en iteración.

Eso se hace mucha veces, pero definitivamente no me agrada.
Tiene una terminación indefinida, si el número aleatorio te sale siempre una casilla ocupada por obstaculos. Puede ser todo lo improbable que quieras, pero creo que es mala programación fiarse de la probabilidad de que un programa termine o no.

La cantidad de casilleros para colocar monstruos es 24-numero de obstáculos (para todos los monstruos, ya que los siguientes que coloques pueden superponerse dice).
Yo haría lo siguiente (que conste que no estoy haciendo la tarea de nadie porque no digo como implementarlo):
para simplificarlo, mi tablero es de 3x3=9 casillas
nº de obstaculos: 2
nº de monstruos: 3
Tablero inicial:
0 0 0 0 0 0 0 0 0
Elijo aleatoriamente un numero del 0 al 8-obstaculos ubicados hasta el momento (cantidad de posiciones disponibles)
numero elegido: 2
Tablero luego de colocar el obstaculo
0 0 'X' 1 1 1 1 1 1
Elijo aleatoriamente un numero del 0 al 8-obstaculos ubicados hasta el momento
numero elegido: 3
0 0 'X' 1 X 2 2 2 2

Nota: Cuando ubicamos el obstaculo en la posición x, introducimos en dicha posicion el valor 'X' (caracter 'X'=88.

Reglas para ubicar el obstaculo:
Genero un numero random entre 0 y "9-numero de obstaculos" ubicado hasta el momento, lo llamo r a dicho numero.
Si en r hay un numero a lo ubico en g(r+a)
Si en r hay un obstaculo lo ubico en g(r+1)
g(x)=x Si en x no hay obstaculo.
g(x)=g(x+1) Si en x hay obstaculo.
Incluso conviene no hacerlo recursivo, es mucho más rápido obviamente.
Luego actualizo el tablero de la siguiente manera:
Para las casillas posteriores a donde ubiqué el obstáculo, le sumo 1+o si es un numero, de ser un obstaculo, no modifico la casilla, pero incremento o en 1. o empiza siendo 0 y vendría a ser el numero de obstáculos con el que me topé en este proceso de actualización.

El proceso de ubicación de monstruos es análogo, pero no necesito actualizar el tablero luego de ubicar un monstruos porque es posible superponerlos. g(x) sigue igual ya que no puedo superponer con obstaculos.
Obviamente que las casillas que contengan un monstruo no van a ser todas "m" ya que esto no nos diría nada sobre la cantidad de monstruos que hay, podemos entonces hacer "m+x" siendo x igual a "la cantidad de monstruos sobre esa casilla-1"
Total, cuanto mucho habrá 24 monstruos... osea, el valor de la variable no superará el máximo de un char (255).
Por que "m" minuscula, porque si fuese mayuscula y tuviese 12 monstruos, les dejo a ustedes deducir las consecuencias...

La verdad que en el enunciado, por más que el profesor trata de ser lo más detallista posible, se presta a ciertas ambigüedades. Además debo aclarar que detesto cuando tratan de "programar a los programadores" (diciendole como tienen q hacer el código, en vez de dandole la descripcion de la entrada y la relación la la salida) xD

-Al parecer según veo, los argumentos para tus funciones están en el orden en que los nombra en el enunciado.
Además no es sólo en la función carge que pasas la cantidad de articulos como puntero a int, sino en el resto de las funciones que requieren ese dato.
En primer lugar, pensé que quizás la función carga podría modificar la cantidad, en este caso es importante que pases el puntero a la variable, para tener acceso a la variable que pasas como argumento desde el main y no tener una simple "copia" de ella... Espero que lo entiendas, sino, repasa un poco esto:

void fun1 (int a)
{
a++;
return;
}
void fun2 (int *a)
{
(*a)++;
return;
}

En el primer caso paso el valor de un entero, y la modificacion no influye sobre la variable que le paso dede el main (o en donde se llame a fun1). En el segundo paso la direccion y modifico el valor del entero a donde esa direccion apunta, osea que la modificacion es efectiva en la variable con la que trabajo en el main.
Entonces convenimos en esto: si quieres modificar la variable, pasa el puntero a dicha variable... xD Pero creo que no necesitas modificar el valor de la cantidad, así que no sé para que... Si, como dices tu sería mejor pasar el valor (un int directamente). Igualmente no sé de donde sacaste esos prototipos, en el enunciado no están...

-Las variables las declaras bien, no usas variables globales como la consigna bien aclara que no hay que usar. Pero declaras 49 variables del tipo "struct productos", cuando necesitas 50, en las cadenas de caracteres dentro de la definicion de la estructura no tienes problemas con esto... Creo que la confusion viene por este lado:
Cuando hacés

int a[20]

declaras 20 variables int, que serán nombradas desde a[0] hasta a[19]. Yo antes, cuando empecé a programar, pensaba que haciendo int a[19] declarabas 20 variables...

-En la definición de la esctructura no pones el tipo de "nom_p[30]", que como leí en el enunciado debería ser una cadena de caracteres...

-La función buscar, según el enunciado devuelve todos los datos del producto... Justamente aclara (y aca el error de muchos estudiantes) que no muestra dichos datos... Por que? porque a veces vamos a tener que buscar un producto no para mostrar sus datos, sino para trabajar con ellos...Como son muchos datos (todos los de la estructura), puedes hacer varias cosa:
a)devolver un entero, que sea la posicion de la estructura buscada en el array.
b)devolver un puntero a la estructura encontrada (ahí estaría bien hacer "struct producto *").
c)devolver una estructura "struct producto" que sea la estructura encontrada.
La mejor opcion a mi criterio es la "a", ya que con ese dato podés determinar todos los otros. Si tienes un puntero a la estructura en verdad también porque hacés la diferencia entre éste y el puntero q apunta al principio de la estructura y te da la posición en la lista, pero es complicarse sin mucho sentido. Por ultimo, la opción "b" no te brinda información alguna sobre en que posición se encuentra, simplemente te pasa los datos del producto, pero como la consigna dice simplemente esto, no creo que esté mal...

Lo leí muy a la ligera, probablemente me olvide de más cosas, así que revisalo vos...

Primero que nada es más que obvio que tu bucle es indefinido, ya que la variable condicion no se modifica en el while...
Creo que lo que te propones hacer es:
-O dadas n iteraciones, cuantas veces de n los dos numeros <=50 suman exactamente el otro numero <=100...
-O hacer el proceso, HASTA que se cumpla 1 vez esta condición que mencionas e ir contando cuantas iteraciones fueron necesarias.

Obviamente que deberias realizar muchas pruebas para elaborar una conclusión (inductiva) estadística precisa...
Si quieres calcular las probabilidades que esto suceda te recomendaría hacerlo de manera deductiva (matemáticamente).

También te recomiendo analizar que posibles números te puede dar por resultado x=(n%50) y te darás cuenta que x (entero) pertenece al rango [0;49]

También creo que no sabés precisamente y con claridad que quieres de entrada y que quieres de salida, así como te falta comprensión tanto de lo que hace tu código como del enunciado en sí...
Y usa las etiquetas GeSHi para el código.

No querría ser grosero, pero me huele a clásica tarea.
Perdón si a veces prejuzgo a la gente, espero que lo puedas resolver...

Hago concreto por fin el proyecto mío de establecer en la sección de C/C++ una serie de retos.

He aquí las reglas que he elaborado para tal fin, luego agregaré los primeros dos problemas:


Los retos son una forma de estimular a la comunidad a participar mediante la resolución de problemas que competen a las ciencias de la computación. En este caso particular, la implementación será en C/C++.

Los retos NO son una competencia, de serlo, la administración sería, obviamente, más rígida (en una competencia todos entregan sus códigos al mismo tiempo, por ejemplo).
Por lo cual, me parece redundante aclarar, que nadie viene aquí para demostrar nada o pelearse con el resto de los participantes.
Igualmente confío en el actuar responsable de la comunidad y espero que los retos se desarrollen con éxito y participación asidua, de modo que se transforme en un buen espacio para  compartir el hábito de la programación.



Los retos se desarrollarán de la siguiente manera:
-Se decidirán uno o dos problemas.
-Se crearán los hilos respectivos, los cuales serán puesto en chincheta por un mes, de modo que no haya ninguna ventaja (si alguno hubiese visto el mismo problema o problema similar con anterioridad). Y para que todos puedan hacerse un tiempo para participar, aún cuando estén muy atareados por el trabajo/estudio.
-Luego del mes el post se cerrará y quedarán las mediciones oficiales.
-Se creará otro post en chincheta que irá almacenando el historial de todos los retos que se cierren, de modo que no se pierdan aquellas resoluciones.



Los problemas serán todos de índole matemática. De ningún modo se exigirán conocimientos como APIs o demás que no estén en el estándar.
Con esto me refiero a que no serán retos al estilo de “programar un servidor”, “hacer un rootkit”, “hacer una interface gráfica”, etc. Obviamente que puedo modificar el enunciado del problema para hacer una “historia” divertida, pero me aseguraré que con conocimientos muy básicos y un poco de lógica se puedan resolver. No necesito resolverlos, simplemente leyéndolos uno puede darse cuenta de como “pinta” el ejercicio, si es un problema matemático, o si se necesitan conocimientos avanzados que no son del estandar.

El hecho es que pongan sus esfuerzos en un programa que resuelva el problema de manera COMPLETA (que no haya casos sin cubrir), respetando los requerimientos de memoria explicitados en el enunciado y se deberá tratar de que sea los más óptimo posible en velocidad de resolución.

Además, cada código que se posteé tendrá que poseer una descripción de QUÉ es precisamente lo que hace (osea una explicación del algoritmo usado), de modo que se pruebe fehacientemente de que uno entiende lo que postea y además, contribuya a entender el método de resolución adoptado. Ya que, si bien es posible entender leyendo el código, ahorra mucho tiempo que se explique POR QUÉ se hace lo que se hace; especialmente en problemas que tienen una solución original, la cual es producto de todo un proceso matemático deductivo.
Si alguien usa una idea ya posteada, sólo con mencionarlo no necesita explicar otra cosa que la modificación añadida.

Yo, personalmente, me encargaré de las mediciones oficiales de los códigos, lo que no quiere decir que ustedes no puedan aportar sus propias mediciones. Del mismo modo, trataré de leer todos los algoritmos y códigos para asegurarme de que la solución sirve para todos los ingresos (para lo cual es importante que hagan la descripción de su algoritmo).

Además me ocuparé de buscar problemas. Mas cualquiera puede sugerir alguno, probablemente espere un poco para ponerlo como reto, de modo que nadie sugiera un problema que en realidad sea una tarea. Tengan en cuenta que probablemente, si participan en los retos frecuentemente haciendo buenos aportes se ganarán la confianza para que acepte los problemas que sugieran.
Es muy importante para que yo acepte poner un problema como reto, las fuentes. Ya que no sobra el listo que desea que se le haga la tarea (y de forma óptima! xD). Eso no es todo, ya que existen competiciones online y sería terrible que estuviesemos resolviendole los problemas a alguien. Yo también postearé las fuentes para que sea completamente transparente este tema tan delicado.



El incumplimiento de cualquier norma, tanto de la sección en general, como de las de normas particulares de los retos, podría acarrear a la eliminación del comentario sin aviso previo.



Problema #1:

Fuente: Es un problema que tenía en la computadora hace tiempo, y revisando (como siempre anoto las fuentes) descubrí que lo había sacado de éste foro.
El post de donde fue sacado es este: http://foro.elhacker.net/empty-t278773.0.html
Yo ya lo he resuelto, es un problema que tengo como ejemplo para explicarle a algunos chicos que a veces optimizar significa trabajar un poco el problema matemáticamente y abandonar la forma bruta de resolverlos. Además es original y fue uno de los primeros problemas de envergadura media con que me enfrenté.
En brevedad escanearé las hojas donde tengo la explicación (me gusta desarrollarlo a mano) y subiré el código que hice hace tiempo. No lo revisé, pero puede que sea factible hacerle optimizaciones.





Problema #2:
Trataremos el problema G del pdf que aquí adjunto (perdon por el hecho de que esté en inglés, si alguien no entiende avisa y lo traduzco).
http://cm.baylor.edu/ICPCWiki/attach/Problem%20Resources/1992WorldFinalProblemSet.pdf
Fuente: Exámen de la final del mundo de las competencias ACM de 1992 (organizadas por IBM) una olimpíada de programación universitaria internacionaldonde se valora el trabajo en grupo (se programa en grupos de a 3) para el diseño de soluciones óptimas a problemáticas de envergadura (siempre hablando de problemas de algoritmia) y donde también se valora la velocidad (se tiene 5 horas para realizar la prueba).





Este problema todavía no lo he tratado todavía pero probablemente lo haga, ya que estamos pensando en competir ahora q voy a la facu...


Suerte!

No sé como será el código completo
Puede que shortcuts esté declarado de forma global y sea visible para todas las funciones.
Lo más probable es que sea, a mi criterio, un puntero a char, ya que se compara el contenido de lo que apunta con una caracter ('^')...
Yo, personalmente, aprendí de acá http://c.conclase.net/curso/?cap=012#inicio.
Espero que te sirva, suerte y sigue aprendiendo

Si me permites, te cito: