From 877c7ea141e825715f1bff5afae75d1f306ae3f2 Mon Sep 17 00:00:00 2001
From: MTBBK <barbaros@cezeri.tech>
Date: Sun, 2 Oct 2022 13:54:54 +0300
Subject: [PATCH] Update 'minesweeper.py'

---
 snakeware.py => minesweeper.py | 2678 ++++++++++++++++----------------
 1 file changed, 1339 insertions(+), 1339 deletions(-)
 rename snakeware.py => minesweeper.py (95%)

diff --git a/snakeware.py b/minesweeper.py
similarity index 95%
rename from snakeware.py
rename to minesweeper.py
index e0884a2..12b602f 100644
--- a/snakeware.py
+++ b/minesweeper.py
@@ -1,1340 +1,1340 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Sat Oct  1 16:50:14 2022
-
-@author: mtbbk
-"""
-
-import pygame
-import time
-import random
-import json
-import math
-
-"""
-Qiskit
-"""
-import numpy as np
-# Importing standard Qiskit libraries
-from qiskit import QuantumCircuit, execute, transpile, QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer, IBMQ
-from qiskit.tools.jupyter import *
-from qiskit.visualization import *
-from ibm_quantum_widgets import *
-    
-def rastgele():
-    # Loading your IBM Quantum account(s)
-    print('Libraries imported successfully!')
-    
-    qc = QuantumCircuit(1,1)
-    qc.h(0)
-    qc.x(0)
-    qc.measure(0,0)
-    print(qc)
-    backend = Aer.get_backend('qasm_simulator') # Choosing the simulator we want to use
-    job = execute(qc, backend, shots = 1024) # Running the simulator - specifying the circuit we want to simulate and the number of times we want to simulate it (shots)
-    result = job.result()
-    counts = result.get_counts() # Getting the counts of 0 and 1 from the result
-    plot_histogram(counts)
-    print(counts)
-    
-    coundDeger = str(counts)
-    coundDeger = coundDeger.replace("'", " ")
-    coundDeger = coundDeger.replace(",", " ")
-    coundDeger = coundDeger.replace("}", " ")
-    first_word = coundDeger.split()[1]
-    print("Deger: ", first_word)
-    print(coundDeger)
-    xDeger = coundDeger.split()[3]
-    yDeger = coundDeger.split()[6]
-    xDegerXE = int(xDeger)
-    yDegerYE = int(yDeger)
-    
-    
-    valueX = random.randint(0, 512)
-    
-    while True:
-        if valueX%32 != 0:
-            valueX= valueX+1
-        else:
-            break
-    
-    valueY = random.randint(0, 512)
-    
-    while True:
-        if valueY%32 != 0:
-            valueY= valueY+1
-        else:
-            break
-    
-    xDegerX = valueX
-    yDegerY = valueY
-    
-    Test = 54
-    while True:
-        if Test%32 != 0:
-            Test= Test+1
-        else:
-            break
-        
-    print(Test)
-    print("DegerX: ", xDegerX)
-    print("DegerY: ", yDegerY)
-    type(qc)
-     
-    """
-    Qiskit Bitti / JSON
-    """
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    print('\nGrovers Algorithm')
-    print('------------------\n')
-    
-    
-    grid_konumu = 0
-    
-    
-    
-    brid=[[0]*16]*16
-    y = xDegerX
-    x = yDegerY
-    #mayin = T[x][y]
-    a = f"{x//4}"
-    b = f"{y//4}"
-    
-    a_int = int(a)
-    b_int = int(b)
-    
-    z = a_int*4 +b_int
-    grid_konumu = z
-    
-    print(grid_konumu)
-            
-    pi = math.pi
-    q = QuantumRegister(4,'q')
-    c = ClassicalRegister(4,'c')
-    qc = QuantumCircuit(q,c)
-    
-    print('\nInitialising Circuit...\n')
-    
-    ### Initialisation ###
-    
-    qc.h(q[0])
-    qc.h(q[1])
-    qc.h(q[2])
-    qc.h(q[3])
-    
-    print('\nPreparing Oracle circuit....\n')
-    
-    ### 0000 Oracle ###
-    
-    if(grid_konumu == 0):
-        qc.x(q[0])
-        qc.x(q[1])
-        qc.x(q[2])
-        qc.x(q[3])
-    
-        qc.cp(pi/4, q[0], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(-pi/4, q[1], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(pi/4, q[1], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-    
-    
-        qc.x(q[0])
-        qc.x(q[1])
-        qc.x(q[2])
-        qc.x(q[3])
-    
-    ### 0001 Oracle ###
-    
-        
-    if(grid_konumu == 1):
-    
-        qc.x(q[1])
-        qc.x(q[2])
-        qc.x(q[3])
-    
-        qc.cp(pi/4, q[0], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(-pi/4, q[1], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(pi/4, q[1], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-    
-        qc.x(q[1])
-        qc.x(q[2])
-        qc.x(q[3])
-    
-    
-    
-    ### 0010 Oracle ###
-    if(grid_konumu == 2):
-        qc.x(q[0])
-        qc.x(q[2])
-        qc.x(q[3])
-    
-        qc.cp(pi/4, q[0], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(-pi/4, q[1], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(pi/4, q[1], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-    
-        qc.x(q[0])
-        qc.x(q[2])
-        qc.x(q[3])
-    
-    
-    
-    ### 0011 Oracle ###
-    if(grid_konumu == 3):
-        qc.x(q[2])
-        qc.x(q[3])
-    
-        qc.cp(pi/4, q[0], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(-pi/4, q[1], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(pi/4, q[1], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-    
-        qc.x(q[2])
-        qc.x(q[3])
-    
-    
-    
-    ### 0100 Oracle ###
-    if(grid_konumu == 4):
-        qc.x(q[0])
-        qc.x(q[1])
-        qc.x(q[3])
-    
-        qc.cp(pi/4, q[0], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(-pi/4, q[1], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(pi/4, q[1], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-    
-        qc.x(q[0])
-        qc.x(q[1])
-        qc.x(q[3])
-    
-    
-    
-    ### 0101 Oracle ###
-    if(grid_konumu == 5):
-        qc.x(q[1])
-        qc.x(q[3])
-    
-        qc.cp(pi/4, q[0], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(-pi/4, q[1], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(pi/4, q[1], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-    
-        qc.x(q[1])
-        qc.x(q[3])
-    
-    
-    
-    ### 0110 Oracle ###
-    if(grid_konumu == 6):
-        qc.x(q[0])
-        qc.x(q[3])
-    
-        qc.cp(pi/4, q[0], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(-pi/4, q[1], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(pi/4, q[1], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-    
-        qc.x(q[0])
-        qc.x(q[3])
-    
-    
-    
-    ### 0111 Oracle ###
-    if(grid_konumu == 7):
-        qc.x(q[3])
-    
-        qc.cp(pi/4, q[0], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(-pi/4, q[1], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(pi/4, q[1], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-    
-        qc.x(q[3])
-    
-    
-    ### 1000 Oracle ###
-    if(grid_konumu == 8):
-        qc.x(q[0])
-        qc.x(q[1])
-        qc.x(q[2])
-    
-        qc.cp(pi/4, q[0], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(-pi/4, q[1], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(pi/4, q[1], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-    
-        qc.x(q[0])
-        qc.x(q[1])
-        qc.x(q[2])
-    
-    
-    
-    ### 1001 Oracle ###
-    if(grid_konumu == 9):
-        qc.x(q[1])
-        qc.x(q[2])
-    
-        qc.cp(pi/4, q[0], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(-pi/4, q[1], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(pi/4, q[1], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-    
-        qc.x(q[1])
-        qc.x(q[2])
-    
-    
-    
-    ### 1010 Oracle ###
-    if(grid_konumu == 10):
-        qc.x(q[0])
-        qc.x(q[2])
-    
-        qc.cp(pi/4, q[0], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(-pi/4, q[1], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(pi/4, q[1], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-    
-        qc.x(q[0])
-        qc.x(q[2])
-    
-    
-    
-    ### 1011 Oracle ###
-    if(grid_konumu == 11):
-        qc.x(q[3])
-    
-        qc.cp(pi/4, q[0], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(-pi/4, q[1], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(pi/4, q[1], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-    
-        qc.x(q[3])
-    
-    
-    
-    ### 1100 Oracle ###
-    if(grid_konumu == 12):
-        qc.x(q[0])
-        qc.x(q[1])
-    
-        qc.cp(pi/4, q[0], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(-pi/4, q[1], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(pi/4, q[1], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-    
-        qc.x(q[0])
-        qc.x(q[1])
-    
-    
-    ### 1101 Oracle ###
-    if(grid_konumu == 13):
-        qc.x(q[1])
-    
-        qc.cp(pi/4, q[0], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(-pi/4, q[1], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(pi/4, q[1], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-    
-        qc.x(q[1])
-        print("aaaaaaaaaaaaaaaa")
-    
-    
-    ### 1110 Oracle ###
-    if(grid_konumu == 14):
-        qc.x(q[0])
-    
-        qc.cp(pi/4, q[0], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(-pi/4, q[1], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(pi/4, q[1], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-    
-        qc.x(q[0])
-    
-    
-    
-    ###1111 Oracle###
-    if(grid_konumu == 15):
-        qc.cp(pi/4, q[0], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(-pi/4, q[1], q[3])
-        qc.cx(q[0], q[1])
-        qc.cp(pi/4, q[1], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-        qc.cx(q[1], q[2])
-        qc.cp(-pi/4, q[2], q[3])
-        qc.cx(q[0], q[2])
-        qc.cp(pi/4, q[2], q[3])
-    
-    
-    print('\nPreparing Amplification circuit....\n')
-    #### Amplification ####
-    
-    qc.h(q[0])
-    qc.h(q[1])
-    qc.h(q[2])
-    qc.h(q[3])
-    qc.x(q[0])
-    qc.x(q[1])
-    qc.x(q[2])
-    qc.x(q[3])
-    
-    qc.cp(pi/4, q[0], q[3])
-    qc.cx(q[0], q[1])
-    qc.cp(-pi/4, q[1], q[3])
-    qc.cx(q[0], q[1])
-    qc.cp(pi/4, q[1], q[3])
-    qc.cx(q[1], q[2])
-    qc.cp(-pi/4, q[2], q[3])
-    qc.cx(q[0], q[2])
-    qc.cp(pi/4, q[2], q[3])
-    qc.cx(q[1], q[2])
-    
-    qc.cp(-pi/4, q[2], q[3])
-    qc.cx(q[0], q[2])
-    qc.cp(pi/4, q[2], q[3])
-    
-    qc.x(q[0])
-    qc.x(q[1])
-    qc.x(q[2])
-    qc.x(q[3])
-    qc.h(q[0])
-    qc.h(q[1])
-    qc.h(q[2])
-    qc.h(q[3])
-    
-    ### Measurment ###
-    qc.barrier(q)
-    qc.measure(q[0], c[0])
-    qc.measure(q[1], c[1])
-    qc.measure(q[2], c[2])
-    qc.measure(q[3], c[3])
-    
-    backend = Aer.get_backend('qasm_simulator')
-    print('\nExecuting job....\n')
-    job = execute(qc, backend, shots=250)
-    
-    result = job.result()
-    counts = result.get_counts(qc)
-    
-    coundDeger = str(counts)
-    coundDeger = coundDeger.replace("'", " ")
-    coundDeger = coundDeger.replace("{", " ")
-    coundDeger = coundDeger.replace(":", " ")
-    
-    
-    coundDeger = coundDeger.replace(",", " ")
-    coundDeger = coundDeger.replace("}", " ")
-    print(coundDeger)
-    
-            
-            
-    grids = ["0000","0001","0010","0100","1000","0011","0101","1001","0110","1010","1100","0111","1011","1101","1110","1111"]
-    grids_count = ["0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0"]
-    
-    
-    
-    
-    # Bubble sort in Python
-    
-    
-    ali=max(counts,key=lambda x:counts[x])
-    print(20*"-")
-    print(int(ali,2))
-    print(20*"-")
-    print(max(counts,key=lambda x:counts[x]))
-    print(20*"-")
-    print('RESULT: ',counts,'\n')
-    print('Press any key to close')
-    
-    
-    buyuk_x = x%4 
-    buyuk_y = y%4 
-    
-    q1 = QuantumRegister(4,'q')
-    c1 = ClassicalRegister(4,'c')
-    qc1 = QuantumCircuit(q1,c1)
-    
-    
-    z = (buyuk_x)*4 + buyuk_y
-    grid_konumu = z
-    
-    
-    print(grid_konumu)
-    
-    qc1.h(q1[0])
-    qc1.h(q1[1])
-    qc1.h(q1[2])
-    qc1.h(q1[3])
-    
-    
-    if(grid_konumu == 0):
-        qc1.x(q1[0])
-        qc1.x(q1[1])
-        qc1.x(q1[2])
-        qc1.x(q1[3])
-    
-        qc1.cp(pi/4, q1[0], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(-pi/4, q1[1], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(pi/4, q1[1], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-    
-    
-        qc1.x(q1[0])
-        qc1.x(q1[1])
-        qc1.x(q1[2])
-        qc1.x(q1[3])
-    
-    ### 0001 Oracle ###
-    
-        
-    if(grid_konumu == 1):
-    
-        qc1.x(q1[1])
-        qc1.x(q1[2])
-        qc1.x(q1[3])
-    
-        qc1.cp(pi/4, q1[0], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(-pi/4, q1[1], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(pi/4, q1[1], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-    
-        qc1.x(q1[1])
-        qc1.x(q1[2])
-        qc1.x(q1[3])
-    
-    
-    
-    ### 0010 Oracle ###
-    if(grid_konumu == 2):
-        print("AAAAAAAAAAAAAAAAAAAAA")
-        qc1.x(q1[0])
-        qc1.x(q1[2])
-        qc1.x(q1[3])
-    
-        qc1.cp(pi/4, q1[0], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(-pi/4, q1[1], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(pi/4, q1[1], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-    
-        qc1.x(q1[0])
-        qc1.x(q1[2])
-        qc1.x(q1[3])
-    
-    
-    
-    ### 0011 Oracle ###
-    if(grid_konumu == 3):
-        qc1.x(q1[2])
-        qc1.x(q1[3])
-    
-        qc1.cp(pi/4, q1[0], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(-pi/4, q1[1], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(pi/4, q1[1], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-    
-        qc1.x(q1[2])
-        qc1.x(q1[3])
-    
-    
-    
-    ### 0100 Oracle ###
-    if(grid_konumu == 4):
-        qc1.x(q1[0])
-        qc1.x(q1[1])
-        qc1.x(q1[3])
-    
-        qc1.cp(pi/4, q1[0], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(-pi/4, q1[1], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(pi/4, q1[1], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-    
-        qc1.x(q1[0])
-        qc1.x(q1[1])
-        qc1.x(q1[3])
-    
-    
-    
-    ### 0101 Oracle ###
-    if(grid_konumu == 5):
-        qc1.x(q1[1])
-        qc1.x(q1[3])
-    
-        qc1.cp(pi/4, q1[0], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(-pi/4, q1[1], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(pi/4, q1[1], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-    
-        qc1.x(q1[1])
-        qc1.x(q1[3])
-    
-    
-    
-    ### 0110 Oracle ###
-    if(grid_konumu == 6):
-        qc1.x(q1[0])
-        qc1.x(q1[3])
-    
-        qc1.cp(pi/4, q1[0], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(-pi/4, q1[1], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(pi/4, q1[1], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-    
-        qc1.x(q1[0])
-        qc1.x(q1[3])
-    
-    
-    
-    ### 0111 Oracle ###
-    if(grid_konumu == 7):
-        qc1.x(q1[3])
-    
-        qc1.cp(pi/4, q1[0], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(-pi/4, q1[1], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(pi/4, q1[1], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-    
-        qc1.x(q1[3])
-    
-    
-    ### 1000 Oracle ###
-    if(grid_konumu == 8):
-        qc1.x(q1[0])
-        qc1.x(q1[1])
-        qc1.x(q1[2])
-    
-        qc1.cp(pi/4, q1[0], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(-pi/4, q1[1], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(pi/4, q1[1], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-    
-        qc1.x(q1[0])
-        qc1.x(q1[1])
-        qc1.x(q1[2])
-    
-    
-    
-    ### 1001 Oracle ###
-    if(grid_konumu == 9):
-        qc1.x(q1[1])
-        qc1.x(q1[2])
-    
-        qc1.cp(pi/4, q1[0], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(-pi/4, q1[1], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(pi/4, q1[1], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-    
-        qc1.x(q1[1])
-        qc1.x(q1[2])
-    
-    
-    
-    ### 1010 Oracle ###
-    if(grid_konumu == 10):
-        qc1.x(q1[0])
-        qc1.x(q1[2])
-    
-        qc1.cp(pi/4, q1[0], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(-pi/4, q1[1], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(pi/4, q1[1], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-    
-        qc1.x(q1[0])
-        qc1.x(q1[2])
-    
-    
-    
-    ### 1011 Oracle ###
-    if(grid_konumu == 11):
-        qc1.x(q1[3])
-    
-        qc1.cp(pi/4, q1[0], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(-pi/4, q1[1], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(pi/4, q1[1], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-    
-        qc1.x(q1[3])
-    
-    
-    
-    ### 1100 Oracle ###
-    if(grid_konumu == 12):
-        qc1.x(q1[0])
-        qc1.x(q1[1])
-    
-        qc1.cp(pi/4, q1[0], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(-pi/4, q1[1], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(pi/4, q1[1], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-    
-        qc1.x(q1[0])
-        qc1.x(q1[1])
-    
-    
-    ### 1101 Oracle ###
-    if(grid_konumu == 13):
-        qc1.x(q1[1])
-    
-        qc1.cp(pi/4, q1[0], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(-pi/4, q1[1], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(pi/4, q1[1], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-    
-        qc1.x(q1[1])
-        print("aaaaaaaaaaaaaaaa")
-    
-    
-    ### 1110 Oracle ###
-    if(grid_konumu == 14):
-        qc1.x(q1[0])
-    
-        qc1.cp(pi/4, q1[0], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(-pi/4, q1[1], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(pi/4, q1[1], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-    
-        qc1.x(q1[0])
-    
-    
-    
-    ###1111 Oracle###
-    if(grid_konumu == 15):
-        qc1.cp(pi/4, q1[0], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(-pi/4, q1[1], q1[3])
-        qc1.cx(q1[0], q1[1])
-        qc1.cp(pi/4, q1[1], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-        qc1.cx(q1[1], q1[2])
-        qc1.cp(-pi/4, q1[2], q1[3])
-        qc1.cx(q1[0], q1[2])
-        qc1.cp(pi/4, q1[2], q1[3])
-    
-    
-    print('\nPreparing Amplification circuit....\n')
-    #### Amplification ####
-    
-    qc1.h(q1[0])
-    qc1.h(q1[1])
-    qc1.h(q1[2])
-    qc1.h(q1[3])
-    qc1.x(q1[0])
-    qc1.x(q1[1])
-    qc1.x(q1[2])
-    qc1.x(q1[3])
-    
-    qc1.cp(pi/4, q1[0], q1[3])
-    qc1.cx(q1[0], q1[1])
-    qc1.cp(-pi/4, q1[1], q1[3])
-    qc1.cx(q1[0], q1[1])
-    qc1.cp(pi/4, q1[1], q1[3])
-    qc1.cx(q1[1], q1[2])
-    qc1.cp(-pi/4, q1[2], q1[3])
-    qc1.cx(q1[0], q1[2])
-    qc1.cp(pi/4, q1[2], q1[3])
-    qc1.cx(q1[1], q1[2])
-    
-    qc1.cp(-pi/4, q1[2], q1[3])
-    qc1.cx(q1[0], q1[2])
-    qc1.cp(pi/4, q1[2], q1[3])
-    
-    qc1.x(q1[0])
-    qc1.x(q1[1])
-    qc1.x(q1[2])
-    qc1.x(q1[3])
-    qc1.h(q1[0])
-    qc1.h(q1[1])
-    qc1.h(q1[2])
-    qc1.h(q1[3])
-    
-    ### Measurment ###
-    qc1.barrier(q)
-    qc1.measure(q1[0], c[0])
-    qc1.measure(q1[1], c[1])
-    qc1.measure(q1[2], c[2])
-    qc1.measure(q1[3], c[3])
-    
-    
-    backend = Aer.get_backend('qasm_simulator')
-    print('\nExecuting job....\n')
-    job = execute(qc1, backend, shots=250)
-    
-    result = job.result()
-    counts = result.get_counts(qc1)
-    
-    mustafa=max(counts,key=lambda x:counts[x])
-    print(20*"-")
-    print(int(mustafa,2))
-    print(20*"-")
-    
-    gercek_konumy = a_int*4 + buyuk_x
-    gercek_konumx = b_int*4 + buyuk_y
-    
-    print("b_int",b_int)
-    print("a_int",a_int)
-    print("buyuk_x",buyuk_x)
-    print("buyuky",buyuk_y)
-    print(gercek_konumx)
-    print(gercek_konumy)
-    print('RESULT: ',counts,'\n')
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    dictionary = {
-        "minescanner": "mineware",
-        "degerx": xDegerX,
-        "degery": yDegerY,
-        "phonenumber": "9976770500"
-    }
-    
-    json_object = json.dumps(dictionary, indent=4)
-    
-    with open("sample.json", "w") as outfile:
-        outfile.write(json_object)
-    
-    """
-    JSON Bitti
-    """
-    
-    pygame.init()
-     
-    white = (255, 255, 255)
-    gray = (208, 209, 217)
-    yellow = (255, 255, 102)
-    black = (0, 0, 0)
-    red = (213, 50, 80)
-    green = (0, 255, 0)
-    blue = (50, 153, 213)
-     
-    dis_width = 512
-    dis_height = 512
-    
-    rows = 16
-    w = 512
-    
-    dis = pygame.display.set_mode((dis_width, dis_height))
-    pygame.display.set_caption('Quantum Minesweeper')
-     
-    clock = pygame.time.Clock()
-    
-    pygame.init()
-    
-    counter, text = 3, '3'.rjust(3)
-    pygame.time.set_timer(pygame.USEREVENT, 1000)
-    font = pygame.font.SysFont('Consolas', 30)
-    screen = pygame.display.set_mode((256, 256))
-    clock = pygame.time.Clock()
-    run = True
-    while run:
-        for e in pygame.event.get():
-            if e.type == pygame.USEREVENT: 
-                counter -= 1
-                text = str(counter).rjust(3) if counter > 0 else 'boom!'
-            if e.type == pygame.QUIT: 
-                run = False
-        screen.fill((255, 255, 255))
-        screen.blit(font.render(text, True, (0, 0, 0)), (92, 110))
-        pygame.display.flip()
-        clock.tick(60)
-    dis = pygame.display.set_mode((dis_width, dis_height))
-    snake_block = 32
-    snake_speed = 10
-     
-    font_style = pygame.font.SysFont("bahnschrift", 25)
-    score_font = pygame.font.SysFont("comicsansms", 35)
-    
-    
-    
-    def Your_score(score):
-        valuex = score_font.render("DegerX: " +str(xDegerX), True, white)
-        valuey = score_font.render("DegerY: " +str(yDegerY), True, white)
-        dis.blit(valuex, [300, 0])
-        dis.blit(valuey, [300, 32])
-    
-     
-    def our_snake(snake_block, snake_list):
-        for x in snake_list:
-            pygame.draw.rect(dis, red, [x[0], x[1], snake_block, snake_block])
-     
-     
-    def message(msg, color):
-        mesg = font_style.render(msg, True, color)
-        dis.blit(mesg, [10, dis_height / 16])
-              
-     
-    def gameLoop():
-        game_over = False
-        game_close = False
-     
-        x1 = dis_width / 2
-        y1 = 128
-     
-        x1_change = 0
-        y1_change = 0
-     
-        xgit = gercek_konumx/32
-        print(xgit)
-        
-        snake_List = []
-        Length_of_snake = 1
-     
-        foodx = round((xDegerX - snake_block) / 160.0) * 160.0
-        foody = round((yDegerY - snake_block) / 160.0) * 160.0
-     
-        pygame.display.flip()
-        pygame.event.pump()
-        pygame.time.delay(1000) # 1 second == 1000 milliseconds
-        
-    
-                
-        while not game_over:
-    
-            while game_close == True:
-                message("Mission Completed!", red)
-                #Your_score(Length_of_snake - 1)
-                pygame.display.update()
-                for event in pygame.event.get():
-                    if event.type == pygame.KEYDOWN:
-                        if event.key == pygame.K_q:
-                            game_over = True
-                            game_close = False
-                        if event.key == pygame.K_r:
-                            rastgele()
-            for event in pygame.event.get():
-                if event.type == pygame.QUIT:
-                    game_over = True
-                if event.type == pygame.KEYDOWN:
-                    if event.key == pygame.K_LEFT:
-                        x1_change = -snake_block
-                        y1_change = 0
-                    elif event.key == pygame.K_RIGHT:
-                        x1_change = snake_block
-                        y1_change = 0
-                    elif event.key == pygame.K_UP:
-                        y1_change = -snake_block
-                        x1_change = 0
-                    elif event.key == pygame.K_DOWN:
-                        y1_change = snake_block
-                        x1_change = 0
-    
-                
-                
-            #if x1 >= dis_width or x1 < 0 or y1 >= dis_height or y1 < 0:
-             #   game_close = True
-            x1 += x1_change
-            y1 += y1_change
-            
-            if gercek_konumx < x1:
-                x1_change = -snake_block
-                print("SOL")
-            elif gercek_konumx > x1:
-                x1_change = snake_block
-                print("SAĞ")
-            if gercek_konumy < y1:
-                y1_change = -snake_block
-                print("AŞAĞI")
-            elif gercek_konumy > y1:
-                y1_change = snake_block
-                print("YUKARI")
-                
-                
-                
-            print("XXXX", x1)
-            print("YYYY", y1)
-            print("GERÇEK-X", gercek_konumx)
-            print("GERÇEK-Y", gercek_konumy)
-    
-            dis.fill(black)
-            sizeBtwn = w // rows
-            sizeBtwna = w // rows * 4
-    
-            x = 0
-            y = 0
-            xa = 0
-            ya = 0
-            for l in range(rows-1):
-                pygame.draw.rect(dis,red,(1,0,1,512))
-                pygame.draw.rect(dis,red,(128,0,1,512))
-                pygame.draw.rect(dis,red,(256,0,1,512))
-                pygame.draw.rect(dis,red,(384,0,1,512))
-                pygame.draw.rect(dis,red,(511,0,1,512))
-                pygame.draw.rect(dis,red,(0,1,512,1))
-                pygame.draw.rect(dis,red,(0,128,512,1))
-                pygame.draw.rect(dis,red,(0,256,512,1))
-                pygame.draw.rect(dis,red,(0,384,512,1))
-                pygame.draw.rect(dis,red,(0,511,512,1))
-                
-                x = x + sizeBtwn
-                y = y + sizeBtwn
-    
-                xa = xa + sizeBtwna
-                ya = ya + sizeBtwna
-    
-                pygame.draw.line(dis, (gray), (x,0),(x,w))
-                pygame.draw.line(dis, (gray), (0,y),(w,y))
-                
-                pygame.draw.line(dis, (213, 50, 80), (xa,0),(xa,w))
-                pygame.draw.line(dis, (213, 50, 80), (0,ya),(w,ya))  
-            pygame.draw.rect(dis, green, [foodx, foody, snake_block, snake_block])
-            snake_Head = []
-            snake_Head.append(x1)
-            snake_Head.append(y1)
-            snake_List.append(snake_Head)
-            if len(snake_List) > Length_of_snake:
-                del snake_List[0]
-     
-            for x in snake_List[:-1]:
-                if x == snake_Head:
-                    game_close = True
-     
-            our_snake(snake_block, snake_List)
-            Your_score(Length_of_snake - 1)
-     
-            pygame.display.update()
-     
-            if x1 == foodx and y1 == foody:
-                foodx = round((xDegerX - snake_block) / 160.0) * 160.0
-                foody = round((yDegerY - snake_block) / 160.0) * 160.0
-                Length_of_snake += 1
-     
-            xgel = foodx + 100
-            if pygame.key.get_pressed()[pygame.K_a]:
-                x1_change = -xgit
-                y1_change = 0
-            if pygame.key.get_pressed()[pygame.K_s]:
-                y1_change = xgit
-                x1_change = 0
-                
-    
-            if pygame.key.get_pressed()[pygame.K_w]:
-                y1_change = -xgit
-                x1_change = 0
-    
-                
-            if x1==foodx:
-                print("X")
-                x1_change = 0
-            if y1==foody:
-                print("Y")
-                y1_change = 0
-            clock.tick(snake_speed)
-     
-        pygame.quit()
-        quit()
-     
-    
-    gameLoop()
+# -*- coding: utf-8 -*-
+"""
+Created on Sat Oct  1 16:50:14 2022
+
+@author: mtbbk
+"""
+
+import pygame
+import time
+import random
+import json
+import math
+
+"""
+Qiskit
+"""
+import numpy as np
+# Importing standard Qiskit libraries
+from qiskit import QuantumCircuit, execute, transpile, QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer, IBMQ
+from qiskit.tools.jupyter import *
+from qiskit.visualization import *
+from ibm_quantum_widgets import *
+    
+def rastgele():
+    # Loading your IBM Quantum account(s)
+    print('Libraries imported successfully!')
+    
+    qc = QuantumCircuit(1,1)
+    qc.h(0)
+    qc.x(0)
+    qc.measure(0,0)
+    print(qc)
+    backend = Aer.get_backend('qasm_simulator') # Choosing the simulator we want to use
+    job = execute(qc, backend, shots = 1024) # Running the simulator - specifying the circuit we want to simulate and the number of times we want to simulate it (shots)
+    result = job.result()
+    counts = result.get_counts() # Getting the counts of 0 and 1 from the result
+    plot_histogram(counts)
+    print(counts)
+    
+    coundDeger = str(counts)
+    coundDeger = coundDeger.replace("'", " ")
+    coundDeger = coundDeger.replace(",", " ")
+    coundDeger = coundDeger.replace("}", " ")
+    first_word = coundDeger.split()[1]
+    print("Deger: ", first_word)
+    print(coundDeger)
+    xDeger = coundDeger.split()[3]
+    yDeger = coundDeger.split()[6]
+    xDegerXE = int(xDeger)
+    yDegerYE = int(yDeger)
+    
+    
+    valueX = random.randint(0, 512)
+    
+    while True:
+        if valueX%32 != 0:
+            valueX= valueX+1
+        else:
+            break
+    
+    valueY = random.randint(0, 512)
+    
+    while True:
+        if valueY%32 != 0:
+            valueY= valueY+1
+        else:
+            break
+    
+    xDegerX = valueX
+    yDegerY = valueY
+    
+    Test = 54
+    while True:
+        if Test%32 != 0:
+            Test= Test+1
+        else:
+            break
+        
+    print(Test)
+    print("DegerX: ", xDegerX)
+    print("DegerY: ", yDegerY)
+    type(qc)
+     
+    """
+    Qiskit Bitti / JSON
+    """
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    print('\nGrovers Algorithm')
+    print('------------------\n')
+    
+    
+    grid_konumu = 0
+    
+    
+    
+    brid=[[0]*16]*16
+    y = xDegerX
+    x = yDegerY
+    #mayin = T[x][y]
+    a = f"{x//4}"
+    b = f"{y//4}"
+    
+    a_int = int(a)
+    b_int = int(b)
+    
+    z = a_int*4 +b_int
+    grid_konumu = z
+    
+    print(grid_konumu)
+            
+    pi = math.pi
+    q = QuantumRegister(4,'q')
+    c = ClassicalRegister(4,'c')
+    qc = QuantumCircuit(q,c)
+    
+    print('\nInitialising Circuit...\n')
+    
+    ### Initialisation ###
+    
+    qc.h(q[0])
+    qc.h(q[1])
+    qc.h(q[2])
+    qc.h(q[3])
+    
+    print('\nPreparing Oracle circuit....\n')
+    
+    ### 0000 Oracle ###
+    
+    if(grid_konumu == 0):
+        qc.x(q[0])
+        qc.x(q[1])
+        qc.x(q[2])
+        qc.x(q[3])
+    
+        qc.cp(pi/4, q[0], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(-pi/4, q[1], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(pi/4, q[1], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+    
+    
+        qc.x(q[0])
+        qc.x(q[1])
+        qc.x(q[2])
+        qc.x(q[3])
+    
+    ### 0001 Oracle ###
+    
+        
+    if(grid_konumu == 1):
+    
+        qc.x(q[1])
+        qc.x(q[2])
+        qc.x(q[3])
+    
+        qc.cp(pi/4, q[0], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(-pi/4, q[1], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(pi/4, q[1], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+    
+        qc.x(q[1])
+        qc.x(q[2])
+        qc.x(q[3])
+    
+    
+    
+    ### 0010 Oracle ###
+    if(grid_konumu == 2):
+        qc.x(q[0])
+        qc.x(q[2])
+        qc.x(q[3])
+    
+        qc.cp(pi/4, q[0], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(-pi/4, q[1], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(pi/4, q[1], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+    
+        qc.x(q[0])
+        qc.x(q[2])
+        qc.x(q[3])
+    
+    
+    
+    ### 0011 Oracle ###
+    if(grid_konumu == 3):
+        qc.x(q[2])
+        qc.x(q[3])
+    
+        qc.cp(pi/4, q[0], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(-pi/4, q[1], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(pi/4, q[1], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+    
+        qc.x(q[2])
+        qc.x(q[3])
+    
+    
+    
+    ### 0100 Oracle ###
+    if(grid_konumu == 4):
+        qc.x(q[0])
+        qc.x(q[1])
+        qc.x(q[3])
+    
+        qc.cp(pi/4, q[0], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(-pi/4, q[1], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(pi/4, q[1], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+    
+        qc.x(q[0])
+        qc.x(q[1])
+        qc.x(q[3])
+    
+    
+    
+    ### 0101 Oracle ###
+    if(grid_konumu == 5):
+        qc.x(q[1])
+        qc.x(q[3])
+    
+        qc.cp(pi/4, q[0], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(-pi/4, q[1], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(pi/4, q[1], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+    
+        qc.x(q[1])
+        qc.x(q[3])
+    
+    
+    
+    ### 0110 Oracle ###
+    if(grid_konumu == 6):
+        qc.x(q[0])
+        qc.x(q[3])
+    
+        qc.cp(pi/4, q[0], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(-pi/4, q[1], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(pi/4, q[1], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+    
+        qc.x(q[0])
+        qc.x(q[3])
+    
+    
+    
+    ### 0111 Oracle ###
+    if(grid_konumu == 7):
+        qc.x(q[3])
+    
+        qc.cp(pi/4, q[0], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(-pi/4, q[1], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(pi/4, q[1], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+    
+        qc.x(q[3])
+    
+    
+    ### 1000 Oracle ###
+    if(grid_konumu == 8):
+        qc.x(q[0])
+        qc.x(q[1])
+        qc.x(q[2])
+    
+        qc.cp(pi/4, q[0], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(-pi/4, q[1], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(pi/4, q[1], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+    
+        qc.x(q[0])
+        qc.x(q[1])
+        qc.x(q[2])
+    
+    
+    
+    ### 1001 Oracle ###
+    if(grid_konumu == 9):
+        qc.x(q[1])
+        qc.x(q[2])
+    
+        qc.cp(pi/4, q[0], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(-pi/4, q[1], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(pi/4, q[1], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+    
+        qc.x(q[1])
+        qc.x(q[2])
+    
+    
+    
+    ### 1010 Oracle ###
+    if(grid_konumu == 10):
+        qc.x(q[0])
+        qc.x(q[2])
+    
+        qc.cp(pi/4, q[0], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(-pi/4, q[1], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(pi/4, q[1], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+    
+        qc.x(q[0])
+        qc.x(q[2])
+    
+    
+    
+    ### 1011 Oracle ###
+    if(grid_konumu == 11):
+        qc.x(q[3])
+    
+        qc.cp(pi/4, q[0], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(-pi/4, q[1], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(pi/4, q[1], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+    
+        qc.x(q[3])
+    
+    
+    
+    ### 1100 Oracle ###
+    if(grid_konumu == 12):
+        qc.x(q[0])
+        qc.x(q[1])
+    
+        qc.cp(pi/4, q[0], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(-pi/4, q[1], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(pi/4, q[1], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+    
+        qc.x(q[0])
+        qc.x(q[1])
+    
+    
+    ### 1101 Oracle ###
+    if(grid_konumu == 13):
+        qc.x(q[1])
+    
+        qc.cp(pi/4, q[0], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(-pi/4, q[1], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(pi/4, q[1], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+    
+        qc.x(q[1])
+        print("aaaaaaaaaaaaaaaa")
+    
+    
+    ### 1110 Oracle ###
+    if(grid_konumu == 14):
+        qc.x(q[0])
+    
+        qc.cp(pi/4, q[0], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(-pi/4, q[1], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(pi/4, q[1], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+    
+        qc.x(q[0])
+    
+    
+    
+    ###1111 Oracle###
+    if(grid_konumu == 15):
+        qc.cp(pi/4, q[0], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(-pi/4, q[1], q[3])
+        qc.cx(q[0], q[1])
+        qc.cp(pi/4, q[1], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+        qc.cx(q[1], q[2])
+        qc.cp(-pi/4, q[2], q[3])
+        qc.cx(q[0], q[2])
+        qc.cp(pi/4, q[2], q[3])
+    
+    
+    print('\nPreparing Amplification circuit....\n')
+    #### Amplification ####
+    
+    qc.h(q[0])
+    qc.h(q[1])
+    qc.h(q[2])
+    qc.h(q[3])
+    qc.x(q[0])
+    qc.x(q[1])
+    qc.x(q[2])
+    qc.x(q[3])
+    
+    qc.cp(pi/4, q[0], q[3])
+    qc.cx(q[0], q[1])
+    qc.cp(-pi/4, q[1], q[3])
+    qc.cx(q[0], q[1])
+    qc.cp(pi/4, q[1], q[3])
+    qc.cx(q[1], q[2])
+    qc.cp(-pi/4, q[2], q[3])
+    qc.cx(q[0], q[2])
+    qc.cp(pi/4, q[2], q[3])
+    qc.cx(q[1], q[2])
+    
+    qc.cp(-pi/4, q[2], q[3])
+    qc.cx(q[0], q[2])
+    qc.cp(pi/4, q[2], q[3])
+    
+    qc.x(q[0])
+    qc.x(q[1])
+    qc.x(q[2])
+    qc.x(q[3])
+    qc.h(q[0])
+    qc.h(q[1])
+    qc.h(q[2])
+    qc.h(q[3])
+    
+    ### Measurment ###
+    qc.barrier(q)
+    qc.measure(q[0], c[0])
+    qc.measure(q[1], c[1])
+    qc.measure(q[2], c[2])
+    qc.measure(q[3], c[3])
+    
+    backend = Aer.get_backend('qasm_simulator')
+    print('\nExecuting job....\n')
+    job = execute(qc, backend, shots=250)
+    
+    result = job.result()
+    counts = result.get_counts(qc)
+    
+    coundDeger = str(counts)
+    coundDeger = coundDeger.replace("'", " ")
+    coundDeger = coundDeger.replace("{", " ")
+    coundDeger = coundDeger.replace(":", " ")
+    
+    
+    coundDeger = coundDeger.replace(",", " ")
+    coundDeger = coundDeger.replace("}", " ")
+    print(coundDeger)
+    
+            
+            
+    grids = ["0000","0001","0010","0100","1000","0011","0101","1001","0110","1010","1100","0111","1011","1101","1110","1111"]
+    grids_count = ["0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0"]
+    
+    
+    
+    
+    # Bubble sort in Python
+    
+    
+    ali=max(counts,key=lambda x:counts[x])
+    print(20*"-")
+    print(int(ali,2))
+    print(20*"-")
+    print(max(counts,key=lambda x:counts[x]))
+    print(20*"-")
+    print('RESULT: ',counts,'\n')
+    print('Press any key to close')
+    
+    
+    buyuk_x = x%4 
+    buyuk_y = y%4 
+    
+    q1 = QuantumRegister(4,'q')
+    c1 = ClassicalRegister(4,'c')
+    qc1 = QuantumCircuit(q1,c1)
+    
+    
+    z = (buyuk_x)*4 + buyuk_y
+    grid_konumu = z
+    
+    
+    print(grid_konumu)
+    
+    qc1.h(q1[0])
+    qc1.h(q1[1])
+    qc1.h(q1[2])
+    qc1.h(q1[3])
+    
+    
+    if(grid_konumu == 0):
+        qc1.x(q1[0])
+        qc1.x(q1[1])
+        qc1.x(q1[2])
+        qc1.x(q1[3])
+    
+        qc1.cp(pi/4, q1[0], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(-pi/4, q1[1], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(pi/4, q1[1], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+    
+    
+        qc1.x(q1[0])
+        qc1.x(q1[1])
+        qc1.x(q1[2])
+        qc1.x(q1[3])
+    
+    ### 0001 Oracle ###
+    
+        
+    if(grid_konumu == 1):
+    
+        qc1.x(q1[1])
+        qc1.x(q1[2])
+        qc1.x(q1[3])
+    
+        qc1.cp(pi/4, q1[0], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(-pi/4, q1[1], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(pi/4, q1[1], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+    
+        qc1.x(q1[1])
+        qc1.x(q1[2])
+        qc1.x(q1[3])
+    
+    
+    
+    ### 0010 Oracle ###
+    if(grid_konumu == 2):
+        print("AAAAAAAAAAAAAAAAAAAAA")
+        qc1.x(q1[0])
+        qc1.x(q1[2])
+        qc1.x(q1[3])
+    
+        qc1.cp(pi/4, q1[0], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(-pi/4, q1[1], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(pi/4, q1[1], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+    
+        qc1.x(q1[0])
+        qc1.x(q1[2])
+        qc1.x(q1[3])
+    
+    
+    
+    ### 0011 Oracle ###
+    if(grid_konumu == 3):
+        qc1.x(q1[2])
+        qc1.x(q1[3])
+    
+        qc1.cp(pi/4, q1[0], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(-pi/4, q1[1], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(pi/4, q1[1], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+    
+        qc1.x(q1[2])
+        qc1.x(q1[3])
+    
+    
+    
+    ### 0100 Oracle ###
+    if(grid_konumu == 4):
+        qc1.x(q1[0])
+        qc1.x(q1[1])
+        qc1.x(q1[3])
+    
+        qc1.cp(pi/4, q1[0], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(-pi/4, q1[1], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(pi/4, q1[1], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+    
+        qc1.x(q1[0])
+        qc1.x(q1[1])
+        qc1.x(q1[3])
+    
+    
+    
+    ### 0101 Oracle ###
+    if(grid_konumu == 5):
+        qc1.x(q1[1])
+        qc1.x(q1[3])
+    
+        qc1.cp(pi/4, q1[0], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(-pi/4, q1[1], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(pi/4, q1[1], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+    
+        qc1.x(q1[1])
+        qc1.x(q1[3])
+    
+    
+    
+    ### 0110 Oracle ###
+    if(grid_konumu == 6):
+        qc1.x(q1[0])
+        qc1.x(q1[3])
+    
+        qc1.cp(pi/4, q1[0], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(-pi/4, q1[1], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(pi/4, q1[1], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+    
+        qc1.x(q1[0])
+        qc1.x(q1[3])
+    
+    
+    
+    ### 0111 Oracle ###
+    if(grid_konumu == 7):
+        qc1.x(q1[3])
+    
+        qc1.cp(pi/4, q1[0], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(-pi/4, q1[1], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(pi/4, q1[1], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+    
+        qc1.x(q1[3])
+    
+    
+    ### 1000 Oracle ###
+    if(grid_konumu == 8):
+        qc1.x(q1[0])
+        qc1.x(q1[1])
+        qc1.x(q1[2])
+    
+        qc1.cp(pi/4, q1[0], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(-pi/4, q1[1], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(pi/4, q1[1], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+    
+        qc1.x(q1[0])
+        qc1.x(q1[1])
+        qc1.x(q1[2])
+    
+    
+    
+    ### 1001 Oracle ###
+    if(grid_konumu == 9):
+        qc1.x(q1[1])
+        qc1.x(q1[2])
+    
+        qc1.cp(pi/4, q1[0], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(-pi/4, q1[1], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(pi/4, q1[1], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+    
+        qc1.x(q1[1])
+        qc1.x(q1[2])
+    
+    
+    
+    ### 1010 Oracle ###
+    if(grid_konumu == 10):
+        qc1.x(q1[0])
+        qc1.x(q1[2])
+    
+        qc1.cp(pi/4, q1[0], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(-pi/4, q1[1], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(pi/4, q1[1], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+    
+        qc1.x(q1[0])
+        qc1.x(q1[2])
+    
+    
+    
+    ### 1011 Oracle ###
+    if(grid_konumu == 11):
+        qc1.x(q1[3])
+    
+        qc1.cp(pi/4, q1[0], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(-pi/4, q1[1], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(pi/4, q1[1], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+    
+        qc1.x(q1[3])
+    
+    
+    
+    ### 1100 Oracle ###
+    if(grid_konumu == 12):
+        qc1.x(q1[0])
+        qc1.x(q1[1])
+    
+        qc1.cp(pi/4, q1[0], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(-pi/4, q1[1], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(pi/4, q1[1], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+    
+        qc1.x(q1[0])
+        qc1.x(q1[1])
+    
+    
+    ### 1101 Oracle ###
+    if(grid_konumu == 13):
+        qc1.x(q1[1])
+    
+        qc1.cp(pi/4, q1[0], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(-pi/4, q1[1], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(pi/4, q1[1], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+    
+        qc1.x(q1[1])
+        print("aaaaaaaaaaaaaaaa")
+    
+    
+    ### 1110 Oracle ###
+    if(grid_konumu == 14):
+        qc1.x(q1[0])
+    
+        qc1.cp(pi/4, q1[0], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(-pi/4, q1[1], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(pi/4, q1[1], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+    
+        qc1.x(q1[0])
+    
+    
+    
+    ###1111 Oracle###
+    if(grid_konumu == 15):
+        qc1.cp(pi/4, q1[0], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(-pi/4, q1[1], q1[3])
+        qc1.cx(q1[0], q1[1])
+        qc1.cp(pi/4, q1[1], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+        qc1.cx(q1[1], q1[2])
+        qc1.cp(-pi/4, q1[2], q1[3])
+        qc1.cx(q1[0], q1[2])
+        qc1.cp(pi/4, q1[2], q1[3])
+    
+    
+    print('\nPreparing Amplification circuit....\n')
+    #### Amplification ####
+    
+    qc1.h(q1[0])
+    qc1.h(q1[1])
+    qc1.h(q1[2])
+    qc1.h(q1[3])
+    qc1.x(q1[0])
+    qc1.x(q1[1])
+    qc1.x(q1[2])
+    qc1.x(q1[3])
+    
+    qc1.cp(pi/4, q1[0], q1[3])
+    qc1.cx(q1[0], q1[1])
+    qc1.cp(-pi/4, q1[1], q1[3])
+    qc1.cx(q1[0], q1[1])
+    qc1.cp(pi/4, q1[1], q1[3])
+    qc1.cx(q1[1], q1[2])
+    qc1.cp(-pi/4, q1[2], q1[3])
+    qc1.cx(q1[0], q1[2])
+    qc1.cp(pi/4, q1[2], q1[3])
+    qc1.cx(q1[1], q1[2])
+    
+    qc1.cp(-pi/4, q1[2], q1[3])
+    qc1.cx(q1[0], q1[2])
+    qc1.cp(pi/4, q1[2], q1[3])
+    
+    qc1.x(q1[0])
+    qc1.x(q1[1])
+    qc1.x(q1[2])
+    qc1.x(q1[3])
+    qc1.h(q1[0])
+    qc1.h(q1[1])
+    qc1.h(q1[2])
+    qc1.h(q1[3])
+    
+    ### Measurment ###
+    qc1.barrier(q)
+    qc1.measure(q1[0], c[0])
+    qc1.measure(q1[1], c[1])
+    qc1.measure(q1[2], c[2])
+    qc1.measure(q1[3], c[3])
+    
+    
+    backend = Aer.get_backend('qasm_simulator')
+    print('\nExecuting job....\n')
+    job = execute(qc1, backend, shots=250)
+    
+    result = job.result()
+    counts = result.get_counts(qc1)
+    
+    mustafa=max(counts,key=lambda x:counts[x])
+    print(20*"-")
+    print(int(mustafa,2))
+    print(20*"-")
+    
+    gercek_konumy = a_int*4 + buyuk_x
+    gercek_konumx = b_int*4 + buyuk_y
+    
+    print("b_int",b_int)
+    print("a_int",a_int)
+    print("buyuk_x",buyuk_x)
+    print("buyuky",buyuk_y)
+    print(gercek_konumx)
+    print(gercek_konumy)
+    print('RESULT: ',counts,'\n')
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    dictionary = {
+        "minescanner": "mineware",
+        "degerx": xDegerX,
+        "degery": yDegerY,
+        "phonenumber": "9976770500"
+    }
+    
+    json_object = json.dumps(dictionary, indent=4)
+    
+    with open("sample.json", "w") as outfile:
+        outfile.write(json_object)
+    
+    """
+    JSON Bitti
+    """
+    
+    pygame.init()
+     
+    white = (255, 255, 255)
+    gray = (208, 209, 217)
+    yellow = (255, 255, 102)
+    black = (0, 0, 0)
+    red = (213, 50, 80)
+    green = (0, 255, 0)
+    blue = (50, 153, 213)
+     
+    dis_width = 512
+    dis_height = 512
+    
+    rows = 16
+    w = 512
+    
+    dis = pygame.display.set_mode((dis_width, dis_height))
+    pygame.display.set_caption('Quantum Minesweeper')
+     
+    clock = pygame.time.Clock()
+    
+    pygame.init()
+    
+    counter, text = 3, '3'.rjust(3)
+    pygame.time.set_timer(pygame.USEREVENT, 1000)
+    font = pygame.font.SysFont('Consolas', 30)
+    screen = pygame.display.set_mode((256, 256))
+    clock = pygame.time.Clock()
+    run = True
+    while run:
+        for e in pygame.event.get():
+            if e.type == pygame.USEREVENT: 
+                counter -= 1
+                text = str(counter).rjust(3) if counter > 0 else 'boom!'
+            if e.type == pygame.QUIT: 
+                run = False
+        screen.fill((255, 255, 255))
+        screen.blit(font.render(text, True, (0, 0, 0)), (92, 110))
+        pygame.display.flip()
+        clock.tick(60)
+    dis = pygame.display.set_mode((dis_width, dis_height))
+    snake_block = 32
+    snake_speed = 10
+     
+    font_style = pygame.font.SysFont("bahnschrift", 25)
+    score_font = pygame.font.SysFont("comicsansms", 35)
+    
+    
+    
+    def Your_score(score):
+        valuex = score_font.render("DegerX: " +str(xDegerX), True, white)
+        valuey = score_font.render("DegerY: " +str(yDegerY), True, white)
+        dis.blit(valuex, [300, 0])
+        dis.blit(valuey, [300, 32])
+    
+     
+    def our_snake(snake_block, snake_list):
+        for x in snake_list:
+            pygame.draw.rect(dis, red, [x[0], x[1], snake_block, snake_block])
+     
+     
+    def message(msg, color):
+        mesg = font_style.render(msg, True, color)
+        dis.blit(mesg, [10, dis_height / 16])
+              
+     
+    def gameLoop():
+        game_over = False
+        game_close = False
+     
+        x1 = dis_width / 2
+        y1 = 128
+     
+        x1_change = 0
+        y1_change = 0
+     
+        xgit = gercek_konumx/32
+        print(xgit)
+        
+        snake_List = []
+        Length_of_snake = 1
+     
+        foodx = round((xDegerX - snake_block) / 160.0) * 160.0
+        foody = round((yDegerY - snake_block) / 160.0) * 160.0
+     
+        pygame.display.flip()
+        pygame.event.pump()
+        pygame.time.delay(1000) # 1 second == 1000 milliseconds
+        
+    
+                
+        while not game_over:
+    
+            while game_close == True:
+                message("Mission Completed!", red)
+                #Your_score(Length_of_snake - 1)
+                pygame.display.update()
+                for event in pygame.event.get():
+                    if event.type == pygame.KEYDOWN:
+                        if event.key == pygame.K_q:
+                            game_over = True
+                            game_close = False
+                        if event.key == pygame.K_r:
+                            rastgele()
+            for event in pygame.event.get():
+                if event.type == pygame.QUIT:
+                    game_over = True
+                if event.type == pygame.KEYDOWN:
+                    if event.key == pygame.K_LEFT:
+                        x1_change = -snake_block
+                        y1_change = 0
+                    elif event.key == pygame.K_RIGHT:
+                        x1_change = snake_block
+                        y1_change = 0
+                    elif event.key == pygame.K_UP:
+                        y1_change = -snake_block
+                        x1_change = 0
+                    elif event.key == pygame.K_DOWN:
+                        y1_change = snake_block
+                        x1_change = 0
+    
+                
+                
+            #if x1 >= dis_width or x1 < 0 or y1 >= dis_height or y1 < 0:
+             #   game_close = True
+            x1 += x1_change
+            y1 += y1_change
+            
+            if gercek_konumx < x1:
+                x1_change = -snake_block
+                print("SOL")
+            elif gercek_konumx > x1:
+                x1_change = snake_block
+                print("SAĞ")
+            if gercek_konumy < y1:
+                y1_change = -snake_block
+                print("AŞAĞI")
+            elif gercek_konumy > y1:
+                y1_change = snake_block
+                print("YUKARI")
+                
+                
+                
+            print("XXXX", x1)
+            print("YYYY", y1)
+            print("GERÇEK-X", gercek_konumx)
+            print("GERÇEK-Y", gercek_konumy)
+    
+            dis.fill(black)
+            sizeBtwn = w // rows
+            sizeBtwna = w // rows * 4
+    
+            x = 0
+            y = 0
+            xa = 0
+            ya = 0
+            for l in range(rows-1):
+                pygame.draw.rect(dis,red,(1,0,1,512))
+                pygame.draw.rect(dis,red,(128,0,1,512))
+                pygame.draw.rect(dis,red,(256,0,1,512))
+                pygame.draw.rect(dis,red,(384,0,1,512))
+                pygame.draw.rect(dis,red,(511,0,1,512))
+                pygame.draw.rect(dis,red,(0,1,512,1))
+                pygame.draw.rect(dis,red,(0,128,512,1))
+                pygame.draw.rect(dis,red,(0,256,512,1))
+                pygame.draw.rect(dis,red,(0,384,512,1))
+                pygame.draw.rect(dis,red,(0,511,512,1))
+                
+                x = x + sizeBtwn
+                y = y + sizeBtwn
+    
+                xa = xa + sizeBtwna
+                ya = ya + sizeBtwna
+    
+                pygame.draw.line(dis, (gray), (x,0),(x,w))
+                pygame.draw.line(dis, (gray), (0,y),(w,y))
+                
+                pygame.draw.line(dis, (213, 50, 80), (xa,0),(xa,w))
+                pygame.draw.line(dis, (213, 50, 80), (0,ya),(w,ya))  
+            pygame.draw.rect(dis, green, [foodx, foody, snake_block, snake_block])
+            snake_Head = []
+            snake_Head.append(x1)
+            snake_Head.append(y1)
+            snake_List.append(snake_Head)
+            if len(snake_List) > Length_of_snake:
+                del snake_List[0]
+     
+            for x in snake_List[:-1]:
+                if x == snake_Head:
+                    game_close = True
+     
+            our_snake(snake_block, snake_List)
+            Your_score(Length_of_snake - 1)
+     
+            pygame.display.update()
+     
+            if x1 == foodx and y1 == foody:
+                foodx = round((xDegerX - snake_block) / 160.0) * 160.0
+                foody = round((yDegerY - snake_block) / 160.0) * 160.0
+                Length_of_snake += 1
+     
+            xgel = foodx + 100
+            if pygame.key.get_pressed()[pygame.K_a]:
+                x1_change = -xgit
+                y1_change = 0
+            if pygame.key.get_pressed()[pygame.K_s]:
+                y1_change = xgit
+                x1_change = 0
+                
+    
+            if pygame.key.get_pressed()[pygame.K_w]:
+                y1_change = -xgit
+                x1_change = 0
+    
+                
+            if x1==foodx:
+                print("X")
+                x1_change = 0
+            if y1==foody:
+                print("Y")
+                y1_change = 0
+            clock.tick(snake_speed)
+     
+        pygame.quit()
+        quit()
+     
+    
+    gameLoop()
 rastgele()
\ No newline at end of file