## Given a Linked List. Write a Program to retain n elements and delete m elements till the end of the List.

Consider a Linked List is given to you. And you have to retain n elements and delete m elements till the end of the List. To understand the problem with more clarity consider the following example.

`Input: N = 1, M = 1 Linked List: 1 → 2 → 3 → 4 → 5 → 6 → 7 → 8 → 9 → 10`

Here you have to retain 1 element and delete 1 element till the end of the LinkedList. If we perform the operation in the given list, then the result will be :

[Retain 1] [Delete 2] [Retain 3] [Delete 4] .... end of the list = 1 → 3 → 5 → 7 → 9

Consider some other values of N and M in the given LinkedList.

```CASE 2:
/*
* Input: N = 3, M = 2 Linked List: 1->2->3->4->5->6->7->8->9->10 Output:
*/

CASE 3:
/*
* Input: N = 2, M = 2 Linked List: 1->2->3->4->5->6->7->8 Output: Linked
* List: 1->2->5->6
*/```

Now let us check the Java program to implement the same.

```package com.linked.list;

import java.util.Iterator;
import java.util.List;

import org.junit.Test;

public class RetainNAndDeleteM {

/**
* From the list retain n and delete m till the end of the list
*
* @param list
* @param n
* @param m
*/
private static void retainNDeleteM(List < Integer > list, int n, int m) {
if (list == null || list.isEmpty())
return;
int tempN = n;
int tempM = m;
Iterator < Integer > listItr = list.iterator();
while (listItr.hasNext()) {
if (tempN > 0) {
listItr.next();
tempN--;
} else if (tempM > 0) {
listItr.next();
listItr.remove();
tempM--;
} else {
tempN = tempN == 0 ? n : tempN;
tempM = tempM == 0 ? m : tempM;
}
}
}

/*
* Input: N = 1, M = 1 Linked List: 1->2->3->4->5->6->7->8->9->10 Output:
*/
@Test
public void Test3() {
List < Integer > list = getList(10);
retainNDeleteM(list, 1, 1);
System.out.println(list);
}

/*
* Input: N = 3, M = 2 Linked List: 1->2->3->4->5->6->7->8->9->10 Output:
*/
@Test
public void Test2() {
List < Integer > list = getList(10);
retainNDeleteM(list, 3, 2);
System.out.println(list);
}

/*
* Input: N = 2, M = 2 Linked List: 1->2->3->4->5->6->7->8 Output: Linked
* List: 1->2->5->6
*/
@Test
public void Test1() {
List < Integer > list = getList(8);
retainNDeleteM(list, 2, 2);
System.out.println(list);
}

private List < Integer > getList(int val) {
List < Integer > list = new LinkedList < > ();
for (int i = 1; i <= val; i++) {
}
return list;
}
}```

core java 12 Algorithm 12