Главная · Поиск книг · Поступления книг · Top 40 · Форумы · Ссылки · Читатели

Настройка текста
Перенос строк


    Прохождения игр    
Roman legionnaire vs Knight Artorias
Ghost-Skeleton in DSR
Expedition SCP-432-4
Expedition SCP-432-3 DATA EXPUNGED

Другие игры...


liveinternet.ru: показано число просмотров за 24 часа, посетителей за 24 часа и за сегодня
Rambler's Top100
Образование - Богатырев А. Весь текст 120.46 Kb

Руководство полного идиота по программированию на C

Предыдущая страница Следующая страница
1 ... 3 4 5 6 7 8 9  10 11
        char tmp;

        if(n <= 1)              /* нечего инвертировать */
                return;

        tmp = s[0];             /* спасти */
        shiftLeft(s, n);        /* сдвинуть */
        s[n-1] = tmp;           /* переместить */

        reverse(s, n-1);        /* инвертировать начало */
}

/* ВТОРАЯ ВЕРСИЯ нерекурсивна. Рекурсия заменена циклом.
   Длина начала массива, которую надо инвертировать,
   вынесена на переменную length.
*/
void reverse1(char s[], int n){
        char tmp;
        int length;

        for(length=n; length > 1; --length){
                tmp = s[0];
                shiftLeft(s, length);
                s[length-1] = tmp;
        }
}

char testString[] = "abcdefghijklmnopqrstuvwxyz";

/* Если не задать размер массива, он будет вычислен компилятором автоматически.
   Он будет равен числу букв внутри "..." ПЛЮС одна ячейка для невидимого
   символа '\0' на конце.
   В данном случае это 27.
*/

void main(){
        int len;

        len = strlen(testString);
        /* вычислить длину строки: 26 ('\0' на конце не считается) */

        printf("Строка для теста: \"%s\", ее длина %d\n",
                                    testString,    len);
        /* Обратите внимание на два момента:
                - строку (массив char) следует печатать по формату %s
                - чтобы внутри "..." напечатать символ "
                  надо изобразить его как \"

           А чтобы в putchar напечатать символ ' надо писать putchar('\'');
         */

        /* Первая инверсия */
        reverse(testString, len);
        putstr("Инвертированная строка:");
        putstr(testString);

        /* Вторая инверсия - возвращает в исходное состояние */
        reverse1(testString, len);
        putstr("Инвертированная в исходное состояние строка:");
        putstr(testString);
}
     19_1.c

/* Еще более простой вариант решения:
   просто обменивать элементы местами.

        A B C D E F G H I J
        J B C D E F G H I A
        |                 |     эти
        J B C D E F G H I A
        J I C D E F G H B A
          |             |       потом эти
        J I C D E F G H B A
        J I H D E F G C B A
            |         |         потом эти
          ---->     <-----

        J I H D E F G C B A
        J I H G E F D C B A
              |     |
        J I H G E F D C B A
                | |
        J I H G F E D C B A

                стоп.
*/

#include

/* Обмен значений двух переменных типа char */
void swap(char *s1, char *s2){
        char c;

        c = *s1; *s1 = *s2; *s2 = c;
}

void reverse(char s[], int n){
        int first, last;

        first = 0;              /* индекс первого элемента массива */
        last = n-1;             /* индекс последнего элемента массива */

        while(first < last){    /* пока first левее last */
                swap(&s[first], &s[last]);
                first++;        /* сдвинуть вправо */
                last--;         /* сдвинуть влево  */
        }
}

char testString[] = "abcdefghijklmnopqrstuvwxyz.";

void main(){
        int len;

        len = strlen(testString);       /* Есть такая стандартная функция */
        reverse(testString, len);
        printf("Инвертированная строка: %s\n", testString);
}
     19_2.c

/* Еще один вариант решения:
   сформировать ответ в дополнительном массиве,
   а потом скопировать его на прежнее место.
*/

#include

char testString[] = "abcdefghijklmnopqrstuvwxyz.";

