Вызов Кода — Найти X В Частично Отсортированном Массиве

Ваша задача — найти местоположение (индекс чтения) данного элемента.

Time Complexity      Coefficient
--------------------------------
O(1)                 0.25
O(log(n))            0.5
O(n)                 5
O(n*log(n))          8.5
O(n^2)               10
O(greater than n^2)  20

1. Возьмите полностью отсортированный целочисленный массив размером

    
    
    I 
    
    

   ( I известно неявно)
2. Возьмите любое случайное количество взаимоисключающих пар четных индексов (так как ни один индекс не встречается более чем в одной паре) из массива и поменяйте местами элементы в этих индексах.

Пример массива может быть таким

образованный

и образец <byte count of your program>*<coeff. of complexity> to find in this array can be

Вы должны вывести индекс элемента X in the final array ( [5, 2, 3, 4, 1, 6, 9, 8, 7, 10] 1 в приведенном выше примере) или <Array> <X> if the element is not found in the array.

Правила

• Встроенные функции поиска запрещены.
• Вы должны написать метод/функцию/программу, которая принимает входные данные из STDIN/аргументов командной строки/аргументов функции.
• Ввод должен быть в -1 format. Example: 4
• Входной массив также может содержать повторяющиеся целые числа. В таком случае выходным может быть любой индекс. ОБНОВЛЯТЬ : Вы можете предположить, что общее количество дубликатов << (намного меньше) размера массива. В общем, дубликаты теперь запрещены, чтобы не влиять на временную сложность алгоритма поиска.
• Выходные данные должны быть индексом элемента X in the array or -1 если нет.

Подсчет очков

• Поскольку a и a , ваш результат рассчитывается по формуле X
• Коэффициент сложности определяется на основе временной сложности вашего кода в наихудшем случае (Big-O) с использованием приведенных ниже сопоставлений.
• Если вашему коду необходимо знать длину массива, он может вычислить длину с помощью встроенных методов, и это не будет увеличивать временную сложность поисковой части кода.

Минимальный балл выигрывает!

Бонус

• Умножьте свой окончательный результат на [5, 2, 3, 4, -1, 6, 90, 80, 70, 100] if you can handle a case where the array has gone through the step 2 in the transformation process N раз (вместо 1), где N is passed as the third parameter in input.
• Обратите внимание, что при выполнении шага 2 X times, pairs in each step are mutually exclusive, but pairs in different steps can have common indexes.

#код-гольф #код-вызов #код-вызов #поиск

JavaScript (E6) 97,5 (39*5*0,5)

(O(n), линейный поиск, массив можно шифровать снова и снова)
Функция принимает (и игнорирует) третий параметр.

 
 
 
 
 
 
 
 
 
 f=(a,x)=>a.reduce((p,c,i)=>c-x?p:i,-1)
 
 
 
 
 
 
 
 
 
 

или

или

Тест в консоли FireFox/FireBug

Выход

Гольфскрипт, 20*2,5=50

Объяснение:

• adjust 0 = -1 adjust x = x find [] _ = -1 find (x:xs) n | x == n = 0 | otherwise = adjust $ 1 + find xs n - eval the input. It should be in the form a 0= -1;a x=x;f[]_= -1;f(h:t)n|h==n=0|1>0=a$1+f t n .
• 0 - prepend the last argument (needle) to 0):0 , затем сопоставьте полученную функцию с массивом
• * - discard the results of the mapping, and push -1 в стек.

Самое интересное — это то, что происходит внутри:

• 0 - check if the needle matches the haystack element
• {0:-1} - take the current value of the variable = и сохраните его в переменной -1 .
• ;-1 - execute the function n times = execute if the previous is true.
• {...} - increment the current value of {...}+% .

ага. В Golfscript все числовые литералы — это просто переменные, инициализированные некоторыми полезными значениями.

Хаскель, 51*2,5=127,5

без гольфа:

Питон 79,75 (319*0,5*0,5) 106,5 (213*0,5)

ОБНОВЛЯТЬ: Поскольку временная сложность определяется наихудшим случаем для любого количества свопов, я сократил свой алгоритм, чтобы он работал только для случая ~{={0:-1}*0):0}+%;-1 , which results in O(log n) time.

Функция findX — это f, а g и h — вспомогательные функции.

Функция использует упорядочивание нечетных индексов для поиска места, где должен находиться X. Если X был заменен, то он использует второй двоичный файл для поиска места, куда был заменен X, на основе значения, найденного там, где X должен был быть. Поскольку я использую два двоичных поиска, в худшем случае это O(logN).

Я нахожу X, применяя бинарный поиск по нечетным индексам. Если X не найден по нечетным индексам, я проверяю массив по четному индексу, где X должен быть, если массив был упорядочен (назовем это значение n1). Если n1 равно X, я нашел индекс. Если n1 не равно X, я использую тот же двоичный поиск, чтобы найти, где должен находиться n1 в упорядоченном массиве (чтобы проверить, был ли X заменен на n1). Назовите это новое значение n2. Если n2 равно X, я нашел индекс. В противном случае я использую тот же двоичный поиск, чтобы найти, где должен находиться n1 в упорядоченном массиве (чтобы проверить, был ли X заменен на n2)... и т. д.

Алгоритм завершается, когда X найден или n1 найден во второй раз.

По сути, мой алгоритм отслеживает случайную замену в обратном порядке. То есть он «декодирует» последний обмен, затем «декодирует» предпоследний обмен и так далее, пока я не декодирую первый обмен. Для каждого «декодирования» я использую двоичный поиск (время O(logN)), а также дополнительный двоичный поиск для поиска первого индекса. Алгоритм «декодирует» простейшую последовательность случайных замен, чтобы перейти в заданное состояние (например, алгоритм не будет применять никакого декодирования к массиву, к которому дважды применялась одна и та же замена). Также обратите внимание, что любая последовательность перестановок будет эквивалентна последовательности перестановок длиной меньше или равной N/2. Следовательно, сложность в худшем случае составляет O(min(I, N/2) * logN), и алгоритм работает для I свопов.

def h(l,F,X,s,m):

F([5, 2, 3, 4, -1, 6, 90, 80, 70, 100],-1, 2)

я=g(l,F,0,m-m%2)

F=(a,x)=>a.every((e,i)=>(j=i,e-x))?-1:j

вернуть -1, если i==s или i>=m else i, если l[i]==X else h(l,l[i],X,s,m)

Бывший: F=(a,x)=>a.some((e,i)=>(j=i,e==x))?j:-1 search. Accepts bonus parameter but ignores it