Здравствуйте, Sidoruk, Вы писали:

S>Как это правильно организовать, подскажите пожалуйста.

Ты стебёшься?

for( char i = '0'; i <= '9'; i++ ) {
    for( char j = '0'; j <= '9'; j++ ) {
        for( char k = '0'; k <= '9'; k++ ) {
            char v[] = { i, j, k }; // Тебе это надо? ;)
        }
    }
}

std::next_permutation ?

Здравствуйте, Erop, Вы писали:

E>Здравствуйте, Sidoruk, Вы писали:

S>>грубо говоря должно получиться что-то типа брутфорса.

E>Ну и тут какие проблемы?
E>

bool nextVariant( std::vector<int>& pos, int maxValue )
E>{
E>    for( std::vector<int>::reverse_iterator i = pos.rbegin(); i != pos.rend(); ++i ) {
E>        if( ++*i <= maxValue )
E>             return true;
E>        *i = 0;
E>    }
E>    return false;
E>}

E>void foo( int maxValue, int count )
E>{
E>    assert( maxValue > 0 && count > 0 );

E>    std::vector<int> indexes( count );
E>    do {
E>         use( indexes ); // Это то, что тебе надо?
E>    } while( nextVariant( indexes, maxValue ) );
E>}
E>

Что такое use()?
E> use( indexes ); // Это то, что тебе надо? — может быть и это надо, не могу проверить, т.к. тут ошибка, что use неопределена

Спасисбо всем за помощь, особенно Eropу... Очень интересные методы предложил!

Здравствуйте, Sidoruk, Вы писали:

S>Добрый день(вечер, ночь)... Задача довольна стара, но никак не могу понять алгоритм работы... Надо заполнить массив всеми возможными последовательностями из ряда чисел, т.е., например массив из 3 эл-ов должен иметь следующий вид :
S>001
S>002
S>...
S>009
S>010
S>011
S>...
S>901
S>902
S>...
S>991
S>992
S>...
S>999
S>Как это правильно организовать, подскажите пожалуйста.

попробовал написать, мне понравилось ( в смысле писать )

#include <iostream>
//const char *elements[]={ "A", "B", "C", "D", "E", "F", "G", "H", "I", "J" , "K", "L", "M", "N", "O", "P" };
const char *elements[]={ "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A" , "B", "C", "D", "E", "F" };
bool inc( int *variant, int count_variant, int count_elements )
{ 
    variant += count_variant;
    while( --variant && --count_variant != -1 ) 
    { 
        if( *variant != count_elements - 1 ) 
        { 
            ++(*variant );
            return true;
        } 
        else
        {
            *variant = 0;
        } 
    } 
    return false;
}

void print_variant( int *variant, int count_variant ) 
{ 
  for( int i = 0; i < count_variant; ++i ) 
  {
    std::cout << elements [ *( variant + i  ) ] << " ";
  } 
  std::cout << std::endl;
} 
 
int main() 
{ 
    int variant[5]={0}; //Количество элементво в ряду

    while( inc( variant, sizeof( variant )/sizeof( int ), sizeof( elements )/sizeof(char *) ) ) 
    { 
        print_variant( variant, sizeof( variant )/sizeof( int ) );
    }     
}

Здравствуйте, Sidoruk, Вы писали:

S>001
S>002
S>...
S>...
S>999

int k=3;// количество елементов массива
int num = pow(10,k);
for(int i=1;i<num;++i)
{
   //тут раскладываеш число в массив
}

Здравствуйте, Sidoruk, Вы писали:
S>>>Это был бы стёб, если б не слово НАПРИМЕР. А если у меня будет массив не из 3, а из 10000 элементов?! Как тогда?

E>>Тогда не дождёшься... гугол в квадрате (10 ** 10000) -- это очень много

E>>Объясни ПОНЯТНО что у тебя за задача, может что кто и посоветует...

S>Есть 2-а char'овых массива.
S>1-й массив это набор цифер и букв, т.е. char mass1[] = {'1','2','3','4','5','6','7','8','9','0','A','B','C','D','E','F','G','H'};
S>2-й массив — пустой(длина варьируется) — должен принять все значения 1-го, но не перестановкой елементов (это я про

Второй массив можно рассматривать как число, записанное в системе счисления по основанию N, где N -- количество символов в первом массиве.

То есть необходимо реализовать операцию прибавления 1 к числу, зписанному в N-ичной системе (заметьте, что в приведенном примере символ '1' играет роль нуля ). Получается проще некуда: реализуем инкремент с переносом для одного разряда и применяем эту процедуру ко всем разрядам, начиная с младшего, пока перенос не равен 0.

Ну а про количество итераций уже написали. Не дождетесь.

Добрый день(вечер, ночь)... Задача довольна стара, но никак не могу понять алгоритм работы... Надо заполнить массив всеми возможными последовательностями из ряда чисел, т.е., например массив из 3 эл-ов должен иметь следующий вид :
001
002
...
009
010
011
...
901
902
...
991
992
...
999
Как это правильно организовать, подскажите пожалуйста.

Здравствуйте, alexei_s, Вы писали:

_>std::next_permutation ?

И какую начальную последовательность использовать?

Здравствуйте, Erop, Вы писали:

E>Здравствуйте, Sidoruk, Вы писали:

S>>Как это правильно организовать, подскажите пожалуйста.

E>Ты стебёшься?

for( char i = '0'; i <= '9'; i++ ) {
E>    for( char j = '0'; j <= '9'; j++ ) {
E>        for( char k = '0'; k <= '9'; k++ ) {
E>            char v[] = { i, j, k }; // Тебе это надо? ;)
E>        }
E>    }
E>}

Это был бы стёб, если б не слово НАПРИМЕР. А если у меня будет массив не из 3, а из 10000 элементов?! Как тогда?

Здравствуйте, Sidoruk, Вы писали:

S>Это был бы стёб, если б не слово НАПРИМЕР. А если у меня будет массив не из 3, а из 10000 элементов?! Как тогда?

10^10000, если ты даже будеш генерировать по миллиарду "перестановок" в секунду тебе не хватит жизни (вселенной?) что-бы дождаться результата.

Здравствуйте, Sidoruk, Вы писали:

S>Это был бы стёб, если б не слово НАПРИМЕР. А если у меня будет массив не из 3, а из 10000 элементов?! Как тогда?

Тогда не дождёшься... гугол в квадрате (10 ** 10000) -- это очень много

Объясни ПОНЯТНО что у тебя за задача, может что кто и посоветует...

Здравствуйте, Erop, Вы писали:

E>Здравствуйте, Sidoruk, Вы писали:

S>>Это был бы стёб, если б не слово НАПРИМЕР. А если у меня будет массив не из 3, а из 10000 элементов?! Как тогда?

E>Тогда не дождёшься... гугол в квадрате (10 ** 10000) -- это очень много

E>Объясни ПОНЯТНО что у тебя за задача, может что кто и посоветует...

Есть 2-а char'овых массива.
1-й массив это набор цифер и букв, т.е. char mass1[] = {'1','2','3','4','5','6','7','8','9','0','A','B','C','D','E','F','G','H'};
2-й массив — пустой(длина варьируется) — должен принять все значения 1-го, но не перестановкой елементов (это я про std::next_permutation), а именно перебором, т.е.
mass2[0] = mass1[0];
mass2[0] = mass1[1];
mass2[0] = mass1[2];
...................
mass2[1] = mass1[0];
mass2[0] = mass1[0];
mass2[0] = mass1[1];
...................
mass2[1] = mass1[1];
mass2[0] = mass1[0];
mass2[0] = mass1[1];
...................
mass2[1] = mass1[2];
mass2[0] = mass1[0];
mass2[0] = mass1[1];
и т.д.

грубо говоря должно получиться что-то типа брутфорса.

Здравствуйте, Sidoruk, Вы писали:

S>грубо говоря должно получиться что-то типа брутфорса.

Ну и тут какие проблемы?

bool nextVariant( std::vector<int>& pos, int maxValue )
{
    for( std::vector<int>::reverse_iterator i = pos.rbegin(); i != pos.rend(); ++i ) {
        if( ++*i <= maxValue )
             return true;
        *i = 0;
    }
    return false;
}

void foo( int maxValue, int count )
{
    assert( maxValue > 0 && count > 0 );

    std::vector<int> indexes( count );
    do {
         use( indexes ); // Это то, что тебе надо?
    } while( nextVariant( indexes, maxValue ) );
}

S>>Есть 2-а char'овых массива.
S>>1-й массив это набор цифер и букв, т.е. char mass1[] = {'1','2','3','4','5','6','7','8','9','0','A','B','C','D','E','F','G','H'};
S>>2-й массив — пустой(длина варьируется) — должен принять все значения 1-го, но не перестановкой елементов (это я про

TB>Второй массив можно рассматривать как число, записанное в системе счисления по основанию N, где N -- количество символов в первом массиве.

TB>То есть необходимо реализовать операцию прибавления 1 к числу, зписанному в N-ичной системе (заметьте, что в приведенном примере символ '1' играет роль нуля ). Получается проще некуда: реализуем инкремент с переносом для одного разряда и применяем эту процедуру ко всем разрядам, начиная с младшего, пока перенос не равен 0.

TB>Ну а про количество итераций уже написали. Не дождетесь.

Хех, мысли сошлись, тебя не читал а написал как по инструкции.

Здравствуйте, Sidoruk, Вы писали:


S>Что такое use()?
E>> use( indexes ); // Это то, что тебе надо? — может быть и это надо, не могу проверить, т.к. тут ошибка, что use неопределена

это способ использовать массив нужным тебе образом. Что ты там брутфорсить собрался?

Здравствуйте, Sidoruk, Вы писали:

S>Что такое use()?
Кстати, а расмер массива известен в CT? Если известен, можно панкануть примерно так:

template<int N, int M = N> struct X {
    int Head;
    X<N, M - 1> Tail;

    void Iterate()
    {
        for( Head = 0; Head <= maxValue; Head++    ) {
            Tail.Iterate();
        }
    }
};

template<int N> struct X<N, 1> {
    int Head;
    void Iterate()
    {
        for( Head = 0; Head <= maxValue; Head++    ) {
            use( 1 - N + &Head );
        }
    }
};

void foo()
{
    X<ArrSize> arr;
    arr.Iterate();
}

#include <stdio.h>

char init_seq [] = { '0', '1', '2', '3', '4', '5' };
char permutation [sizeof(init_seq)+1] = {};

void go(int pos = 0)
{
    for(int i=0;i<sizeof(init_seq);++i)
    {
        permutation[pos] = init_seq[i];
        if(pos == sizeof(init_seq)-1) printf("%s\n", permutation);
        else go(pos+1);
    }
}

int main()
{
    go();
    return 0;
}