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

@LyciferAnZ · Регистрация: 28.09.2016

Студворк — интернет-сервис помощи студентам

Помогите получить список комбинаций. Вот например двумерный массив:
[(2,4),0,0],
[0,0,(7,2)],
[0,0,0]
Значения в дужках это значения которые может принимать элемент массива. Массив может бить любой размерности от 3 до 9, но обязательно квадратный. Но желательно 9 на 9.
Результатом должен быть например List<int[,]> из массивов:
2 0 0
0 0 7
0 0 0

2 0 0
0 0 2
0 0 0

4 0 0
0 0 7
0 0 0

4 0 0
0 0 2
0 0 0

(Вместо 0 могут быть любые значения от 1 до 9)
Знаю как сделать обычные перестановки в одномерном массиве, а тут без понятия. Буду благодарен за помощь.

Добавлено через 2 часа 52 минуты
Решил попробовать решить алгоритм на листике бумаги. Что то вышло но нужно перенести в алгоритм на c#.
Вот что вышло:
По сути двумерный массив не нужен.
На вход я получаю List<List<int>> если по предыдущему примеру смотреть, то
[(2,4),0,0,0,0,(7,2),0,0]
Количество выходных массивов можно узнать перемноживши все количества вложеных List<int>, тоесть 2*1*1*1*1*2*1*1 = 4.
Пробую рисовать все комбинации
1) 2 0 0 0 0 7 0 0 0
2) 2 0 0 0 0 2 0 0 0
3) 4 0 0 0 0 7 0 0 0
4) 4 0 0 0 0 2 0 0 0
Наче сошлось
После этого можно переводить в двумерные и делать что нужно
Помогите плс

@Элд Хасп · 25.11.2018, 22:29

LyciferAnZ, то что Вы просите - не понятно.
Дайте более детальное объяснение, и желательно с несколькими примерами

@LyciferAnZ · 25.11.2018, 22:56 **[ТС]**

Смотрите:
На вход я получаю List<List<int>>
У него внутри внутри: [(2,4),0,0,0,0,(7,2),0,0]
Нужно получить из полученных данных эти:
1) 2 0 0 0 0 7 0 0 0
2) 2 0 0 0 0 2 0 0 0
3) 4 0 0 0 0 7 0 0 0
4) 4 0 0 0 0 2 0 0 0

Добавлено через 3 минуты
Элд Хасп, То есть перестановки перестановок, вот только меняются местами не элементы массива а возможные позиции элементов в массиве + я расписал как я на листочке решил это. Можете уточнить что вам не понятно, чтобы я смог вам дать более развернутый ответ?

Добавлено через 1 минуту

C#

List<List<int>> data = new List<List<int>>();
            List<int> ss = new List<int>();
            ss.Add(2);
            ss.Add(4);
            data.Add(ss);
            ss = new List<int>();
            ss.Add(1);
            data.Add(ss);
            ss = new List<int>();
            ss.Add(1);
            data.Add(ss);
            ss = new List<int>();
            ss.Add(1);
            data.Add(ss);
            ss = new List<int>();
            ss.Add(1);
            data.Add(ss);
            ss = new List<int>();
            ss.Add(7);
            ss.Add(2);
            data.Add(ss);
            ss = new List<int>();
            ss.Add(1);
            data.Add(ss);
            ss = new List<int>();
            ss.Add(1);
            data.Add(ss);
            ss = new List<int>();
            ss.Add(1);
            data.Add(ss);
            ss = new List<int>();
 
            int combinations = 1;
 
            foreach (List<int> unsets in data)
            {
                combinations *= unsets.Count;
            }
 
            Console.WriteLine(">>>" + combinations);
 
            int[] mat = new int[9];
 
            int count_pos_comb = 0, pos_id = 0, current_comb = 0;
            for (int i = 0; i < combinations; i++)
            {
                for (int j = 0; j < data.Count; j++)
                {
// В этом блоке нужно добавить генерацию перестановок
                    if (data[j].Count > 1)
                    {
                        count_pos_comb = data[j].Count;
                        pos_id = j;
                    }
                    if (data[j].Count == 1)
                    {
                        mat[j] = data[j][0];
                    }
                    else
                    {
 
                        //
                    }
                }
            }
 
            Console.WriteLine();
            foreach (int i in mat )
            {
                Console.Write(i + " ");
            }

