Создание каждого возможного значения массива фиксированного размера - PullRequest
1 голос
/ 05 января 2010

Я пытаюсь сделать что-то очень элементарное, что будет циклически проходить через каждую возможную перестановку массива.

На самом деле это делается в сборке, но я объясню это на языке C.

В основном, скажем, у нас есть массив uint8_t *data=malloc(10);

Я хочу создать алгоритм, который будет печатать каждую возможную комбинацию байтов в массиве data.

Да, я знаю, что это будет медленно (и есть много значений), и я не прошу действительно сложную оптимизированную версию ... Я просто ищу что-то, что я могу оставить на своем компьютере что-то типа грубой силы, чтобы найти определенные значения, которые подчиняются определенным условиям ..

(обратите внимание, я говорю перестановка, потому что [0,1,2] не следует считать таким же, как [2,1,0])

редактирование: Кроме того, постарайтесь не использовать слишком много функций libc, потому что я буду преобразовывать это в автономный загрузчик с 512 байтами.

Я знаю, что знаю, как это сделать, но ради жизни я просто не могу заставить алгоритм работать в моей голове!

Ответы [ 6 ]

4 голосов
/ 05 января 2010

Ну, все это бесполезное упражнение (см. Мой комментарий, прикрепленный к вопросу), но вы все равно начинаете (сборка в стиле x86_64 AT & T, предполагает соглашения о вызовах системы AMD V). Я просто пишу здесь без тестирования, поэтому вполне возможно, что в нем есть ошибки. Тем не менее, основная операция кода должна быть полностью понятной.

Вместо того чтобы работать с 80-битным буфером в памяти, я просто использую все возможности 80-битного поля, разделенного на два 64-битных регистра. Ваша процедура, которая проверяет ваши условия, может сохранять их в памяти и обращаться к этой памяти как uint8_t, если вы действительно хотите.

    push r12
    push r13
    xor  r12, r12 // zero out low 64 bits of our "buffer" in register
    xor  r13, r13 // zero out high 16 bits of our "buffer"

loop:
    // Copy the current array value into rsi:rdi and call whatever routine you're
    // using to check for magic conditions.  This routine's copy (in r13:r12)
    // should be unaffected if you're obeying the System V calling conventions.
    mov  r12, rdi
    mov  r13, rsi
    call _doSomethingWithValue

    // Increment r13:r12 to get the next value.  We only need to worry about r13
    // if the increment of r12 wraps around to zero.
    inc  r12
    jnz  loop
    inc  r13

    // Check for the termination condition, though you'll never hit it =)
    cmp  $0x10000, r13
    jne  loop

    // We don't actually need to clean up; the apocalypse will come and there
    // won't be electricity to run the computer before it reaches this point of
    // the program.  Nonetheless, let's be exhaustively correct.
    pop  r13 
    pop  r12
3 голосов
/ 05 января 2010

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

Код, который генерирует все возможные 10 кортежей значений uint8_t, легко найти. Например, следующий простой код сделает это

#define N 10u

uint8_t data[N] = { 0 };
unsigned i;

do {

  /* Process the current 10-typle in `data` array */
  /* in any way you want do */

  /* Generate next tuple */
  for (i = 0; i < N && ++data[i] == 0; ++i);

} while (i < N);

Это не что иное, как просто циклическое приращение 80-разрядного числа с прямым порядком байтов.

Конечно, как уже отмечали другие, количество времени, которое это займет, делает все это абсолютно бесполезным с любой практической точки зрения.

2 голосов
/ 05 января 2010

Я бы посоветовал вам прочитать,

Дональд Кнут. Искусство компьютерного программирования, том 4, глава 2: создание всех кортежей и перестановок.

0 голосов
/ 05 января 2010

Если вы работали в C ++,

#include <algorithm>
#include <iterator>
#include <iostream>
#include <numeric>

int main() {
    int N;
    std::cin >> N;
    std::vector<int> data(N);
    std::fill(data.begin(), data.end(), 1);
    std::partial_sum(data.begin(), data.end(), data.begin());

    do {
        std::copy(data.begin(), data.end(),
                std::ostream_iterator<int>(std::cout, " "));
        std::cout << std::endl;
    } while (std::next_permutation(data.begin(), data.end()));

    return 0;
}

Если вы введете 3, он выдаст

1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1

См. Следующая перестановка: когда C ++ понимает это правильно , как работает std::next_permutation.


Перевод этого на простой C,

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

