# Find the number on the card that remains in the end after performing the given operations

• Last Updated : 15 Apr, 2021

Given an integer N which represents the number of cards in a deck. The deck is ordered from 1 to N where 1 is the topmost card and N is at the bottom. You take out the topmost card from the deck and insert it at the bottom and throw the next card that appears at the top of the deck. Again you do the same thing until a single card remains. The task is to find the number of the card that remains at the end.
Examples:

```Input: N = 4
Output: 1
1 2 3 4
^     ^
Top   Bottom

Operation 1: 3 4 1 (1 got shifted to the bottom and 2 got removed)
Operation 2: 1 3 (3 got shifted and 4 got removed)
Operation 3: 1 (3 got removed after shifting 1)

Input: N = 10
Output: 5```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Approach:

1. First of all insert numbers from 1 to N in a queue.
2. Now, dequeue the front element from the queue and enqueue it at the end.
3. Finally, pop the element at the front.
4. Print the final element left in the queue.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function that will find the``// card number which is remaining``int` `remainingCard(``int` `n)``{``    ``queue<``int``> queCards;` `    ``// Inserting all the numbers from 1 to n``    ``for` `(``int` `i = 1; i <= n; i++)``        ``queCards.push(i);` `    ``// While there are atleast two``    ``// elements in the queue``    ``while` `(((``int``)queCards.size()) >= 2) {` `        ``// Push the front element at the back``        ``queCards.push(queCards.front());` `        ``// Remove the front element``        ``queCards.pop();` `        ``// Remove another element``        ``queCards.pop();``    ``}` `    ``// Return the only element``    ``// left in the queue``    ``return` `queCards.front();``}` `// Driver code``int` `main()``{``    ``int` `n = 10;` `    ``cout << remainingCard(n);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `class` `GFG``{` `// Function that will find the``// card number which is remaining``static` `int` `remainingCard(``int` `n)``{``    ``Queue queCards = ``new` `LinkedList<>();` `    ``// Inserting all the numbers from 1 to n``    ``for` `(``int` `i = ``1``; i <= n; i++)``    ``{``        ``queCards.add(i);``    ``}` `    ``// While there are atleast two``    ``// elements in the queue``    ``while` `(((``int``) queCards.size()) >= ``2``)``    ``{` `        ``// Push the front element at the back``        ``queCards.add(queCards.peek());` `        ``// Remove the front element``        ``queCards.remove();` `        ``// Remove another element``        ``queCards.remove();``    ``}` `    ``// Return the only element``    ``// left in the queue``    ``return` `queCards.peek();``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `n = ``10``;` `    ``System.out.println(remainingCard(n));``}``}` `// This code is contributed by PrinciRaj1992`

## Python3

 `# Python3 implementation of the approach` `# Function that will find the``# card number which is remaining``def` `remainingCard(n):` `    ``queCards ``=` `[]` `    ``# Inserting all the numbers from 1 to n``    ``for` `i ``in` `range``(``1``, n ``+` `1``):``        ``queCards.append(i)` `    ``# While there are atleast two``    ``# elements in the queue``    ``while` `(``len``(queCards) >``=` `2``):` `        ``# Push the front element at the back``        ``queCards.append(queCards[``0``]);` `        ``# Remove the front element``        ``queCards.pop(``0``);` `        ``# Remove another element``        ``queCards.pop(``0``);` `    ``# Return the only element``    ``# left in the queue``    ``return` `queCards[``0``]` `# Driver code``n ``=` `10``print``(remainingCard(n))` `# This code is contributed by divyamohan123`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `// Function that will find the``// card number which is remaining``static` `int` `remainingCard(``int` `n)``{``    ``Queue<``int``> queCards = ``new` `Queue<``int``>();` `    ``// Inserting all the numbers from 1 to n``    ``for` `(``int` `i = 1; i <= n; i++)``    ``{``        ``queCards.Enqueue(i);``    ``}` `    ``// While there are atleast two``    ``// elements in the queue``    ``while` `(((``int``) queCards.Count) >= 2)``    ``{` `        ``// Push the front element at the back``        ``queCards.Enqueue(queCards.Peek());` `        ``// Remove the front element``        ``queCards.Dequeue();` `        ``// Remove another element``        ``queCards.Dequeue();``    ``}` `    ``// Return the only element``    ``// left in the queue``    ``return` `queCards.Peek();``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int` `n = 10;` `    ``Console.WriteLine(remainingCard(n));``}``}` `// This code is contributed by Princi Singh`

## Javascript

 ``
Output:
`5`

My Personal Notes arrow_drop_up