import hashlib

def mine(data, difficulty):
    # The prefix is a string of zeros, the length of which is the difficulty level
    prefix = '0' * difficulty
    # The nonce starts at 0
    nonce = 0
    # Keep looping until we find a hash that starts with the prefix
    while True:
        # Increment the nonce
        nonce += 1
        # Calculate the SHA-256 hash of the data concatenated with the nonce
        hash = hashlib.sha256(f'{data}{nonce}'.encode()).hexdigest()
        # If the hash starts with the prefix, we've found a solution
        if hash.startswith(prefix):
            # Return the nonce and the hash
            return nonce, hash

import time

# The data that we want to mine
data = 'This is my data'

# Loop over difficulty levels from 1 to 6
for difficulty in range(1, 7):
    # Record the start time
    start_time = time.time()
    
    # Mine the data with the current difficulty level
    nonce, hash = mine(data, difficulty)
    
    # Record the end time
    end_time = time.time()
    
    # Print the difficulty level, time taken, nonce and hash
    print(f"Difficulty {difficulty}, Time taken: {end_time - start_time} seconds, Nonce: {nonce}, Hash: {hash}")

import hashlib
import time
import json

class Block:
    def __init__(self, index, previous_hash, timestamp, data, hash, nonce):
        self.index = index  # The position of the block in the blockchain
        self.previous_hash = previous_hash  # The hash of the previous block in the blockchain
        self.timestamp = timestamp  # The time when the block was created
        self.data = data  # The data stored in the block
        self.hash = hash  # The hash of the block's content
        self.nonce = nonce  # The nonce used for the proof of work

    def to_dict(self):
        # Convert the block to a dictionary for visualization
        return {
            'index': self.index,
            'previous_hash': self.previous_hash,
            'timestamp': self.timestamp,
            'data': self.data,
            'hash': self.hash,
            'nonce': self.nonce
        }

class Blockchain:
    def __init__(self, difficulty):
        self.difficulty = difficulty  # The difficulty level for the proof of work
        # Create the genesis block with index 0 and arbitrary previous hash
        self.genesis_block = Block(0, "0", int(time.time()), "Genesis Block", self.calculate_hash(0, "0", int(time.time()), "Genesis Block", 0), 0)
        self.blockchain = [self.genesis_block]  # Initialize the blockchain with the genesis block

    def calculate_hash(self, index, previous_hash, timestamp, data, nonce):
        # Calculate the SHA-256 hash of a block
        value = str(index) + str(previous_hash) + str(timestamp) + str(data) + str(nonce)
        return hashlib.sha256(value.encode('utf-8')).hexdigest()

    def proof_of_work(self, index, previous_hash, timestamp, data):
        # Implement the proof of work
        nonce = 0
        while True:
            hash = self.calculate_hash(index, previous_hash, timestamp, data, nonce)
            if hash[:self.difficulty] == '0' * self.difficulty:
                return nonce, hash
            nonce += 1

    def create_new_block(self, data):
        # Create a new block with the given data
        latest_block = self.blockchain[-1]
        index = latest_block.index + 1
        timestamp = int(time.time())
        nonce, hash = self.proof_of_work(index, latest_block.hash, timestamp, data)
        new_block = Block(index, latest_block.hash, timestamp, data, hash, nonce)
        self.blockchain.append(new_block)
        return new_block

    def get_latest_block(self):
        # Get the latest block in the blockchain
        return self.blockchain[-1]

    def validate_blockchain(self):
        # Validate the integrity of the blockchain
        for i in range(1, len(self.blockchain)):
            current_block = self.blockchain[i]
            previous_block = self.blockchain[i - 1]

            # Check if the current block's hash is correct
            if current_block.hash != self.calculate_hash(current_block.index, current_block.previous_hash, current_block.timestamp, current_block.data, current_block.nonce):
                return False
            # Check if the current block's previous hash matches the hash of the previous block
            if current_block.previous_hash != previous_block.hash:
                return False
            # Check if the current block's hash starts with the correct number of zeros
            if not current_block.hash.startswith('0' * self.difficulty):
                return False
        return True

    def to_json(self):
        return json.dumps([block.to_dict() for block in self.blockchain], indent=4)

# Create a new Blockchain
my_blockchain = Blockchain(difficulty=5)

# Add data to a new block
my_blockchain.create_new_block("Some data for the first block")

# Add data to another new block
my_blockchain.create_new_block("Some data for the second block")

# Print the blockchain
print(my_blockchain.to_json())

# Validate the blockchain
if my_blockchain.validate_blockchain():
    print("\n\nThe blockchain is valid.")
else:
    print("\n\nThe blockchain is not valid.")