@Элд Хасп · 25.11.2018, 23:06

То есть на позициях где стоит несколько значений, надо получить варианты с каждым из них?

@LyciferAnZ · 25.11.2018, 23:23 **[ТС]**

Элд Хасп, именно)

@Элд Хасп · 25.11.2018, 23:37

Где-то у меня валялся для символов - недавно делал. Надо переделать под числа.

Добавлено через 19 секунд
Перебрать все возможные комбинации символов и в верхнем, и в нижнем регистрах

@LyciferAnZ · 25.11.2018, 23:45 **[ТС]**

Элд Хасп, Простите но тут перестановки просто символов, а у меня есть символы которые можно переставлять а есть те которые нельзя переставлять. Тут немножко сложнее.

Добавлено через 1 минуту
Элд Хасп, + запрещено использовать Linq((

@Элд Хасп · 26.11.2018, 00:26

Сообщение от LyciferAnZ

Простите но тут перестановки просто символов, а у меня есть символы которые можно переставлять а есть те которые нельзя переставлять. Тут немножко сложнее.

Там похоже. Там тоже только в определённой позиции символы имеют два варианта.
У Вас же тоже можно только в указанных позициях менять варианты значений. Там где варианты из одного значения там, только один выход.

Сообщение от LyciferAnZ

запрещено использовать Linq((

Посмотрю: может сегодня, но уже поздно, может завтра.

Добавлено через 15 минут
Вот по быстрому сделал. Но не проверял. Проверьте сами и отпишите результат. Завтра добью, если что.

C#

static List<List<int>> GetCombinations(List<List<int>> CharVariations)
{
    if (!(CharVariations?.Count > 0)) // Если входной последовательности нет
        return null;           // то возвращаем null 
 
    if (CharVariations.Count == 1)    // Если входная последовательность состоит из одной вариации
        return CharVariations;          // то возвращаем эту вариацию
 
    List<int> variation = CharVariations[CharVariations.Count - 1]; // Выделяем последнюю вариацию
    List<List<int>> сharVariations = CharVariations.GetRange(0, CharVariations.Count - 1); // Выделяем оставшиеся вариации
    List<List<int>> getVariations = GetCombinations(сharVariations); // Получаем комбинации из остававшихся элементов
    List<List<int>> ret = new List<List<int>>(); // Создание выходной комбинации
 
    foreach (List<int> getVar in сharVariations) // Цикл по полученным комбинациям
        foreach (int val in variation) // Цикл по выделенной вариации
        {
            List<int> newVar = new List<int>(getVar); // Создание новой копии комбинации
            newVar.Add(val); // Добавление в неё нового значения в последнюю позицию
            ret.Add(newVar); // Добавление полученной новой комбинации в выходной список
        }
 
    return ret;
}

@LyciferAnZ · 26.11.2018, 00:31 **[ТС]**

Элд Хасп, Извините, но не верно(( Ладно я уже придумал другой вариант решения. Если интерестно то я делаю судоку)

@Элд Хасп · 26.11.2018, 01:00

Что-то подумал и понял что ошибка. Надо так

C#

static List<List<int>> GetCombinations(List<List<int>> CharVariations)
{
    if (CharVariations == null) // Если входной последовательности нет
        return null;           // то возвращаем null 
 
    List<List<int>> ret = new List<List<int>>(); // Создание выходной комбинации
 
    if (CharVariations.Count == 0) // Если входная последовательность пустая
        return ret;           // то возвращаем пустую последовательность
 
    if (CharVariations.Count == 1)    // Если входная последовательность состоит из одной вариации
    {
        foreach (int val in CharVariations[0]) // Цикл по единственной вариации
            ret.Add(new List<int>() { val }); // Создаём из каждого значения вариации список с одним членом
        return ret;          // то возвращаем сформированные комбинации
    }                                         // И добавляем его в выходные комбинации
 
 
    // Если список вариацийсодержит 2 и более вариаций
 
    List<int> variation = CharVariations[CharVariations.Count - 1]; // Выделяем последнюю вариацию
    List<List<int>> сharVariations = CharVariations.GetRange(0, CharVariations.Count - 1); // Выделяем оставшиеся вариации
    List<List<int>> getVariations = GetCombinations(сharVariations); // Получаем комбинации из оставшихся элементов
 
    foreach (List<int> getVar in сharVariations) // Цикл по полученным комбинациям
        foreach (int val in variation) // Цикл по выделенной вариации
        {
            List<int> newVar = new List<int>(getVar); // Создание новой копии комбинации
            newVar.Add(val); // Добавление в неё нового значения в последнюю позицию
            ret.Add(newVar); // Добавление полученной новой комбинации в выходной список
        }
 
    return ret;
}

Добавлено через 56 секунд

Сообщение от LyciferAnZ

Если интерестно то я делаю судоку

Тоже когда-то делал...

Добавлено через 17 минут
Сам проверил - нашёл ошибку. В строке 25 перепутал переменные. Надо так

C#

25	foreach (List<int> getVar in getVariations) // Цикл по полученным комбинациям

Добавлено через 18 секунд
теперь всё работает.

@Aael · 26.11.2018, 01:13

до кучи вариант сразу с двумерным массивом (тут кортежи, но их легко убрать несколькими push'ами)

Кликните здесь для просмотра всего текста

C#

static IEnumerable<T[,]> Gen<T>(T[,][] data)
{
    var n = data.GetLength(0);
    var m = data.GetLength(1);
 
    var stack = new Stack<(int, int, int)>();
    var result = new T[n, m];
 
    stack.Push((0, 0, 0));
    while (stack.Count > 0)
    {
        (int i, int j, int k) = stack.Pop();
 
        if (i == n)
            yield return (T[,])result.Clone();
 
        else if (k < data[i, j].Length)
        {
            result[i, j] = data[i, j][k];
            stack.Push((i, j, k + 1));
            stack.Push((i + (j + 1) / m, (j + 1) % m, 0));
        }
    }
}
 
static void Main()
{
    var items = Gen(new int[,][]
    {
        { new int[]{2,4}, new int[]{0}, new int[]{0} },
        { new int[]{0}, new int[]{0}, new int[]{7, 2} },
        { new int[]{0}, new int[]{0}, new int[]{0} },
    });
 
    foreach (var item in items)
    {
        Console.WriteLine();
        for (int i = 0; i < 3; i++)
        {
            Console.WriteLine();
            for (int j = 0; j < 3; j++)
                Console.Write(item[i, j] + " ");
        }
    }
 
    Console.ReadLine();
}

@LyciferAnZ · 26.11.2018, 01:34 **[ТС]**

Спасибо работают 2 варианта))

Сделал судоку решает самый сложный судоку за 3-4 секунды. Работает как часи. Сначала работает по получению возможной позиции а если не справляется то идет решение по сегментам. Вот вопщем) Думаю препод поставит автомат)) Обещал просто)

