1
2
3
4
5
6
7
8
9
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define TRUE 1
#define FALSE 0
 
int check_vowel(char);
 
int main()
 ...

1
2
3
4
5
6
7
8
9
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define TRUE 1
#define FALSE 0
 
int check_vowel(char);
 
int main()
 ...

1
2
3
4
5
6
7
8
9
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define TRUE 1
#define FALSE 0
 
int check_vowel(char);
 
main()
 ...

1
2
3
4
5
6
7
8
9
#include<stdio.h>
int main()
{
 
  long long int i=0,n;
    while(1)
    {n=i;
        if(n%7==3)
        {
 ...

1
2
3
4
5
6
7
8
9
#include<stdio.h>
int main()
{
 
  long long int i=0,n;
    while(1)
    {n=i;
        if(n%7==3)
        {
 ...

1
2
3
4
5
6
7
8
9
#include<stdio.h>
int main()
{
 
  long long int i=0,j,n;
    while(1)
    {n=i;
        if(n%7==3)
        {
 ...

1
2
3
4
5
6
7
8
9
#include "stdio.h"
 
void triplePointeur(int *pointeurSurNombre);
 
int main(int argc, char *argv[])
{
    int nombre = 5;
 
    triplePointeur(&nombre); // On envoie l'adresse de nombre à la fonction
 ...

1
2
3
4
5
6
7
8
9
void triplePointeur(int *pointeurSurNombre);
 
int main(int argc, char *argv[])
{
    int nombre = 5;
 
    triplePointeur(&nombre); // On envoie l'adresse de nombre à la fonction
    printf("%d", nombre); // On affiche la variable nombre. La fonction a directement modifié la valeur de la variable car elle connaissait son adresse
 
 ...

1
2
3
4
5
6
7
8
9
#include <stdio.h>
#include <stdlib.h>
 
 
char *stringIP(unsigned int IP);
unsigned int intIP(char *string);
 
 
int main(void) {
 ...

1
2
3
4
5
6
#include <stdio.h>
 
int main( void ) {
printf( "%d remainder %d\n", -5 / 3, -5 % 3 );
return 0;
}

1
2
3
4
5
6
#include <stdio.h>
 
int main( void ) {
printf( "%g\n", 0x1.AB2Cp12 );
return 0;
}

1
2
3
4
5
6
#include <stdio.h>
 
int main( void ) {
printf( "%g\n", 0x1.AB2Fp12 );
return 0;
}

1
2
3
4
5
6
#include <stdio.h>
 
int main( void ) {
printf( "%g\n", 0x1.AB2Fp15 );
return 0;
}

1
2
3
4
5
6
#include <stdio.h>
 
int main( void ) {
printf( "%g\n", 0x1.AB2Fp16 );
return 0;
}

1
2
3
4
5
6
#include <stdio.h>
 
int main( void ) {
printf( "%g\n", 0x1.AB2Fp12 );
return 0;
}

1
2
3
4
5
6
#include <stdio.h>
 
int main( void ) {
printf( "%g\n", 0x3.3333333333334p-5 );
return 0;
}

1
2
3
4
5
6
7
8
9
#include<iostream>
#include<string>
using namespace std;
/*    y=m*x+c;    */
 
int main()
{
int x,y,m,c;
cout<<"Enter value of X-coordinate  ";
 ...

1
2
3
4
5
6
7
8
9
 
#include<stdio.h>
#include<stdlib.h>
 
struct link
{
int coeff,pow_x,pow_y,pow_z;
struct link *next;
};
 ...

1
2
3
4
5
6
#include <stdio.h>
 
int main( void ) {
printf( "%g\n", 0xA.Fp12 );
return 0;
}

1
2
3
4
5
6
#include <stdio.h>
 
int main( void ) {
printf( "%g\n", 0xA.Fp12 );
return 0;
}

1
2
3
4
5
6
#include <stdio.h>
 
int main( void ) {
printf( "%g\n", 0xA.Fp1A );
return 0;
}

1
2
3
4
5
6
#include <stdio.h>
 
int main( void ) {
printf( "%g\n", 0xA.FpA );
return 0;
}

1
2
3
4
5
6
7
8
9
#include <stdio.h>
#include <sys/time.h>
#include <sys/resource.h>
 
int main (void)
{
  struct rlimit limit;
 
  getrlimit (RLIMIT_STACK, &limit);
 ...

1
2
3
4
5
6
7
8
9
#include <stdio.h>
#include <sys/time.h>
#include <sys/resource.h>
 
int main (void)
{
  struct rlimit limit;
 
  getrlimit (RLIMIT_STACK, &limit);
 ...

1
2
3
4
5
6
7
8
9
#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
    printf("Available stack size is %d bytes\n", stackavail());
 
    return 0;
}

1
2
3
4
5
6
7
8
9
#include <stdio.h>
 
void foo( void )
{
        unsigned char a, b, c;
 
        a = 10;
        b = 20;
        c = 30;
 ...

1
2
3
4
5
6
7
8
9
#include<stdio.h>
#include<malloc.h>
 
struct node
{
  int data;
  struct node* left;
  struct node* right;
  struct node* next;
 ...

1
2
3
4
5
6
7
8
9
#include<stdio.h>
#include<malloc.h>
 
struct node
{
  int data;
  struct node* left;
  struct node* right;
  struct node* next;
 ...

1
2
3
4
5
6
7
8
9
#include<stdio.h>
#include<malloc.h>
 
struct node
{
  int data;
  struct node* left;
  struct node* right;
  struct node* next;
 ...

1
2
3
4
5
6
7
8
9
#include<stdio.h>
#include<malloc.h>
 
struct node
{
  int data;
  struct node* left;
  struct node* right;
  struct node* next;
 ...