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

Эта функция по умолчанию присутствует в python, но не в старых языках программирования, таких как C / C ++, Java и т. Д. И по этой удивительной причине я однажды подумал об использовании python для решения конкурентных задач кодирования, когда у нас ограничено время и мы не можем использовать такие реализации для построить или накрыть самостоятельно. Но потом я подумал, что если разработчики на Python могут, то и я могу.

Сначала я искал общие решения, при которых, если массив передается с индексом, превышающим его предел, мы можем просто вычесть значение, эквивалентное последнему индексу массива, используя условие «если» во всех местах, где используется массив, а затем передать полученное значение в массив. Если вы не понимаете, почему мы вычтем длину, а не значение, равное последнему индексу, тогда вам следует прекратить чтение и попробовать эту проблему, а затем вернуться для предварительного, но небольшого решения, но перед этим поищите реализацию приведенного выше объяснения. .

// len is equal to the length of the array

if(index > len-1)
{
  Array[index - len];
}

/* we will subtract length of array and not value equal to the last index because                by subtracting length only we can get indexes starting from zero when the array limit is crossed. For example if index has value 10, then 10 should correspond to index value 0 of the array, similarly 11 corresponds to index 1 and so on till 19 corresponding to the last index 9 which can be achieved if we subtract the length of the array from index if index exceeds the array limit.
*/

Это решение, вероятно, первое, что придет вам в голову, когда вы думаете об этой проблеме, но в любом случае вы должны сначала подумать о своем собственном решении, а затем прочитать это решение. В дальнейшем это решение не совсем оптимальное. Почему ? Подумайте о состоянии, при котором значение, переданное в массив, 2 раза превышает ограничение массива. В этом состоянии простое вычитание длины не сработает, так как она все равно выйдет за пределы. Но вы все равно можете создать лестницу «если еще», чтобы охватить случаи, когда значение, переданное в массив, может быть в 2 или 3 раза больше его длины, или давайте предположим, что вы делали это до 10 раз, но что после этого. Несмотря на то, что это может быть редким случаем в вашей ситуации, но не каждый раз для всех, и, следовательно, это не универсальное решение, и даже если вы просто рассматриваете свой случай, и он работает для вас, этот трюк также будет длительным и не оптимально. Посмотрите приведенное выше объяснение ниже.

// if else ladder to cover index crossing array limit upto 10 times
// let length of the array is 10, which means from index 0 to 9

if(index > 89)       // if index exceeds the array limit 9 times
{
   Array[index - (len*9)];
}

else if(index > 79)  // if index exceeds the array limit 8 times
{
   Array[index - (len*8)];
}

.
.
.

else if(index > 9)  // if index exceeds the array limit 1 time
{
   Array[index - (len*1)];
}
// general notation to above code is given below which can be replicated

if(index > (len*t-1)) // len is length of array and t is no. of times limit is              {                     //exceeding, for which this case is written
   Array[index - (len*t)];
}

Наконец, окончательное решение этой проблемы - использование модуля (%). Если вы занимаетесь программированием, вы должны знать, что такое модуль. Этот оператор в программировании возвращает целочисленный остаток после деления заданных чисел. Считайте, что число, которое нужно передать в массив, - это «index», а размер массива - «len», тогда все, что вам нужно сделать, это вместо того, чтобы писать массив с индексом «index» как Array [index], запишите его как Array [index % len]. Помните, что «len» всегда должно быть равно длине массива, а не последнему значению индекса.

Array[index % len]; 
// for all cases including when array limit is not exceeded

Пример выполнения: предположим, что существует массив размером 10, что означает от индекса 0 до 9. Если значение для индекса переменной равно 10, тогда решение «index% len», то есть в этом случае 10% 10 равно 0 и что это то, что мы хотим. Для индекса 15 это будет 15% 10, что равно 5, а для значения индекса 98 это будет 98% 10, что равно 8. Даже для случаев, когда значение индекса остается меньше длины, тогда это также будет работать нормально. Пример: 3% 10 равно 3, а 0% 10 равно нулю и так далее.

Modulo - мощный оператор, и этот пример - лишь одна из реализаций, демонстрирующих его силу. И не только по модулю, но есть много концепций, которые мы изучаем, но никогда не реализуем, чтобы придумать что-то мощное. Оставайтесь на связи, чтобы узнать больше об удивительных трюках и теориях, которые скоро появятся….

#uvt