# Pairs

### Problem Statement :

```Given an array of integers and a target value, determine the number of pairs of array elements that have a difference equal to the target value.

Function Description

Complete the pairs function below.

pairs has the following parameter(s):

int k: an integer, the target difference
int arr[n]: an array of integers
Returns

int: the number of pairs that satisfy the criterion
Input Format

The first line contains two space-separated integers n and k, the size of arr and the target value.
The second line contains n space-separated integers of the array arr .

Constraints

2   <=   n   <=   10^5
0   <=   k   <=   10^9
0   <=   arr[ i ]  <=  2^31 -1
each integer arr[ i ]  will be unique

Sample Input

STDIN          Function
-----                 --------
5 2              arr[] size n = 5, k =2
1 5 3 4 2    arr = [1, 5, 3, 4, 2]

Sample Output

3```

### Solution :

```                            ```Solution in C :

In   C :

#include<stdio.h>
int get_num()
{
int num=0;
char c=getchar_unlocked();
while(!(c>='0' && c<='9'))
c=getchar_unlocked();
while(c>='0' && c<='9')
{
num=(num<<3)+(num<<1)+c-'0';
c=getchar_unlocked();
}
return num;
}
void quicksort(int x[],int first,int last)
{
int pivot,j,temp,i;

if(first<last)
{
pivot=first;
i=first;
j=last;

while(i<j){
while(x[i]<=x[pivot]&&i<last)
i++;
while(x[j]>x[pivot])
j--;
if(i<j){
temp=x[i];
x[i]=x[j];
x[j]=temp;
}
}

temp=x[pivot];
x[pivot]=x[j];
x[j]=temp;
quicksort(x,first,j-1);
quicksort(x,j+1,last);

}
}
int main()
{
int n=get_num();
int k=get_num();
int a={0};
int i=0;
while(i<n)
a[i++]=get_num();
quicksort(a,0,n-1);
int temp=0,count=0,flag=0;
for(i=0;i<n-1;i++)
{
int j=i+1;
temp=0;
for(;j<n;j++)
{
if(a[j]-a[i]==k)
count++;
else if(a[j]-a[i]>k)
break;
}
}
printf("%d\n",count);
return 0;
}```
```

```                        ```Solution in C++ :

In   C++  :

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <cstdio>
#include <limits>
#include <vector>
#include <cstdlib>
#include <numeric>
#include <sstream>
#include <iostream>
#include <algorithm>
using namespace std;

int pairs(vector <int> a,int k) {
int ans = 0;
set<long long> s;
for(int i = 0; i < a.size(); i++) s.insert(a[i]);
for(int i = 0; i < a.size(); i++){
long long b = a[i] - k;
if(s.count(b)) ans ++;
}
return ans;
}

/* Tail starts here */
int main() {
int res;

int _a_size,_k;
cin >> _a_size>>_k;
cin.ignore (std::numeric_limits<std::streamsize>::max(), '\n');
vector<int> _a;
int _a_item;
for(int _a_i=0; _a_i<_a_size; _a_i++) {
cin >> _a_item;
_a.push_back(_a_item);
}

res = pairs(_a,_k);
cout << res;

return 0;
}```
```

```                        ```Solution in Java :

In  Java  :

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {
static int pairs(int[] a,int k) {
Arrays.sort(a);
int N = a.length;
int count = 0;
for (int i = 0; i < N - 1; i++)
{
int j = i + 1;
while((j < N) && (a[j++] - a[i]) < k);
j--;
while((j < N) && (a[j++] - a[i]) == k)
count++;
}

return count;
}

public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int res;

String n = in.nextLine();
String[] n_split = n.split(" ");

int _a_size = Integer.parseInt(n_split);
int _k = Integer.parseInt(n_split);

int[] _a = new int[_a_size];
int _a_item;
String next = in.nextLine();
String[] next_split = next.split(" ");

for(int _a_i = 0; _a_i < _a_size; _a_i++) {
_a_item = Integer.parseInt(next_split[_a_i]);
_a[_a_i] = _a_item;
}

res = pairs(_a,_k);
System.out.println(res);
}
}```
```

```                        ```Solution in Python :

In  Python3 :

def main():
N, K = (int(x) for x in sys.stdin.readline().split())
A = [int(x) for x in sys.stdin.readline().split()]
setA = set(A)
count = 0
for x in A:
if (x-K) in setA:
count = count +1
print (count)

if __name__ == '__main__':
import sys
main()```
```

## Delete a Node

Delete the node at a given position in a linked list and return a reference to the head node. The head is at position 0. The list may be empty after you delete the node. In that case, return a null value. Example: list=0->1->2->3 position=2 After removing the node at position 2, list'= 0->1->-3. Function Description: Complete the deleteNode function in the editor below. deleteNo

## Print in Reverse

Given a pointer to the head of a singly-linked list, print each data value from the reversed list. If the given list is empty, do not print anything. Example head* refers to the linked list with data values 1->2->3->Null Print the following: 3 2 1 Function Description: Complete the reversePrint function in the editor below. reversePrint has the following parameters: Sing

Given the pointer to the head node of a linked list, change the next pointers of the nodes so that their order is reversed. The head pointer given may be null meaning that the initial list is empty. Example: head references the list 1->2->3->Null. Manipulate the next pointers of each node in place and return head, now referencing the head of the list 3->2->1->Null. Function Descriptio