void decompte(int nombre)
{
    printf("%d\n", nombre);
    if(nombre > 0)
        decompte(nombre - 1);
}

Citation : jaloyan

Citation : zx-spectrum
U(n+1) = U(n) + 1

Tu est sur?

Je dirais plutôt :
U(n+1) = U(n) + U

Citation : zx-spectrum

Citation : jaloyan

Citation : zx-spectrum
U(n+1) = U(n) + 1

Tu est sur?

Je dirais plutôt :
U(n+1) = U(n) + U

je suis sur de ma formule :
exemple de ma suite
U(0)=0
U(1)= U(0) + 1 ---------> U(1)=1
U(2)= U(1) + 1 ---------> U(2)= U(1)+1 ---------> U(2)=2
par un raisonnement réccurent on a
U(n+1) = U(n) +1
et non pas U(n+1) = U(n) + U ?
C'est tellement simple, que t'y perd ton latin !
Ici la solution récursive est simple a trouver pour le cas des suites numériques et aussi pour le calcul des factorielles(c'est un autres exemple de suite) que tu définis par :
U(n+1) = U(n) * (n+1) avec n >0;

Merci Brugnar pour ta reponse, c'est beaucoup plus clair de la facon dont tu l'expliques.

Citation : Jaloyan1

Car en effet, soit U et n deux nombre réels,

U(n + 1) = U(n) + U * 1 = U(n) + U

Citation : Jaloyan1

U est une fonction ou un nombre?

car c'est toute la différence.

fonction mintab(tab, n):
    min = tab[0]
    Pour i allant de 1 à (n - 1)
    - Si tab[i] < min
    --- min = tab[i]
    retourner min

fonction mintab(tab, n):
    // Soit on est dans le cas ou le tableau n'a que 2 cases
    Si n == 2
    - Si tab[0] < tab[1]
    --- retourner tab[0]
    - Sinon
    --- retourner tab[1]

    // Soit on est dans le cas plus complexe ou le tableau a plus de 2 cases
    // et il faut rappeler la fonction sur le sous tableau tab[1 .. (n-1)]
    min = mintab(tab[1 .. (n-1)], n - 1)
    // On peut maintenant comparer tab[0] avec le minimum de ce sous-tableau
    Si tab[0] < min
    - retourner tab[0]
    Sinon
    - retourner min

#include <stdio.h>

int mintab(int tab[], size_t size) {
    /*  tab contient size valeurs. Ses indices vont donc de 0 à (size - 1). */
    int min;

    /*  si le sous-tableau tab contient 2 valeurs
        alors on retourne la plus petite de ces valeurs. */
    if(size == 2) {
        return tab[0] < tab[1] ? tab[0] : tab[1];
    }

    /*  on rappelle la fonction sur le sous-tableau
        de (size - 1) cases formé de tab[1] jusqu'à tab[size - 1]. */
    min = mintab(tab + 1, size - 1);

    /*  ainsi, la plus petite valeur du sous-tableau tab correspond à
        la plus petite valeur entre sa case d'indice 0, et le minimum du sous-tableau formé à partir de tab[1]. */
    return tab[0] < min ? tab[0] : min;
}

int main(void) {
    int tab[10] = {5, 8, 64, 30, 27, 2, 41, 12, 88, 61};
    printf("%d\n", mintab(tab, 10));
    return 0;
}

2

Process returned 0 (0x0)   execution time : 0.057 s
Press any key to continue.

Citation : Jaloyan1

Je n'ai pas pu le tester ton code, car il y a un truc qui me chatouille bien ,essaie ton code avec 1 base 10 et base 2 en 2eme arg.

#include <stdio.h>

static char digit[] = "0123456789ABCDEF";

void conversion_(int nombre, int base)
{
  if (nombre != 0)
    {
      conversion_(nombre / base, base);
      putchar(digit[nombre % base]);
    }
}



void conversion(int nombre, int base)
{
  int quotien, reste;

  quotien = nombre / base;
  reste = nombre % base;
  if (quotien != 0)
    conversion(quotien, base);
  putchar(digit[reste]);
}



int main(void)
{
  int nombre, base = 17;

  puts("entrez le nombre en decimal");
  scanf("%d", &nombre);
  while (base > 16 || base < 2)
    {
      puts
        ("entrez la base auquelle vous voulez convertir votre nombre [2-16]");
      scanf("%d", &base);
    }
  printf("%d en base %d est egal a ", nombre, base);
  conversion_(nombre, base);
  printf("\n");
  conversion(nombre, base);
  return 0;
}

candide@candide-desktop:~$ ./x
entrez le nombre en decimal
5
entrez la base auquelle vous voulez convertir votre nombre [2-16]
2
5 en base 2 est egal a 101
101candide@candide-desktop:~$ ./x
entrez le nombre en decimal
1
entrez la base auquelle vous voulez convertir votre nombre [2-16]
2
1 en base 2 est egal a 1
1candide@candide-desktop:~$

Correction pour zBinary

• Par divisions successives
• Par soustractions successives
• Par accès aux bits avec l'opérateur &

Divisions successives

void bin(unsigned val)
{
    if(val == 0) return;
    bin(val/2);
    putchar((val%2)? '1':'0');
}

Appel de bin(25)
    val = 25 donc != 0
    Appel de bin(12)
        val = 12 donc != 0
        Appel de bin(6)
            val = 6 donc != 0
            Appel de bin(3)
                val = 3 donc != 0
                Appel de bin(1)
                    val = 1 donc != 0
                    Appel de bin(0)
                        val = 0 donc Arrêt
                On affiche 1%2 donc 1
            On affiche 3%2 donc 1
        On affiche 6%2 donc 0
    On affiche 12%2 donc 0
On affiche 25%2 donc 1

Soustractions successives

void bin(unsigned val)
{
    unsigned twoPow = 1;
    for(; twoPow <= val ; twoPow*=2){}
    for(twoPow/=2 ; twoPow >=1 ; twoPow/=2)
    {
        if(val >= twoPow){
            val -= twoPow;
            putchar('1');}
        else putchar('0');
    }
}

Accès aux bits avec l'opérateur &

void bin(unsigned val)
{
    unsigned twoPow = 1;
    for(; twoPow <= val ; twoPow*=2){} //On trouve la puissance de deux de départ
    for(twoPow/=2 ; twoPow >= 1 ; twoPow/=2)
        putchar((twoPow & val)?'1':'0');
}

#include <stdio.h>

int main(void)
{
  char ch[5] = { 0 };
  int n = 2009;

  sprintf(ch, "%x", (unsigned) n);
  printf("%d en base 16 : %s\n", n, ch);
  sprintf(ch, "%o", (unsigned) n);
  printf("%d en base  8 : %s\n", n, ch);

  return 0;
}

2009 en base 16 : 7d9
2009 en base  8 : 3731

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <limits.h>

int convertir(int n)
{
  int k;
  char ch[(sizeof(int) * CHAR_BIT) / 3 + 2] = { 0 };
  char *t[8] = { "000", "001", "010", "011", "100", "101", "110", "111" };
  int n8 = sprintf(ch, "%o", n);        /* le nombre de chiffres en octal */

  printf("%ld", strtol(t[ch[0] - '0'], NULL, 10));      /* car pas de zeros
                                                           dominants */
  for (k = 1; k < n8; k++)
    printf("%s", t[ch[k] - '0']);

  printf("\n\n");
  return 0;
}

int main(void)
{
      printf("Entier a convertir en base 2 (-1 pour quitter):\n");
  while (1)
    {
      int n;

      scanf("%d", &n);
      if (n == -1)
        break;
      else
        convertir(n);
    }
  return 0;
}

Entier a convertir en base 2 (-1 pour quitter):
2009
11111011001

1
1

0
0

1024
10000000000

4095
111111111111

-1

Objectif

• Le tri à bulles
• Le tri par sélection
• Le tri par insertion

Combien d'éléments voulez-vous trier ? 50000
Tri par insertion en cours ... 12 secondes
Tri par sélection en cours ... 8 secondes
Tri à bulles en cours ........ 15 secondes

Citation : crys'

L'objectif de cet exercice est de réaliser un comparatif de différents algorithmes de tri en O(n²).(...)
Je ne vous demande pas d'implémenter ces tris (sauf si vous y tenez), vous trouverez les fonctions de ces tris à la pelle sur internet et même certains sur le SdZ.

Citation : crys'

Hum, j'y avait bien pensé mais es-tu sur que ce soit à la portée des débutants ?

Citation : Jaloyan1

je trouve que le principe de comparaison des secondes ne sert pas à grand chose.

Citation : Goost

Citation : Jaloyan1

je trouve que le principe de comparaison des secondes ne sert pas à grand chose.

Tu viens de découvrir la définition d'exercice, bravo. Personne n'a jamais dit que ça devait "servir à quelque chose", c'est pour s'entrainer, c'est tout.

#include <stdio.h>
#include <limits.h>

void affichage_binaire(unsigned int n)
{
    int i;
    for (i = (sizeof(n)*CHAR_BIT)-1 ; i >= 0 ; i--)
        putchar( ((n >> i)&1) ? '1' : '0');
    putchar('\n');
}

#include <stdio.h>
#include <limits.h>

void affichage_binaire(unsigned int n)
{
    int i;
    for (i = (sizeof(n)*CHAR_BIT)-1 ; i >= 0 ; i--)
        putchar( ((n >> i)&1) + '0');
    putchar('\n');
}

Citation : yoch

Bonsoir,

Je tenais a mettre ma solution au zBinary si elle ne serait pas proposée (méthode opérateurs binaires).

Voici

Citation : candide

Et ton code n'est pas satisfaisant car il ne supprime pas les zéros dominants voire faux dans le second cas (moi j'ai un '1' qui apparait comme bit dominant).

