Codes sources C

Resolveur de sudoku codé en c permettant de résoudre les grilles simples (sans hypothèses).

Programme console qui affiche les k-combinaisons sur n éléments distincts.
Ensemble des éléments : {0,1, ..., n}
contraintes : 0 ... > c_(k-1)
Ordre numérique : ordre lexicographique avec c_0 < c_1 < ... < c_(k-1)
----

Exemple de mise en oeuvre de la simulation d'un nombre dynamique de boucles for
Gestion simplifiée des paramètres en ligne de commande
L'ordre Knuth est nommé ainsi suite à une discussion et à l'évocation d'un exemple du fascicule 3a du TAO
----

OS : linux
Compilateur : gcc 4.5

Devrait pouvoir être compilé sur windows (mingw/cygwin) mac(gcc) ou toute autre plateforme pour laquelle les outils GNU sont supportés.
----

Compilation :
Dézipper l'archive
cd kcomb
make
----

Utilisation :
kcomb n k [ordre]
n -> nombre d'éléments distincts (requis)
k -> longueur de la k-combinaison (requis)
ordre -> K = ordre de Knuth/ N = ordre numérique (optionnel, par défaut ordre numérique)
----

Exemple :

~/Projects/kcomb$ Release/kcomb 5 3 K
2 1 0
3 1 0
3 2 0
3 2 1
4 1 0
4 2 0
4 2 1
4 3 0
4 3 1
4 3 2

Vous entrez un nombre et le programme trouvera tous les nombres premiers compris entre 0 et votre nombre!

Au début, vous avez un nombre prédéfini d'allumettes. Chacun leur tour, 2 joueurs enlèvent une à trois allumettes. Celui qui doit enlever la dernière a perdu.