/* Конструкция sizeof(массив)/sizeof(массив[0])
   выдает размер массива, даже если он не был явно объявлен.
   Эта конструкция применяется (чаще всего) для задания массива
   с размером, равным размеру уже объявленного массива.
 */

char tempString[ sizeof(testString) / sizeof(testString[0]) ];

void reverse(char s[], int n){
        int i;

        /* вывернуть, результат в tempString[] */
        for(i=0; i < n; i++)
                tempString[n-1-i] = s[i];

        tempString[n] = '\0';   /* признак конца строки */

        /* скопировать на старое место */
        for(i=0; i < n; i++)
                s[i] = tempString[i];

        s[n] = '\0';            /* признак конца строки */
}

void main(){
        int len;

        len = strlen(testString);       /* Есть такая стандартная функция */
        reverse(testString, len);
        printf("Инвертированная строка: %s\n", testString);
}
     19_3.c

/* Задача инвертирования массива целых чисел */

#include

int arr[]  = {1, 5, 10, 15, 20, 25, 30};
int arrLen = sizeof(arr) / sizeof(arr[0]);   /* размер массива */

/* Распечатка массива в строку */
void printit(int row[], int n){
        int i;

        for(i=0; i < n; i++){
                printf("%d", row[i]);

                if(i == n-1) putchar('\n');
                else         putchar(' ');
        }
}
/* Печать отступа. Отладочная функция */
void printShift(int n){
        n = arrLen - n;
        while(n > 0){
                printf("   ");
                n--;
        }
}
/* Сдвиг массива */
void shiftleft(int row[], int n){
        int i;

        for(i=1; i < n; i++)
                row[i-1] = row[i];
}
/* Инвертирование */
void reverse(int  row[], int n){
        int pocket;

        printShift(n);                          /* трассировка */
        printf("CALLED reverse(row, %d)\n", n); /* трассировка */

        if(n <= 1){
                printShift(n);                  /* трассировка */
                printf("return from reverse(row, %d);\n", n); /* трассировка */
                return;
        }

        pocket = row[0];
        shiftleft(row, n);
        row[n-1] = pocket;

        printShift(n);                          /* трассировка */
        printit(arr, arrLen);                   /* трассировка */

        reverse(row, n-1);

        printShift(n);                          /* трассировка */
        printf("all done; return from reverse(row, %d);\n", n); /* трассировка */
}
void main(){
        reverse(arr, arrLen);
        printit(arr, arrLen);
}

     20.c

/* Задача: написать функцию для распечатки массива целых чисел
   в виде таблицы в columns столбцов.
   При этом порядок элементов должен быть таков:

   0    4    8
   1    5    9
   2    6    10
   3    7
*/

/* Пусть в массиве n элементов.
   Если n < columns, то мы получаем такую ситуацию (n=2, columns=4)

        0       1       пусто       пусто

   Поэтому

        if(n < columns) columns = n;

   Далее, прямоугольная таблица с columns столбцами и lines строками
   может содержать максимум columns*lines элементов. Поэтому:

        columns*lines >= n

   Вычислим число строк.
   Нам нужно минимальное целое число строк, такое что

        lines >= n/columns

   Такое число вычисляется по формуле

        lines = (n + (columns - 1)) / columns;

   где деление целочисленное.

   Далее надо только вывести формулу для индекса элемента в массиве
   в зависимости от номера строки (y) и столбца (x).

   index(x, y) = (x * lines + y);
                 причем если index >= n, то ничего не выводить
*/

#include

int array[100];

