Question

我陷入了 Hackerrank 问题之一，问题描述如下：-

将为您提供一个整数数组和一个目标值。确定差值等于目标值的数组元素对的数量。

例如，给定一个[1, 2, 3, 4]数组和一个目标值1，我们有三个满足条件的值：(2,1), (3,2), (4,3)。因此，函数对应该返回值3。

我们必须使用以下参数实现结对功能：-

k: an integer, the target difference
arr: an array of integers

约束：-

1> Each Integer in arr[i] will be unique and positive.
2> target k will also be positive.

我的下面的函数实现由于错误的结果而无法通过18个测试用例之一。谁能帮我调试问题：-

def binSearch(target,arr):
    lower = 0
    upper = len(arr)-1
    while lower <= upper:
        mid = int((lower + upper)/2)
        if(arr[mid] == target):
            return 1
        elif(arr[mid] > target):
            upper = mid - 1
        elif(arr[mid] < target):
            lower = mid + 1
    return -1

def pairs(k, arr):
    arr.sort()
    count = 0
    for i in range(len(arr)):
        target = abs(arr[i] - k)
        if(arr[i] == target):
            pass
        elif(binSearch(target,arr) == 1):
            count += 1
    return count

Answer 1

这应该是O（n）解决方案（其中<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" android:id="@+id/container" android:layout_width="match_parent" android:layout_height="match_parent" android:background="@drawable/back" tools:context="com.nooshindroid.yastashir.activities.MainActivity"> <FrameLayout android:id="@+id/fragment_container" android:layout_width="match_parent" android:layout_height="match_parent" android:layout_marginBottom="@dimen/margin_main" android:layout_marginLeft="@dimen/margin_main" android:layout_marginRight="@dimen/margin_main" android:background="@drawable/border1" app:layout_constraintBottom_toTopOf="@id/navigation" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf="parent"> </FrameLayout> <com.google.android.material.bottomnavigation.BottomNavigationView android:id="@+id/navigation" android:layout_width="0dp" android:layout_height="wrap_content" android:background="@color/colorPrimary" android:foregroundGravity="center" android:layoutDirection="rtl" app:itemBackground="@color/colorPrimary" app:itemIconTint="@color/colorNavText" app:itemTextColor="@color/colorNavText" app:layout_constraintBottom_toBottomOf="parent" app:layout_constraintLeft_toLeftOf="parent" app:layout_constraintRight_toRightOf="parent" app:menu="@menu/navigation" />是n的大小）。首先，将数组转换为集合。然后遍历arr中的每个值，并检查arr是否在集合中，即另一个值与当前值arr + k之间的差等于val。如果是这样，请将k加1。

counter

Answer 2

对于数组limit查找所有对arr使得(arr[i],arr[j])等同于发现arr[i] - arr[j] = k这样arr[i]。如果我们尝试在原始数组arr[i] = arr[j] + k中找到元素arr[j] + k，则其时间复杂度为arr。

但是，由于数组中的所有数字对于每个O(len(arr))都是不同的，因此可能存在单个结果arr[j] + k: 0=<j<len(arr)（或没有结果）。这就是为什么我们可以将数组arr[i]的所有元素放入集合中以改善对arr的搜索的原因。

因此，计算对数可以是1线：）：

O(1)

Answer 3

通过Java，朗姆酒时间将花费O（n log n）来对数组进行排序，而二进制搜索则花费O（log m）从而O（n log n + log m）==> O（n log n）空间将占用O（n）

public static ArrayList<Pair<Integer, Integer>> pairThatHaveDiffrenceK(int[] arr , int arrLength , int k ){



        ArrayList<Pair<Integer, Integer>> arrayList = new ArrayList<>();
        Arrays.sort(arr);

        for (int i = 0; i < arrLength ; i++) {
            temp = arr[i] + k;
            int testIfFound = indexFromBinarySearch(arr, temp);
            if (testIfFound != -1){
                arrayList.add(new Pair<>(arr[i],arr[testIfFound] ));
           }
        }

        return arrayList ;
    }


    public static int indexFromBinarySearch(int[] arr, int valueForTarget){
        int start =0 ;
        int end = arr.length-1;
        while (start <= end){
            int mid = (start+end)/2 ;
            if(arr[mid] == valueForTarget){
                return mid;
            }
            else if(valueForTarget > arr[mid])
                start =mid+1;
            else
                end = mid-1;

        }
        return -1 ;
    }

在数组中找到总和等于给定值的所有元素对

3 个答案: