1
2
3
4
5
6
7
8
9
#include<stdio.h>
main()
{
int a[2][2][2] = { {10,2,3,4}, {5,6,7,8} };
int *p,*q;
p=&a[2][2][2];
*q=***a;
printf("%d----%d",*p,*q);
return 0;}

1
2
3
4
5
6
7
8
9
#include<stdio.h>
#include<string.h>
int arr[105][105];
int res[105][105];
 
char a[105];
char b[105];
char c[105];
char result[222];
 ...

1
2
3
4
5
6
7
8
9
#include<stdio.h>
#include<string.h>
int arr[105][105];
int res[105][105];
 
char a[105];
char b[105];
char c[105];
char result[222];
 ...

1
2
3
4
5
6
7
8
9
#include<stdio.h>
#include<string.h>
int arr[105][105];
int res[105][105];
 
char a[105];
char b[105];
char c[105];
char result[222];
 ...

1
2
3
4
5
6
7
8
#include<stdio.h>
#include<conio.h>
void main()
{
char c[]="gate2011";
char *p=c;
printf("%s",p+p[3]-p[1]);
}

1
2
3
4
5
6
7
8
9
#include<stdio.h>
int main()
{
        int c,k=0,i,j,temp=0;
        scanf("%d",&c);
        int a[c][2];
        while(k!=c)
        {
                scanf("%d%d",&a[k][0],&a[k][1]);
 ...

1
2
3
4
5
6
7
8
9
#include<stdio.h>
#include <conio.h>
int main()
{
        int c,k=0,i,j,temp=0;
        scanf("%d",&c);
        int a[c][2];
        while(k!=c)
        {
 ...

1
2
3
4
5
6
7
8
9
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define swap(A, B) do \
{ \
    char __swap_temp__[sizeof(A) == sizeof(B) ? (signed) sizeof(A) : -1]; \
    memcpy(__swap_temp__, &A, sizeof(A)); \
 ...

1
2
3
4
5
6
7
8
9
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define swap(A, B) do \
{ \
    char __swap_temp__[sizeof(A) == sizeof(B) ? (signed) sizeof(A) : -1]; \
    memcpy(__swap_temp__, &A, sizeof(A)); \
 ...

1
2
3
4
5
6
7
8
9
#include<stdio.h>
void main()
{
        long x;
        float t;
        scanf("%f",&t);
        printf("%d\n",t);
        x=90;
        printf("%f\n",x);
 ...

1
2
3
4
5
6
7
8
9
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define swap(A, B) do \
{ \
    char __swap_temp__[sizeof(A) == sizeof(B) ? (signed) sizeof(A) : -1]; \
    memcpy(__swap_temp__, &A, sizeof(A)); \
 ...

1
2
3
4
5
6
7
8
9
#include<stdio.h>
void main()
{
        long x;
        float t;
        scanf("%f",&t);
        printf("%d\n",t);
        x=90;
        printf("%f\n",x);
 ...

1
2
3
4
5
6
7
8
9
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define swap(A, B) do \
{ \
    char __swap_temp__[sizeof(A) == sizeof(B) ? (signed) sizeof(A) : -1]; \
    memcpy(__swap_temp__, &A, sizeof(A)); \
 ...

1
2
3
4
5
6
7
8
9
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define swap(A, B) do \
{ \
    char __swap_temp__[sizeof(A) == sizeof(B) ? (signed) sizeof(A) : -1]; \
    memcpy(__swap_temp__, &A, sizeof(A)); \
 ...

1
2
3
4
5
6
7
8
9
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define swap(A, B) do \
{ \
    char __swap_temp__[sizeof(A) == sizeof(B) ? (signed) sizeof(A) : -1]; \
    memcpy(__swap_temp__, &A, sizeof(A)); \
    memcpy(&A, &B, sizeof(A)); \
 ...

1
2
3
4
5
6
7
8
9
#include<stdio.h>
void main()
{
        long x;
        float t;
        scanf("%f",&t);
        printf("%d\n",t);
        x=90;
        printf("%f\n",x);
 ...

1
2
3
4
5
6
7
8
9
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define swap(A, B) do \
{ \
    char __swap_temp__[sizeof(A) == sizeof(B) ? (signed) sizeof(A) : -1]; \
    memcpy(__swap_temp__, &A, sizeof(A)); \
    memcpy(&A, &B, sizeof(A)); \
 ...

1
2
3
4
5
6
7
8
9
#include <stdio.h>
 
int main()
{
        int x=10;
 
        switch(x)
        {       
                case 1:
 ...

1
2
3
4
5
6
7
8
9
#include<stdio.h>
void main()
{
        long x;
        float t;
        scanf("%f",&t);
        printf("%d\n",t);
        x=90;
        printf("%f\n",x);
 ...

1
2
3
4
5
6
7
8
9
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define swap(A, B) do \
{ \
    char __swap_temp__[sizeof(A) == sizeof(B) ? (signed) sizeof(A) : -1]; \
    memcpy(__swap_temp__, &A, sizeof(A)); \
    memcpy(&A, &B, sizeof(A)); \
 ...

1
2
3
4
5
6
7
8
/*Oscar Lupiañez*/
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
//variable global
float pi= 3.141592;
 ...

1
2
3
4
5
6
7
8
/*Oscar Lupiañez*/
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
//variable global
float pi= 3.141592;
 ...

1
2
3
4
5
6
7
8
9
#include<stdio.h>
void main()
{
        long x;
        float t;
        scanf("%f",&t);
        printf("%d\n",t);
        x=90;
        printf("%f\n",x);
 ...

1
2
3
4
5
6
7
8
/*Oscar Lupiañez*/
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
//variable global
float pi= 3.141592;
 ...

1
2
3
4
5
6
7
8
9
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define swap(A, B) do \
{ \
    char __swap_temp__[sizeof(A) == sizeof(B) ? (signed) sizeof(A) : -1]; \
    memcpy(__swap_temp__, &A, sizeof(A)); \
    memcpy(&A, &B, sizeof(A)); \
 ...

1
2
3
4
5
6
7
8
9
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define swap(A, B) do \
{ \
    char __swap_temp__[sizeof(A) == sizeof(B) ? (signed) sizeof(A) : -1]; \
    memcpy(__swap_temp__, &A, sizeof(A)); \
    memcpy(&A, &B, sizeof(A)); \
 ...

1
2
3
4
5
6
7
8
/*Oscar Lupiañez*/
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
//variable global
float pi= 3.141592;
 ...

1
2
3
4
5
6
7
8
9
#include<stdio.h>
void main()
{
        long x;
        float t;
        scanf("%f",&t);
        printf("%d\n",t);
        x=90;
        printf("%f\n",x);
 ...

1
2
3
4
5
6
7
8
9
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define swap(A, B) do \
{ \
    char __swap_temp__[sizeof(A) == sizeof(B) ? (signed) sizeof(A) : -1]; \
    memcpy(__swap_temp__, &A, sizeof(A)); \
    memcpy(&A, &B, sizeof(A)); \
 ...

1
2
3
4
5
6
7
8
9
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define swap(A, B) do \
{ \
    char __swap_temp__[sizeof(A) == sizeof(B) ? (signed) sizeof(A) : -1]; \
    memcpy(__swap_temp__, &A, sizeof(A)); \
    memcpy(&A, &B, sizeof(A)); \
 ...