C#

using System;
using System.Collections.Generic;
 
namespace Sudoku
{
    class SudokuV4
    {
        public bool Error { get; private set; }
 
        public void PrintBoard(int[,] board)
        {
            int block_col = 0, block_row = 0;
            int rows_count = board.GetLength(0), cols_count = board.GetLength(1);
            int percent_row = rows_count / 3, percend_col = cols_count / 3;
            for (int row = 0; row < rows_count; row++)
            {
                block_row++;
                for (int col = 0; col < rows_count; col++)
                {
                    block_col++;
                    Console.Write("{0}{1}", board[row, col], col < cols_count - 1 ? (block_col == 3 ? "  " : " ") : string.Empty);
                    if (block_col == percend_col)
                    {
                        block_col = 0;
                    }
                }
                if (block_row == percent_row)
                {
                    Console.WriteLine();
                    block_row = 0;
                }
                if (row < rows_count - 1)
                {
                    Console.WriteLine();
                }
            }
        }
 
        public int[,] Solver(int[,] board)
        {
            int[,] backup_board = (int[,])board.Clone();
            int[,] small_board = new int[3, 3];
            List<List<int>> unset_block = new List<List<int>>();
            List<int> positions = new List<int>();
            for (int row = 0; row < 9; row += 3)
            {
                for (int col = 0; col < 9; col += 3)
                {
                    for (int row_small = 0; row_small < 3; row_small++)
                    {
                        for (int col_small = 0; col_small < 3; col_small++)
                        {
                            small_board[row_small, col_small] = board[row + row_small, col + col_small];
                        }
                    }
                    unset_block.Add(GetUnset(small_board));
                }
            }
            while (CheckZero(board))
            {
                int block = 0, row_block = 0;
                for (int row = 0; row < 9; row++)
                {
                    for (int col = 0; col < 9; col++)
                    {
                        if (board[row, col] == 0)
                        {
                            positions = GetRowColTrueValues(board, row, col, unset_block[block]);
                            if (positions.Count == 1)
                            {
                                board[row, col] = positions[0];
                                unset_block[block].Add(board[row, col]);
                            }
                            else
                            {
                                positions = GetRowTrueValues(board, row, unset_block[block]);
                                if (positions.Count == 1)
                                {
                                    board[row, col] = positions[0];
                                    unset_block[block].Add(board[row, col]);
                                }
                                else
                                {
                                    positions = GetColTrueValues(board, col, unset_block[block]);
                                    if (positions.Count == 1)
                                    {
                                        board[row, col] = positions[0];
                                        unset_block[block].Add(board[row, col]);
                                    }
                                }
                            }
                        }
                        if ((col + 1) % 3 == 0)
                        {
                            block++;
                        }
                    }
                    block -= 3;
                    if (row_block == 2)
                    {
                        block += 3;
                    }
                    row_block++;
                    if ((row + 1) % 3 == 0)
                    {
                        row_block = 0;
                    }
                }
                if (CheckBoards(board, backup_board))
                {
                    int[] segment_board = ToOneDimensional(board);
                    if (CheckSudoku(segment_board))
                    {
 
                        if (SegmentSolver(0, ref segment_board))
                        {
                            return ToTwoDimensional(segment_board);
                        }
                        else
                        {
                            Error = true;
                            return board;
                        }
                    }
                    else
                    {
                        Error = true;
                        return board;
                    }
                }
                backup_board = (int[,])board.Clone();
            }
            return board;
        }
 