Citation : yoch

Pourrais tu expliquer ?

#include <stdio.h>
#include <limits.h>

void affichage_binaire(unsigned int n)
{
    int i;
    for (i = sizeof(n)*CHAR_BIT ; i >= 0 ; i--)
        putchar( ((n >> i)&1) ? '1' : '0');
    putchar('\n');
}

int main(void)
{
   affichage_binaire(5);
  return 0;
}

candide@candide-desktop:~$ ./x
100000000000000000000000000000101
candide@candide-desktop:~$

Citation : candide

Citation : yoch

Pourrais tu expliquer ?

Voilà ce que mon dernier essai donne :

#include <stdio.h>
#include <limits.h>

void affichage_binaire(unsigned int n)
{
    int i;
    for (i = sizeof(n)*CHAR_BIT ; i >= 0 ; i--)
        putchar( ((n >> i)&1) ? '1' : '0');
    putchar('\n');
}

int main(void)
{
   affichage_binaire(5);
  return 0;
}

candide@candide-desktop:~$ ./x
100000000000000000000000000000101
candide@candide-desktop:~$

#include <stdio.h>
#include <limits.h>

void affichage_binaire(unsigned int n)
{
    int i;
    for (i = sizeof(n)*CHAR_BIT ; i > 0 ; i--)
        putchar( ((n >> i)&1) ? '1' : '0');
    putchar('\n');
}

int main(void)
{
   affichage_binaire(5);
  return 0;
}

Citation : yoch

J'édite mon post plus haut...

Citation : crys

L'objectif de cet exercice est de réaliser un comparatif de différents algorithmes de tri en O(n²). Pour cela, vous devez savoir comment récupérer les secondes système (time.h) et connaître quelques algorithmes de tri en O(n²). En voici trois :

Le tri à bulles
Le tri par sélection
Le tri par insertion