DEV Community: Phoenix

LLM vs Agentic AI

Phoenix — Mon, 02 Mar 2026 06:57:11 +0000

LLM
An LLM (like OpenAI’s GPT models) reads text and predicts what words should come next. It can:

Answer questions
Write emails
Explain concepts
Translate languages
Help with code

But here’s the key thing:

👉 It only responds when you ask it something.
👉 It doesn’t take actions on its own.
👉 It doesn’t have goals.

ChatGPT, Claude (in basic chat mode) = LLMs in action

It’s like a very smart assistant waiting for instructions.

Agentic AI
Agentic AI is more like:
An AI that can act to achieve a goal.

Instead of just answering, it can:

Make a plan
Use tools (search the web, run code, access apps)
Make decisions without you guiding each step
Try again if something fails
Work step-by-step toward a goal

Claude Code, ChatGPT with plugins doing multi-step tasks = Agentic AI
It behaves more like an independent worker than just a chatbot.

Most agentic AI systems actually use LLMs inside them.

Think of it like this:

LLM = the brain

Agentic system = the brain + hands + memory + ability to act

Annotation in SpringBoot Web Application

Phoenix — Mon, 02 Feb 2026 07:29:45 +0000

Core Spring

@Component
Marks a class as a Spring-managed bean so it can be automatically created and injected.

@Service
Used for business logic classes; it’s a specialized form of @Component.

@Autowired
Tells Spring to automatically inject a required dependency.

@Bean
Defines a bean inside a configuration class.

@Configuration
Marks a class that contains Spring bean definitions.

@Primary
Marks a bean as the default choice when multiple beans are available.

@Qualifier
Used when multiple beans exist to specify which one should be injected.

@Repository
“Used for data access classes and also enables automatic exception translation.

@Controller
Marks a class as a web controller that handles HTTP requests.

@RestController
A controller that returns data (usually JSON) instead of views.

Spring Boot
@SpringBootApplication
Main annotation that enables auto-configuration, component scanning, and configuration support.

@EnableAutoConfiguration
Allows Spring Boot to automatically configure beans based on the project setup.

@ComponentScan
Tells Spring where to look for components.

@Value
Used to read values from application.properties.

Password Management - SpringBoot

Phoenix — Mon, 02 Feb 2026 06:12:39 +0000

Why Password Hashing Is Needed

Storing passwords in plain text is dangerous.
If a database is leaked, attackers immediately get all user passwords.

So instead of storing passwords, we store hashed values.

A hash is a one-way mathematical function that converts a password into an unreadable string.
You cannot reverse it to get the original password.

mypassword → $2a$10$Hf7sd8KJH...3fd2

How Login Works with Hashed Passwords

When a user logs in:
User enters password
Spring Security hashes the entered password
It compares the new hash with the stored hash in DB
If both match → login succeeds
The original password is never stored or compared

PasswordEncoder in Spring Security

Spring Security uses an interface called:

PasswordEncoder

It has two main methods:

String encode(CharSequence rawPassword);
boolean matches(CharSequence rawPassword, String encodedPassword);

Best Algorithm: BCrypt

Spring recommends BCrypt because it:

Uses salt automatically
Is slow (harder for hackers to brute force)
Is adaptive (can be made stronger over time)

@Bean
public PasswordEncoder passwordEncoder() {
    return new BCryptPasswordEncoder();
}

Why Salting Matters

Without salt:

password → hash

With salt:

password + randomValue → hash

Even if two users have the same password, their hashes will be different.

BCrypt handles salting automatically.

“A salt is a random value added to a password before hashing to make each hash unique and protect against rainbow-table and brute-force attacks.”

How Salt Works

User creates a password
System generates a random salt
Password + salt are hashed together
Both salt and hash are stored in the database

Example:

$2a$10$WERTY...SALT...HASH

When user logs in:

Spring Security extracts the salt from the stored hash
It hashes the entered password using that same salt
If hashes match → login succeeds

Tomcat Server - Servlet Container

Phoenix — Sat, 31 Jan 2026 09:48:55 +0000

Tomcat is the web server that runs your Spring application and connects it to the browser.

What is a Servlet?

In Java web development, a Servlet is just a Java class that:

Receives an HTTP request and returns an HTTP response

Like this:

Browser  →  Servlet  →  Response (HTML / JSON)

Example:

GET /login

