Определить тип данных переменной из контекста ее описания

//------------------------------------------------------1

   char *f(void);

//------------------------------------------------------2

   int (*p[5])(void);

//------------------------------------------------------3

   void ( *(*p)(void) )(void);

//------------------------------------------------------4

  int (*f(void))();

//------------------------------------------------------5

  char **f(void);

//------------------------------------------------------6

  typedef char *PTR;

  PTR a[20];

//------------------------------------------------------7

   typedef void (*PTR)(void);

   PTR F(void);

//------------------------------------------------------8

   typedef void (*PTR)(void);

   PTR F[20];

//------------------------------------------------------9

   struct list {...};

   list *F(list *);

//------------------------------------------------------10

   void **p[20];

//------------------------------------------------------11

   char *(*pf)(char *);

//------------------------------------------------------12

   int F(char *,...);

//------------------------------------------------------13

   char **F(int);

//------------------------------------------------------14

  typedef char *PTR;

     PTR F(int);

Структуры и объединения.

Определить значения переменных после выполнения действий.

//---------------------------------------------------------

union x       // sizeof(int) = 2

  {       // sizeof(long)= 4

  char c[4];

  int n[2];

  unsigned char u[4];

  long l;

  }

UNI;

struct man

  {

  char name[20];

  int dd,mm,yy;

  char *zodiak;

  }

A= { "Иванов",1,10,1969,"Весы" }, B[10], *p;

//------------------------------------------------------- 1

void F1() {

char c; int i;

for (i=0; i<10; i++)

  B[i].zodiak = "abcdefghij" + i;

c = B[1].zodiak[2]; }

//------------------------------------------------------- 2

void F2() {

char c; int i,j;

for (i=0; i<10; i++)

  {

  for (j=0; j<10; j++)

        B[i].name[j] = 'a' + i + j;

  B[i].name[j]='\0';

  }

c = B[1].zodiak[2]; }

//------------------------------------------------------ 3

void F3() {

int i,n;

for (i=0; i<10; i++)

  B[i].dd = i;

for (p=B, n=5; n!=0; n--, p++)

  n += p->dd; }

//------------------------------------------------------ 4

void F4() {

char c; int i;

for (i=0; i<10; i++)

  B[i].zodiak = A.zodiak + i % 4;

c = B[5].zodiak[2]; }

//------------------------------------------------------ 5

void F5() {

int i,n; char *p;

for (i=0; i<10; i++)

  B[i].zodiak = "abcdefghij" + i;

for (n=0, p=B[6].zodiak; *p !='\0'; p++, n++); }

//----------------------------------------------------- 6

void F6() {

long s; int i;

for (i=0; i<4; i++) UNI.c[i]='0'+i;

s = UNI.l; }

//----------------------------------------------------- 7

void F7() {

char z;

UNI.l = 0x00003130;

z = UNI.c[1]; }

//----------------------------------------------------- 8

void F8() {

long s; char z;

UNI.l = 0x0000FFFF;

z = UNI.c[1]; UNI.c[1]=UNI.c[2]; UNI.c[2]=z;

s = UNI.l; }

//----------------------------------------------------- 9

void F9() {

long s;

UNI.l = 0x0001FFFF;

UNI.n[0] >>=2;

s = UNI.l; }

//---------------------------------------------------- 10

void F10() {

long s;

UNI.l = 0x0001FFFF;

UNI.c[1] <<=2;

s = UNI.l; }

//---------------------------------------------------- 11

void F11() {

long s;

UNI.l = 0x0001FFFF;

UNI.u[1] >>=2;

s = UNI.l; }

//---------------------------------------------------- 12

void F12() {

long s; int i,m, cr;

UNI.l = 0x00010000;

for (i=0; i<4; i++) UNI.c[i] = ~UNI.c[i];

for (cr=1, i=0; i<4; i++)

  {

  m = UNI.c[i] + cr;

  UNI.c[i] = m;

  cr = (m & 0x100) !=0;

  }

s = UNI.l; }

Указатель на структуру

Определите значения переменных после выполнения действий.

//------------------------------------------------------- 1

struct man1

  {

  char name[20];

int dd,mm,yy;

  char *zodiak;

  struct man1 *next;

  }

  A1= {"Петров",1,10,1969,"Весы",NULL },

  B1= {"Сидоров",8,9,1958,"Дева",&A1 },

  *p1 = &B1;

