Ca03exerc1 Enonce Java XXX 1

Impôt sur le revenu [ca03] - Exercice
Karine Zampieri, Stéphane Rivière
Unisciel algoprog Version 21 mai 2018
Table des matières

1 Impôt sur le revenu / pgimpotrv 2
1.1 Calcul de l’impôt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Saisie du statut familial . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 Calcul du nombre de parts . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.4 Affichage de la fiche d’imposition . . . . . . . . . . . . . . . . . . . . . . 8
1.5 Est-il avantageux de se marier ? . . . . . . . . . . . . . . . . . . . . . . . 10
1.6 Facultatif : Calcul détaillé de l’impôt . . . . . . . . . . . . . . . . . . . . 12
2 Références générales 16
Java - Impôt sur le revenu (Solution)

Mots-Clés Calculs
Requis Structures de base, Structures conditionnelles, Algorithmes paramétrés
Difficulté • • ◦ (2 h)
Objectif
Cet exercice calcule l’impôt sur le revenu.
1
Unisciel algoprog – Impôt sur le revenu [ca03] 2
1 Impôt sur le revenu / pgimpotrv
1.1 Calcul de l’impôt
Barème de calcul (2016-2017)

L’impôt sur le revenu se calcule en fonction du revenu par part.
Rpart = R / QF Montant de l’impôt brut

(R=revenu imposable, QF=quotient familial) (en euros)
N’excédant pas 9 710 euros 0
de 9 710 à 26 818 euros R × 0.14 − 1359.40 × QF
de 26 818 à 71 898 euros R × 0.30 − 5650.28 × QF
de 71 898 à 152 260 euros R × 0.41 − 13559.06 × QF
au-delà de 152 260 euros R × 0.45 − 19949.46 × QF
Exemple
Soient un revenu imposable de 30000 et un quotient familial de 1.5.
Alors le revenu par part vaut 30000/1.5 = 20000 ce qui correspond à la fourchette : « de
9 710 à 26 818 euros » (2è formule).
Écrivez une fonction imposition1(rv,qf,taux,coef) qui, pour un revenu annuel rv (réel), un

quotient familial qf (réel), un taux d’imposition taux (réel) et un coefficient coef (réel),
calcule et renvoie la valeur de l’expression rv*taux-coef*qf.
Déduisez une fonction impotRevenu(rv,qf) qui calcule et renvoie l’impôt correspondant

au revenu imposable rv (réel) et au nombre de parts du quotient familial qf (réel). Ne
gardez pas les centimes dans le résultat final. Attention, les comparaisons s’effectuent
par rapport au revenu par part et non pas le revenu imposable.
Outil Java
L’opération bxc s’écrit Math.floor(x).
Solution simple
On déclare une variable rs pour le résultat et une variable rpart pour le revenu par part.
On utilise des structures Si en cascade ainsi que la fonction imposition1 avec les bons
paramètres.
Validez vos fonctions avec la solution.

Solution Java @[pgimpotrv.java]

/**
Imposition simple
@param[in] rv - revenu
@param[in] qf - quotient familial
@param[in] taux - taux
@param[in] coef - coefficient
@return l’imposition simple
*/
public static double imposition1(double rv, double qf, double taux, double coef)
{
return (rv * taux - coef * qf);
}
/**
Impot sur le revenu
@return l’impot sur le revenu
*/
public static double impotRevenu(double rv, double qf)

{
double rpart = rv / qf;
double rs = 0.0;
if (rpart < 9710)
{
rs = 0.0;
}
else if (rpart < 26818)
{
rs = imposition1(rv,qf,0.14,1359.40);
}
{
}
{
}
else
{
}
return Math.floor(rs);
}
Écrivez une procédure test_impotRevenu qui saisit le revenu imposable et le nombre de

parts du quotient familial de l’utilisateur. Affichez les invites :
Revenu global imposable (en euros)?
Nombre de part du coefficient familial?
Calculez et affichez l’impôt sur le revenu :

==> Votre impot est ... euros
Testez. Exemples d’exécution :