Servlet runs Java code and returns:

<h1>Welcome</h1>

But…

A servlet cannot run by itself
It needs a Servlet Container

What is a Servlet Container?

A Servlet Container is a software that:

✔ Starts your servlets
✔ Listens to HTTP requests
✔ Calls the right servlet
✔ Sends the response back
✔ Manages threads, memory, security

Servlet Container = Runtime environment for servlets

So we need something that:

Opens port 8080
Accepts browser requests
Runs your servlet Java code

That “something” is called a Servlet Container

What is Tomcat?
Apache Tomcat is a Servlet Container

Tomcat’s job is:

Browser → Tomcat → Servlet → Response → Tomcat → Browser

Tomcat:

Opens a port (like 8080)
Understands HTTP
Runs servlets
Manages lifecycle of web apps

Without Tomcat, your Spring web app is just Java files — nobody can access it via browser.

Spring is a framework that helps you write Java code.

So Spring needs Tomcat to run on.

Think like this:

Spring Boot Application
    ↓
Runs inside Tomcat
    ↓
Tomcat runs inside JVM

What happens when you run a Spring Boot app?

When you click Run on:

@SpringBootApplication
public class MyApp {
    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args);
    }
}

Spring Boot:

Starts Tomcat internally
Registers Spring as a servlet
Tomcat listens on port 8080
Requests come in
Tomcat forwards them to Spring
Spring runs your controllers

When you create a Spring Boot Web project, this dependency is added automatically:

spring-boot-starter-web

Inside it is:

spring-boot-starter-tomcat

Spring Boot comes with Tomcat built-in by default

Spring Boot creates exactly ONE main servlet

It is called:

DispatcherServlet

This is Spring’s front controller.

What is DispatcherServlet?

It is a special servlet written by Spring.

Tomcat talks only to servlets.
So Spring creates one servlet and tells Tomcat:

“Send all requests to this servlet.”

So flow becomes:

Browser
   ↓
Tomcat
   ↓
DispatcherServlet (Spring)
   ↓
Your @Controller / @RestController

One DispatcherServlet
        |
        |-- "/login" → login()
        |-- "/register" → register()
        |-- "/products" → products()

So:

Spring has one servlet but thousands of routes

What happens internally when you hit a URL in Spring Boot?

You type this in browser

http://localhost:8080/hello

1️⃣ Browser sends HTTP request

Browser sends:

GET /hello
Host: localhost:8080

This goes to…

2️⃣ Tomcat (Web Server)
Tomcat is running because Spring Boot started it.

Tomcat:

Is listening on port 8080
Receives the HTTP request
But Tomcat doesn’t know Spring controllers.

It only knows:

“I must send requests to a servlet”

Spring registered one servlet:

DispatcherServlet

So Tomcat forwards request to it.

3️⃣DispatcherServlet (Heart of Spring MVC)

DispatcherServlet receives:

GET /hello

4️⃣ HandlerMapping

Spring looks in HandlerMapping
This is just an internal routing table.

It finds:

/hello → HelloController.hello()

5️⃣ Spring calls your method

Your controller runs:

Now it asks:

“Which controller method should handle /hello?”

To answer that, Spring has built a map when app started:

/hello  →  hello()
/login  →  login()
/users  →  getUsers()

Annotation Returns
@Controller HTML page
@RestController JSON / Text / Data

@RestController = @Controller + @ResponseBody

Beans using Autowiring

Phoenix — Thu, 29 Jan 2026 15:49:32 +0000

Creating beans alone is not enough.
They must also be wired together.

That wiring is what Autowiring (DI) does.

What does “wiring” mean?

Connecting beans together by injecting one bean into another.

Car → needs → Engine

@Autowired
Engine engine;

Spring injects the dependency for you.

That is autowiring.

What is @Autowired?

@Autowired tells Spring to automatically inject a required dependency into a Spring Bean.

It is Spring’s way of doing Dependency Injection

When @Autowired is on a setter

@Component
class Car {

    private Engine engine;

    @Autowired
    public void setEngine(Engine engine) {
        this.engine = engine;
    }
}

You might wonder:

“Who calls this setter? I never call it.”

Spring does.

What happens internally?

When Spring starts:

Spring creates the Car object using its constructor
Spring looks for any @Autowired methods
It finds setEngine(...)
It looks for an Engine bean
It finds it in the context
It calls the setter
car.setEngine(engineBean);

The dependency is injected

This happens automatically during bean creation.

Beans define which objects Spring manages, and autowiring defines how those objects are connected to each other through dependency injection.

Creating Spring Beans

Phoenix — Thu, 29 Jan 2026 09:42:15 +0000

When you use Spring without Spring Boot, you start by creating something called the ApplicationContext.
This object is the Spring IoC container — it is the place where Spring keeps and manages all the objects it creates.

ApplicationContext context =
        new AnnotationConfigApplicationContext(AppConfig.class);

Here, you are telling Spring:

“Start your container and use AppConfig as the configuration.”

What is AppConfig?

AppConfig is a class you write and mark with @Configuration:

@Configuration
public class AppConfig {
}

This tells Spring:

This class contains methods that create objects Spring should manage (factory of Spring Beans)

Inside this class, you write methods marked with @Bean :

@Configuration
public class AppConfig {

    @Bean
    public Engine engine() {
        return new Engine();
    }

    @Bean
    public Car car() {
        return new Car(engine());
    }
}

Each @bean method:

The object returned by this method should be stored in the Spring context as a Bean.
And hands it over to Spring

Spring then takes that object and stores it inside the ApplicationContext.

These stored objects are called Spring Beans.

What happens when the context is created?

When this line runs:

new AnnotationConfigApplicationContext(AppConfig.class);

Spring does the following:

Reads AppConfig
Finds all methods marked with @bean
Calls those methods
Creates the objects (Engine, Car)
Stores them inside the context
Keeps track of their dependencies and lifecycle

Now the IoC container fully controls these objects.

How do you use them?

Instead of writing:

Car car = new Car();

Car car = context.getBean(Car.class);

Spring gives you the object it created and manages.

That is Inversion of Control:
Spring controls object creation, not you.

Putting it all together

@Configuration tells Spring where the bean definitions are
@Bean tells Spring which objects to create
AnnotationConfigApplicationContext starts the IoC container
ApplicationContext stores and manages the beans
You ask the context for objects instead of using new

@Component is one of the most important Spring annotations — it’s how you tell Spring:

“Please create and manage an object of this class.”

What is @Component?

@Component marks a class as a Spring Bean so that Spring will automatically create and manage its object in the IoC container.

@Component
public class Engine {
}

This tells Spring:

“When the context starts, create an Engine object and store it.”

How Spring finds it

When the ApplicationContext starts, Spring performs component scanning.

It looks through your packages and finds classes annotated with:

@Component
@Service
@Repository
@Controller These are all forms of @Component.

Spring Beans, Context, Spring IoC container

Phoenix — Thu, 29 Jan 2026 07:16:10 +0000

Spring Beans
we hear a lot about beans when we are working with spring

A Spring Bean is any Java object that is instantiated, configured, and managed by the Spring IoC container.

a Bean is a POJO(Plain Old Java Object)
But not every POJO is a Bean.

A Bean = POJO + managed by Spring

What does “managed by Spring” mean?
Spring:

Creates the object
Stores it in the container
Injects its dependencies
Controls its lifecycle
Destroys it when the app shuts down
Only such objects are called Beans.

It is not mandatory that every class inside your application should be beans, like (utilities classes)

How spring knows which needs to be maintained?

with the help of configurations that we supply either through XML files or Annotations

Context
context is like a memory location where we add all the object instances that we want the framework to manage. by default spring doesn't know any of the objects that we define in the application. to enable spring to see your object you need to add them to the context.

We add classes to the Spring context by annotating them so that Spring can create and manage their objects as beans.

*Spring IoC container *
The Spring IoC Container is the core part of Spring that creates, manages, and injects application objects (beans) and controls their lifecycle.

Here’s the big picture

When a Spring (or Spring Boot) application starts, the first thing it creates is something called the ApplicationContext.
This ApplicationContext is the Spring IoC container.

You can think of it as Spring’s brain and memory.

What does this IoC container do?

It looks at your project and searches for classes marked with things like:

@Component
@Service
@Repository
@Controller

These annotations tell Spring:

“You are allowed to manage this class.”

Spring then creates objects of those classes and stores them inside the ApplicationContext.

These objects are called Spring Beans.

Bean→ the object Spring creates from that class

Context → where Spring stores and manages those objects

In simple words:
Spring creates a context (IoC container), puts your beans inside it, and then runs your application using those beans.

