using System;

using System.Collections.Generic;

​

public class PasswordChallenge

{

    public static object Hack(int mainKey, int mainLock, int lockX)

    {

        // Track all possible lock values and their attempt counts

        var lockStates = new Dictionary<int, int>();

        var currentLock = lockX;

        var totalAttempts = 0;

        // Keep track of visited lock values to detect cycles

        var visitedLocks = new HashSet<int>();

        while (true)

        {

            // If we've seen this lock value before, we're in a cycle

            if (visitedLocks.Contains(currentLock))

            {

                return "system with a high level of security";

            }

            visitedLocks.Add(currentLock);

            // For each lock value, we need to try all possible keys (0 to lock-1)

            // The worst case is when we need to try all possible keys

            // Since key = code % lock, the possible keys are 0, 1, 2, ..., lock-1

            // In the worst case, we might need to try all keys for this lock

            // But we only get 10 attempts before the lock changes

            int attemptsForThisLock = Math.Min(10, currentLock);

            totalAttempts += attemptsForThisLock;

            // Check if we can potentially find the key with current lock

            // The key space for this lock is [0, currentLock-1]

            // If we can try all possible keys within the attempt limit, we can find it

            if (currentLock <= 10)

            {

                // We can try all possible keys for this lock value

                return totalAttempts;

            }

            // After 10 failed attempts, lock updates

            currentLock = currentLock + mainKey;

            // Prevent infinite loops - if lock grows too large, it's impossible

            if (currentLock > 1000000) // Given constraint: inputs < 10^6

            {

                return "system with a high level of security";

            }

        }

    }

    // Alternative approach that better matches the expected outputs

    public static object HackOptimized(int mainKey, int mainLock, int lockX)

    {

        var visitedLocks = new HashSet<int>();

        var currentLock = lockX;

        var totalAttempts = 0;

        while (!visitedLocks.Contains(currentLock))

        {

            visitedLocks.Add(currentLock);

            // For this lock, we can make at most 10 attempts

            // If the lock value is <= 10, we can guarantee finding the key

            if (currentLock <= 10)

            {

                // We need at most 'currentLock' attempts to find the right key

                return totalAttempts + currentLock;

            }

            // We make 10 attempts and fail, so lock gets updated

            totalAttempts += 10;

            currentLock = currentLock + mainKey;

            // Safety check to prevent infinite growth

            if (currentLock > 10000000)

            {

                return "system with a high level of security";

            }

        }

        return "system with a high level of security";

    }

    // Most accurate implementation based on the examples

    public static object HackFinal(int mainKey, int mainLock, int lockX)

    {

        var visitedLocks = new HashSet<int>();

        var currentLock = lockX;

        var totalAttempts = 0;

        while (!visitedLocks.Contains(currentLock))

        {

            visitedLocks.Add(currentLock);

            // Check if we can crack this lock value

            // We can make up to 10 attempts before lock changes

            // If lock <= 10, we can guarantee success within those attempts

            if (currentLock <= 10)

            {

                // In worst case, the correct key is the last one we try

                return totalAttempts + currentLock;

            }

            // We exhaust our 10 attempts and lock gets updated

            totalAttempts += 10;

            currentLock += mainKey;

            // Prevent infinite loops for very large numbers

            if (totalAttempts > 10000)

            {

                return "system with a high level of security";

            }

        }

        return "system with a high level of security";

    }

    // Main method with user input

    public static void Main()

    {

        Console.WriteLine("=== Password Challenge Solver ===");

        Console.WriteLine("This program calculates how many attempts a hacker needs to crack a security system.");

        Console.WriteLine();

        while (true)

        {

            try

            {

                // Get user input

                Console.Write("Enter the main key: ");

                int mainKey = int.Parse(Console.ReadLine());

                Console.Write("Enter the main lock: ");

                int mainLock = int.Parse(Console.ReadLine());

                Console.Write("Enter the target lock (lock_x): ");

                int lockX = int.Parse(Console.ReadLine());

                // Validate inputs

                if (mainKey <= 0 || mainLock <= 0 || lockX <= 0)

                {

                    Console.WriteLine("Error: All values must be positive integers.");

                    Console.WriteLine();

                    continue;

                }

                if (mainKey >= 1000000 || mainLock >= 1000000 || lockX >= 1000000)

                {

                    Console.WriteLine("Error: All values must be less than 1,000,000.");

                    Console.WriteLine();

                    continue;

                }

                // Calculate the result

                Console.WriteLine("\nCalculating...");

                var result = HackFinal(mainKey, mainLock, lockX);

                Console.WriteLine($"\nResult: {result}");

                if (result is int attempts)

                {

                    Console.WriteLine($"The hacker needs {attempts} attempts to guarantee access to the lock.");

                }

                else

                {

                    Console.WriteLine("The system has a high level of security - it's impossible to guarantee access.");

                }

                // Ask if user wants to see the trace

                Console.Write("\nWould you like to see a step-by-step trace? (y/n): ");

                string traceChoice = Console.ReadLine().ToLower();

                if (traceChoice == "y" || traceChoice == "yes")

                {

                    Console.WriteLine("\nStep-by-step trace:");

                    TraceExample(mainKey, mainLock, lockX);

                }

            }

            catch (FormatException)

            {

                Console.WriteLine("Error: Please enter valid integers only.");

            }

            catch (OverflowException)

            {

                Console.WriteLine("Error: Number is too large. Please enter a smaller value.");

            }

            catch (Exception ex)

            {

                Console.WriteLine($"Error: {ex.Message}");

            }

            // Ask if user wants to continue

            Console.WriteLine();

            Console.Write("Would you like to try another set of values? (y/n): ");

            string continueChoice = Console.ReadLine().ToLower();

            if (continueChoice != "y" && continueChoice != "yes")

            {

                break;

            }

            Console.WriteLine();

        }

        Console.WriteLine("Thank you for using the Password Challenge Solver!");

        Console.WriteLine("Press any key to exit...");

        Console.ReadKey();

    }

    public static void TraceExample(int mainKey, int mainLock, int lockX)

    {

        var currentLock = lockX;

        var totalAttempts = 0;

        var step = 1;

        Console.WriteLine($"Initial lock: {currentLock}");

        while (currentLock > 10)

        {

            Console.WriteLine($"Step {step}: Lock = {currentLock}, too big (> 10)");

            Console.WriteLine($"  Making 10 attempts, all fail");

            totalAttempts += 10;

            currentLock += mainKey;

            Console.WriteLine($"  Lock updated to: {currentLock}");

            Console.WriteLine($"  Total attempts so far: {totalAttempts}");

            step++;

        }

        Console.WriteLine($"Step {step}: Lock = {currentLock}, small enough (<= 10)");

        Console.WriteLine($"  Can crack with at most {currentLock} attempts");

        totalAttempts += currentLock;

        Console.WriteLine($"Final answer: {totalAttempts}");

    }

}