void printArray(int a[], int n, int columns){
        int lines;      /* число строк */

        int x, y;       /* номер колонки, номер строки - с нуля */
        int index;      /* индекс элемента в массиве */

        if(n < columns) columns = n;
        lines = (n + (columns-1)) / columns;

        /* Используем вложенные циклы: по строкам, а внутри - по столбцам */
        for(y=0; y < lines; y++){
                for(x=0; x < columns; x++){
                        index = x * lines + y;
                        if(index >= n)  /* элемент за концом массива */
                                break;  /* прервать строку */

                        /* break выводит только
                           из внутреннего цикла (по столбцам) */

                        /* сделать отступ в следующую колонку */
                        if(x != 0) putchar('\t');

                        printf("%02d|%d", index, a[index]);
                        /* Формат %02d заставляет печатать целое число
                           с использованием ДВУХ цифр, причем если
                           число состоит из одной цифры, то спереди
                           приписывается нуль.
                         */
                }
                putchar('\n');  /* перейти к следующей строке */
        }
}
void main(){
        int i, cols;

        /* Инициализация значений элементов массива */
        for(i=0; i < 100; i++)
                array[i] = i + 1;

        for(cols=4; cols <= 13; cols++){
                printf("\t\t* * * ТАБЛИЦА В %d СТОЛБЦОВ * * *\n", cols);
                printArray(array, 77, cols);
                putchar('\n');
        }
}
     20_1.c

#include

main(){
        int x, y;
        int COLUMNS = 11;
        int LINES = 10;

        int value;

        /* цикл по строкам */
        for(y=0; y < LINES; y++){

                /* цикл по столбцам */
                for(x=0; x < COLUMNS; x++){

                        /* что напечатать */
                        value = LINES * x + y;

                        /* если это не нулевой столбец, то перейти
                           в следующую колонку
                         */

                        if(x > 0) putchar('\t');

                        /* ... и в ней напечатать значение */
                        printf("%d", value);

                }
                putchar('\n');  /* новая строка */
        }
}
     20_2.c

/*
        elem(x, y) = LINES * x + y;

                тогда

        elem(0, y+1) - elem(COLUMNS-1, y) = 1 + LINES - COLUMNS*LINES;
        elem(x+1, y) - elem(x, y)         = LINES;
*/

#include

int A = 150;            /* Количество элементов      */
int COLUMNS = 7;        /* Количество столбцов       */
int LINES;              /* Количество строк          */
int value;              /* Значение в текущей клетке */

int OFFSET_NEXT_COLUMN;
int OFFSET_NEXT_LINE;

/* Рисуем строку таблицы */
void line(){
        int col;        /* номер колонки */

        for(col=0; col < COLUMNS; col++){
                if(value >= A)       /* отсутствующий элемент */
                        printf("* ");
                else    printf("%03d ", value);

                /* Увеличение при переходе в соседнюю колонку */
                value += OFFSET_NEXT_COLUMN;    /* 1 */
        }
        /* Перейти к следующей строке */
        putchar('\n');

        /* Увеличение при переходе из конца одной строки к началу следующей.
           Заметим, что к value уже прибавлено OFFSET_NEXT_COLUMN из точки 1,
           поэтому при переходе в начало следующей строки в сумме прибавляется
           OFFSET_NEXT_COLUMN + OFFSET_NEXT_LINE равное
                1 - LINES*COLUMNS + LINES,
           что соответствует формуле.
         */
        value += OFFSET_NEXT_LINE;              /* 2 */
}

int main(){
        int nline;  /* Номер строки */

        LINES = (A + (COLUMNS - 1)) / COLUMNS;

        OFFSET_NEXT_COLUMN = LINES;
        OFFSET_NEXT_LINE = 1 - LINES*COLUMNS;

        for(nline=0; nline < LINES; nline++)
                line();

        /* возврат 0 из main() означает "программа завершена успешно" */
        return 0;
}
     21.c

/* ДВУМЕРНЫЕ МАССИВЫ */

/*
        Двумерный массив представляет собой двумерную
        прямоугольную таблицу из нумерованных переменных.

        Он объявляется так:

                int array[LINES][COLUMNS];

        А индексируется так:

                    array[y][x]

                где 0 <= y <= LINES - 1
                    0 <= x <= COLUMNS - 1

Предыдущая страница Следующая страница
1 ... 3 4 5 6 7 8 9  10 11
Ваша оценка:
Комментарий:
  Подпись:
(Чтобы комментарии всегда подписывались Вашим именем, можете зарегистрироваться в Клубе читателей)
  Сайт:
 
Комментарии (6)

Реклама