IoC and DI

Phoenix — Thu, 29 Jan 2026 06:49:37 +0000

IoC and DI are the core principles that spring framework follows

Inversion of Control - It is a software design principle, in which the control of object creation and dependency management should be transferred from application code to framework or container.
It is just a guideline that says who takes the control of creation? but not how to imeplement it.
it just describes the way how objects are created. control of object creation should be shifted from application code to external entity or framework

IoC is just this rule:

A class must not decide or create the objects it depends on.

It does not say:

Who will create them
How they will be passed

It only says:

“The control must be outside the class.”

Dependency Injection - it is a design principle that implements IoC, where the dependencies are injected from outside through a framework, but not created by object itself.

It reduces coupling between objects as it is dynamically injected by framework.

Advantages of IoC and DI

Loose coupling - Don't have to change your code whenever the dependencies gets changed.
minimises the amount of code.
make unit testing very easy with different mock tests.
increased system maintainability and module reusability.
allows concurrent independent development.
replacing modules has no side-effects on other modules.
even if the requirements in future, we don't have to make lot of changes

Spring is called an IoC Container because it stores application objects and takes control of their creation, lifecycle, and dependency wiring instead of the application code.

using spring framework
we just define these are the dependencies of my class, during runtime execution the framework automatically creates this objects and injects them into this class.

OS Notes - 1

Phoenix — Tue, 01 Oct 2024 15:10:10 +0000

*Operating Systems - *
It acts as an intermediate between computer applications and it's hardware. The OS handles tasks such as running applications, managing files, and controlling hardware like the keyboard, mouse, and printer, so you don’t have to manage these details yourself.

Multiprogramming Operating System - Multiprogramming utilizes the CPU more efficiently. The OS assigns a process to the CPU and when it waits for I/O the CPU assigns another process in the queue to the CPU. The main aim is not to keep the CPU idle.
Multitasking Operating System - In multitasking, each job or process is given some time to execute and the operating system switches the jobs after a certain interval of time. The switch is so quick that the user can interact with each program as it runs. This is also known as Time Sharing OS.

Process -
A process is a large independent program that is in execution.
Thread is small component in the process that performs individual tasks within program like running different parts of it at the same time.

Threads can directly communicate between each other because it shares memory space where as for process, OS interventatioon takes place.
There are two types of threads.
User threads - It is implemented by the user.
Kernel threads - It is implemented by the Operating System.

A thread has its own program counter, register set, and stack
A thread shares resources with other threads of the same process the code section, the data section, files and signals.

Context Switching- A context switch is the action of the computer switching from one task to another. It's necessary to efficiently manage different tasks and make sure they all get a turn to run.

Process Scheduling Algorithms
First Come First Serve (FCFS) - It schedules the Process according to the arrival time. The process which arrives first is scheduled first. It is the simplest scheduling algorithm.
Shortest Job First (SJF) - The Process which has the shortest execution time or Burst time is scheduled first in this algorithm.
Shortest Remaining Time First - The only difference between SJF and this is preemption happens in this. The processes are scheduled according to the shortest remaining time for execution.
Round Robin Scheduling - In Round Robin each process is cyclically assigned a fixed time. Each process executes for a certain time and waits for its turn again.
Priority Scheduling - In Priority Scheduling, processes are scheduled according to their priority. The process which has higher priority is scheduled first and so on.
Multilevel Queue Scheduling - There are multiple queues in this algorithm according to the priority of the processes. The processes with higher priority are placed in one queue and lower ones in another similarly. The processes with lower priority are executed only after the execution of all higher priority processes.
*Multilevel Queue with Feedback *- This also uses the multiple queues concept but the processes may be moved from lower priority queue to higher priority queue according to their feedback. If a process needs lower CPU time, it can be moved to a higher priority queue and vice versa.

Race Around Condition
This condition occurs when more than one process tries to access the same data at the same time and tries to manipulate it.

Process Synchronization is the coordination of execution of multiple processes in a multi-process system to ensure that they access shared resources in a controlled and predictable manner. It aims to resolve the problem of race conditions and other synchronization issues in a concurrent system.

A critical section is a code segment that can be accessed by only one process at a time.

Semaphore
A semaphore is a variable that is used to prevent the simultaneous access of common resources by one or more threads in concurrent systems.