void F1() {

char c1,c2,c3,c4;

c1 = A1.name[2]; c2 = B1.zodiak[3];

c3 = p1->name[3]; c4 = p1->next->zodiak[1];

}

//------------------------------------------------------- 2

struct man2

  {

  char name[20];

  char *zodiak;

  struct man2 *next;

  } C2[3] = {

        {"Петров","Весы",NULL },

        {"Сидоров","Дева",&C2[0] },

        {"Иванов","Козерог",&C2[1] }

        };

void F2() {

char c1,c2,c3,c4;

c1 = C2[0].name[2];c2 = C2[1].zodiak[3];

c3 = C2[2].next->name[3];

c4 = C2[2].next->next->zodiak[1];

}

//------------------------------------------------------- 3

struct tree3

  {

  int vv;

  struct tree3 *l,*r;

  }

  A3 = { 1,NULL,NULL },

  B3 = { 2,NULL,NULL },

  C3 = { 3, &A3, &B3 },

  D3 = { 4, &C3, NULL },

  *p3 = &D3;

void F3() {

int i1,i2,i3,i4;

i1 =A3.vv;     i2 = D3.l->vv;

i3 =p3->l->r->vv;i4 = p3->vv;

}

//------------------------------------------------------- 4

struct tree4

  {

  int vv;

  struct tree4 *l,*r;

  }

  F[4] =

  {{ 1,NULL,NULL },

   { 2,NULL,NULL },

   { 3, &F[0], &F[1] },

   { 4, &F[2], NULL }};

void F4() {

int i1,i2,i3,i4;

i1 = F[0].vv;  i2 = F[3].l->vv;

i3 = F[3].l->r->vv; i4 = F[2].r->vv;

}

//------------------------------------------------------- 5

struct list5

  {

  int vv;

  struct list5 *pred,*next;

  };

extern struct list5 C5,B5,A5;

struct list5 A5 = { 1, &C5, &B5 },

        B5 = { 2, &A5, &C5 },

        C5 = { 3, &B5, &A5 },

        *p5 = &A5;

void F5() {

int i1,i2,i3,i4;

i1 = A5.next->vv; i2 = p5->next->next->vv;

i3 = A5.pred->next->vv; i4 = p5->pred->pred->pred->vv;

}

//------------------------------------------------------ 6

char *p6[] = { "Иванов","Петров","Сидоров",NULL};

void F6() {

char c1,c2,c3,c4;

c1 = *p6[0];   c2 = *(p6[1]+2);

c3 = p6[2][3];        c4 = (*(p6+2))[1];

}

//------------------------------------------------------ 7

struct dat7

  {

  int dd,mm,yy;

  }

  aa = { 17,7,1977 },

  bb = { 22,7,1982 };

struct man7

  {

  char name[20];

  struct dat7 *pd;

  struct dat7 dd;

  char *zodiak;

  }

  A7= {"Петров", &aa, { 1,10,1969 }, "Весы" },

  B7= {"Сидоров", &bb, { 8,9,1958 }, "Дева" },

  *p7 = &B7;

void F7() {

int i1,i2,i3,i4;

i1 = A7.dd.mm;        i2 = A7.pd->yy;

i3 = p7->dd.dd;       i4 = p7->pd->yy;

}

//------------------------------------------------------ 8

struct dat8

  {

  int dd,mm,yy;

  };

struct man8

  {

  char name[20];

  struct dat8 dd[3];

  }

  A8[2] = {

  {"Петров", {{1,10,1969},{8,8,1988},{3,2,1978}}},

  {"Иванов",{{8,12,1958},{12,3,1976},{3,12,1967}}}

  };

void F8() {

int i1,i2,i3,i4;

i1 = A8[0].dd[0].mm;  i2 = A8[1].dd[2].dd;

}

5 Функции в С++

Определить ошибки при объявлении, определении или вызове функций.

// Объявления ----------------------------------------1

(a) set( int *, int );

(b) void func();

(c) string error( int );

(d) arr[10] sum( int *, int );

(e) void print( int arr[][], int size );

(f) int ff( int a, int b = 0, int с = 0 );

(g) void operate ( int *matrix[] );

(h) char *screenlnit( int height = 24, int width,char background );

(i) void putValues( int (&ia)[] );

// Вызовы---------------------------------------------2

doublecalc( double ) ;

int count( const string &, char ) ;