        private int[] ToOneDimensional(int[,] board)
        {
            int position = 0;
            int[] one_d_boad = new int[81];
            for (int row = 0; row < 9; row++)
            {
                for (int col = 0; col < 9; col++)
                {
                    one_d_boad[position] = board[row, col];
                    position++;
                }
            }
            return one_d_boad;
        }
 
        private int[,] ToTwoDimensional(int[] one_d_boad)
        {
            int row = 0, col = 0;
            int[,] board = new int[9, 9];
            for (int index = 0; index < one_d_boad.Length; index++)
            {
                board[row, col] = one_d_boad[index];
                col++;
                if (col == 9)
                {
                    col = 0;
                    row++;
                }
            }
            return board;
        }
 
        private bool CheckBoards(int[,] board, int[,] check_board)
        {
            for (int row = 0; row < 9; row++)
            {
                for (int col = 0; col < 9; col++)
                {
                    if (board[row, col] != check_board[row, col])
                    {
                        return false;
                    }
                }
            }
            return true;
        }
 
        private List<int> GetUnset(int[,] small_board)
        {
            List<int> result = new List<int>();
            for (int row = 0; row < 3; row++)
            {
                for (int col = 0; col < 3; col++)
                {
                    if (small_board[row, col] != 0)
                    {
                        result.Add(small_board[row, col]);
                    }
                }
            }
            return result;
        }
 
