CodeS-SourceS est hébergé par Frontier.fr

Ce site au démarrage

begin process at 2012 02 11 11:33:17

Accueil Codes Tutoriels Forum Livres Emploi Services Connexion

Trouver un code source :

dans

[ Dernières recherches ]

Accueil > Forum >

c++ algo

Poser une question dans le forum ou lancer une discussion

c++ algo

lundi 7 avril 2003 à 20:48:34 | c++ algo

altay

6 msg

24 msg CS

L'analyste programmeur a 3 dimension
est ce que quelqu'un pourrait me faire l'algo de ce code
merci d'avance :
#pragma hdrstop

#include <conio.h>
#include <iomanip.h>
#include <iostream.h>
#include <stdlib.h>

//---------------------------------------------------------------------------

int **multiplieMatrice(int **matriceA, int colonnesA, int lignesA, int **matriceB, int colonnesB, int lignesB);

#pragma argsused
int main(int argc, char* argv[])
{
int lignes1;
int colonnes1 ;
int lignes2 ;
int colonnes2 ;
int **m1 ;
int **m2 ;
int **m3 ;
int i, j ;

do
{
cout << "1ere matrice : " << endl ;
cout << "combien de lignes ? " ;
cin >> lignes1 ;

cout << endl << "combien de colonnes ? " ;
cin >> colonnes1 ;

cout << endl << "2eme matrice : " << endl ;
cout << "combien de lignes ? " ;
cin >> lignes2 ;

cout << endl << "combien de colonnes ? " ;
cin >> colonnes2 ;

if (colonnes1!= lignes2)
cout << "erreur, les matrices ne peuvent pas etre multipliees!!! " << endl ;

}
while (colonnes1 != lignes2) ;

// si les matrices sont ok : colonnes1 == lignes2

m1 = (int**)malloc(lignes1 * sizeof(int*)) ;
m2 = (int**)malloc(lignes2 * sizeof(int*)) ;

if (!m1)
{
free(m1) ;
cout << endl << "erreur d'alloc 1ere matrice!!! " ;
return NULL ;
}

for (i=0 ; i<lignes1 ; i++)
{
m1[i] = (int*)malloc(colonnes1 * sizeof(int)) ;

if (!m1[i])
{
free(m1) ;
cout << endl << "erreur d'alloc lignes!!! " ;
return NULL ;
}
}

if (!m2)
{
free(m2) ;
cout << endl << "erreur d'alloc 1ere matrice!!! " ;
return NULL ;
}

for (i=0 ; i<lignes2 ; i++)
{
m2[i] = (int*)malloc(colonnes2 * sizeof(int)) ;

if (!m2[i])
{
free(m2) ;
cout << endl << "erreur d'alloc lignes!!! " ;
return NULL ;
}
}

cout << endl << "1ere matrice : " << endl ;

for (i=0 ; i<lignes1 ; i++)
{
for (j=0 ; j<colonnes1 ; j++)
{
cout << endl << "nombre en place " <> m1[i][j] ;
}
}

cout << endl ;

// affichage 1ere matrice
for (i=0 ; i<lignes1 ; i++)
{
for (j=0 ; j<colonnes1 ; j++)
{
cout << setw(3) << m1[i][j] ;
}
cout << endl ;
}

cout << endl << "2eme matrice : " << endl ;

for (i=0 ; i<lignes2 ; i++)
{
for (j=0 ; j<colonnes2 ; j++)
{
cout << "nombre en place " <> m2[i][j] ;
}
}

cout << endl ;

// affichage 2eme matrice
for (i=0 ; i<lignes2 ; i++)
{
for (j=0 ; j<colonnes2 ; j++)
cout << setw(3) << m2[i][j] ;
cout << endl ;
}

// multiplication des matrices

m3 = multiplieMatrice(m1, colonnes1, lignes1, m2, colonnes2, lignes2) ;

cout << endl << "Multiplication des matrices......" << endl ;
cout << endl << "Matrice Resultat : " << endl ;

for (i=0 ; i<lignes1 ; i++)
{
for (j=0 ; j<colonnes2 ; j++)
cout << setw(3) << m3[i][j] ;
cout << endl ;
}

free(m1) ;
free(m2) ;
free(m3) ;

cout << endl << endl << "appuyer sur une touche pour quitter..." ;
getch () ;
return 0 ;

}
//---------------------------------------------------------------------------