void sum( vector<int>&, int ) ;

vector<int>vec( 10 );

(a)    саlс( 23.4,55.1);

(b) count( "abcda", 'a' ) ;

(c) sum( vec, 43.8 );

(d) calc( 66 ) ;

// Повторныеобъявления----------------------------------4

(a)

char *screenlnit( int height, int width,char background = ' ' );

char *screenlnit( int height = 24, int width,char background );

(b)

void print( int (*arr)[6], int size );

void print( int (*arr)[5J, int size );

(c)

void manip( int *pi, int first, int end = 0 );

void manip( int *pi, int first = 0, int end = 0 )

// Ошибкиввызовах--------------------------------------5

void print( int arr[][5], int size );

void operate(int *matrix[7]);

char *screenlnit( int height = 24, int width = 80,char background = ' ');

(a) screenlnit();

(b) int *matrix[5];

operate( matrix );

(c) int arr[5][5]; print( arr, 5 );

Обработка массивов

Содержательно сформулировать результат выполнения функции, примерно в таком виде: "Функция находит в массиве минимальный элемент и возвращает в качестве результата его индекс". Для этого необходимо формальную запись алгоритма перевести в словесное описание, а затем попытаться сформулировать результат. Если это не получается, то же самое можно попытаться проделать по шагам, либо по нисходящей, либо по восходящей цепочке конструкций языка: перевести конструкцию в словесное описание, сформулировать результат или алгоритм ее выполнения, затем то же самое сделать с учетом вложенной или объемлющей конструкции. То есть использовать ту же технологию структурного проектирования с точностью до наоборот.

//------------------------------------------------ 1

int F1(int c[], int n)

{ int s,i;

for (s=0, i=0; i<n; i++) s +=c[i]; return s; }

//------------------------------------------------ 2

int F2(int c[], int n)

{ int m,i,k;

for (m=c[0],i=1,k=0; i<n; i++)

  if (c[i] > m) { m=c[i]; k=i;}

return k; }

//------------------------------------------------ 3

int F3(int c[], int n)

{ int i,j;

for (i=0; i<n-1; i++)

for (j=i+1; j<n; j++)

  if (c[i]==c[j]) return i;

return -1; }

//------------------------------------------------ 4

int F4(int n)

{ int k,m;

for (k=0, m=1; m <= n; k++, m = m * 2);

return k-1; }

//------------------------------------------------ 5

void F5(int c[], int n)

{ int i,j,k;

for (i=0,j=n-1; i < j; i++,j--)

  { k = c[i]; c[i] = c[j]; c[j] = k; }

}

//------------------------------------------------ 6

int F6(int c[], int n)

{ int i,j,k1,k2;

for (i=0; i<n; i++)

  {

  for (j=k1=k2=0; j<n; j++)

        if (c[i] != c[j])

      { if (c[i] < c[j]) k1++; else k2++; }

  if (k1 == k2) return i;

  }

return -1; }

//------------------------------------------------ 7

int F7(int c[], int n)

{ int i,j,m,s;

for (s=0, i=0; i < n-1; i++)

  {

  for (j=i+1, m=0; j<n; j++)

        if (c[i]==c[j]) m++;

  if (m > s) s = m;

  }

return s; }

//------------------------------------------------ 8

int F8(int c[], int n)

{ int i,j,k,m;

for (i=k=m=0; i < n-1; i++)

if (c[i] < c[i+1])

k++;

else

    {

    if (k > m) m=k;

    k=0;

    }

return m; }

//------------------------------------------------ 9

int F9(int n)

{ int i,k, c[6];

for (i=0; n !=0; i++, n /=10) c[i]=n % 10;

for( k=0; k < i; k++) n = n *10 + c[k];

return n; }

//------------------------------------------------ 10

int F10(int n)

{ int m,k;

for (m=0; n!=0; n /=10)

  if ((k = n % 10) > m) m = k;

return m; }

Степенные ряды

//-----------------------------------------------1

double sum(double x,double eps)

{

double s,sn; int n;

for (s=0, sn = 1, n=1; fabs(sn) > eps; n++)

  { s += sn;

  sn= - sn * x / n;

  }

return s; }

//-----------------------------------------------2

for (s=0, sn = x, n=1; fabs(sn) > eps; n++)

  { s += sn;

  sn= - sn * x / n;

  }

//-----------------------------------------------3

for (s=0, sn = x; n=1; fabs(sn) > eps; n+=2)

  { s += sn;

  sn= sn * x * x / (n*(n+1));

  }

//-----------------------------------------------4

for (s=0, sn = x, n=1; fabs(sn) > eps; n+=2)

  { s += sn;

  sn= sn * x / (n*(n+1));

  }

//-----------------------------------------------5

for (s=0, sn = x, n=1; fabs(sn) > eps; n++)

  { s += sn;

  sn= sn * x * (2*n) / (2*n-1);

  }

//-----------------------------------------------6

for (s=0, sn = x, n=1; fabs(sn) > eps; n+=2)

  { s += sn;

  sn= sn * x *x * n / (n+1);

  }

//-----------------------------------------------7

for (s=0, sn = x, n=1; fabs(sn) > eps; n++)

  { s += sn;

  sn= sn * x * x * (2*n-1) / (2*n+1);

  }

//-----------------------------------------------8

for (s=0, sn = x, n=2; fabs(sn) > eps; n+=2)

  { s += sn;

  sn= sn * x *x * (n-1) / (n+1);

  }

//-----------------------------------------------9

for (s=0, sn = 1, n=1; fabs(sn) > eps; n++)

  { s += sn;

  int nn = 2*n-2; if (nn==0) nn=1;

  sn= sn * x * x * nn / (2*n);

  }

//-----------------------------------------------10

for (s=0, sn = 1, n=1; fabs(sn) > eps; n+=2)

  { s += sn;

  int nn = n-1; if (nn==0) nn=1;

  sn= sn * x *x * nn / (n+1);

  }

Строки, символы и тексты

//------------------------------------------------- 2

void F1(c1[],c2[])

{

int i,j;

for (j=0,i=0;c1[i]!=0;i++)   // Посимвольный просмотр строки

  {if (c1[i]!=' ')        // Текущий символ – не пробел

        {

        if (i!=0 && c1[i-1]==' ') // Первый в слове -

               c2[j++]=' ';       // добавить пробел

        c2[j++]=c1[i];       // Перенести символ слова

        }                            // в выходную строку

  }

c2[j]=0;

}

//------------------------------------------------- 2

void F2(char c[])

{ int i,j;

for (i=0; c[i] !='\0'; i++);

for (j=0,i--; i>j; i--,j++)

  { char s; s=c[i]; c[i]=c[j]; c[j]=s; }

}

//------------------------------------------------- 3

int F3(char s)

{ if (s >='0' && s <='9') return(s - '0');

else return(-1); }

}

