Android में सरणी में दूसरी सबसे अधिक दोहराई जाने वाली स्ट्रिंग कैसे ढूंढें?

Android में दूसरी सबसे अधिक दोहराई जाने वाली स्ट्रिंग ढूंढना

यह उदाहरण दर्शाता है कि Android में स्ट्रिंग सरणी में दूसरी सबसे अधिक बार आने वाली स्ट्रिंग कैसे ढूंढी जाती है।

चरण 1: नया प्रोजेक्ट बनाएं

Android Studio में File → New Project पर जाएं और आवश्यक विवरण भरकर एक नया प्रोजेक्ट बनाएं।

चरण 2: लेआउट XML में कोड जोड़ें

res/layout/activity_main.xml में निम्नलिखित कोड जोड़ें:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="https://schemas.android.com/apk/res/android"
    xmlns:app="https://schemas.android.com/apk/res-auto"
    xmlns:tools="https://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:gravity="center"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <TextView
        android:id="@+id/text"
        android:textSize="30sp"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

</LinearLayout>

उपरोक्त कोड में, हमने सरणी में दूसरी सबसे अधिक दोहराई जाने वाली स्ट्रिंग दिखाने के लिए TextView लिया है।

चरण 3: MainActivity.java में कोड जोड़ें

package com.example.myapplication;

import android.os.Build;
import android.os.Bundle;
import android.support.annotation.RequiresApi;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.widget.TextView;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class MainActivity extends AppCompatActivity {
    TextView textView;
    String[] strArray = {"aaa", "aaa", "bbb", "ccc", "bbb"};

    @RequiresApi(api = Build.VERSION_CODES.P)
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 1. फ्रीक्वेंसी मैप बनाएं
        HashMap<String, Integer> frequencyMap = new HashMap<>();
        for (String str : strArray) {
            frequencyMap.put(str, frequencyMap.getOrDefault(str, 0) + 1);
        }

        // 2. फ्रीक्वेंसी के अनुसार सॉर्ट करें
        List<Map.Entry<String, Integer>> sortedEntries = new ArrayList<>(frequencyMap.entrySet());
        sortedEntries.sort((e1, e2) -> e2.getValue().compareTo(e1.getValue()));

        // 3. दूसरी सबसे अधिक फ्रीक्वेंसी वाली स्ट्रिंग प्राप्त करें
        String secondMostFrequent = "";
        if (sortedEntries.size() >= 2) {
            secondMostFrequent = sortedEntries.get(1).getKey();
        } else if (sortedEntries.size() == 1) {
            secondMostFrequent = sortedEntries.get(0).getKey();
        }

        TextView textView = findViewById(R.id.text);
        textView.setText("दूसरी सबसे अधिक: " + secondMostFrequent);
        
        // डीबग के लिए सभी फ्रीक्वेंसी दिखाएं
        Log.d("Frequency", frequencyMap.toString());
    }
}

एप्लिकेशन चलाएं

अपने Android डिवाइस को कंप्यूटर से कनेक्ट करें। Android Studio में प्रोजेक्ट की एक्टिविटी फाइल खोलें और टूलबार से Run आइकन पर क्लिक करें। अपना मोबाइल डिवाइस चुनें और परिणाम देखें।

Android में सरणी में दूसरी सबसे अधिक दोहराई जाने वाली स्ट्रिंग कैसे ढूंढें?

परिणाम: सरणी {"aaa", "aaa", "bbb", "ccc", "bbb"} में:

"aaa" - 2 बार
"bbb" - 2 बार
"ccc" - 1 बार

दोनों "aaa" और "bbb" 2 बार आते हैं। दूसरी सबसे अधिक "bbb" या "aaa" हो सकती है (टाई-ब्रेकिंग पर निर्भर)।

बेहतर दृष्टिकोण - टाई हैंडलिंग के साथ

public String findSecondMostFrequent(String[] array) {
    // 1. फ्रीक्वेंसी गिनें
    Map<String, Integer> freqMap = new HashMap<>();
    for (String s : array) {
        freqMap.put(s, freqMap.getOrDefault(s, 0) + 1);
    }

    // 2. फ्रीक्वेंसी के अनुसार ग्रुप करें
    Map<Integer, List<String>> freqGroups = new TreeMap<>(Collections.reverseOrder());
    for (Map.Entry<String, Integer> entry : freqMap.entrySet()) {
        freqGroups.computeIfAbsent(entry.getValue(), k -> new ArrayList<>()).add(entry.getKey());
    }

    // 3. दूसरी सबसे बड़ी फ्रीक्वेंसी ढूंढें
    List<Integer> frequencies = new ArrayList<>(freqGroups.keySet());
    if (frequencies.size() < 2) {
        return frequencies.isEmpty() ? null : freqGroups.get(frequencies.get(0)).get(0);
    }

    int secondHighestFreq = frequencies.get(1);
    return freqGroups.get(secondHighestFreq).get(0); // पहली स्ट्रिंग लौटाएं
}

Java 8 Stream API के साथ

String secondMost = Arrays.stream(strArray)
    .collect(Collectors.groupingBy(s -> s, Collectors.counting()))
    .entrySet().stream()
    .sorted(Map.Entry.comparingByValue().reversed())
    .skip(1)
    .findFirst()
    .map(Map.Entry::getKey)
    .orElse("Not found");

मुख्य बिंदु

HashMap का उपयोग करके फ्रीक्वेंसी गिनें - O(n) समय
फ्रीक्वेंसी के अनुसार सॉर्ट करें - O(m log m) जहां m यूनिक स्ट्रिंग्स की संख्या
टाई (बराबर फ्रीक्वेंसी) को हैंडल करें
एज केस: खाली सरणी, सभी यूनिक, सभी समान
Java 8 Streams कोड को संक्षिप्त बनाते हैं