Understand What is FLAMES Calculator and Their Working Model

When I first heard about the FLAMES Calculator, I thought it was just a fun game people played for entertainment. But when I started exploring how it works from a technical and programming perspective, I realized it’s a great beginner project to understand basic string manipulation, logic flow, and condition-based programming.

In this blog, I’ll walk you through what is FLAMES Calculator, what is FLAMES, and what is their working model — not as a romantic tool, but as a logical model that can help beginner coders or college students understand basic programming concepts. If you’ve never coded before, don’t worry. I’m explaining everything in plain language.

What is FLAMES Calculator?

The FLAMES Calculator is a simple tool that takes two names as input and gives an output based on the acronym

FLAMES. Each letter stands for a type of relationship:

• L - Love
• A - Affection
• M - Marriage
• E - Enemy
• F - Friends
• S - Siblings

While most people use it as a fun game to "predict" relationships, from a programming point of view, it’s a logic-based matching system. It’s often one of the first tools that new developers try to build because it teaches core concepts like:

1. Taking user input
2. Working with strings
3. Using loops and conditions
4. Eliminating common characters
5. Working with array-based logic

What is Their Working Model?

Let me break the working model of FLAMES Calculator into easy steps. This is where the actual logic lives, and it’s very beginner-friendly if you look at it step by step:

Step 1: Take Inputs

The first thing the calculator does is take two names. For example:

• Name 1: Alex
• Name 2: Maria

Step 2: Clean the Inputs

We remove spaces and convert all letters to lowercase or uppercase so that the comparison is case-insensitive. This ensures we’re comparing clean data.

alex -> alex  
maria -> maria

Step 3: Remove Common Characters

Now we compare both names and cancel out the letters that appear in both. For example:

• alex vs maria → remove 'a'
• Remaining: lex and mri

This step is crucial. We compare each letter in the first name to each letter in the second name and remove matching characters once for each match.

Step 4: Count Remaining Letters

Now we count the letters that are left after removing the common ones.

In our example:

• lex (3 letters)
• mri (3 letters)
• Total remaining = 3 + 3 = 6

Step 5: Use FLAMES Logic

We now use this number to eliminate letters from the word FLAMES. Here's how it works:

• Start with F, L, A, M, E, S
• Begin counting from the first letter, go up to the number (in our case, 6), and remove the 6th letter.
• Keep repeating the count from the next letter after the removed one.
• Continue until one letter remains.

The last letter that remains is the result.

Steps 6 : Let’s apply  to “FLAMES”

1. Count 6: S is removed → F, L, A, M, E
2. Start again, count 6: L is removed → F, A, M, E
3. Count again: M is removed → F, A, E
4. Count again: F is removed → A, E
5. Count again: E is removed → A

Final result: A = Affection

How you Make This?

As someone interested in coding, you wanted to understand how to build this logic in a basic programming language. you can chose to build it using HTML, CSS, and JavaScript because it’s easy to test in the browser.

Here’s a basic overview of how you made it:

1. HTML Form

I created two input fields for the user to enter names and a button to submit the form.

<label for="name1">Enter First Name:</label><br>
  <input type="text" id="name1"><br>

  <label for="name2">Enter Second Name:</label><br>
  <input type="text" id="name2"><br>

  <button onclick="calculateFLAMES()">Check Relationship</button>

  <div id="result"></div>

2. JavaScript Logic

When the user clicks the button, the script runs the logic:

• It gets the values from the input boxes.
• Cleans and formats the strings.
• Removes common characters.
• Counts the remaining letters.
• Runs the FLAMES elimination logic.
• Displays the result on the page.

function calculateFLAMES() {
      let name1 = document.getElementById("name1").value.toLowerCase().replace(/\s/g, "");
      let name2 = document.getElementById("name2").value.toLowerCase().replace(/\s/g, "");

      let name1Arr = name1.split('');
      let name2Arr = name2.split('');

      // Remove common characters
      for (let i = 0; i < name1Arr.length; i++) {
        let index = name2Arr.indexOf(name1Arr[i]);
        if (index !== -1) {
          name1Arr.splice(i, 1);
          name2Arr.splice(index, 1);
          i--; // adjust index after splice
        }
      }

      let count = name1Arr.length + name2Arr.length;

      let flames = ['F', 'L', 'A', 'M', 'E', 'S'];

      let i = 0;
      while (flames.length > 1) {
        let removeIndex = (count % flames.length) - 1;
        if (removeIndex >= 0) {
          flames.splice(removeIndex, 1);
          flames = flames.slice(removeIndex).concat(flames.slice(0, removeIndex));
        } else {
          flames.pop();
        }
      }

      let relationship = {
        F: "Friends",
        L: "Love",
        A: "Affection",
        M: "Marriage",
        E: "Enemy",
        S: "Siblings"
      };

      document.getElementById("result").textContent = "Result: " + relationship[flames[0]];
    }

This helped me learn how to:

• Work with strings (.replace(), .toLowerCase())
• Use loops (for, while)
• Use arrays (.splice(), .push())
• Manipulate the DOM (Document Object Model)

You didn’t need to use any libraries or frameworks so that you can understand every line of code. I recommend doing it the same way if you are just getting started with programming.

Why This Is Good for Beginners

If you're just starting to learn to code and don’t know where to begin, the FLAMES Calculator is a perfect first project. Here’s why:

• It uses only basic coding concepts.
• You learn data cleaning, which is a common task in real programming.
• You learn to build step-by-step logic, similar to how real apps work.
• It gives you visible output, which helps you understand cause and effect.
• You can build it without knowing complex math or design.

The FLAMES Calculator may seem like a simple relationship tool, but behind the scenes, it’s a great beginner-level programming exercise. It teaches you how to work with input data, use loops, manage arrays, and apply logic in a structured way.

Even though it has nothing to do with real relationship prediction, it can help you practice and improve your coding skills.

If you’re a student or someone who’s just starting your coding journey, try building your own FLAMES Calculator. You’ll not only have fun but also understand some key programming principles that will help you with bigger projects later.