        private List<int> GetRowTrueValues(int[,] check_board, int row, List<int> unset)
        {
            List<int> row_values = new List<int>();
            for (int i = 0; i < 9; i++)
            {
                if (!row_values.Contains(check_board[row, i]))
                {
                    row_values.Add(check_board[row, i]);
                }
            }
            List<int> result = new List<int>();
            for (int i = 1; i < 10; i++)
            {
                if (!row_values.Contains(i))
                {
                    result.Add(i);
                }
            }
            if (unset.Count > 0)
            {
                foreach (int position in unset)
                {
                    result.Remove(position);
                }
            }
            return result;
        }
 
        private List<int> GetColTrueValues(int[,] check_board, int col, List<int> unset)
        {
            List<int> col_values = new List<int>();
            for (int i = 0; i < 9; i++)
            {
                if (!col_values.Contains(check_board[i, col]))
                {
                    col_values.Add(check_board[i, col]);
                }
            }
            List<int> result = new List<int>();
            for (int i = 1; i < 10; i++)
            {
                if (!col_values.Contains(i))
                {
                    result.Add(i);
                }
            }
            if (unset.Count > 0)
            {
                foreach (int position in unset)
                {
                    result.Remove(position);
                }
            }
            return result;
        }
 
        private List<int> GetRowColTrueValues(int[,] check_board, int row, int col, List<int> unset)
        {
            List<int> row_values = new List<int>();
            List<int> col_values = new List<int>();
            for (int i = 0; i < 9; i++)
            {
                if (!row_values.Contains(check_board[row, i]) && check_board[row, i] != 0)
                {
                    row_values.Add(check_board[row, i]);
                }
                if (!col_values.Contains(check_board[i, col]) && check_board[i, col] != 0)
                {
                    col_values.Add(check_board[i, col]);
                }
            }
            List<int> result = new List<int>();
            for (int i = 1; i < 10; i++)
            {
                if (!row_values.Contains(i) && !col_values.Contains(i))
                {
                    result.Add(i);
                }
            }
            if (unset.Count > 0)
            {
                foreach (int position in unset)
                {
                    result.Remove(position);
                }
            }
            return result;
        }
 
        private bool CheckZero(int[,] board)
        {
            for (int i = 0; i < board.GetLength(1); i++)
            {
                for (int j = 0; j < board.GetLength(1); j++)
                {
                    if (board[i, j] == 0)
                    {
                        return true;
                    }
                }
            }
            return false;
        }
 
        private bool CheckSudoku(int[] board)
        {
            for (int index = 0; index < 81; index++)
            {
                if (9 < board[index] || board[index] < 0)
                {
                    return false;
                }
                if (board[index] != 0)
                {
                    if (!CheckTrueValue(board[index], index, board))
                    {
                        return false;
                    }
                }
            }
            return true;
        }
 
        private bool SegmentSolver(int index, ref int[] board)
        {
            if ((index < 81) && (board[index] == 0))
            {
                Stack<int> trueValues = new Stack<int>();
                for (int possibleValue = 1; possibleValue < 10; possibleValue++)
                {
                    if (CheckTrueValue(possibleValue, index, board))
                    {
                        trueValues.Push(possibleValue);
                    }
                }
                while (trueValues.Count > 0)
                {
                    board[index] = trueValues.Pop();
                    if (SegmentSolver(index + 1, ref board))
                    {
                        return true;
                    }
                }
                board[index] = 0;
                return false;
            }
            else if (index < 81)
            {
                if (SegmentSolver(index + 1, ref board) == false)
                {
                    return false;
                }
            }
            return true;
        }
 
