LINUX.ORG.RU

Проверьте простенькую программу на C

 , ,


0

1

Хочу на компьютере проверить правильность возведения следующей перестановки в некоторую степень:
1 -> 4
2 -> 6
3 -> 3
4 -> 1
5 -> 2
6 -> 5

Для этого написал

#include <stdio.h>
     
int permutation(int *m, int *result);
     
int main()
{
  int m[] = {0, 1, 2, 3, 4, 5, 6};
  int result[7];
  int iterations = 2, i = 1;
  while (i <= iterations)
    {
	permutation(m, result);
	i++;
    }
  for (i = 1; i < 7; i++)
    {
      printf("%d: %d\n", i, result[i]);
    }
  return 0;
}

int permutation(int *m, int *result)     
{
  result[1] = m[4];
  result[2] = m[6];
  result[3] = m[3];
  result[4] = m[1];
  result[5] = m[2];
  result[6] = m[5];     
}

Собственно, вопрос — почему функция permutation исполняется только один раз независимо от значения переменной iterations? Не вижу своей ошибки.

★★

потому что результат каждой перестановки хранится в result и не попадает обратно в m

anonymous ()

Аноним прав, тебе нужно что-то вроде

#define swap(a,b)  do{ register int t = a; a = b; b = a;}while(0)
int permutation(int *m, int *result){ 
  int table[7] = {0, 4, 6, 3, 1, 2, 5}, i;
  for(i = 1; i < 7; ++i) swap(result[i], m[table[i]]);
}

anonymous ()

Хотя, нет. Вангую, что тебе нужно что-то вроде этого:

#include <stdio.h>
#include <string.h>

int permutation(int *m);

int main(){
  int m[] = {0, 1, 2, 3, 4, 5, 6};
  int iterations = 2, i = 1, j;
  while (i <= iterations){
    permutation(m);
    printf("step %d:\n", i++);
    for (j = 1; j < 7; j++){
      printf("%d: %d\n", j, m[j]);
    }
  }
  return 0;
}

int permutation(int *m){
  int table[7] = {0, 4, 6, 3, 1, 2, 5}, i;
  int tmp[7];
  memcpy(tmp, m, 7*sizeof(int));
  for(i = 1; i < 7; ++i) m[i] = tmp[table[i]];
}

anonymous ()

ужас и кошмар-если у тебя объяслен нулевой эелемент он должен использоваться,у тебя объйслен нулевой эелемент со значением «0» и весь код использует нумерацию массивов с 1

это ужасно

почему функция permutation исполняется только один раз

как ты узнал что она исполняется один раз?

у тебя в коде она делает одно и тоже ДВА раза

а не один

jsi36331 ()
Ответ на: комментарий от anonymous

Да, действительно. Всё оказалось очень просто. Спасибо!

Hasek ★★ ()
Ответ на: комментарий от anonymous

То, что надо, да. Я сначала самым очевидным образом написал функцию, делающую одну перестановку, а потом, не подумав, пробовал помещать её в цикл. Спасибо!

Hasek ★★ ()
Ответ на: комментарий от jsi36331

ужас и кошмар-если у тебя объяслен нулевой эелемент он должен использоваться,у тебя объйслен нулевой эелемент со значением «0» и весь код использует нумерацию массивов с 1

Мне кажется для читаемости это как раз лучше, чем сдвиг всех индексов на единицу.

Hasek ★★ ()
Ответ на: комментарий от Hasek

Мне кажется для читаемости это как раз лучше, чем сдвиг всех индексов на единицу.

да,окей,тебе кажется

через месяц ты начинаешь работать с «внешней библиотекой» где очевидно что все индексы с 0 номера массива,ты делаешь свое «удобство» где сдвигаешь индексы с 0 на 1 делаешь двустороннее преобразование для всех массивов

через пол года ты забываешь что писал ибо закончил работу,через год следущим летом тебе нужен еще раз подобный функционал и ты вспоминаешь что уже делал такое

ты лежешь в свои коды

начинаешь делать,читаешь доки офф библиотеки(внешней) там все массивы с 0,и ты совершенно не помнишь про свою прослойку сдвигающую все на 1

ты начинаешь делать новый проект опирайсь на весь написанный раннее(год назад) код

начинаешь тестировать-и ловишь непонятные баги,совсем непонятные

начинаешь изучать исходники сначала «внешней библиотеки»(очевидно что ты в своем коде ошибок не допускаешь)
изучил-там все правильно
начинаешь тыкать свой годичный код
а там все индексы массивов сдвиныты
и ты понимаешь-что переписать весь свой код(годичной давности) быстрее чем править кривые индексы и вникать что куда сдвинуто

да это у тебя случиться на первых двух «проектах» с которыми ты будешь работать если не изменишь подход к стандартизированной разработке

jsi36331 ()
Ответ на: комментарий от jsi36331

забыл передать привет microsoft visual c++ стандартной библиотеке

где функция копирования строк в C++ считает «элементы» не с 0 а с 1

и ихже функция для Си с такимже именем-считает элементы с 0

и при конвертировании или использовании эти обе функции в двух разных функциях-надо передвигать всю строку на +-1 элемент туда сюда

ох какже я полубил микрософт делая это все

а еще у микрософт функции winapi принимающие заголовки и всякие тексты окон/меток/кнопок/полей тдтп

каждая из них считает строку по разному,и выводит естественно-часть выводит строку с 0 симсола,другая часть выводит строки с 1 символа

конечно привет индусам также

jsi36331 ()
Ответ на: комментарий от Miguel

Это паскаль головного мозга, как вариант. В принципе можно хранить 8 байт чего-нибудь полезного там, но это при условии что это говно никогда и никто не увидит.

anonymous ()
Ответ на: комментарий от anonymous

Ой даже больше в данном случае, что-то меня переклинило на тему чаров.

anonymous ()

while (i <= iterations)

Ох тыж елки-палки. Почему бы тогда уж не while (i++ <= iterations) ?

nikolnik ★★★ ()
Ответ на: комментарий от jsi36331

через месяц ты начинаешь работать с «внешней библиотекой» где очевидно что все индексы с 0 номера массива,ты делаешь свое «удобство» где сдвигаешь индексы с 0 на 1 делаешь двустороннее преобразование для всех массивов

Проблема в том, что надо понимать массив не как «первый элемент», а как смещение адресов &arrayBeginPointer + sizeof(T)*index, тогда все становится на свои места с пониманием, почему первый элемент с нуля.

nikolnik ★★★ ()
Последнее исправление: nikolnik (всего исправлений: 1)
Ответ на: комментарий от Miguel

Ты это разрабам матлаба и октавы скажи! До сих пор матерюсь, как нужно с индексами в октаве работать. Особенно если до этого долго на сях что-нибудь делал.

Козлы.

Первый элемент имеет индекс == 1. Вот на кой японский лад?

anonymous ()
Ответ на: комментарий от anonymous

паскаль головного мозга

const m: array [0..5] of Integer = (1, 2, 3, 4, 5, 6);
bormant ★★★★★ ()

Не вижу своей ошибки.

У тебя происходит копирование m[] -> result[]. Второй запуск производит точно такое же копирование. Тебе же нужно после m[] -> result[] делать m <- result (копировать обратно для следующей итерации).

P.S.По-изучай оператор XCHG. Поможет постичь дзен.

pacify ★★★★★ ()
Вы не можете добавлять комментарии в эту тему. Тема перемещена в архив.