A deadlock is a situation where multiple processes or threads are stuck because they're waiting for each other to release something. It can be prevented with careful design and resolved by outside intervention or by making one of the processes let go.
It is an unwanted situation in which processes block each other by holding one resource and waiting for another resource that is held by some other process.

Virtual Memory
Virtual memory is a technique that lets a computer use more memory than it actually has. It does this by using a combination of RAM (real memory) and space on the computer's hard drive to store data that might not fit entirely in RAM.

Task Scheduler

Phoenix — Thu, 26 Sep 2024 07:08:11 +0000

Problem link - Task Scheduler
You are given an array of CPU tasks, each labeled with a letter from A to Z, and a number n. Each CPU interval can be idle or allow the completion of one task. Tasks can be completed in any order, but there's a constraint: there has to be a gap of at least n intervals between two tasks with the same label.

Return the minimum number of CPU intervals required to complete all tasks.

Example 1:

Input: tasks = ["A","A","A","B","B","B"], n = 2
Output: 8
Explanation: A possible sequence is: A -> B -> idle -> A -> B -> idle -> A -> B.
After completing task A, you must wait two intervals before doing A again. The same applies to task B. In the 3rd interval, neither A nor B can be done, so you idle. By the 4th interval, you can do A again as 2 intervals have passed.
Example 2:

Input: tasks = ["A","C","A","B","D","B"], n = 1
Output: 6
Explanation: A possible sequence is: A -> B -> C -> D -> A -> B.
With a cooling interval of 1, you can repeat a task after just one other task.
Approach

One key observation is that the task which appears more frequently needs to be executed first because delaying it causes more idle time, increasing the total time required to execute all tasks. Therefore, we will allow the most frequent task to be executed in the CPU whenever it is permitted, thus minimizing the chances of idle time.
We will use a Max-Heap to keep track of the most frequent tasks and a map to store the frequency of each task. Every task frequency will be pushed into the Max-Heap.
Additionally, we will maintain a cooldown queue that stores tasks if there are still instances left to execute. These tasks will be added to the queue along with the remaining executions and the next time when they can be executed.
Whenever the cooldown period for a particular task expires, it will be removed from the queue and added back to the Max-Heap.
A timer will count every step, whether it's an executed task or idle time.

    int leastInterval(vector<char>& tasks, int n) {
        priority_queue<int,vector<int>> pq;
        unordered_map<char,int> mp;
        queue<pair<int,int>> cooldown;
        // int maxi=1;
        for(int i=0;i<tasks.size();i++){
            mp[tasks[i]]++;
            // maxi=max(maxi,mp[tasks[i]]);
        }
        for(auto it: mp){
            pq.push(it.second);
            cout<<it.second<<endl;
        }
        int timer=0;
        while(!pq.empty() ||!cooldown.empty()){
            timer+=1;
            if(!pq.empty()){
                int task=pq.top()-1;
                // cout<<task;
                if(task>0){
                    cooldown.push({task,timer+n});
                }
                pq.pop();
            }
            if(!cooldown.empty()){
                if(cooldown.front().second==timer){
                    pq.push(cooldown.front().first);
                    cooldown.pop();
                }
            }

        }
        return timer;

    }

Time complexity:
Main while loop:
The number of iterations the loop runs is equal to the total time required to finish all tasks (including idle times). Hence, O(timer)
Operations inside the loop:
Heap: pop/push operations = O(logk), where k is the length of heap.
Queue operations are O(1)
Overall: O(timer*logk) as the dominant time complexity.

Space complexity:
Overall, space complexity is O(n), where n is the number of unique tasks.
Map: Uses O(n) space to store the frequency of each unique task.
Max Heap: Can hold up to n unique tasks, so its space complexity is O(n).
Cooldown Queue: Similarly, the cooldown queue can hold up to n unique tasks, so it also uses O(n) space.

Minimum Number of Platforms Required

Phoenix — Wed, 25 Sep 2024 21:02:56 +0000

Problem Statement: We are given two arrays that represent the arrival and departure times of trains that stop at the platform. We need to find the minimum number of platforms needed at the railway station so that no train has to wait.

Input: N=6,
arr[] = {9:00, 9:45, 9:55, 11:00, 15:00, 18:00}
dep[] = {9:20, 12:00, 11:30, 11:50, 19:00, 20:00}
Output:3

Intuition:

our goal is find the minimum number of platforms required so that no station waits. this means we have to track the maximum number of trains that are at the station at any point of time. this will give the minimum platforms that we want.
You are given two arrays:
arr[]: the arrival times of trains.
dep[]: the departure times of trains.

how many trains are present at the station at any given moment?

for each train if it is at the station(hasn't departured), and a new train arrives you need a new platform. So, the task is to check at any moment how many trains overlap (i.e., are at the station at the same time). More overlaps mean more platforms are required.

Sort the trains according to arrival time

To process the trains in order, you first sort them by their arrival time.
intially for the first train one platform is needed.
to keep track of departure times of trains, we will use a min-heap.
it will help us in finding the train that is departuring soon.

For every train

compare its arrival time with the departure times of trains that are already at the station (these departure times are stored in the min-heap).
If the earliest departing train (the one on the top of the heap) has already left (i.e., its departure time is less than the arrival time of the current train), you can remove that train from the heap, freeing up a platform.
add the current train's departure time to the heap (indicating that the platform is now occupied by the current train).
at any time the size of heap tells us the how many platforms are occupied.
so update the ans also to min of previous answer and size of heap.

Code

struct node {
    int arr;
    int dep;
};

// Comparison function to sort trains by arrival times
static bool comp(node a, node b) {
    return a.arr < b.arr;
}

int findPlatform(std::vector<int>& arr, std::vector<int>& dep) {
    int n = arr.size();
    vector<node> temp(n);

    // Initialize the temp array with arrival and departure times
    for (int i = 0; i < n; i++) {
        temp[i].arr=arr[i];
        temp[i].dep=dep[i];
    }

    // Sort the trains by their arrival times
   sort(temp.begin(), temp.end(), comp);

    // Min-heap to track the minimum departure time
    priority_queue<int, vector<int>, greater<int>> pq;

    // Push the first train's departure time
    pq.push(temp[0].dep);

    int ans = 1; // The minimum number of platforms required (at least 1)

    // Iterate over the rest of the trains
    for (int i = 1; i < n; i++) {
        // Remove all trains that have already departed by the time the current train arrives
        while (!pq.empty() && pq.top() < temp[i].arr) {
            pq.pop();
        }

        // Push the current train's departure time
        pq.push(temp[i].dep);

        // Update the answer with the maximum size of the heap (i.e., the maximum number of overlapping trains)
        ans = max(ans, (int)pq.size());
    }

    return ans;
}

Time Complexity:
Sorting: O(n log n), where n is the number of trains.
Heap Operations: Each train involves push and possibly pop operations, which are O(log n) per train. Thus, this part also takes O(n log n).

Minimum distance in an Array

Phoenix — Wed, 25 Sep 2024 19:36:46 +0000

Problem Link - Minimum Distance

You are given an array a, of n elements. Find the minimum index based distance between two distinct elements of the array, x and y. Return -1, if either x or y does not exist in the array.

Examples:

Input: arr[] = {1, 2}, x = 1, y = 2
Output: Minimum distance between 1 and 2 is 1.
Input: arr[] = {3, 4, 5}, x = 3, y = 5
Output: Minimum distance between 3 and 5 is 2.
Input: arr[] = {3, 5, 4, 2, 6, 5, 6, 6, 5, 4, 8, 3}, x = 3, y = 6
Output: Minimum distance between 3 and 6 is 4.
Input: arr[] = {2, 5, 3, 5, 4, 4, 2, 3}, x = 3, y = 2
Output: Minimum distance between 3 and 2 is 1.

Approach

Initialize two indices i1 and i2 to -1 to store the most recent indices of x and y found during the traversal of the array.
Initialize a variable mini to a large value (e.g., INT_MAX) to keep track of the minimum distance.
Traverse through the array and find the indices of x and y,if both were found then calculate the distance between them and update the mini variable.if again we found the x or y, then calcuate the distance with previously found x or y and update the mini variable.

Code

    int minDist(int a[], int n, int x, int y) {
        // code here
        int mini=INT_MAX;
        int i1=-1;
        int i2=-1;
        for(int i=0;i<n;i++){
            if(a[i]==x){
                i1=i;
            }
            else if(a[i]==y){
                i2=i;
            }
            if(i1!=-1&&i2!=-1){
                mini=min(mini,abs(i2-i1));
            }
        }
        if(i1==-1 || i2==-1){
            return -1;
        }
        return mini;
    }