Revenu global imposable (en euros) ? 30000
Nombre de parts du coefficient familial? 1.5
==> Votre impot est 2160 euros
Revenu global imposable (en euros)? 19000

Nombre de parts du coefficient familial? 2
==> Votre impot est 0 euros
Validez votre procédure avec la solution.

/**
@test
*/
public static void test_impotRevenu()

{
Scanner input = new Scanner(System.in);
input.useLocale(Locale.US);
double revenu;
System.out.print("Revenu global imposable (en euros)? ");
revenu = input.nextDouble();
double qf;
System.out.print("Nombre de parts du coefficient familial? ");
qf = input.nextDouble();
System.out.println("==> Votre impot est " + impotRevenu(revenu,qf) + " euros");
}
1.2 Saisie du statut familial
Pour pouvoir calculer le quotient familial (QF), il faut connaı̂tre le nombre de personnes
à charge du contribuable ainsi que son statut familial. On représente ce statut par un
caractère :
• ’c’ pour Célibataire ne vivant pas en concubinage.
• ’u’ pour célibataire vivant en Union-libre ou Divorcé (avec enfants).
• ’m’ pour Marié.
Définissez les constantes CELIBATAIRE=’c’, CONCUBINAGE=’u’ et MARIE=’m’ correspondant aux

différentes valeurs du statut.
Déduisez une fonction saisirStatut() qui saisit et renvoie le statut familial du contri-
buable. Elle pose des questions auxquelles le contribuable répond par oui ou non. Voici
un exemple d’exécution :
Etes vous célibataire: caractere (o,n,O,N)? o
Vivez-vous en concubinage: caractere (o,n,O,N)? n
Solution simple
On déclare une variable rep pour saisir la réponse de l’utilisateur. On pose la question du
célibat et on élimine le cas simple (réponse ’n’), le statut étant alors ’m’ (marié). Donc
dans la clause Sinon, on pose alors la question du concubinage et selon la réponse de
l’utilisateur, on met ’u’ (union-libre) ou ’c’ (célibataire) dans le statut que l’on retourne
finalement.
Validez vos définitions et votre fonction avec la solution.

/**
Constante de statut familial
*/
final static char CELIBATAIRE = ’c’;
/**
*/
final static char CONCUBINAGE = ’u’;
/**
*/
final static char MARIE = ’m’;
/**
Saisie du statut familial
@return le statut familial
*/
public static char saisirStatutFamilial()

{
char statut = ’.’;
char rep;
System.out.print("Etes vous celibataire (o/n)? ");
rep = input.next().charAt(0);
if (rep == ’n’ || rep == ’N’)
{
statut = MARIE;
}
else
{
System.out.print("Vivez-vous en concubinage (o/n)? ");
rep = input.next().charAt(0);
statut = (rep == ’o’ || rep == ’O’ ? CONCUBINAGE : CELIBATAIRE);
}
return statut;
}
1.3 Calcul du nombre de parts
Le quotient familial (QF) est le nombre de parts dont bénéficie le contribuable. Il est
fonction de sa situation de famille comme décrit ci-après :
Célibataire ne Célibataire vivant

vivant pas en en concubinage ou Couple marié
concubinage Divorcé (enfant)
Statut Familial ’c’ ’u’ ’m’
Sans personne à charge 1 part 1 part 2 parts
Avec 1 personne à charge 2 parts 1.5 part 2.5 parts
Avec 2 personnes à charge 2.5 parts 2 parts 3 parts
Chaque personne à charge suivante +1 part +1 part +1 part
Écrivez une fonction QFcalcul(npers,vinitiale,incr1pers)È qui calcule et renvoie le nombre

de parts du quotient familial d’un individu ayant npers (entier) personnes à charge, de
part initiale vinitiale (réel valant 1 ou 2) et d’incrément de part pour une personne
incr1pers (réel valant 0.5 ou 1).
Déduisez une fonction quotientFamilial(statut,npers) qui calcule et renvoie le nombre de