// fonction multiplication des 2 matrices

int **multiplieMatrice(int **matriceA, int colonnesA, int lignesA, int **matriceB, int colonnesB, int lignesB)
{
int **matriceR ;
int i, j, k ;

matriceR = (int**)malloc(lignesA * sizeof(int*)) ;

if (!matriceR)
{
free(matriceR) ;
cout << endl << "erreur d'alloc matrice reponse !!! " ;
return NULL ;
}

for (i=0 ; i<lignesA ; i++)
{
matriceR[i] = (int*)malloc(colonnesB * sizeof(int)) ;

if (!matriceR[i])
{
free(matriceR) ;
cout << endl << "erreur d'alloc lignes!!! " ;
return NULL ;
}
}

for (i=0 ; i<lignesA; i++)
for (j=0 ; j<colonnesB; j++)
{
matriceR[i][j] = 0 ;

for (k=0 ; k<colonnesA ; k++)
matriceR[i][j] += matriceA[i][k] * matriceB[k][j] ;
}
return matriceR ;
}

mercredi 9 avril 2003 à 18:51:50 | Re : c++ algo

payen

222 msg

239 msg CS

mais ... pour faire l'algo, il te suffit de lire les cin, cout et les commentaires. d'ailleurs, pourquoi faire l'algo qd on a le code? c'est plutot l'inverse qui est interessant ...

-------------------------------
Réponse au message :
-------------------------------