        private bool CheckTrueValue(int value, int index, int[] board)
        {
            for (int j = 0; j < 9; j++)
            {
                if (value == board[(index / 9) * 9 + j] && index != (index / 9) * 9 + j)
                {
                    return false;
                }
 
                if (value == board[(index % 9) + 9 * j] && index != (index % 9) + 9 * j)
                {
                    return false;
                }
            }
            for (int j = 0; j < 3; j++)
            {
                for (int k = 0; k < 3; k++)
                {
                    if (value == board[(index / 27 * 27) + (index % 9 / 3 * 3) + (9 * j) + k] && index != ((index / 27 * 27) + (index % 9) / 3 * 3 + (9 * j) + k))
                    {
                        return false;
                    }
                }
            }
            return true;
        }
    }
}
 
class Program
    {
        static void Main(string[] args)
        {
            SudokuV4 sudoku = new SudokuV4();
            int[,] board = new int[,] {
                { 0,6,0,  8,1,4,  5,7,0 },
                { 0,9,0,  2,0,5,  8,4,0 },
                { 0,4,8,  7,0,0,  3,2,0 },
                { 4,0,6,  0,8,0,  1,0,2 },
                { 8,0,7,  9,2,0,  4,0,3 },
                { 0,0,9,  3,4,0,  7,0,8 },
                { 2,0,0,  0,9,8,  0,3,7 },
                { 6,7,0,  0,0,2,  0,8,4 },
                { 9,8,4,  0,0,3,  0,1,5 }
            };
            int[,] board2 = new int[,]
            {
                { 5, 3, 0,  0, 7, 0,  0, 0, 0 },
                { 6, 0, 0,  1, 9, 5,  0, 0, 0 },
                { 0, 9, 8,  0, 0, 0,  0, 6, 0 },
                { 8, 0, 0,  0, 6, 0,  0, 0, 3 },
                { 4, 0, 0,  8, 0, 3,  0, 0, 1 },
                { 7, 0, 0,  0, 2, 0,  0, 0, 6 },
                { 0, 6, 0,  0, 0, 0,  2, 8, 0 },
                { 0, 0, 0,  4, 1, 9,  0, 0, 5 },
                { 0, 0, 0,  0, 8, 0,  0, 7, 9 }
            };
            int[,] max_hard = new int[,]
            {
                { 8, 0, 0,  0, 0, 0,  0, 0, 0 },
                { 0, 0, 3,  6, 0, 0,  0, 0, 0 },
                { 0, 7, 0,  0, 9, 0,  2, 0, 0 },
                { 0, 5, 0,  0, 0, 7,  0, 0, 0 },
                { 0, 0, 0,  0, 4, 5,  7, 0, 0 },
                { 0, 0, 0,  1, 0, 0,  0, 3, 0 },
                { 0, 0, 1,  0, 0, 0,  0, 6, 8 },
                { 0, 0, 8,  5, 0, 0,  0, 1, 0 },
                { 0, 9, 0,  0, 0, 0,  4, 0, 0 }
            };
            board = sudoku.Solver(board2);
            sudoku.PrintBoard(board);
            Console.ReadLine();
        }
    }

@Элд Хасп · 26.11.2018, 03:23

Сообщение от LyciferAnZ

Сделал судоку решает самый сложный судоку за 3-4 секунды. Работает как часи. Сначала работает по получению возможной позиции а если не справляется то идет решение по сегментам. Вот вопщем) Думаю препод поставит автомат)) Обещал просто)

Удачной сдачи!
Теперь следующий шаг - сделайте теперь это как положено в ООП.....классы: судоку, строка, колонка, блок, ячейка и т.д. Все связи между ними. Потом WPF представление к нему, ViewModel - опыт получите хороший.