parts du quotient familial de la personne de statut familial statut (caractère) ayant npers
(entier) personnes à charge.

/**
Calcul du quotient familial
@param[in] npers - nombre de personnes a charge
@param[in] vinitiale - valeur initiale (1 ou 2)
@param[in] incr1pers - increment pour 1 personne (1 ou 0.5)
@return le quotient familial
*/
public static double QFcalcul(int npers, double vinitiale, double incr1pers)

{
double rs = vinitiale;
if (npers >= 1)
{
rs += incr1pers;
}
if (npers >= 2)
{
rs += 0.5 + (npers - 2);
}
return rs;
}
/**
Quotient familial
@param[in] statut - statut familial parmi une des constantes
@param[in] npers - nombre de personnes à charge >= 0
@return le quotient familial
*/
public static double quotientFamilial(char statut, int npers)

{
double rs = 0.0;
switch (statut)
{
case CELIBATAIRE:
rs = QFcalcul(npers,1.0,1.0);
break;
case CONCUBINAGE:
break;
case MARIE:
break;
}
return rs;
}
Écrivez alors une procédure test_quotientFamilial qui demande à l’utilisateur son statut
familial et le nombre de personnes à charge puis calcule et affiche le nombre de parts de
son quotient familial.

Etes vous célibataire (o/n)? o
Vivez-vous en concubinage (o/n)? o
Nombre de personnes à charge? 2

==> Vous avez 2 parts

Vivez-vous en concubinage (o/n)? n
==> Vous avez 2.5 parts
Etes vous célibataire (o/n)? n

==> Vous avez 4 parts

/**
@test
*/
public static void test_quotientFamilial()

{
char statut = saisirStatutFamilial();
int npers;
System.out.print("Nombre de personnes a charge? ");
npers = input.nextInt();
System.out.println("==> Vous avez " + quotientFamilial(statut,npers) + " parts");
}
1.4 Affichage de la fiche d’imposition
Écrivez une procédure afficherFicheImpot(rv,statut,npers) qui, à partir du revenu impo-

sable rv (réel), du statut familial statut (caractère) du contribuable et du nombre de
personnes à charge npers (entier), affiche la fiche récapitulative de l’impôt sous la forme
suivante :
==> Vous etes : ...
==> Nombre de personnes a charge : ...
==> Nombre de parts : ...
==> Revenu imposable : ... euros
==> Impot sur le revenu : ... euros

/**
Affichage d’une fiche d’impot
@param[in] statut - statut familial
@param[in] npers - nombre de personnes à charge
*/
public static void afficherFicheImpots(double rv, char statut, int npers)

{
System.out.print("==> Vous etes : ");
if (statut == CELIBATAIRE)
{
System.out.println("celibataire ne vivant pas en concubinage");
}
else if (statut == CONCUBINAGE)
{
System.out.println("celibataire vivant en concubinage");
}
else
{
System.out.println("marie");
}
System.out.println("==> Nombre de personnes a charge : " + npers);
// quotient familial
double qf = quotientFamilial(statut,npers);
System.out.println("==> Nombre de parts : " + qf);
System.out.println("==> Revenu imposable : " + rv + " euros");
System.out.println("==> Votre impot sur le revenu : " + impotRevenu(rv,qf) + " euros");
}
Écrivez alors une procédure test_impotFinal qui :

• Saisit le revenu imposable de l’utilisateur.
• Saisit son statut familial et le nombre de personnes à charge.
• Affiche la fiche récapitulative de son impôt.
Testez. Exemple d’exécution :

Vivez-vous en concubinage (o/n)? n
==> Vous etes : celibataire ne vivant pas en concubinage

==> Nombre de personnes a charge : 2
==> Nombre de parts : 2.5
==> Revenu imposable : 50210 euros
==> Impot sur le revenu : 3630 euros

/**
@test
*/
public static void test_impotFinal()