> L'analyste programmeur a 3 dimension
> est ce que quelqu'un pourrait me faire l'algo de ce code
> merci d'avance :
> #pragma hdrstop
>
> #include <conio.h>
> #include <iomanip.h>
> #include <iostream.h>
> #include <stdlib.h>
>
> //---------------------------------------------------------------------------
>
> int **multiplieMatrice(int **matriceA, int colonnesA, int lignesA, int **matriceB, int colonnesB, int lignesB);
>
> #pragma argsused
> int main(int argc, char* argv[])
> {
> int lignes1;
> int colonnes1 ;
> int lignes2 ;
> int colonnes2 ;
> int **m1 ;
> int **m2 ;
> int **m3 ;
> int i, j ;
>
> do
> {
> cout << "1ere matrice : " << endl ;
> cout << "combien de lignes ? " ;
> cin >> lignes1 ;
>
> cout << endl << "combien de colonnes ? " ;
> cin >> colonnes1 ;
>
> cout << endl << "2eme matrice : " << endl ;
> cout << "combien de lignes ? " ;
> cin >> lignes2 ;
>
> cout << endl << "combien de colonnes ? " ;
> cin >> colonnes2 ;
>
> if (colonnes1!= lignes2)
> cout << "erreur, les matrices ne peuvent pas etre multipliees!!! " << endl ;
>
> }
> while (colonnes1 != lignes2) ;
>
> // si les matrices sont ok : colonnes1 == lignes2
>
> m1 = (int**)malloc(lignes1 * sizeof(int*)) ;
> m2 = (int**)malloc(lignes2 * sizeof(int*)) ;
>
> if (!m1)
> {
> free(m1) ;
> cout << endl << "erreur d'alloc 1ere matrice!!! " ;
> return NULL ;
> }
>
> for (i=0 ; i<lignes1 ; i++)
> {
> m1[i] = (int*)malloc(colonnes1 * sizeof(int)) ;
>
> if (!m1[i])
> {
> free(m1) ;
> cout << endl << "erreur d'alloc lignes!!! " ;
> return NULL ;
> }
> }
>
> if (!m2)
> {
> free(m2) ;
> cout << endl << "erreur d'alloc 1ere matrice!!! " ;
> return NULL ;
> }
>
> for (i=0 ; i<lignes2 ; i++)
> {
> m2[i] = (int*)malloc(colonnes2 * sizeof(int)) ;
>
> if (!m2[i])
> {
> free(m2) ;
> cout << endl << "erreur d'alloc lignes!!! " ;
> return NULL ;
> }
> }
>
>
> cout << endl << "1ere matrice : " << endl ;
>
> for (i=0 ; i<lignes1 ; i++)
> {
> for (j=0 ; j<colonnes1 ; j++)
> {
> cout << endl << "nombre en place " < cin >> m1[i][j] ;
> }
> }
>
> cout << endl ;
>
> // affichage 1ere matrice
> for (i=0 ; i<lignes1 ; i++)
> {
> for (j=0 ; j<colonnes1 ; j++)
> {
> cout << setw(3) << m1[i][j] ;
> }
> cout << endl ;
> }
>
> cout << endl << "2eme matrice : " << endl ;
>
> for (i=0 ; i<lignes2 ; i++)
> {
> for (j=0 ; j<colonnes2 ; j++)
> {
> cout << "nombre en place " < cin >> m2[i][j] ;
> }
> }
>
> cout << endl ;
>
> // affichage 2eme matrice
> for (i=0 ; i<lignes2 ; i++)
> {
> for (j=0 ; j<colonnes2 ; j++)
> cout << setw(3) << m2[i][j] ;
> cout << endl ;
> }
>
> // multiplication des matrices
>
> m3 = multiplieMatrice(m1, colonnes1, lignes1, m2, colonnes2, lignes2) ;
>
> cout << endl << "Multiplication des matrices......" << endl ;
> cout << endl << "Matrice Resultat : " << endl ;
>
> for (i=0 ; i<lignes1 ; i++)
> {
> for (j=0 ; j<colonnes2 ; j++)
> cout << setw(3) << m3[i][j] ;
> cout << endl ;
> }
>
> free(m1) ;
> free(m2) ;
> free(m3) ;
>
> cout << endl << endl << "appuyer sur une touche pour quitter..." ;
> getch () ;
> return 0 ;
>
> }
> //---------------------------------------------------------------------------
>
> // fonction multiplication des 2 matrices
>
> int **multiplieMatrice(int **matriceA, int colonnesA, int lignesA, int **matriceB, int colonnesB, int lignesB)
> {
> int **matriceR ;
> int i, j, k ;
>
> matriceR = (int**)malloc(lignesA * sizeof(int*)) ;
>
> if (!matriceR)
> {
> free(matriceR) ;
> cout << endl << "erreur d'alloc matrice reponse !!! " ;
> return NULL ;
> }
>
> for (i=0 ; i<lignesA ; i++)
> {
> matriceR[i] = (int*)malloc(colonnesB * sizeof(int)) ;
>
> if (!matriceR[i])
> {
> free(matriceR) ;
> cout << endl << "erreur d'alloc lignes!!! " ;
> return NULL ;
> }
> }
>
> for (i=0 ; i<lignesA; i++)
> for (j=0 ; j<colonnesB; j++)
> {
> matriceR[i][j] = 0 ;
>
> for (k=0 ; k<colonnesA ; k++)
> matriceR[i][j] += matriceA[i][k] * matriceB[k][j] ;
> }
> return matriceR ;
> }

samedi 12 avril 2003 à 20:19:58 | Re : c++ algo

CoreBreaker

128 msg

534 msg CS

C'est l'algoritme de base d'une saisie de 2 matrices, de leur multiplication, et leur affichage.

pour toute ligne i de la matrice 1 et pour toute colonne j de la matrice 2
valeur temporaire=0
{ pour toute colonne k de la matrice 1
valeur temporaire= valeur temporaire + valeur de la ligne i et de la colonne k de la matrice 1 * valeur de la ligne k et de la colonne j de la matrice 2 }

valeur de la ligne i et de la colonne j de la matrice résultante= valeur temporaire

Core Breaker

-------------------------------
Réponse au message :
-------------------------------

