struct Elem
{
    int rebro;
    struct Elem *next;
};

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main()
{
    int T[10];
    int k = sizeof(T)/sizeof(int);
    int first = -1, last;
    int i;

srand(time(NULL));

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

{
    T[i]=rand()%10-1;
}          

for(i = 0; i < k; ++i)
    {
        if(T[i] == 0)
        {
            first = i;
            break;
        }
    }                            
    if (first >=0)
      for(i = k-1; i >= first; --i)
      {
          if(T[i] == 0)
          {
             last = i;
             break;
          }
      }                            
      printf("Исходный массив:");
    for(i = 0; i < k; i++)
       printf(" %d", T[i]);
    printf("\nРезультат:\n");
    if (last == first)
    {
        printf("Нулевой элемент здесь один, и он на  %d месте\n\n", last);
    }
    else if (first != -1)
    {
        printf("Первый нулевой элемент на %d позиции.\n", first);
        printf("Последний нулевой элемент на %d позиции.\n\n", last);
    }
    else
        printf("Этом массив не содержит нулей!\n\n");

    return 0;

int main()
{
    int T[100][100];
    int k = sizeof(T)/sizeof(int);
    int first = -1, last;
    int i, m, n, j;

    printf("   Введите количество строк -->> ");
    scanf("%d",&m);
    printf("\n   Введите количество столбцов -->> ");
    scanf("%d",&n);

    
    int **T = new int *[m];
    for( int i =0; i < m; i++){
        T[i]= new int [n];
    }


srand (time( NULL ));

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

{
  for (j=0; j<n; j++)
  {
   T[i][j]=rand()%10-1;
  }
}          

for(i = 0; i < k; ++i)
    {
        if(T[i] == 0)
        {
            first = i;
            break;
        }
    }                            
    if (first >=0)
      for(i = k-1; i >= first; --i)
      {
          if(T[i][j] == 0)
          {
             last = i;
             break;
          }
      }                            
    printf("Исходный массив:");
    for(i = 0; i < k; i++)
       printf(" %.2d ", T[i][j]);
    printf("\n\nРезультат:\n");
    if (last == first)
    {
        printf("Ноль здесь один и находится на %d позиции!\n\n", last);
    }
    else if (first != -1)
    {
        printf("Первый нулевой элемент на %d позиции.\n", first);
        printf("Последний нулевой элемент на %d позиции.\n\n", last);
    }
    else
        printf("Этот массив не содержит нулей!\n\n");

    return 0;
}

#include <stdio.h>
#include <conio.h>

float average( int *_a, int _n )
{
    float sum=0; int i;
    for(i=0;i<_n;i++) sum += _a[i];
    return sum/_n;
}

float average( float *_a, int _n )
{
    float sum=0; int i;
    for(i=0;i<_n;i++) sum += _a[i];
    return sum/_n;
}

void main()
{
    int i, n, m, *S1; float *S2;
    // Заполняем массив целых чисел:
    printf( "Enter number of integer values: " );
    scanf( "%d", &n );
    S1 = new int[n];
    printf( "Enter every integer value that's supposed to be in an array: " );
    for(i=0;i<n;i++) scanf( "%d", S1+i );
    // Заполняем массив float'ов:
    printf( "Enter number of floating point values: " );
    scanf( "%d", &m );
    S2 = new float[m];
    printf( "Enter every floating point value that's supposed to be in an array: " );
    for(i=0;i<m;i++) scanf( "%f", S2+i );
    // Вызываем перегруженные функции:
    printf( "Average among integers: %f\n", average(S1,n) );
    printf( "Average among floating points: %f", average(S2,m) );
    getch();
}

template <class X> float average( X *_a, int _n )
{
    float sum=0; int i;
    for(i=0;i<_n;i++) sum += _a[i];
    return sum/_n;
}

#include <string.h>

class ttString {
    char *s; int l;
public:
    ttString();                                                        // Различные
    ttString( char *_s );                                            //           версии
    ttString( ttString& _s );                                        //                  конструктора
    ~ttString();                                                    // Деструктор
    ttString& operator =( char *_s );                                // Различные версии
    ttString& operator =( ttString &_s );                            //                  оператора присваивания
    ttString& operator +=( char *_s );                                // Этого не было в задании, хотя
    ttString& operator += ( ttString &_s );                            // должно бы быть...
    friend ttString& operator +( ttString &_s1, ttString &_s2 );    // Различные версии
    friend ttString& operator +( ttString &_s1, char *_s2 );        //                  оператора
    friend ttString& operator +( char *_s1, ttString &_s2 );        //                            конкатенации
};

ttString::ttString()
// Стандартный конструктор
{
    s = 0;        // Избавляемся от случайных значений указателя в памяти
    l = 0;
}

ttString::ttString( char *_s )
// Конструктор, использующий массив символов как прототип
{
    l = strlen( _s );        // Вычисляем длину строки
    s = new char[l+1];        // Выделяем память
    memcpy( s, _s, l );        // Выполняем копирование
}

ttString::ttString( ttString& _s )
// Конструктор, использующий другой объект как прототип
{
    l = _s.l;                // Крадём длину строки
    s = new char[l+1];        // Выделяем память
    memcpy( s, _s.s, l );    // Выполняем копирование
}

ttString::~ttString()
// Деструктор
{
    if( s )delete s;        // Освобождаем память
}

ttString& ttString::operator =( char *_s )
// Присваивание строке значения из массива символов
{
    if( s )delete s;        // Освобождаем буфер, если нужно
    l = strlen( _s );        // Вычисляем длину строки
    s = new char[l+1];        // Выделяем память
    memcpy( s, _s, l );        // Выполняем копирование
    return *this;
}

ttString& ttString::operator =( ttString &_s )
// Копирование объекта строки
{
    if( s )delete s;        // Освобождаем буфер, если нужно
    l = _s.l;                // Крадём длину строки
    s = new char[l+1];        // Выделяем память
    memcpy( s, _s.s, l );    // Выполняем копирование
    return *this;
}

ttString& ttString::operator +=( char *_s )
// Конкатенация с другой строкой из массива символов
{
    if( !s )                // Если эта строка пуста..
    {
        *this = _s;            // ..передаём управление оператору присваивания,
        return *this;        // т.к. конкатенацию как таковую выполнять не нужно.
    }
    char *o = s;
    l += strlen( _s );        // Вычисляем новую длину буфера
    s = new char[l+1];        // Выделяем память
    strcpy( s, o );            // Копируем строку из старого буфера..
    strcat( s, _s );        // И складываем её с новой
    delete o;                // Убиваем старый буфер
    return *this;
}

ttString& ttString::operator += ( ttString &_s )
// Конкатенация с другой строкой из такого же объекта
{
    if( !s )                // Если эта строка пуста..
    {
        *this = _s;            // ..передаём управление оператору присваивания,
        return *this;        // т.к. конкатенацию как таковую выполнять не нужно.
    }
    char *o = s;
    l += _s.l;                // Вычисляем новую длину буфера
    s = new char[l+1];        // Выделяем память
    strcpy( s, o );            // Копируем строку из старого буфера..
    strcat( s, _s.s );        // И складываем её с новой
    delete o;                // Убиваем старый буфер
    return *this;
}

ttString& operator +( ttString &_s1, ttString &_s2 )
// Конкатенация, продуктом которой станет вновь созданный объект
{
    ttString *t;
    t = new ttString( _s1 );    // Создаём новый объект и пишем в него первую часть строки
    *t += _s2;                    // Затем просто складываем со второй
    return *t;                    // И возвращаем этот объект
}

ttString& operator +( ttString &_s1, char *_s2 )
// Конкатенация, продуктом которой станет вновь созданный объект
{
    ttString *t;
    t = new ttString( _s1 );    // Создаём новый объект и пишем в него первую часть строки
    *t += _s2;                    // Затем просто складываем со второй
    return *t;                    // И возвращаем этот объект
}

ttString& operator +( char *_s1, ttString &_s2 )
// Конкатенация, продуктом которой станет вновь созданный объект
{
    ttString *t;
    t = new ttString( _s1 );    // Создаём новый объект и пишем в него первую часть строки
    *t += _s2;                    // Затем просто складываем со второй
    return *t;                    // И возвращаем этот объект
}