{
double revenu;
char statut = saisirStatutFamilial();
int npers;
npers = input.nextInt();
afficherFicheImpots(revenu,statut,npers);
}
1.5 Est-il avantageux de se marier ?
Un couple ne vivant pas en concubinage veut savoir s’il est avantageux de se marier.
Voici un exemple :
Revenu imposable de l’homme? 30000
Nombre de personnes à charge de l’homme? 2
Revenu imposable de la femme? 20000
Nombre de personnes à charge de la femme? 1
==> Impot séparés : 882 euros
==> Impot mariés : 1562 euros
==> Restez séparés
Écrivez une procédure test_mariage qui :

• Saisit le revenu imposable et le nombre de personnes à charge du (futur ?) mari.
• Saisit le revenu imposable et le nombre de personnes à charge de la (future ?) femme.
• Calcule l’impôt séparé pour chaque personne.
• Calcule l’impôt en tant que couple marié.
• Compare l’impôt en tant que couple marié avec la somme des impôts séparés.
• Affiche s’il est plus avantageux ou non d’être marié.

On pourra, à titre de comparaison, afficher chacune des fiches d’impôt : celle de l’homme,
celle de la femme et celle du couple.
Testez. Exemple d’exécution :

Revenu imposable de l’homme? 30000
Nombre de personnes à charge de l’homme? 2
Revenu imposable de la femme? 20000
Nombre de personnes à charge de la femme? 1
==> Impot séparés : 882 euros
==> Impot mariés : 1562 euros
==> Restez séparés
== Calculs détaillés ==
==> Nombre de parts : 2.5
==> Votre impot sur le revenu : 801 euros
==> Nombre de parts : 2
==> Vous etes : marié
==> Nombre de parts : 4

/**
@test
*/
public static void test_mariage()

{
double rvh;
System.out.print("Revenu global imposable (en euros) de l’homme? ");
rvh = input.nextDouble();
int npersh;
npersh = input.nextInt();
double rvf;
System.out.print("Revenu global imposable (en euros) de la femme? ");
rvf = input.nextDouble();
int npersf;
npersf = input.nextInt();
double qf1 = impotRevenu(rvh,quotientFamilial(CELIBATAIRE,npersh));
double qf2 = impotRevenu(rvf,quotientFamilial(CELIBATAIRE,npersf));
double isepares = qf1 + qf2;
double imaries = impotRevenu(rvh + rvf,quotientFamilial(MARIE,npersh + npersf));
System.out.println("==> Impot separes : " + isepares + " euros");
System.out.println("==> Impot maries : " + imaries + " euros");
if (isepares < imaries)
{
System.out.println("==> Restez separes");
}
else
{
System.out.println("==> Mariez-vous");
}
System.out.println("== Calculs detailles ==");
afficherFicheImpots(rvh,CELIBATAIRE,npersh);
afficherFicheImpots(rvf,CELIBATAIRE,npersf);
afficherFicheImpots(rvh + rvf,MARIE,npersh + npersf);
}
1.6 Facultatif : Calcul détaillé de l’impôt
En fait, le revenu imposable est soumis au barème progressif par tranches :

• On divise le revenu imposable par le nombre de parts du quotient familial.
• Ce revenu par part est imposé par tranches selon le barème suivant :
— jusqu’à 9 710 euros : 0%
— de 9 710 euros à 26 818 euros : 14.0%
— de 26 818 euros à 71 898 euros : 30.0%
— de 71 898 euros à 152 260 euros : 41.0%
— au delà de 152 260 euros : 45.0%
• Le montant ainsi obtenu est multiplié par le nombre de parts du quotient familial.
Exemple
Un couple marié sans enfants a 2 parts. S’il a un revenu imposable de 146060 euros, cela
donne un revenu par part de 146060/2 = 73030 euros.
Sur ce revenu imposable net de 73030 euros on paye :
• 0% sur la tranche inférieure à 9710 e