> L'analyste programmeur a 3 dimension
> est ce que quelqu'un pourrait me faire l'algo de ce code
> merci d'avance :
> #pragma hdrstop
>
> #include <conio.h>
> #include <iomanip.h>
> #include <iostream.h>
> #include <stdlib.h>
>
> //---------------------------------------------------------------------------
>
> int **multiplieMatrice(int **matriceA, int colonnesA, int lignesA, int **matriceB, int colonnesB, int lignesB);
>
> #pragma argsused
> int main(int argc, char* argv[])
> {
> int lignes1;
> int colonnes1 ;
> int lignes2 ;
> int colonnes2 ;
> int **m1 ;
> int **m2 ;
> int **m3 ;
> int i, j ;
>
> do
> {
> cout << "1ere matrice : " << endl ;
> cout << "combien de lignes ? " ;
> cin >> lignes1 ;
>
> cout << endl << "combien de colonnes ? " ;
> cin >> colonnes1 ;
>
> cout << endl << "2eme matrice : " << endl ;
> cout << "combien de lignes ? " ;
> cin >> lignes2 ;
>
> cout << endl << "combien de colonnes ? " ;
> cin >> colonnes2 ;
>
> if (colonnes1!= lignes2)
> cout << "erreur, les matrices ne peuvent pas etre multipliees!!! " << endl ;
>
> }
> while (colonnes1 != lignes2) ;
>
> // si les matrices sont ok : colonnes1 == lignes2
>
> m1 = (int**)malloc(lignes1 * sizeof(int*)) ;
> m2 = (int**)malloc(lignes2 * sizeof(int*)) ;
>
> if (!m1)
> {
> free(m1) ;
> cout << endl << "erreur d'alloc 1ere matrice!!! " ;
> return NULL ;
> }
>
> for (i=0 ; i<lignes1 ; i++)
> {
> m1[i] = (int*)malloc(colonnes1 * sizeof(int)) ;
>
> if (!m1[i])
> {
> free(m1) ;
> cout << endl << "erreur d'alloc lignes!!! " ;
> return NULL ;
> }
> }
>
> if (!m2)
> {
> free(m2) ;
> cout << endl << "erreur d'alloc 1ere matrice!!! " ;
> return NULL ;
> }
>
> for (i=0 ; i<lignes2 ; i++)
> {
> m2[i] = (int*)malloc(colonnes2 * sizeof(int)) ;
>
> if (!m2[i])
> {
> free(m2) ;
> cout << endl << "erreur d'alloc lignes!!! " ;
> return NULL ;
> }
> }
>
>
> cout << endl << "1ere matrice : " << endl ;
>
> for (i=0 ; i<lignes1 ; i++)
> {
> for (j=0 ; j<colonnes1 ; j++)
> {
> cout << endl << "nombre en place " < cin >> m1[i][j] ;
> }
> }
>
> cout << endl ;
>
> // affichage 1ere matrice
> for (i=0 ; i<lignes1 ; i++)
> {
> for (j=0 ; j<colonnes1 ; j++)
> {
> cout << setw(3) << m1[i][j] ;
> }
> cout << endl ;
> }
>
> cout << endl << "2eme matrice : " << endl ;
>
> for (i=0 ; i<lignes2 ; i++)
> {
> for (j=0 ; j<colonnes2 ; j++)
> {
> cout << "nombre en place " < cin >> m2[i][j] ;
> }
> }
>
> cout << endl ;
>
> // affichage 2eme matrice
> for (i=0 ; i<lignes2 ; i++)
> {
> for (j=0 ; j<colonnes2 ; j++)
> cout << setw(3) << m2[i][j] ;
> cout << endl ;
> }
>
> // multiplication des matrices
>
> m3 = multiplieMatrice(m1, colonnes1, lignes1, m2, colonnes2, lignes2) ;
>
> cout << endl << "Multiplication des matrices......" << endl ;
> cout << endl << "Matrice Resultat : " << endl ;
>
> for (i=0 ; i<lignes1 ; i++)
> {
> for (j=0 ; j<colonnes2 ; j++)
> cout << setw(3) << m3[i][j] ;
> cout << endl ;
> }
>
> free(m1) ;
> free(m2) ;
> free(m3) ;
>
> cout << endl << endl << "appuyer sur une touche pour quitter..." ;
> getch () ;
> return 0 ;
>
> }
> //---------------------------------------------------------------------------
>
> // fonction multiplication des 2 matrices
>
> int **multiplieMatrice(int **matriceA, int colonnesA, int lignesA, int **matriceB, int colonnesB, int lignesB)
> {
> int **matriceR ;
> int i, j, k ;
>
> matriceR = (int**)malloc(lignesA * sizeof(int*)) ;
>
> if (!matriceR)
> {
> free(matriceR) ;
> cout << endl << "erreur d'alloc matrice reponse !!! " ;
> return NULL ;
> }
>
> for (i=0 ; i<lignesA ; i++)
> {
> matriceR[i] = (int*)malloc(colonnesB * sizeof(int)) ;
>
> if (!matriceR[i])
> {
> free(matriceR) ;
> cout << endl << "erreur d'alloc lignes!!! " ;
> return NULL ;
> }
> }
>
> for (i=0 ; i<lignesA; i++)
> for (j=0 ; j<colonnesB; j++)
> {
> matriceR[i][j] = 0 ;
>
> for (k=0 ; k<colonnesA ; k++)
> matriceR[i][j] += matriceA[i][k] * matriceB[k][j] ;
> }
> return matriceR ;
> }