//------------------------------------------------- 4

int F4(char c[])

{ int i,old,nw;

for (i=0, old=0, nw=0; c[i] !='\0'; i++)

  {

  if (c[i]==' ') old = 0;

  else { if (old==0) nw++; old=1; }

  }

return nw; }

//------------------------------------------------- 5

void F5(char c[])

{ int i,j;

for (i=0, j=0; c[i] !='\0'; i++)

if (c[i] !=' ') c[j++] = c[i];

c[j] = '\0';

}

//------------------------------------------------- 6

void F6(char c[], int nn)

{ int k,mm;

for (mm=nn, k=1; mm !=0; mm /=10,k++);

for (c[k--]='\0'; k>=0; k--)

{ c[k]= nn % 10 + '0'; nn /=10; }

}

//------------------------------------------------- 7

int F7(char c[])

{ int i,s;

for (i=0; c[i] !='\0'; i++)

if (c[i] >='0' && c[i]<='7') break;

for (s=0; c[i] >='0' && c[i] <='7'; i++)

s = s * 8 + c[i] - '0';

return s; }

//------------------------------------------------- 8

int F8(char c[])

{ int n,k,ns;

for (n=0,ns=0; c[n] !='\0'; n++)

{

for (k=0; n-k !=0 && c[n+k] !='\0'; k++)

    if (c[n-k] != c[n+k]) break;

  if (k >=3) ns++;

  }

 return ns; }

//------------------------------------------------- 9

int F9(char c1[],char c2[])

{int i,j;

for (i=0; c1[i] !='\0'; i++)

{

  for (j=0; c2[j] !='\0'; j++)

        if (c1[i+j] != c2[j]) break;

  if (c2[j] =='\0') return i;

  }

return -1;}

//------------------------------------------------ 10

char F10(char c[])

