ISC Practical 2027: Player Tag Analyzer (Teams and Top Scorer) – Algorithm and Java Program

import java.util.Scanner;

/**
 * ISC Practical 2027 - Sample Paper 1, Question 2
 * Validates game tags of the form NAME-NUMBER, finds two-player teams
 * (same 3-digit number) and the top scorer among valid tags.
 */
public class PlayerAnalyzer
{
    String tag[];        // player tags
    int score[];         // player scores
    boolean valid[];     // valid[i] is true if tag[i] follows the format
    int n;               // number of players

    PlayerAnalyzer(int num)
    {
        n = num;
        tag = new String[n];
        score = new int[n];
        valid = new boolean[n];
    }

    void accept(Scanner sc)
    {
        for (int i = 0; i < n; i++)
        {
            System.out.print("Tag and score of player " + (i + 1) + ": ");
            tag[i] = sc.next();
            score[i] = sc.nextInt();
        }
    }

    // NAME (one or more uppercase letters) + '-' + exactly 3 digits
    boolean isValidTag(String t)
    {
        int dash = t.indexOf('-');
        if (dash < 1 || dash != t.lastIndexOf('-'))     // exactly one '-', not at the start
            return false;
        String name = t.substring(0, dash);
        String num = t.substring(dash + 1);
        if (num.length() != 3)
            return false;
        for (int i = 0; i < name.length(); i++)
            if (name.charAt(i) < 'A' || name.charAt(i) > 'Z')
                return false;
        for (int i = 0; i < 3; i++)
            if (!Character.isDigit(num.charAt(i)))
                return false;
        return true;
    }

    // returns the 3-digit number part of a valid tag
    String numberPart(String t)
    {
        return t.substring(t.indexOf('-') + 1);
    }

    void checkTags()
    {
        for (int i = 0; i < n; i++)
        {
            valid[i] = isValidTag(tag[i]);
            System.out.println((valid[i] ? "Valid Tag: " : "Invalid Tag: ") + tag[i]);
        }
    }

    // a team is exactly two valid players sharing the same 3-digit number
    void findTeams()
    {
        boolean found = false;
        boolean done[] = new boolean[n];          // players already grouped with an earlier player
        for (int i = 0; i < n; i++)
        {
            if (!valid[i] || done[i])
                continue;
            int count = 1, partner = -1;
            for (int j = i + 1; j < n; j++)
            {
                if (valid[j] && numberPart(tag[j]).equals(numberPart(tag[i])))
                {
                    count++;
                    partner = j;
                    done[j] = true;
                }
            }
            if (count == 2)                       // groups of 3 or more are not complete teams
            {
                System.out.println("TEAMS : " + tag[i] + ", " + tag[partner]);
                System.out.println("Combined Score: " + (score[i] + score[partner]));
                found = true;
            }
        }
        if (!found)
            System.out.println("TEAMS: NO COMPLETE TEAMS FOUND.");
    }

    void topScorer()
    {
        int max = -1;
        boolean anyValid = false;
        for (int i = 0; i < n; i++)
        {
            if (valid[i])
            {
                anyValid = true;
                if (score[i] > max)
                    max = score[i];
            }
        }
        if (!anyValid)
        {
            System.out.println("NO VALID TAGS FOUND.");
            return;
        }
        for (int i = 0; i < n; i++)               // all players who share the highest score
            if (valid[i] && score[i] == max)
                System.out.println("TOP SCORER: " + tag[i] + " - " + score[i]);
    }

    public static void main(String args[])
    {
        Scanner sc = new Scanner(System.in);
        System.out.print("N = ");
        int n = sc.nextInt();
        if (n < 5 || n > 15)
        {
            System.out.println("INVALID INPUT");
            return;
        }
        PlayerAnalyzer ob = new PlayerAnalyzer(n);
        ob.accept(sc);
        ob.checkTags();
        ob.findTeams();
        ob.topScorer();
    }
}

Name           Type       Purpose
-------------  ---------  -------
tag[]          String[]   player tags
score[]        int[]      player scores (parallel to tag[])
valid[]        boolean[]  result of the format check for each player
n              int        number of players
done[]         boolean[]  players already counted in an earlier group
count          int        players sharing the current number
partner        int        index of the team mate
max            int        highest valid score

INPUT:
N = 5
PRO-117 850
ACE-112 720
MAX-117 910
ZEN-115 800
BAD-12 950

OUTPUT:
Valid Tag: PRO-117
Valid Tag: ACE-112
Valid Tag: MAX-117
Valid Tag: ZEN-115
Invalid Tag: BAD-12
TEAMS : PRO-117, MAX-117
Combined Score: 1760
TOP SCORER: MAX-117 - 910

INPUT:
N = 5
PRO-117 850
MAX-910 910
ACE-115 720
ZEN-120 800
RAY-225 650

OUTPUT:
Valid Tag: PRO-117
Valid Tag: MAX-910
Valid Tag: ACE-115
Valid Tag: ZEN-120
Valid Tag: RAY-225
TEAMS: NO COMPLETE TEAMS FOUND.
TOP SCORER: MAX-910 - 910

INPUT:
N = 3

OUTPUT:
INVALID INPUT

INPUT:
N = 6
PRO-101 700
ACE-101 640
MAX-101 910
ZEN-202 910
RAY-202 500
kid-303 990

OUTPUT:
Valid Tag: PRO-101
Valid Tag: ACE-101
Valid Tag: MAX-101
Valid Tag: ZEN-202
Valid Tag: RAY-202
Invalid Tag: kid-303
TEAMS : ZEN-202, RAY-202
Combined Score: 1410
TOP SCORER: MAX-101 - 910
TOP SCORER: ZEN-202 - 910

INPUT:
N = 5
P1-111 10
-222 20
ABC-12A 30
ABC 40
AB-1234 50

OUTPUT:
Invalid Tag: P1-111
Invalid Tag: -222
Invalid Tag: ABC-12A
Invalid Tag: ABC
Invalid Tag: AB-1234
TEAMS: NO COMPLETE TEAMS FOUND.
NO VALID TAGS FOUND.