dimanche 20 avril 2003 à 13:10:39 | Re : c++ algo

Krox68

72 msg

Krox68
oua complexe...
-------------------------------
Réponse au message :
-------------------------------

> L'analyste programmeur a 3 dimension
> est ce que quelqu'un pourrait me faire l'algo de ce code
> merci d'avance :
> #pragma hdrstop
>
> #include <conio.h>
> #include <iomanip.h>
> #include <iostream.h>
> #include <stdlib.h>
>
> //---------------------------------------------------------------------------
>
> int **multiplieMatrice(int **matriceA, int colonnesA, int lignesA, int **matriceB, int colonnesB, int lignesB);
>
> #pragma argsused
> int main(int argc, char* argv[])
> {
> int lignes1;
> int colonnes1 ;
> int lignes2 ;
> int colonnes2 ;
> int **m1 ;
> int **m2 ;
> int **m3 ;
> int i, j ;
>
> do
> {
> cout << "1ere matrice : " << endl ;
> cout << "combien de lignes ? " ;
> cin >> lignes1 ;
>
> cout << endl << "combien de colonnes ? " ;
> cin >> colonnes1 ;
>
> cout << endl << "2eme matrice : " << endl ;
> cout << "combien de lignes ? " ;
> cin >> lignes2 ;
>
> cout << endl << "combien de colonnes ? " ;
> cin >> colonnes2 ;
>
> if (colonnes1!= lignes2)
> cout << "erreur, les matrices ne peuvent pas etre multipliees!!! " << endl ;
>
> }
> while (colonnes1 != lignes2) ;
>
> // si les matrices sont ok : colonnes1 == lignes2
>
> m1 = (int**)malloc(lignes1 * sizeof(int*)) ;
> m2 = (int**)malloc(lignes2 * sizeof(int*)) ;
>
> if (!m1)
> {
> free(m1) ;
> cout << endl << "erreur d'alloc 1ere matrice!!! " ;
> return NULL ;
> }
>
> for (i=0 ; i<lignes1 ; i++)
> {
> m1[i] = (int*)malloc(colonnes1 * sizeof(int)) ;
>
> if (!m1[i])
> {
> free(m1) ;
> cout << endl << "erreur d'alloc lignes!!! " ;
> return NULL ;
> }
> }
>
> if (!m2)
> {
> free(m2) ;
> cout << endl << "erreur d'alloc 1ere matrice!!! " ;
> return NULL ;
> }
>
> for (i=0 ; i<lignes2 ; i++)
> {
> m2[i] = (int*)malloc(colonnes2 * sizeof(int)) ;
>
> if (!m2[i])
> {
> free(m2) ;
> cout << endl << "erreur d'alloc lignes!!! " ;
> return NULL ;
> }
> }
>
>
> cout << endl << "1ere matrice : " << endl ;
>
> for (i=0 ; i<lignes1 ; i++)
> {
> for (j=0 ; j<colonnes1 ; j++)
> {
> cout << endl << "nombre en place " < cin >> m1[i][j] ;
> }
> }
>
> cout << endl ;
>
> // affichage 1ere matrice
> for (i=0 ; i<lignes1 ; i++)
> {
> for (j=0 ; j<colonnes1 ; j++)
> {
> cout << setw(3) << m1[i][j] ;
> }
> cout << endl ;
> }
>
> cout << endl << "2eme matrice : " << endl ;
>
> for (i=0 ; i<lignes2 ; i++)
> {
> for (j=0 ; j<colonnes2 ; j++)
> {
> cout << "nombre en place " < cin >> m2[i][j] ;
> }
> }
>
> cout << endl ;
>
> // affichage 2eme matrice
> for (i=0 ; i<lignes2 ; i++)
> {
> for (j=0 ; j<colonnes2 ; j++)
> cout << setw(3) << m2[i][j] ;
> cout << endl ;
> }
>
> // multiplication des matrices
>
> m3 = multiplieMatrice(m1, colonnes1, lignes1, m2, colonnes2, lignes2) ;
>
> cout << endl << "Multiplication des matrices......" << endl ;
> cout << endl << "Matrice Resultat : " << endl ;
>
> for (i=0 ; i<lignes1 ; i++)
> {
> for (j=0 ; j<colonnes2 ; j++)
> cout << setw(3) << m3[i][j] ;
> cout << endl ;
> }
>
> free(m1) ;
> free(m2) ;
> free(m3) ;
>
> cout << endl << endl << "appuyer sur une touche pour quitter..." ;
> getch () ;
> return 0 ;
>
> }
> //---------------------------------------------------------------------------
>
> // fonction multiplication des 2 matrices
>
> int **multiplieMatrice(int **matriceA, int colonnesA, int lignesA, int **matriceB, int colonnesB, int lignesB)
> {
> int **matriceR ;
> int i, j, k ;
>
> matriceR = (int**)malloc(lignesA * sizeof(int*)) ;
>
> if (!matriceR)
> {
> free(matriceR) ;
> cout << endl << "erreur d'alloc matrice reponse !!! " ;
> return NULL ;
> }
>
> for (i=0 ; i<lignesA ; i++)
> {
> matriceR[i] = (int*)malloc(colonnesB * sizeof(int)) ;
>
> if (!matriceR[i])
> {
> free(matriceR) ;
> cout << endl << "erreur d'alloc lignes!!! " ;
> return NULL ;
> }
> }
>
> for (i=0 ; i<lignesA; i++)
> for (j=0 ; j<colonnesB; j++)
> {
> matriceR[i][j] = 0 ;
>
> for (k=0 ; k<colonnesA ; k++)
> matriceR[i][j] += matriceA[i][k] * matriceB[k][j] ;
> }
> return matriceR ;
> }