• 14.0% sur la tranche de revenu comprise entre 9710 e et 26818 e.
Soit 14% × (26818 − 9710) = 14% × 17108 = 2395.12
• 30% sur la tranche de revenu comprise entre 26818 e et 71898 e.
Soit 30% × (71898 − 26818) = 30% × 45080 = 13524
• 41% sur la tranche de revenu supérieure à 71898 e.
Soit 41% × (73030 − 71898) = 41% × 1132 = 464.12
Soit au total : 2395.12 + 13524.00 + 464.12 = 16384.24.
L’impôt de ce couple marié est donc 2 × 16384.24 qui arrondi donne 32766 e.
Écrivez une fonction imposition2(rv,binf,taux) qui, pour un revenu annuel rv (réel), une
borne inférieure binf (réel) et un taux d’imposition taux (réel), calcule et renvoie la valeur
de l’expression : (rv-binf)*taux.
Écrivez une fonction impotRevenu2(rv,qf) qui calcule et renvoie l’impôt sur le revenu cor-
respondant au revenu imposable rv (réel) et au nombre de parts du quotient familial qf
(réel) selon le calcul détaillé. Ne gardez pas les centimes dans le résultat final.

/**
Imposition détaillée
@param[in] binf - borne inférieure
@return l’imposition détaillée
*/
public static double imposition2(double rv, double binf, double taux)

{
return (rv - binf) * taux;
}
/**
Impot sur le revenu
*/
public static double impotRevenu2(double rv, double qf)

{
double rs = 0.0;
if (rpart > 9710)
{
if (rpart <= 26818)
{
rs += imposition2(rpart,9710,0.14);
}
else
{
rs += imposition2(26818,9710,0.14);
if (rpart <= 71898)
{
}
else
{
rs += imposition2(71898,26818,0.30);
if (rpart <= 152260)
{
}
else
{
rs += imposition2(152260,71898,0.41);
}
}
}
}
return Math.floor(rs * qf);
}
Solution Java : Autre solution @[pgimpotrv.java]

/**
Imposition détaillée (autre méthode)
@param[in] binf - borne inférieure
@param[in] bsup - borne supérieure
@return l’imposition détaillée
*/
public static double imposition3(double rv, double binf, double bsup, double taux)
{
double rs = 0.0;
if (rv < binf)
{
rs = 0.0;
}
else if (rv < bsup)
{
rs = (rv - binf) * taux;
}
else
{
rs = (bsup - binf) * taux;
}
return rs;
}
/**
Impot sur le revenu
@param[in] qf - quotient familial (uniqt 1)
*/
public static double impotRevenu3(double rv, double qf)

{
double rs = 0.0;
rs += imposition3(rpart,9710,26818,0.14);
return Math.floor(rs);
}
Solution commentée
La fonction impotRevenu3 utilise la fonction imposition3 permettant de réaliser une suite
d’alternatives Si. Elle effectue systématiquement les quatre tests. Son intérêt est sa lisi-
bilité et sa symétrie.
La fonction imposition3(rv,binf,bsup,taux) calcule et renvoie l’impôt de la tranche, étant
donnés un revenu annuel rv, la borne inférieure de la tranche binf, la borne supérieure
de la tranche bsup et le taux d’imposition taux de la tranche. Elle renvoie 0.0 si rv est
inférieur à binf.
Écrivez alors une procédure test_impotRevenu2 qui saisit le revenu imposable ainsi que le
nombre de parts du quotient familial, puis calcule et affiche l’impôt sur le revenu grâce
aux méthodes (méthode simple et méthode détaillée).

Nombre de parts du coefficient familial? 1
==> Impot (methode simple) : 4858 euros
==> Impot (calcul detaille) : 4858 euros

Nombre de parts du coefficient familial? 1.5
==> Impot (methode simple) : 5024 euros
==> Impot (calcul detaille) : 5024 euros

/**
@test
*/
public static void test_impotRevenu2()

