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;
}
 

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!

Esto va para principalmente para Littlehorse, que me había pedido (hace mucho mucho mucho tiempo, quizás ni se acuerde) un brute force iterativo (yo había posteado uno recursivo).

Y aquí va:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main(int argc, char *argv[])
{
  int contadores[50], len, cant, i;
  char caracteres[200], pass[50];
 
  printf ("Ingrese los caracteres a usar para la contrasena: ");
  scanf ("%s", caracteres);
 
  printf ("Ingrese la longitud de la contraseña: ");
  scanf ("%i", &len);
 
  cant = strlen (caracteres);
 
  /*contadores = (int *) malloc (sizeof (int) * (len+1) );
  pass = (char *) malloc (len+1);*/
 
  for (i=0 ; i<len ; i++)
    {
        pass[i] = caracteres[0];
        contadores[i] = 0;
    }
  contadores[i] = 0;
  pass [i] = '\0';
    //Inicio bucle
 
    while (!contadores[len])
    {
        printf ("%s\n", pass);
 
        for (i=0;contadores[i]==cant-1;i++)
            pass[i] = caracteres [contadores[i] = 0];
 
        pass[i] = caracteres [++contadores[i]];
    }
 
  /*free (contadores);
  free (pass);*/
 
  system("PAUSE");
  return 0;
}

Bueno, luego de un gran descanso empezaré a postear nuevamente mis cosillas.

Aquí un jueguito que muchos quizás lo tengan en su casa con el nombre de "Mastermind"

El juego se base en adivinar un número de n dígitos elegido aleatoriamente por la máquina (el número de dígitos n es ingreso).

Pero se cuentan con una serie de pistas, lo que no indica que en el juego no influya la suerte obvio, pero lo hace un juego más para pensar que para "tirar números al azar".

Estas pistas consiste en dar al usuario el número de cifras en las que ha acertado. Y el número de cambios o conmutaciones que podrían hacer para hacer que una ficha que está incorrecta, lo esté.
Un ejemplo vale más que mil palabras:

Imaginemos que n vale 4 (osea, estamos operando con 4 dígitos)

El número elegido por la pc es: 3345

Nosotros ingresamos el: 5542

Cantidad de aciertos (o blancas): 1 (el 4 en la tercera posición)
Cantidad de rojas: 1 (ya que si bien tengo dos 5, osea, dos incorrectas, en la incógnita tengo sólo un 5. Así que el otro está de más)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define LIMPIAR_PANTALLA system("cls");
 
 
 
 
int esnumero (const char usuario[], int cant)
    {
        while (cant)
            if ( usuario[--cant]<'0' || usuario[cant]>'9' )
                return 1;
        return 0;
    }
 
 
int main(int argc, char *argv[])
{
  FILE *historial;
  char *incognita, *usuario, h;
  int cant, i, j, blancas, rojas;
  srand (time(NULL));
 
  do {
        printf ("Ingrese la cantidad de caracteres para jugar: ");
        scanf ("%i", &cant);
    } while (cant<1);
 
  do {
      printf ("\n\nDesea guardar el historial de la partida (ingrese 1 por si y 0 por no): ");
      scanf ("%i", &h);
    } while (h!=0&&h!=1);
 
  if (h)
    if (! (  historial = fopen ("historial.txt", "w")  )  )
        {
            do {
                printf ("\n\n\nHa surgido un error al crear el historial. Que desea hacer:\n1-Cerrar el programa\n2-Continuar sin guardar el historial\n\n\tOpcion: ");
                scanf ("%i", &h);
                } while (h!=0&&h!=1);
            if (h)
                return 0;
            else
                h=0;
        }
 
  usuario = (char *) malloc (cant);
  incognita = (char *) malloc (cant);
 
  for (i=0 ; i<cant ; i++)
    incognita[i] = rand ()%10+'0';
  incognita[cant] = '\0';
 
  if (h)
    fprintf (historial, "%s\n\n\n", incognita);
 
  for (i=0,j=0 ; i<cant ; i++)
    {
    j *= 10;
    j += 9;
    }
  // Programa propiamente dicho:
  LIMPIAR_PANTALLA
  printf ("A continuacion debe numeros entre 0 y %i hasta que adivine el numero\nLuego de cada numero le aparecera las pistas\n\nAprete una teclea para comenzar a jugar...", j);
  system ("PAUSE>>nul");
  LIMPIAR_PANTALLA
 
  do {
        do
            scanf ("%s", usuario);
              while (strlen (usuario) != cant || esnumero (usuario, cant) );
 
        if (h)
            fwrite (usuario, 1, cant, historial);
 
        blancas=0;
        rojas=0;
 
        for (i=0;i<cant;i++)
            if (incognita[i]==usuario[i])
                {
                    usuario[i] = 'b';
                    blancas++;
                }
 
        for (i=0;i<cant;i++)
            if (usuario[i]!='b')
                for (j=0;j<cant;j++)
                    if (usuario[j]!='b'&&usuario[j]!='r'&&incognita[i]==usuario[j])
                        {
                        usuario[j] = 'r';
                        rojas++;
                        break;
                        }
 
        if (h)
            fprintf (historial, "\nBlancas: %i Rojas: %i\n\n", blancas, rojas);
 
        printf ("Blancas: %i Rojas: %i\n\n", blancas, rojas);
 
    } while (blancas!=cant);
 
    LIMPIAR_PANTALLA
 
    printf ("\n\tFELICITACIONES!\n\n\nUsted ha adivinado el numero (%s)\n\n", incognita);
 
  free (usuario);
  free (incognita);
  system("PAUSE");
  return 0;
}

Bueno, es un juego muy popular también en mi escuela.

PD: También posee la opción de guardar el historial del juego