Cette discussion est classée dans : int, for, cout, endl, matricer

Répondre à ce message

Sujets en rapport avec ce message

algo C++ [ par altay ] L'analyste programmeur a 3 dimensionest ce que quelqu'un pourrait me faire l'algo de ce code merci d'avance :#pragma hdrstop#include #include que des boucles. [ par pratix ] Salut à tous.Je post mon prg cherchenbr modifié (voir sujet précédent ''int main" ).Programme compilé avec visual C++ 06. ( zéro erreur )j'ai essay tableaux dans prototype erreur [ par darmoor ] Bonjour tout le monde! bon, j'ai un petit probleme de compilation au niveau d'un tableau 2D dans un prototype. J'ai demandé à quelqu'un qui s'y conna mise à jour dans un fichier txt [ par imanedaoudi ] Bonjour; j'ai un fichier ouvert en mode mise à jour et la position (pos) ,ou je dois inserer mes elements. comment faire?? sachant que pos est un enti Les pointeurs : aie aie ! [ par coyotte49 ] Salut ! Je fais un p'tit topic sur les pointeurs, parce que la confusion règne ! J'ai compris la base de chez base pour les pointeurs, mais dans certa probleme avec un tableau a 3 dimensions [ par tomalille ] bonjour, j'utilise un tableau a 3 dimensions dans un procedure. Je ne comprend pas du tout les resultats de l'algo que j'ai implemente. Je modifie les probleme de debug [ par elhajjajireda ] si le vous plait j'ai placé un breakpoint sur ma fonction principale linge22 ou s'est écrit l'instruction " Image2.Load(argv[2]); sur Windows et avec exercice C++ [ par maina87 ] Bonjour, je suis débutante e C++ et j'ai eu a faire a un exercice, svp corrigez le moi: Voilà l'exercice: Donnez le résultat du code suivant: int c++ [ par yesoun1 ] je serai reconnaissant de votre aide ;) et merci d'avance[^^happy10] quel est le rôle de "*" ?? for(unsigned int i=0; i < hauteur; i++) { for Aide [ par Hellboy67 ] Il me faut une petite aide pour un programme que j'essaille de créerIl est censé convertir un nombre décimal en binaire.donc d'après ce que j'ai pu co