Ce jeu se joue soit en mode 2 joueurs, soit en mode 1 joueur (contre l'ordi). Dans ce cas, l'IA possède 3 niveaux. Le lvl 1 est très facile à battre, mais le lvl 3 possède une grande logique !

Donc... Bonne chance :P

Note : Les feedbacks sont appréciés (à envoyer à l'adresse inscrite dans les crédits, dans le jeu)

Attention : J'ai fait ce petit jeu sous Windows. Mais je l'utilise aussi sous linux. Le seul truc à modifier : changer les "cls" en "clear" !

Makefile générique

Makefile idéal pour la construction rapide d'un exécutable sans se préoccuper
de la gestion parfois complexe du Makefile : la fénéantise n'est plus une
excuse,

**********************
* Utilisation simple *
**********************

1. décompresser l'archive
2. renommer le répertoire ProjetMakefile
3. placer les sources dans le répertoire src
4. lancer make

make va automatiquement gérer les dépendances entre les fichiers sources et
créer un exécutable dans le répertoire Debug. Cet exécutable portera le nom
du répertoire qui contient le Makefile.
Exemple:

~/Projets> unzip ProjetMakefile.zip
~/Projets> mv ProjetMakefile test
~/Projets> cd test
~/Projets/test> cat > src/main.c #include
>
> int main()
> {
> puts("Hello world");
>
> return 0;
> }
> EOF
~/Projets/test> make
GENDEP libutil/xlog.c
GENDEP src/main.c
CC src/main.c
CC libutil/xlog.c
AR libutil.a
CCLD Debug/test
debug version built
~/Projets/test> ls
Debug/ libutil/ license.txt Makefile src/
~/Projets/test> ./Debug/test
Hello world
~/Projets/test>

***********************
* Utilisation avancée *
***********************

Le fichier Makefile est commenté. Les options et variables qui dictent son
comportement sont décrites lors de leur déclaration.
Ce Makefile est idéal dans le cas d'un petit projet qui ne crée qu'un
exécutable, qui peut utiliser une bibliothèque de commodité et d'autres
bibliothèques gérées par pkg-config.

Deux types principaux de build sont supportés :
* Debug : aucune option d'optimisation activée
* Release : options d'optimisation classiques activées

Dans chaque cas, il est possible d'ajouter les options pour le profilage et
le support des pthreads.

Le build peut se faire en mode SILENT, c'est-à-dire que les commandes ne sont
pas affichées mais une indication (comme dans l'exemple ci-dessus) de ce qui
est fait. Cette option est facilement débrayable soit en modifiant le Makefile,
soit par la ligne de commande : make SILENT=0 (cf les commentaires dans le
Makefile).

Remarques

* par défaut le compilateur utilisé est gcc en mode C99 avec les extensions
GNU (builtins et attibutes gcc et fonctions GNU_SOURCE de la glibc). Pour
uriliser ce Makefile laversion GNU de make est indispensable.

* le template est fourni avec un exemple de bibliothèque de commodité
permettant un logging simple (4 niveaux debug/info/warning/error, sortie
uniquement vers stderr)

* Ce template n'a pas la prétention d'être universel ou de remplacer d'autres
outils comme autoconf et cie. Il a pour seul but de simplifier le prototypage
ou la construction de petits projets. Entre autre il n'y a aucune cible
install ni aucune vérification de la présence de fonctionnalités ou d'outils.

N'hésitez pas à laisser un commentaire, des propositions d'améliorations ou de
correction. N'hésitez pas non plus si vous avez la moindre question à propos
de cette contribution.

K.

Ce code source a pour but de montrer comment utiliser la bibliothèque C libpq pour se connecter à une base de données PostgreSQL sur un système GNU/Linux.

Le seul fichier d'en-tête nécessaire pour compiler notre programme est le fichier libpq-fe.h. Bien sûr, pour avoir ce fichier il faut installer la bibliothèque libpq(et non pq++) . Deux méthodes pour installer la bibliothèque :

1. Installer le RPM ou le DEB de la bibliothèque à l'aide du package manager propre à votre Distribution Linux.
2. Installer PostgreSQL à partir de la source (http://www.postgresql.org/docs/8.4/static/installation.html) : Ainsi, la bibliothèque sera installée par défaut !!

On va utiliser la deuxième méthode. Le serveur sera installé dans le répertoire : /usr/local/pgsql.

Il faut, ensuite, installer la bibliothèque partagée libpq.so.5. Elle sera utilisée par l'éditeur de liens (ld) du compilateur gcc pour construire l'exécutable. Pour cela, vous devez installer le package postgresql-libs.

I. Changer la méthode d'authentification du serveur

Par défaut, la méthode d'authentification du serveur est 'trust'. Vous devez la changer en 'password'. Pour la changer, procédez comme suit :

1. Ouvrir un terminal
2. cd un_dir_propre_à_postgres
3. su postgres
4. /usr/local/pgsql/bin/pg_ctl start -D /usr/local/pgsql/data >logfile 2>&1 & -- lancer le serveur en background
5. /usr/local/pgsql/bin/psql -- psql is a terminal-based front-end to PostgreSQL
6. ALTER USER postgres WITH PASSWORD 'admin'; -- assigner un password ('admin') au superuser (postgres)
7. tapez \q
8. /usr/local/pgsql/bin/pg_ctl -D /usr/local/pgsql/data/ stop -- fermer le serveur

Maintenant, ouvrir en tant-que root le fichier /data/pg_hba.conf et remplacez les mots 'trust' par 'password' .

II. Créer la base des données :

Le programme va se connecter à la base de donnée store. Vous devez le créer ! Suivez les étapes suivantes pour le créer rapidement :

1. su postgres
2. /usr/local/pgsql/bin/pg_ctl -D /usr/local/pgsql/data/ start >logfile 2>&1 &
3. /usr/local/pgsql/bin/psql
4. CREATE USER client1 PASSWORD 'client1'; -- créer un user (role + login) avec le password 'client1'
5. \q
6. /usr/local/pgsql/bin/createdb -T template0 store -- créer une db 'store' à partir du template 'template0'
7. /usr/local/pgsql/bin/psql store < dbstore.txt -- restorer la db 'store' à partir du SQL dump 'dbstore.txt'.
8. /usr/local/pgsql/bin/psql -U client1 store

Vous pouvez maintenant compiler et exécuter le programme. La base de données store est donnée juste pour tester le programme.

Tri à bulle d'un tableau d'entiers en assembleur GNU.

Plus d'explications : http://asm.developpez.com/cours/gas/#LV-A

Ce module permet de faire quelques opérations sur les fichiers à accès séquentiel, il propose les opérations suivantes :

• Recherche du nombre de lignes


• Lecture d'une ligne par son numéro


• Suppression d'une ligne par son numéro


• Suppression d'une ligne par son contenu


• Recherche d'une ligne par une sous-chaîne


• Copie de fichiers


• Concaténation de fichiers


• Nombre d'occurrences d'une lettre


• Nombre d'occurrences d'un mot


• Test si un fichier existe

Voici un jeu codé en C et est console. il s'agit du jeu du plus ou moins ou vous devez deviner le nombre mystère généré par le programme !!

Voici une version écrite en C permettant de faire une partie contre l'ordinateur.

C'est un essai, il y a peu ou pas du tout de commentaires (désolé je suis trop pourri), cependant (logiquement) vous devriez pouvoir mener une partie de bout en bout (soit vers la défaite, soit vers la victoire ^^).

Je voudrais bien trouver un moyen sous Linux de pouvoir apporter des modifications, notamment concernant l'affichage (prévu pour du 1920x1080 ou en 1280x800) je voudrais pouvoir développer une fonction qui permette d'afficher l'interface utilisateur de manière propre peu importe la résolution (attention ce programme est en mode terminal).

Pour compiler le code source:

gcc -pthread sda2013.c -o sda2013

Les répertoires maps doivent se trouver dans le même répertoire que l'exécutable.
Jusqu'à présent vous pouvez jouer sur des maps 12x12, 13x13, 14x14 (mais il est prévu de jouer sur d'autres maps, maximum 26x26 en fonction de la résolution de l'écran, mais c'est pas automatique)

Je pense à faire un serveur java pour pouvoir faire des parties réseau (toute aide pour le module réseau client serait la bienvenue, d'autant que la programmation réseau TCP en C n'est pas une sinécure).

Ce programme permet de lister les répertoires et les sous-répertoires ainsi que les fichiers qui y sont stockés.

Le fichier date.c propose la fonction DATE_eGetTodayDate qui permet de récupérer la date du jour selon le format désiré.

Le fichier str.c propose des fonctions pour supprimer les espaces en début et fin de chaîne, pour mettre une chaîne de caractères en minuscule ou en majuscule.

Jeu où il faut trouver le bon mot. C'est un style de pendu mais en mode console uniquement. Le programme est fournit avec une dictionnaire de 331612 mots !

Ce code source montre comment invoquer correctement une fonction C de la bibliothèque standard GNU libc dans un code écrit en assembleur GNU. Les deux programmes date.c et date.s utilisent les fonctions scanf et printf pour saisir et afficher la date :

• Le programme date.c montre comment appeler une fonction standard dans un code C.
• Le programme date.s montre comment l'appeler dans un programme assembleur GNU.

Pour avoir accès à encore plus d'explications : http://asm.developpez.com/cours/gas/#LV-C

Méthode de résolution de labyrinthe avec l'algorithme A* implémenté à l'aide d'une queue de priorité. Ce programme montre également comment passer d'un tableau bidimensionnel à un tableau unidimensionnel pour représenter le labyrinthe.

Pour plus d'informations sur l'algorithme A* : Recherche de chemin: A* (http://fr.wikipedia.org/wiki/Algorithme_A%2A)

Les listes simplement chaînées : http://nicolasj.developpez.com/articles/listesimple/

Programme de construction et de résolution de labyrinthe. Trois méthodes de résolution sont proposées :

• Recherche en profondeur d'abord récursive


• Recherche en profondeur d'abord avec une pile


• Recherche en largeur d'abord avec une queue

Jeu du taquin programmé avec la bibliothèque GTK+. Le programme permet de choisir son découpage et également de choisir l'image sur laquelle s'amuser !

Les piles : http://nicolasj.developpez.com/articles/pile/