Получить значение определенного номера массива по отношению к данному значению

Question

Получить значение определенного номера массива по отношению к данному значению

1

Я пытаюсь определить, какие ставки соседа будут для данного номера на колесе рулетки. На данный момент я передаю номер кармана функции, а ниже - мой код. "pocket_number() [0]" - это значение числа, которое я хочу определить для соседей.

int[] neightbourbets = neighbourbets(pocket_number()[0]);

neighbourbets() выглядит следующим образом (это выводит массив чисел элементов, так что в другом месте моей программы я могу извлечь их из той же структуры массива). В настоящий момент у меня есть грубый способ определения соседей ставок и получения функции, чтобы указать, какие числа составляют 6 чисел по обе стороны от нее. Есть лучший способ сделать это? Я нашел одну из проблем (которую я преодолел ниже), если я хочу знать соседей для "0", например, это означает, что код должен получить числа от конца массива.

public int[] neighbourbets(int x)
{
    int[] pocket_array = new[] {0, 32, 15, 19, 4, 21, 2, 25, 17, 34, 6, 27, 13, 36, 11, 30, 8, 23, 10, 5, 24, 16, 33, 1, 20, 14, 31, 9, 22, 18, 29, 7, 28, 12, 35, 3, 26};
    int predictednum = Array.IndexOf(pocket_array,x); //element number of pocket_array for chosen number

    int[] neighbourbets = new[] {0,0,0,0,0,0,0,0,0,0,0,0,0};

    neighbourbets[0] = predictednum;
    neighbourbets[1] = predictednum+1;
    neighbourbets[2] = predictednum+2;
    neighbourbets[3] = predictednum+3;
    neighbourbets[4] = predictednum+4;
    neighbourbets[5] = predictednum+5;
    neighbourbets[6] = predictednum+6;
    neighbourbets[7] = predictednum-1;
    neighbourbets[8] = predictednum-2;
    neighbourbets[9] = predictednum-3;
    neighbourbets[10] = predictednum-4;
    neighbourbets[11] = predictednum-5;
    neighbourbets[12] = predictednum-6;

    for (int i = 0; i < neighbourbets.Length; i++)
    {
        //clockwise neighours
        if (neighbourbets[i] == -1) {
                neighbourbets[i] = 36;
        }
        if (neighbourbets[i] == -2) {
                neighbourbets[i] = 35;
        }
        if (neighbourbets[i] == -3) {
                neighbourbets[i] = 34;
        }
        if (neighbourbets[i] == -4) {
                neighbourbets[i] = 33;
        }
        if (neighbourbets[i] == -5) {
                neighbourbets[i] = 32;
        }
        if (neighbourbets[i] == -6) {
                neighbourbets[i] = 31;
        }

        //anticlockwise neighbours  
        if (neighbourbets[i] == 37) {
                neighbourbets[i] = 0;
        }
        if (neighbourbets[i] == 38) {
                neighbourbets[i] = 1;
        }
        if (neighbourbets[i] == 39) {
                neighbourbets[i] = 2;
        }
        if (neighbourbets[i] == 40) {
                neighbourbets[i] = 3;
        }
        if (neighbourbets[i] == 41) {
                neighbourbets[i] = 4;
        }
        if (neighbourbets[i] == 42) {
                neighbourbets[i] = 5;
        }
    }  
    return neighbourbets;
}

Любые помощь или доверие оцениваются! :)

papa_face 18 янв. 2015, в 14:48

Источник

Теги:

c#

arrays

2 ответа

0

Следующее даст вам результат с x в середине массива результатов и соседей слева и справа от него:

public static int[] neighbourbets2(int x, int neighborCount)
{
    int[] pocket_array = new[] { 0, 32, 15, 19, 4, 21, 2, 25, 17, 34, 6, 27, 13, 36, 11, 30, 8, 23, 10, 5, 24, 16, 33, 1, 20, 14, 31, 9, 22, 18, 29, 7, 28, 12, 35, 3, 26 };
    int predictednum = Array.IndexOf(pocket_array, x);

    // Initialize the result array. Its size is double the neighbour count + 1 for x
    int[] result = new int[neighborCount * 2 + 1];

    // Calc the start index. We begin at the most left item.
    int startAt = predictednum - neighborCount;

    // i - position in the result array
    // j - position in the pocket_array
    for (int i = 0, j = startAt; i < result.Length; i++, j++)
    {
        // Adjust j if it less then 0 to wrap around the array.
        result[i] = pocket_array[j < 0 ? j + pocket_array.Length : j];

        // If we are at the end then start from the beginning.
        if (j == pocket_array.Length)
        {        
            j = 0;
        }
    }
    return result;
}

t3chb0t 18 янв. 2015, в 14:13

Ещё вопросы

Chris · Accepted Answer · 2015-01-18T12-21-00.000Z

Напишите небольшую вспомогательную функцию для обертывания индекса:

private int GetPocketIndex( int start, int offset, int count )
{
    int pos = ( start + offset ) % count;
    if( pos >= 0 )
        return pos;
    else
        return count + pos; // pos is negative so we use +
}

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

Тогда, если вам нужен этот конкретный порядок, возможно, что-то вроде этого:

int[] offsets = new int[] { 0,
                            1,  2,  3,  4,  5,  6,
                           -1, -2, -3, -4, -5, -6 };    
int[] neighbourbets = new int[offsets.Length];

for( int i = 0; i < offsets.Length; i++ )
    neighbourbets[i] = GetPocketIndex( predictednum, offsets[i], pocket_array.Length );

Или, если какой-либо заказ будет выполнен:

int count = 6;
int[] neighbourbets = new int[count * 2 + 1];
for( int i = 0; i < neighbourbets.Length; i++ )
    neightbourbets[i] = GetPocketIndex( predictednum, i - count, pocket_array.Length );