int main() {
    int i, N, *data;

    scanf("%d", &N);
    data = malloc(N);
    for (i = 0; i < N; i++) data[i] = i + 1;

    while (1) {
        int j, temp;

        for (i = 0; i < N; i++) printf("%d ", data[i]);
        printf("\n");

        for (i = N - 1; i > 0 && data[i] < data[i - 1]; i--);
        if (i <= 0) break;
        for (j = N; data[i - 1] >= data[--j];);
        temp = data[i - 1], data[i - 1] = data[j], data[j] = temp;
        for (j = N - 1; i < j; i++, j--)
            temp = data[i], data[i] = data[j], data[j] = temp;
    }

    return 0;
}

Если вопрос не в том, чтобы задавать перестановки существующего массива, а в том, чтобы генерировать все возможное содержимое массива, это будет намного проще. (Также есть намного больше комбинаций.)

memset(data, 0, N);
do {
    for (i = 0; i < N; i++) printf("%d ", data[i]);
    printf("\n");
    for (i = 0; i < N && !++data[i++];);
} while (i < N);
0 голосов
/ 05 января 2010

Посмотрите на этот алгоритм для генерации комбинаций N из M предметов. Для комбинации N выберите N, просто используйте inittwiddle (N, N, p);

int twiddle(x, y, z, p)
int *x, *y, *z, *p;
  {
  register int i, j, k;
  j = 1;
  while(p[j] <= 0)
    j++;
  if(p[j-1] == 0)
    {
    for(i = j-1; i != 1; i--)
      p[i] = -1;
    p[j] = 0;
    *x = *z = 0;
    p[1] = 1;
    *y = j-1;
    }
  else
    {
    if(j > 1)
      p[j-1] = 0;
    do
      j++;
    while(p[j] > 0);
    k = j-1;
    i = j;
    while(p[i] == 0)
      p[i++] = -1;
    if(p[i] == -1)
      {
      p[i] = p[k];
      *z = p[k]-1;
      *x = i-1;
      *y = k-1;
      p[k] = -1;
      }
    else
      {
      if(i == p[0])
    return(1);
      else
    {
    p[j] = p[i];
    *z = p[i]-1;
    p[i] = 0;
    *x = j-1;
    *y = i-1;
    }
      }
    }
  return(0);
  }

void inittwiddle(m, n, p)
int m, n, *p;
  {
  int i;
  p[0] = n+1;
  for(i = 1; i != n-m+1; i++)
    p[i] = 0;
  while(i != n+1)
    {
    p[i] = i+m-n;
    i++;
    }
  p[n+1] = -2;
  if(m == 0)
    p[1] = 1;
  }

/************************
  Here is a sample use of twiddle() and inittwiddle():
#define N 5
#define M 2
#include <stdio.h>
void main()
  {
  int i, x, y, z, p[N+2], b[N];
  inittwiddle(M, N, p);
  for(i = 0; i != N-M; i++)
    {
    b[i] = 0;
    putchar('0');
    }
  while(i != N)
    {
    b[i++] = 1;
    putchar('1');
    }
  putchar('\n');
  while(!twiddle(&x, &y, &z, p))
    {
    b[x] = 1;
    b[y] = 0;
    for(i = 0; i != N; i++)
      putchar(b[i]? '1': '0');
    putchar('\n');
    }
  }
************************/

Ответ на этот пост также может помочь вам Алгоритм возврата всех комбинаций k элементов из n

0 голосов
/ 05 января 2010

Существует классический рекурсивный подход к проблеме, подобный следующему:

#include <stdio.h>


void print(const uint8_t *v, const int size)
{
  if (v != 0) {
    for (int i = 0; i < size; i++) {
      printf("%4d", v[i] );
    }
    printf("\n");
  }
} // print


void visit(uint8_t *Value, int N, int k)
{
  static level = -1;
  level = level+1; Value[k] = level;

  if (level == N)
    print(Value, N);
  else
    for (int i = 0; i < N; i++)
      if (Value[i] == 0)
        visit(Value, N, i);

  level = level-1; Value[k] = 0;
}


main()
{
  const int N = 4;
  uint8_t Value[N];
  for (int i = 0; i < N; i++) {
    Value[i] = 0;
  }
  visit(Value, N, 0);
}

пример взят из ссылка , в которой есть другие подходы.Теория, лежащая в основе этого, довольно проста ... если вам нужно, я могу более подробно объяснить алгоритм, но он достаточно понятен.

...