हम उपयोगकर्ता से एक पैराग्राफ पढ़ने के लिए जावा का उपयोग करके एक प्रोग्राम कैसे लिखेंगे और वेक्टर में उल्लिखित विशिष्ट शब्दों को निम्न प्रारूप में बदल देंगे, अर्थात,

उदाहरण के लिए शब्द Happy को घटाकर H**** कर दिया गया है।

किसी भी मदद की सराहना की जाएगी।

import java.io.*;
import java.util.*;

class replaceString {

     public static String putStars(String str) {
        char first_char = str.charAt(0);

        String ans = new String();
        ans = String.valueOf(first_char);

        for(int i = 1;i < str.length(); ++i ) {
            ans = ans + "*";
        }
        return ans;
    }

    public static String replaceWords(String str, Vector<String> v1) {
        String[] words = str.split("\\W+"); //split across all types of punctuation

        String ansString = new String();

            for(String to_be_replaced : words) {
                boolean found = false;

                for(String to_replace_with : v1) {

                if(to_be_replaced.equals(to_replace_with)) {
                    //System.out.println("in");
                    ansString = ansString +putStars(to_be_replaced) +  " ";
                    found = true;

                }
            }  
                if(found == false) {
                    ansString = ansString + to_be_replaced + " ";
                }

        }
        return ansString;
    }

        public static String replaceWords1(String str, Vector<String> v1) {

        for(String currStr : v1) {
            str.replace(str, );
        }

        return ansString;
    } 


    public static void main(String args[])throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Enter the paragraph that you would like to edit ");

        String s = br.readLine();

        // Let us assume some strings in our very own vector

        Vector<String> v1 = new Vector<String>();

        v1.addElement("Hello");
        v1.addElement("Hi");
        v1.addElement("Heya");
        v1.addElement("Howdy");
        v1.addElement("Howu");

        String ans = replaceWords(s, v1);

        System.out.println("Paragraph after replacement becomes\n\n"+ ans);
    }
}

यह मेरा वर्तमान कोड है, लेकिन यह ठीक काम नहीं कर रहा है

1
DimKUsik 4 सितंबर 2017, 18:14

2 जवाब

सबसे बढ़िया उत्तर

अन्य संभावनाएं भी हो सकती हैं, लेकिन यहां एक उदाहरण है जो मैंने इस उत्तर पर आधारित किया है:

  1. हमें उन सभी शब्दों की आवश्यकता है जिनकी हमें आवश्यकता है / मिलान करना चाहते हैं, और उन्हें एक सरणी में संग्रहीत करना चाहते हैं:

    String [] words = {"appy", "eya", "dy"};
    
  2. (वैकल्पिक) यदि आपको वास्तव में Vector की आवश्यकता है, तो मैं इसके बजाय एक List (ArrayList) बनाने का सुझाव देता हूं, और हम इसे इस तरह से कर सकते हैं:

    List <String> wordsToReplace = Arrays.asList(words);
    

    अन्यथा सरणी प्राप्त करने के लिए अगले चरण में विधि को संशोधित करें ...

  3. हम एक फ़ंक्शन बनाते हैं जो इसे प्राप्त करता है List और वह वाक्यांश जिसे हम जांचना चाहते हैं और जो नए String को बदले हुए टेक्स्ट के साथ लौटाता है

तो, हमारा पूरा कोड इस तरह समाप्त होता है:

import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class WordReplacer {
    public static void main(String[] args) {
        String [] words = {"appy", "eya", "dy"};

        List <String> wordsToReplace = Arrays.asList(words);

        System.out.println(replaceWords("Happy", wordsToReplace));
        System.out.println(replaceWords("Heya", wordsToReplace));
        System.out.println(replaceWords("Howdy?", wordsToReplace));
        System.out.println(replaceWords("Howdy? My friend lives in Pompeya and every time I see her I say \"Heya\" to her, she is very happy", wordsToReplace));
    }

    private static String replaceWords(String word, List <String> wordsToReplace) {
        for (String s : wordsToReplace) {
            Pattern p = Pattern.compile(s, Pattern.CASE_INSENSITIVE); //We create a pattern that matches each word in our list. (1)
            Matcher m = p.matcher(word); //We actually check for each match against our phrase
            StringBuilder sb = new StringBuilder();
            if (m.find()) { //If there was a match, we're going to replace each character for an '*' (2)
                for (int i = 0; i < s.length(); i++) {
                    sb.append("*");
                }
            }

            word = m.replaceAll(sb.toString()); //We replace each match with '*' (3)
        }

        return word; //We return the modified word
    }
}

मैं समझाने जा रहा हूं कि प्रत्येक टिप्पणी (1), (2), (3) बेहतर और सरल तरीके से क्या करती है:

  • (1) जैसा कि लिंक किए गए उत्तर में दिखाया गया है, वे पूरे शब्दों का मिलान करने के लिए \b रेगेक्स कमांड का उपयोग करते हैं, लेकिन इस मामले में हम इसका उपयोग शब्दों के कुछ हिस्सों से मेल खाने के लिए कर रहे हैं, पूरे शब्दों से नहीं, इसलिए हमें इसकी आवश्यकता नहीं है यहां...

  • (2) केवल अगर हमें एक मैच मिलता है तो हम StringBuilder को * वर्णों से भरते हैं... अगर हम इसे इस तरह से नहीं करते हैं, तो हमें H* के बजाय H* मिलेगा। H**** Happy शब्द के मामले में, इस तरह हम सुनिश्चित करते हैं कि हमें List में प्रत्येक शब्द के लिए * की सही मात्रा मिले।

  • (3) हम मैचों को * की कुल संख्या के लिए StringBuilder में बदल देते हैं ताकि हमें सही आउटपुट मिले।

उपरोक्त कार्यक्रम निम्नलिखित आउटपुट उत्पन्न करता है:

H****
H***
How**?
How**? My friend lives in Pomp*** and every time I see her I say "H***" to her, she is very h****
2
Frakcool 4 सितंबर 2017, 20:26

ऐसा कुछ ऐसा मानचित्र के साथ करने का प्रयास करें जिसमें आपके प्रतिस्थापन नियम शामिल हैं:

    String input; //input string
    Map<String,String> mapReplace = new HashMap<String,String>();
    mapReplace.put("Hello","H****");
    Iterator<String> keys = mapReplace.keySet().iterator();
    while(keys.hasNext()){
        String key = keys.next();
        input = input.replace(input, mapReplace.get(key));
    }
2
Stéphane Ammar 4 सितंबर 2017, 18:25