coursc/TD3.tex

\documentclass[10pt]{article}

\usepackage[french]{babel}
\usepackage[T1]{fontenc}
\usepackage[utf8]{inputenc}
\usepackage{acronym}

\addtolength{\hoffset}{-1in}
\addtolength{\voffset}{-1.5in}
\setlength{\oddsidemargin}{1cm}
\setlength{\textwidth}{19cm}

\setlength{\headheight}{0pt}
\setlength{\topmargin}{1cm}
\setlength{\textheight}{27cm}

\pagestyle{empty}

\title{TD 3}
\author{Florian Maury}

\begin{document}

\section{Exercice}
\'Ecrire une fonction qui renvoie une structure contenant le quotient et le reste d'une division de son premier argument par son second. Déclarer la structure utilisée.

\begin{verbatim}
struct div_t {
  int q;
  int r;
};

struct div_t divide(int leftOperand, int rightOperand) {
  struct div_t result;
  result.q = leftOperand / rightOperand;
  result.r = leftOperand % rightOperand;
  return result;
}
\end{verbatim}

\section{Exercice}
\'Ecrire 3 fonctions safeAdd, safeSub, safeMul qui permettent d'effectuer des opérations de calcul sans risque de dépassement sur des int. 
Si un integer overflow survient, ces fonctions mettent à 1 une variable globale "g\_iComputeError". 
Si aucun dépassement n'intervient, la variable vaut 0.

\begin{verbatim}
int safeAdd(int leftOperand, int rightOperand) {
  if ((leftOperand > 0 && rightOperand > 0 && leftOperand > INT_MAX - rightOperand) ||
      (leftOperand < 0 && rightOperand < 0 && leftOperand < INT_MIN - rightOperand)) {
    g_iComputeError = 1;
  }
  else {
    g_iComputeError = 0;  
  }
  return leftOperand + rightOperand;
}
int safeSub(int leftOperand, int rightOperand) {
  if ((leftOperand > 0 && rightOperand < 0 && leftOperand > INT_MAX + rightOperand) || 
      (leftOperand < 0 && rightOperand > 0 && leftOperand < INT_MIN + rightOperand)) {
    g_iComputeError = 1;
  }
  else {
    g_iComputeError = 0;  
  }
  return leftOperand - rightOperand;
}
int safeMul(int leftOperand, int rightOperand) {
if (((leftOperand > 0 && rightOperand > 0 )  && leftOperand > INT_MAX / rightOperand)||
    ((leftOperand < 0 && rightOperand < 0 )  && leftOperand < INT_MAX / rightOperand) ||
    ((leftOperand > 0 && rightOperand < 0 )  && leftOperand > INT_MIN / rightOperand) ||
    ((leftOperand < 0 && rightOperand > 0 )  && leftOperand < INT_MIN / rightOperand)) {
    g_iComputeError = 1;
  }
  else {
    g_iComputeError = 0;  
  }
  return leftOperand * rightOperand;
}
\end{verbatim}



\section{Exercice}
Déclarer et implémenter une fonction qui calcule le \ac{PGCD} de deux nombres.
L'algorithme est le suivant :

\begin{verbatim}
Fonction pgcd (a: Entier, b: Entier) : Entier

Tant que b est différent de 0:
     a reçoit la valeur de b
     b reçoit l'ancienne valeur de a modulo b

Renvoyer a

Fin fonction pgcd
\end{verbatim}

\begin{verbatim}
int pgcd(int a, int b) {
  int tmp;
  while(b != 0) {
    tmp = a;
    a = b;
    b = tmp % b;  
  }
  return a;
}
\end{verbatim}

\section{Exercice}
Implémenter la fonction suivante :
\begin{verbatim}
int exercice(int arg1, int arg2);
\end{verbatim}

Voici ce que doit faire cette fonction (dans l'ordre de priorité) :
\begin{enumerate}
  \item Si arg1 xor arg2 vaut 2, la valeur renvoyée est $-1$.
  \item Si arg2 est égal à 1, alors on considère que arg1 est formé de deux entiers 16 bits concaténés : on renvoie alors la valeur stockée dans les 16 bits de poids le plus fort de arg1.
  \item Si arg2 est égal à 2, et arg1 est positif, la valeur renvoyée est le factoriel de arg1.
  \item Si arg1 divise arg2 et que le reste est nul, alors la valeur renvoyée est un entier dont les 16 bits de poids le plus fort sont constitués des 16 bits de poids le plus fort de arg1 et ses 16 bits de poids le plus faible des 16 bits de poids le plus faible d'arg2.
  \item Cette fonction renvoie la somme de ses deux arguments si arg1 est inférieur à 10 et arg2 supérieur à 15
  \item Elle renvoie la multiplication des deux arguments si arg1 est un multiple de 15 et est strictement positif.
  \item Si aucun de ces cas n'est appliqué, alors la valeur renvoyée est $-2$
\end{enumerate}
Vous devez renvoyer 0 si un dépassement d'entier (integer overflow) intervient pendant l'un de ces calculs.
La fonction ne doit avoir qu'une seule instruction return.

%Cas 1: 5 7 => -1
%Cas 2: 196608 1 => 3
%Cas 3: 5 2 => 120
%Cas 4: 65540 10 => 65546
%Cas 5: -30 16 => -14
%Cas 6: 90 4 => 360
%Cas 7: 89 4 => -2

\begin{verbatim}
int exercice(int arg1, int arg2) {
  int result;
  if((arg1 ^ arg2) == 2) {
    result = -1;
  }
  else if(arg2 == 1) {
    result = arg1 >> 16;
  }
  else if(arg2 == 2 && arg1 > 0) {
    result = 1;
    for(int i = 2 ; i <= arg1 ; i++) {
      result = safeMul(result, i);
      if(g_iComputeError) {
        result = 0;
        break;
      }      
    }
  }
  else if(arg1 % arg2 == 0) {
    result = (arg1 & ~((1 << 16) - 1)) + (arg2 & ((1 << 16) - 1));
  }
  else if(arg1 < 10 && arg2 > 15) {
    result = safeAdd(arg1, arg2);
    if(g_iComputeError) {
      result = 0;
    }
  }
  else if(arg1 % 15 == 0 && arg1 > 0) {
    result = safeMul(arg1, arg2);
    if(g_iComputeError) {
      result = 0;
    }
  }
  else {
    result = -2;
  }
  return result;
}
\end{verbatim}


\begin{acronym}
\acro{PGCD}{Plus Grand Commun Diviseur}
\end{acronym}
\end{document}