Parmi les fragments de code Java suivants, quels sont ceux qui correspondent à des initialisations correctes de variables entières ?

int var=1;
int ma variable=2;

int var1=-12;
int var2=-var1;

int var=1.2;
int d=2;

Lequel des fragments de code Java ci-dessous permet de calculer la somme des \(n\) premiers entiers positifs ?

int n=...;  // >0 à initialiser correctement
int count=0;
int sum=0; // la somme
while(count <n) {
   sum=sum+count;
   count=count-1;
}
// la variable sum contient la somme des
// n premiers entiers positifs

int n=...;  // >0 à initialiser correctement
int count=0;
int sum=0; // la somme
while(count <n) {
   sum=sum+count;
   count=count+1;
}
// la variable sum contient la somme des
// n premiers entiers positifs

int n=...;  // à initialiser correctement
int sum=0; // la somme
while( sum=sum+n ) {
   n=n-1;
}
// la variable sum contient la somme des
// n premiers entiers positifs

Les boucles while sont utiles lorsque l'on doit répéter des opérations similaires à de multiples reprises. En arithmétique, la factorielle d'un entier positif (n) et supérieur à 1 est définie comme étant le produit de tous les entiers inférieurs ou égaux à n. La factorielle de n se note \(n!\). Ainsi \(4!=24\). Parmi les boucles while ci-dessous, laquelle permet de calculer correctement \(n!\) ?

long n=17;
long fact=1;  // factorielle
int count=1;  // compteur pour la boucle
while(count<=n) {
   count=count+1;
   fact=fact*count;
}

long n=17;
long fact=1;  // factorielle
int count=1;  // compteur pour la boucle
while(count>1) {
   fact=fact*count;
   count=count+1;
}

long n=17;
long fact=1;  // factorielle
int count=1;  // compteur pour la boucle
while(count<=n) {
   fact=fact*count;
   count=count+1;
}

Parmi les fragments de programmes Java ci-dessous, quels sont ceux qui respectent la syntaxe du langage ?

int i=0.9;
double d=3.2e-1;
char c='0';
boolean b=false;
long l=-1234;

int i=0;
double d=3.2e-1;
char c='9';
boolean b=true;
long l=-1;

int i=7;
double d=-2.34;
char c='z';
boolean b=0;
long l=-1;

Afin de faciliter la compréhension des programmes écrits dans un langage de programmation tel que Java, il est important de bien le documenter en utilisant des commentaires. Parmi les fragments de code Java ci-dessous, lequel est syntaxiquement correct ?

//
// Mon programme
//
//
 int count=7; /* compteur */
 int n=0;
 // test
 if(count>3) {
    n=count;
 }

/***********************
 * Mon programme
 *
 ***********************
 int count=7; // compteur
 int n=0;
 // test
 if(count>3) {
    n=count;
 }

/***********************
 * Mon programme
 *
 ***********************
 int count=7; / compteur
 int n=0;
 / / test
 if(count>3) {
    n=count;
 }

Un langage de programmation tel que Java utilise une syntaxe bien précise. Il est important que vous sachiez reconnaître rapidement des erreurs de syntaxe dans un programme Java pour éviter de les commettre vous-même. Les programmes ci-dessous ont été écrits par des étudiants pour afficher le message Hello, world! à l'écran. Chaque programme est stocké dans le fichier Hello.java. Un seul de ces programmes est acceptable par le compilateur Java. Lequel ?

public class Hello {

 public main (String[] args) {
   System.out.println("Hello, world!");
 }
}

public class Monprog {

 public static void main (String[] args) {
   System.out.println("Hello, world!");
 }
}

public class Hello {

 public static void main (String[] args) {
   System.out.println("Hello, world!");
 }
}

Dans un langage de programmation comme Java, il est souvent nécessaire d'échanger le contenu de deux variables. Considérons le programme ci-dessous dans lequel deux variables sont initialisées :

int a=1401;
int b=1101;

Parmi les fragments de Java ci-dessous, lequel permet de correctement échanger le contenu de la variable a avec le contenu de la variable b ?

int c; // variable d'échange
c=b;
a=c;
b=a;

int c; // variable d'échange
c=b;
b=a;
a=c;

b=a;

Considérons un programme Java qui manipule deux variables : a et b. Parmi les fragments de code ci-dessous, lequel place correctement dans la variable min le minimum entre les contenus de a et b ?

double a;
double b;
double min;

if(a>b)
{
  min=b;
}
else
{
  min=a;
}

  if(a<=b)
  {
    double min;
min=a;
  }
  else
  {
    double min;
    min=b;
  }

  if(a>b)
  {
min=a;
  }
  else
  {
    min=b;
  }

Si x est une variable de type double, lequel de ces fragments de code place dans la variable abs la valeur absolue de x?

double abs=x;
if( x<=0 ) {
  abs=-x;
}

double abs=x;
if( x>=0 ) {
  abs=x;
}

double abs;
if(x!=0) {
   abs=x;
}
else {
   abs=-x;
}

En mathématiques, on définit des intervalles, fermés, ouverts et semi-ouverts. L'intervalle semi-ouvert \([3,7[\) comprend l'ensemble des nombres réels qui sont supérieurs ou égaux à 3 et strictement inférieurs à 7. Sachant que a, b et x sont des variables de type double, lequel des fragments de code suivants affiche vrai sur sa sortie standard si et seulement si x appartient à l'intervalle \([a,b[\) ? On supposera pour cette question que la valeur stockée dans la variable a est strictement inférieure à celle stockée dans la variable b.

if(x>=a) {
  if(x<b) {
     System.out.println("vrai");
 }
}

if( (a>=x) && (x<b) ) {
  System.out.println("vrai");
}

if(x<=b) {
  if(x>=a) {
     System.out.println("vrai");
 }
}

Un seul des fragments de programmes ci-dessous affiche "ok" à l'écran ? Pouvez-vous trouver lequel ?

int i=2;
int j=3;
int k=i/j;
if(k==0) {
   System.out.println("ok");
}

double a=1;
double b=3;
double c=a/b;
if(c==0.0) {
   System.out.println("ok");
}

int i=8;
int j=7;
int k=i/j;
if(k==0) {
   System.out.println("ok");
}