{
double revenu;
double qf;
System.out.print("Nombre de parts du coefficient familial? ");
qf = input.nextDouble();
double impot1 = impotRevenu(revenu,qf);
double impot2 = impotRevenu2(revenu,qf);
System.out.println("==> Votre impot est (methode simple) : " + impot1 + " euros");
System.out.println("==> Votre impot est (calcul detaille) : " + impot2 + " euros");
if (impot1 != impot2)
{
System.out.println("==> OUPS, erreur dans les calculs 1 et 2");
}
double impot3 = impotRevenu3(revenu,qf);
System.out.println("==> Votre impot est (calcul detaille) : " + impot3 + " euros");
if (impot1 != impot3)
{
System.out.println("==> OUPS, erreur dans les calculs 1 et 3");
}
}
2 Références générales
Comprend [Routier-PG1]

Ca03exerc1 Enonce Java XXX 1

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Ca03exerc1 Enonce Java XXX 1

Transféré par

Droits d'auteur :

Formats disponibles

Impôt sur le revenu [ca03] - Exercice

Karine Zampieri, Stéphane Rivière

Unisciel algoprog Version 21 mai 2018

Table des matières

Java - Impôt sur le revenu (Solution)

1 Impôt sur le revenu / pgimpotrv

1.1 Calcul de l’impôt

Barème de calcul (2016-2017)

Rpart = R / QF Montant de l’impôt brut

Écrivez une fonction imposition1(rv,qf,taux,coef) qui, pour un revenu annuel rv (réel), un

Déduisez une fonction impotRevenu(rv,qf) qui calcule et renvoie l’impôt correspondant

Validez vos fonctions avec la solution.

Solution Java @[pgimpotrv.java]

public static double impotRevenu(double rv, double qf)

Écrivez une procédure test_impotRevenu qui saisit le revenu imposable et le nombre de

Calculez et affichez l’impôt sur le revenu :

Testez. Exemples d’exécution :

Revenu global imposable (en euros)? 19000

Validez votre procédure avec la solution.

Solution Java @[pgimpotrv.java]

public static void test_impotRevenu()

1.2 Saisie du statut familial

Définissez les constantes CELIBATAIRE=’c’, CONCUBINAGE=’u’ et MARIE=’m’ correspondant aux

Validez vos définitions et votre fonction avec la solution.

Solution Java @[pgimpotrv.java]

public static char saisirStatutFamilial()

1.3 Calcul du nombre de parts

Célibataire ne Célibataire vivant

Écrivez une fonction QFcalcul(npers,vinitiale,incr1pers)È qui calcule et renvoie le nombre

Déduisez une fonction quotientFamilial(statut,npers) qui calcule et renvoie le nombre de

Validez vos fonctions avec la solution.

Solution Java @[pgimpotrv.java]

public static double QFcalcul(int npers, double vinitiale, double incr1pers)

public static double quotientFamilial(char statut, int npers)

Testez. Exemples d’exécution :

Nombre de personnes à charge? 2

Etes vous célibataire (o/n)? o

Etes vous célibataire (o/n)? n

Validez votre procédure avec la solution.

Solution Java @[pgimpotrv.java]

public static void test_quotientFamilial()

1.4 Affichage de la fiche d’imposition

Écrivez une procédure afficherFicheImpot(rv,statut,npers) qui, à partir du revenu impo-

Validez votre procédure avec la solution.

Solution Java @[pgimpotrv.java]

public static void afficherFicheImpots(double rv, char statut, int npers)

Écrivez alors une procédure test_impotFinal qui :

Testez. Exemple d’exécution :

==> Vous etes : celibataire ne vivant pas en concubinage

Validez votre procédure avec la solution.

Solution Java @[pgimpotrv.java]

public static void test_impotFinal()

1.5 Est-il avantageux de se marier ?

Écrivez une procédure test_mariage qui :

• Affiche s’il est plus avantageux ou non d’être marié.

Testez. Exemple d’exécution :

Validez votre procédure avec la solution.

Solution Java @[pgimpotrv.java]

public static void test_mariage()

1.6 Facultatif : Calcul détaillé de l’impôt

En fait, le revenu imposable est soumis au barème progressif par tranches :

• 0% sur la tranche inférieure à 9710 e

Validez vos fonctions avec la solution.