{ char m,z; int n,s,i;

for (s=0,m='A'; m <='Z'; m++)

{

for (n=0, i=0; c[i] !='\0'; i++)

        if (c[i]==m) n++;

  if (n > s) { z=m; s=n; }

  }

return z; }

//------------------------------------------------ 11

void F11(char c[], double x)

{ int i;

for (c[0]='.',i=1; i<6; i++)

  {

  x *= 10.; c[i]=(int)x + '0'; x -= (int)x;

  }

c[i]='\0'; }

//------------------------------------------------ 12

int F12(char c[])

{

for (int i=0; c[i]!=0; i++)

  {

  if (c[i]==' ') continue;

  for (int j=i+1; c[j]==c[i]; j++);

  for (; c[j]!=0; j++)

        {

        for (int k=0; i+k<j && c[i+k]==c[j+k]; k++);

        if (k>=4)returni;

        }

  }

}

Биты, байты и слова

В первой половине заданий необходимо определить значения переменных после выполнения поразрядных операций.Учтите, что заданные маски соответствуют восьмеричным или шестнадцатеричным цифрам.

//--------------------------------------------------

int i,j; long l; char c; double d;

// Примечание: - sizeof(int) равен 2

//        - sizeof(long) равен 4

//    "~" - операция побитовой инверсии

//------------------------------------------------ 1

i = 0x5678;

l = (i & ~0x00F0) | 0x0010;

c = (l >> 4) & 0xF + '0';

j = (i & 0xFF0F) | (~i & 0x00F0);

//------------------------------------------------ 2

i = 1; j = 2; c = 3;

l = (j > i) + (j==c) << 1 + (i !=c) << 2;

//------------------------------------------------ 3

for (l=1,i=0; l >0; l<<=1, i++);

//------------------------------------------------ 4

for (l=1,i=0; l !=0; l<<=1, i++);

//------------------------------------------------ 5

i = 1; j = 3; c = 2;

l = i + (j << 4) + (c << 8 );

c = i << 8;j = j << j;

//------------------------------------------------ 6

int F6(long n)

{ int i,s;

for (i=0,s=0; i < sizeof(long) * 8; i++)

  { if (n & 1) s++; n >>=1; }

returns; }

//------------------------------------------------ 7

long F7(long n)

{ int i; long s;

for (i=s=0; i < sizeof(long) * 8; i++)

  { s <<=1; s |= n & 1; n >>=1; }

return s; }

//------------------------------------------------ 8

long F8(long n, int m1, int m2)

{ long s,x; int i;

for (i=0,x=1,s=n; i < sizeof(long)*8; i++)

  { if (i >=m1 && i <=m2) s |= x; x <<=1; }

return s; }

//------------------------------------------------ 9

int F9(char c[])

{ int i,s;

for (i=0; c[i] !='\0'; i++)

  if (c[i] >='0' && c[i] <='7') break;

for (s=0; c[i] >='0' && c[i] <='7'; i++)

  { s <<=3; s |= c[i] & 0x7; }

return s; }

//------------------------------------------------ 10

void F10(char c[],long n)

{ int i;

i=sizeof(long)*8/3 +1;

for (c[i--]='\0'; i>=0; i--)

  { c[i] = (n & 0x7) + '0'; n >>=3; }

}

//------------------------------------------------ 11

// Операция "^" - ИСКЛЮЧАЮЩЕЕ ИЛИ

int F11(long n)

{ int i,m,k;

for (i=m=k=0; i < sizeof(long) * 8; i++, n >>= 1)

if ((n & 1) ^ m)

  { k++; m =!m; }

return k; }

Рекурсивный вызов функции

//------------------------------------------------------1

long F(int n)

{if (n==1) return (1);

return (n * F(n-1));}

//------------------------------------------------------2

struct xxx { int val; xxx *next; };

void F( xxx **p, int v)

{ xxx *q;

if (*p !=NULL)

   F( &((*p)->next) ,v );

else

   { q = malloc(sizeof( xxx));

   q->val = v; q->next = NULL; *p = q;

   }

}

//------------------------------------------------------3

double F(double *pk, double x, int n)

{

if (n==0) return(*pk);

return( *pk + x *F(pk+1,x,n-1));

}

void z3()

{

double B[] ={ 5.,0.7,4.,3. } ,X=1., Y; // Примервызова

Y = F(B,X,4); }

//------------------------------------------------------4

void sort(int in[], int a, int b)