@LyciferAnZ 33 / 8 / 6 Регистрация: 28.09.2016 Сообщений: 200
		1
	.NET 4.x Получить массив комбинаций, где элементы массива могут принимать несколько значений 25.11.2018, 22:25. Показов 2751. Ответов 12 Метки нет (Все метки) Помогите получить список комбинаций. Вот например двумерный массив: [(2,4),0,0], [0,0,(7,2)], [0,0,0] Значения в дужках это значения которые может принимать элемент массива. Массив может бить любой размерности от 3 до 9, но обязательно квадратный. Но желательно 9 на 9. Результатом должен быть например List<int[,]> из массивов: 2 0 0 0 0 7 0 0 0 2 0 0 0 0 2 0 0 0 4 0 0 0 0 7 0 0 0 4 0 0 0 0 2 0 0 0 (Вместо 0 могут быть любые значения от 1 до 9) Знаю как сделать обычные перестановки в одномерном массиве, а тут без понятия. Буду благодарен за помощь. Добавлено через 2 часа 52 минуты Решил попробовать решить алгоритм на листике бумаги. Что то вышло но нужно перенести в алгоритм на c#. Вот что вышло: По сути двумерный массив не нужен. На вход я получаю List<List<int>> если по предыдущему примеру смотреть, то [(2,4),0,0,0,0,(7,2),0,0] Количество выходных массивов можно узнать перемноживши все количества вложеных List<int>, тоесть 2111121*1 = 4. Пробую рисовать все комбинации 1) 2 0 0 0 0 7 0 0 0 2) 2 0 0 0 0 2 0 0 0 3) 4 0 0 0 0 7 0 0 0 4) 4 0 0 0 0 2 0 0 0 Наче сошлось После этого можно переводить в двумерные и делать что нужно Помогите плс 0

@Элд Хасп Модератор 15102 / 10394 / 2731 Регистрация: 21.04.2018 Сообщений: 30,823 Записей в блоге: 2
	25.11.2018, 22:29	2
	LyciferAnZ, то что Вы просите - не понятно. Дайте более детальное объяснение, и желательно с несколькими примерами 0

@Элд Хасп Модератор 15102 / 10394 / 2731 Регистрация: 21.04.2018 Сообщений: 30,823 Записей в блоге: 2
	25.11.2018, 23:06	4
	То есть на позициях где стоит несколько значений, надо получить варианты с каждым из них? 0

@LyciferAnZ 33 / 8 / 6 Регистрация: 28.09.2016 Сообщений: 200
	25.11.2018, 23:23 [ТС]	5
	Элд Хасп, именно) 0

@Элд Хасп Модератор 15102 / 10394 / 2731 Регистрация: 21.04.2018 Сообщений: 30,823 Записей в блоге: 2
	25.11.2018, 23:37	6
	Где-то у меня валялся для символов - недавно делал. Надо переделать под числа. Добавлено через 19 секунд Перебрать все возможные комбинации символов и в верхнем, и в нижнем регистрах 0

@LyciferAnZ 33 / 8 / 6 Регистрация: 28.09.2016 Сообщений: 200
	25.11.2018, 23:45 [ТС]	7
	Элд Хасп, Простите но тут перестановки просто символов, а у меня есть символы которые можно переставлять а есть те которые нельзя переставлять. Тут немножко сложнее. Добавлено через 1 минуту Элд Хасп, + запрещено использовать Linq(( 0

@LyciferAnZ 33 / 8 / 6 Регистрация: 28.09.2016 Сообщений: 200
	26.11.2018, 00:31 [ТС]	9
	Элд Хасп, Извините, но не верно(( Ладно я уже придумал другой вариант решения. Если интерестно то я делаю судоку) 0

@Элд Хасп Модератор 15102 / 10394 / 2731 Регистрация: 21.04.2018 Сообщений: 30,823 Записей в блоге: 2
	26.11.2018, 03:23	13
	Сообщение от LyciferAnZ Сделал судоку решает самый сложный судоку за 3-4 секунды. Работает как часи. Сначала работает по получению возможной позиции а если не справляется то идет решение по сегментам. Вот вопщем) Думаю препод поставит автомат)) Обещал просто) Удачной сдачи! Теперь следующий шаг - сделайте теперь это как положено в ООП.....классы: судоку, строка, колонка, блок, ячейка и т.д. Все связи между ними. Потом WPF представление к нему, ViewModel - опыт получите хороший. 1

Опции темы

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

Решение