Livres en rapport

Process Algebra with Timing

Knowledge-based vision-guided

Mini icons

Graphic Design for the 21st century

Tous les livres pour Int, For, Cout, Endl, Matricer

Nos sponsors

Derniers Blogs

[TECHDAYS 2012] SESSION WEBMATRIX 2 : LE COUTEAU SUISSE GRATUIT POUR VOS DéVELOPPEMENTS WEB - SLIDES par gpommier

[SHAREPOINT] LES SESSIONS TECHDAYS 2012. par Patrick Guimonet

TECHDAYS PARIS 2012 : SESSION PLEINIèRE JOUR 3 par ROMELARD Fabrice

MISHRA READER : UN LECTEUR RSS TRèS ZUNE STYLE EN OPEN SOURCE ! par Vko

[FRAMEWORK 4] LES TASKS ET LE THREAD UI par fathi

Forum

RE : MODIFIER UN FICHIER DLL par francko225

RE : DéTRUIR UN CONTRôLE par amina009

RE : MODIFIER UN FICHIER DLL par Renfield

RE : DéTRUIR UN CONTRôLE par Renfield

RE : MODIFIER UN FICHIER DLL par BruNews

Côté IT

Offres d'emploi

Formations Video

Appels d'offres

Passerelle Pericles sur site Joomla 17
Budget : 499€
Infogerance Serveur Debian Linux
Budget : 2 400€
Developpeur applications iphone - ipad - android
Budget : 800€

Logiciels

Academy System (17.2.1.0)
ACADEMY SYSTEM (17.2.1.0)

Logiciel de gestion des établissements. - élèves/étudiants (inscription, dossier, absence...) -...

Cliquez pour télécharger Academy System
Easy-Planning (1.0.0.1)
EASY-PLANNING (1.0.0.1)

Basé sur les mêmes principes que MyPlanning, Easy-Planning permet de créer des plannings sous la ...

Cliquez pour télécharger Easy-Planning
COLLECTOR PLUS (3.00B)
COLLECTOR PLUS (3.00B)

COLLECTOR PLUS version 3.00B est un logiciel utilisant une base de données alimentée par : - L...

Cliquez pour télécharger COLLECTOR PLUS
PONAMEDIA PREMIUM - HELLLOOO FLASH DEMO (V7.4)
PONAMEDIA PREMIUM - HELLLOOO FLASH DEMO (V7.4)

PONAMEDIA TV DEVIENS HELLLOOO FLASH LA TV SUR VOTRE ORDINATEUR. Toute une plateforme Multi...

Cliquez pour télécharger PONAMEDIA PREMIUM - HELLLOOO FLASH DEMO
LettresFaciles 2011 (8.0.0.1)
LETTRESFACILES 2011 (8.0.0.1)

LettresFaciles est un logiciel facilitant la création et la rédaction de lettres types. Son inte...

Cliquez pour télécharger LettresFaciles 2011