{ int i,j,mode;

if (a==b) return;

for (i=a, j=b, mode=1; i != j; mode >0 ? i++ : j--)

if (in[i] > in[j])

   { int c;

   c = in[i]; in[i] = in[j]; in[j]=c; mode = -mode;

   }

sort(in,a,i-1); sort(in,i+1,b);

}

//------------------------------------------------------5

char *F(char *p, char *s)

{

if ( *s =='\0') return p;

*p++ = *s; p=F(p, s+1);*p++ = *s;

return p;

}

void z6()

{ char *q, S[80];

F(S, "abcd");  // Пример вызова

}

//------------------------------------------------------6

void F(char **p, char *s)

{

if ( *s =='\0') return;

*(*p)++ = *s;

F(p, s+1);

*(*p)++ = *s;

}

void z7()

{char *q, S[80];

q = S; F(&q,"abcd");  // Примервызова

}

//------------------------------------------------------7

struct xxx { int val; xxx *next; };

int F( xxx *p)

{ int zzz;

if (p ==NULL) return 0;

zzz = F(p->next));

if (zzz > p->val) return zzz;

return p->val;

}

//------------------------------------------------------8

struct xxx { int val; xxx *p[10]; };

int F( xxx *p)

{ int zzz,i, rrr;

if (p==NULL) return 0;

for (i=0, zzz = p->val; i<20; i++)

   if ((rrr=F(p->p[i])) > zzz) zzz = rrr;

return zzz;

}

//------------------------------------------------------9

struct xxx { int val; xxx *p[10]; };

int F( xxx *p)

{ int zzz,i, rrr;

if (p==NULL) return 0;

for (i=0, zzz = 0; i<20; i++)

   if ((rrr=F(p->p[i])) > zzz) zzz = rrr;

return zzz+1;

}

//------------------------------------------------------10

void F(int p[], int nn)

{ int i;

if (nn==1) { p[0]=0; return; }

for (i=2; nn % i !=0; i++);

p[0]=i;

F(p+1,nn / i);

}

Указатели и ссылки

Обработка указателей

//------------------------------------------------------- 1

void F1(int *p1, int *p2)

{

int c;

c = *p1; *p1 = *p2; *p2 = c;}

//------------------------------------------------------- 2

void F2(int *p, int *q, int n)

{

for (*q = *p++; n > 0; n--, p++)

if (*p > *q) *q = *p;

}

//------------------------------------------------------- 3

int *F3(int *p, int n)

{

int *q;

for (q = p; n > 0; n--, p++)

    if (*p > *q) q = p;

return q;

}

//--- Указатели на строки (char*) ----------------------- 4

void F4(char *p)

{

char *q;

for (q=p; *q !='\0'; q++);

for (q--; p < q; p++, q--)

    { char c; c = *p; *p = *q; *q = c; }

}

//------------------------------------------------------- 5

int F5(char *p)

{

int n;

for (n=0; *p !='\0'; p++, n++);

return n;

}

//------------------------------------------------------- 6

char *F6(char *p,char *q)

{

char *s1,*s2;

for (; *p!='\0'; p++)

    {

    for (s1=p, s2=q; *s2!='\0' && *s1==*s2; s1++,s2++);

    if (*s2 == '\0') return p;

    }

return NULL;

}

//------------------------------------------------------- 7

void F7(char *p, char *q)

{

for (; *p !='\0'; p++);

for (; *q !='\0'; *p++ = *q++);

*q = '\0';

}

//------------------------------------------------------- 8

int F8(char *p)

{

int n;

if (*p=='\0') return (0);

if (*p !=' ') n=1; else n=0;

for (p++; *p !='\0'; p++)

    if (p[0] !=' ' && p[-1]==' ') n++;

return n;

}

//------------------------------------------------------- 9

void F9(char *p)

{ char *q; int n;

for (n=0, q=p; *p !='\0'; p++)

  {if (*p !=' ')

        { n=0; *q++ = *p; }

  else

        { n++; if (n==1) *q++ = *p; }

  }

}

//------------------------------------------------------ 10

void F10(char *p)

{ char *q; int cm;

for (q=p,cm=0; *p !='\0'; p++)

  {

  if (p[0]=='*' && p[1]=='/') { cm--, p++; continue; }

  if (p[0]=='/' && p[1]=='*') { cm++, p++; continue; }

  if (cm==0) *q++ = *p;

  }

*q=0;

}