[APS] Trik So Karti

Трик со карти Problem 9 (3 / 4)

Перо прави трик со карти. Тој има шпил од 51-на карта (некој некогаш не му вратил една) од којшто ви дозволува да влечете карта. Тој, за трикот да биде веродостоен, не ја знае картата, но знае на која позиција се наоѓа. Мааната на Перо е тоа што тој не знае регуларно да измеша карти, туку ги зема првите седум карти, им им го превртува редоследот (пр. од 1 2 3 4 5 6 7 ги реди во 7 6 5 4 3 2 1), потоа зема една карта од превртените и една од врвот од шпилот и го става на крајот од шпилот, така се додека не ги потроши сите седум карти. Со тоа остварува едно мешање на шпил. Ваша задача е, да изработите симулцаија на ваквото мешање, такашто за дадена N-та карта т.ш. 1<=N<=51, вие ќе му изброите колку вакви мешања треба тој да направи за на врв на шпилот да дојде извлечената карта.

Име на класата: card_trick

========================================================================================================================================

#APS-EXCERCISES made by Fensa08

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.NoSuchElementException;



public class card_trick {


    public static class LinkedQueue<E> implements Queue<E> {

        // Redicata e pretstavena na sledniot nacin:
        // length go sodrzi brojot na elementi.
        // Elementite se zachuvuvaat vo jazli dod SLL
        // front i rear se linkovi do prviot i posledniot jazel soodvetno.
        SLLNode<E> front, rear;
        int length;



        // Konstruktor ...

        public LinkedQueue () {
            clear();
        }

        public boolean isEmpty () {
            // Vrakja true ako i samo ako redicata e prazena.
            return (length == 0);
        }

        public int size () {
            // Ja vrakja dolzinata na redicata.
            return length;
        }

        public E peek () {
            // Go vrakja elementot na vrvot t.e. pocetokot od redicata.
            if (front == null)
                throw new NoSuchElementException();
            return front.element;
        }

        public void clear () {
            // Ja prazni redicata.
            front = rear = null;
            length = 0;
        }

        public void enqueue (E x) {
            // Go dodava x na kraj od redicata.
            SLLNode<E> latest = new SLLNode<E>(x, null);
            if (rear != null) {
                rear.succ = latest;
                rear = latest;
            } else
                front = rear = latest;
            length++;
        }

        public E dequeue () {
            // Go otstranuva i vrakja pochetniot element na redicata.
            if (front != null) {
                E frontmost = front.element;
                front = front.succ;
                if (front == null)  rear = null;
                length--;
                return frontmost;
            } else
                throw new NoSuchElementException();
        }

    }

    public static class SLLNode<E> {
        protected E element;
        protected SLLNode<E> succ;

        public SLLNode(E elem, SLLNode<E> succ) {
            this.element = elem;
            this.succ = succ;
        }

        @Override
        public String toString() {
            return element.toString();
        }
    }

    public static interface Queue<E> {

        // Elementi na redicata se objekti od proizvolen tip.

        // Metodi za pristap:

        public boolean isEmpty ();
        // Vrakja true ako i samo ako redicata e prazena.

        public int size ();
        // Ja vrakja dolzinata na redicata.

        public E peek ();
        // Go vrakja elementot na vrvot t.e. pocetokot od redicata.

        // Metodi za transformacija:

        public void clear ();
        // Ja prazni redicata.

        public void enqueue (E x);
        // Go dodava x na kraj od redicata.

        public E dequeue ();
        // Go otstranuva i vrakja pochetniot element na redicata.

    }

    static interface Stack<E> {

        // Elementi na stekot se objekti od proizvolen tip.

        // Metodi za pristap:

        public boolean isEmpty();
        // Vrakja true ako i samo ako stekot e prazen.

        public E peek();
        // Go vrakja elementot na vrvot od stekot.

        // Metodi za transformacija:

        public void clear();
        // Go prazni stekot.

        public void push(E x);
        // Go dodava x na vrvot na stekot.

        public E pop();
        // Go otstranuva i vrakja elementot shto e na vrvot na stekot.
    }

    static class ArrayStack<E> implements Stack<E> {
        private E[] elems;
        private int depth;

        @SuppressWarnings("unchecked")
        public ArrayStack(int maxDepth) {
            // Konstrukcija na nov, prazen stek.
            elems = (E[]) new Object[maxDepth];
            depth = 0;
        }


        public boolean isEmpty() {
            // Vrakja true ako i samo ako stekot e prazen.
            return (depth == 0);
        }


        public E peek() {
            // Go vrakja elementot na vrvot od stekot.
            if (depth == 0)
                throw new NoSuchElementException();
            return elems[depth - 1];
        }


        public void clear() {
            // Go prazni stekot.
            for (int i = 0; i < depth; i++) elems[i] = null;
            depth = 0;
        }


        public void push(E x) {
            // Go dodava x na vrvot na stekot.
            elems[depth++] = x;
        }


        public E pop() {
            // Go otstranuva i vrakja elementot shto e na vrvot na stekot.
            if (depth == 0)
                throw new NoSuchElementException();
            E topmost = elems[--depth];
            elems[depth] = null;
            return topmost;
        }
    }

/*
    public static void shuffle(LinkedQueue<Integer> q){
        Stack<Integer> stek = new Stack<>();
        int i = 0;
        while(i < 7){
            stek.push(q.dequeue());
            i++;
        }

        while(!stek.isEmpty()){
            int x = stek.pop();
            q.enqueue(x);
            q.enqueue(q.dequeue());
        }
    }*/

    public static int count(int N){
        // Vasiot kod tuka

        ArrayStack<Integer> s = new ArrayStack<>(10);
        LinkedQueue<Integer> q = new LinkedQueue<>();

        // incijalizacija na spil
        for(int i = 1; i <= 51; i++){
            q.enqueue(i);
        }

        int counter = 0;
        while(true){

            // polnenje stek
            for(int i = 0; i < 7;i++){
                s.push(q.dequeue());
            }

            // meshanje
            for(int i = 0; i < 7;i++){
                q.enqueue(s.pop());
                q.enqueue(q.dequeue());
            }

            counter++;
            if(q.peek() == N)
                return counter;

        }

       /* LinkedQueue<Integer> queue = new LinkedQueue<Integer>();

        for(int i = 1; i <= 51;i++){
            queue.enqueue(i);
        }

        int counter = 1;
        shuffle(queue);
        while(queue.peek() != N){
            if(queue.peek() != N){
                shuffle(queue);
                counter++;
            }
            else{
                return counter;
            }

        }


        return counter;*/





    }

    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in) );
        System.out.println(count(Integer.parseInt(br.readLine())));

        //  iskomentiranoto e uste eden nacin za resavanje
    }

}