यदि कोई एकल वर्ण स्ट्रिंग में दिखाई देता है तो मैं कैसे जांच सकता हूं?

Question

जावा में स्थिति की जाँच करने का एक तरीका है:

"क्या यह एकल वर्ण स्ट्रिंग x में बिल्कुल दिखाई देता है"

लूप का उपयोग किए बिना ?

Comments

क्या कोई विशेष कारण है कि आप छोरों से बचने की कोशिश कर रहे हैं?

— शीस्टिमेयर

आप एक पाश के बिना चरित्र के लिए एक सामान्य खोज नहीं कर सकते। देखिए कि ट्यूरिंग मशीन कैसे काम करती है।

— साल्वाडोर वालेंसिया

हमें यह मान लेना चाहिए कि @barfoon नहीं चाहता कि लूप उनके कोड में हो। जाहिर है मशीन कहीं न कहीं लूप करती है। अन्यथा प्रश्न बकवास है।

— डब्ल्यू डब्ल्यू।

मैं कहूंगा कि जावा का स्ट्रिंग हेरफेर काफी सीमित है

— एसीवी

Answer 1

आप उपयोग कर सकते हैं string.indexOf('a')।

यदि चार aमें मौजूद है string:

यह चरित्र अनुक्रम में चरित्र की पहली घटना के सूचकांक को इस वस्तु द्वारा दर्शाया जाता है, या -1 होता है यदि चरित्र नहीं होता है।

Comments

लेकिन उस कॉल के पीछे हमेशा एक लूप होता है क्योंकि आप अन्यथा एक प्रतीक नहीं पा सकते हैं।

— vava

indexOf () आंतरिक रूप से एक लूप का उपयोग करता है।

— 6

बरफून ने जो पूछा वह नहीं। B, B के कोड में लूप करने से बचना चाहता है। स्वाभाविक रूप से एपीआई को एक लूप करने की आवश्यकता होती है सभी स्ट्रिंग के बाद बहुत सारे उपयोगी तरीकों के साथ एक अच्छी कक्षा में लिपटे पात्रों की एक सरणी होती है।

— एम.पी.

इन उत्तरों को इतने उत्थान कैसे मिल रहे हैं? indexOf()आंतरिक रूप से लूप का उपयोग करने के समाधान । कोई भी उत्तर सही समाधान नहीं देता है और यदि कोई नया प्रश्न पूछने की हिम्मत करता है, तो लोग इसकी घोषणा करते हैं Duplicate। वास्तव में निराशाजनक;

— प्रशांत प्रभाकर सिंह

@PrashantPrabhakarSingh मैं यह नहीं देखता कि यह बिना लूप के कैसे किया जा सकता है। एक स्ट्रिंग कम या ज्यादा वर्णों का समूह है। यदि यह एक समूह (संग्रह, सरणी, आदि) है, तो कोई फर्क नहीं पड़ता कि यह मूल कोड के लिए आंतरिक या बाहरी है, मुझे उम्मीद है कि आपको "समूह" के भीतर कुछ खोजने के लिए लूप की आवश्यकता होगी। मेरा मानना ​​है कि "लूप का उपयोग किए बिना?" "मेरे अपने पाश को लिखे बिना?"

— टायलर

Answer 2

• String.contains() जो यह जांचता है कि क्या स्ट्रिंग में चार मानों का निर्दिष्ट क्रम है
• String.indexOf() जो निर्दिष्ट वर्ण या सबस्ट्रिंग की पहली घटना के स्ट्रिंग के भीतर सूचकांक लौटाता है (इस पद्धति के 4 रूपांतर हैं)

Comments

एक चारपसंद नहीं है, इसलिए इसे String.contains (CharSequence) में पारित नहीं किया जा सकता है।

— एम.पी.

String.contains () का उपयोग करने के लिए एक char c के साथ ऐसा करें: String.contains (Character.toString (c))

— friederbluemle

या अगर आपको शॉर्ट कोड पसंद है तो ऐसा करें:String.contains(""+c)

— फेलिक्स न्यूमेयर

Answer 3

मुझे यकीन नहीं है कि मूल पोस्टर वास्तव में क्या पूछ रहा है। चूंकि indexOf (...) और इसमें (...) दोनों संभवतया आंतरिक रूप से लूप का उपयोग करते हैं, शायद वह यह देखना चाह रहा है कि क्या यह लूप के बिना संभव है? मैं दो तरह से सोच सकता हूँ, एक बार पुनरावृत्ति होगी:

public boolean containsChar(String s, char search) {
    if (s.length() == 0)
        return false;
    else
        return s.charAt(0) == search || containsChar(s.substring(1), search);
}

अन्य बहुत कम सुरुचिपूर्ण है, लेकिन पूर्णता ...:

/**
 * Works for strings of up to 5 characters
 */
public boolean containsChar(String s, char search) {
    if (s.length() > 5) throw IllegalArgumentException();

    try {
        if (s.charAt(0) == search) return true;
        if (s.charAt(1) == search) return true;
        if (s.charAt(2) == search) return true;
        if (s.charAt(3) == search) return true;
        if (s.charAt(4) == search) return true;
    } catch (IndexOutOfBoundsException e) {
        // this should never happen...
        return false;
    }
    return false;
}

जब आप निश्चित रूप से लंबे और लंबे तार का समर्थन करने की आवश्यकता होती है, तो लाइनों की संख्या बढ़ती है। लेकिन वहाँ कोई छोरों / आवर्ती हैं। आप लंबाई की जाँच को हटा सकते हैं यदि आप चिंतित हैं कि लंबाई () लूप का उपयोग करती है।

Comments

यदि आप पुनरावृत्ति को एक गैर-लूप प्रक्रिया के रूप में परिभाषित करते हैं, तो आप रचनात्मक होने के लिए एक geek: D +1 हैं।

— गुरदा 14

यह सब कठिन कोडित लंबाई के लिए अच्छा है। 5. अन्यथा चरित्र के लिए खोज करने के लिए एक जरूरत है। पांडित्य नहीं है, लेकिन इसका प्रमाण एक ट्यूरिंग मशीन की परिभाषा द्वारा दिखाया गया है। एक कम्प्यूटेशनल डिवाइस की नींव।

— साल्वाडोर वालेंसिया

मुझे सही करें अगर मैं गलत हूं, तो मुझे लगता है कि दिन के अंत में, एक पुनरावृत्ति भेस में एक लूप है न? और यह कुछ परिदृश्यों में एक साधारण लूप की तुलना में अधिक मेमोरी खपत का कारण बन सकता है।

— पासिंदुजय

Answer 4

String temp = "abcdefghi";
if(temp.indexOf("b")!=-1)
{
   System.out.println("there is 'b' in temp string");
}
else
{
   System.out.println("there is no 'b' in temp string");
}

Comments

क्या यह स्वीकार किए गए उत्तर का सटीक डुप्लिकेट नहीं है ?, हम आपके प्रयास को स्वीकार करते हैं लेकिन आपको कुछ अनुत्तरित प्रश्न खोजने और उनका उत्तर देने का प्रयास करना चाहिए।

— शेखर_प्रो।

Answer 5

आप Stringकक्षा से 2 विधियों का उपयोग कर सकते हैं ।

• String.contains() जो यह जांचता है कि क्या स्ट्रिंग में चार मानों का निर्दिष्ट क्रम है
• String.indexOf() जो निर्दिष्ट चरित्र की पहली घटना के स्ट्रिंग के भीतर सूचकांक लौटाता है या प्रतिस्थापन या रिटर्न -1 अगर चरित्र नहीं मिला है (इस पद्धति के 4 रूपांतर हैं)

विधि 1:

String myString = "foobar";
if (myString.contains("x") {
    // Do something.
}

विधि 2:

String myString = "foobar";
if (myString.indexOf("x") >= 0 {
    // Do something.
}

द्वारा लिंक: Zach Scrivena

Answer 6

यह जांचने के लिए कि क्या किसी स्ट्रिंग में मौजूद नहीं है, आपको कम से कम प्रत्येक चरित्र को एक स्ट्रिंग में देखने की आवश्यकता है। तो भले ही आप स्पष्ट रूप से एक लूप का उपयोग नहीं करते हैं, यह एक ही दक्षता होगी। कहा जा रहा है, आप str.contains ("" + char) का उपयोग करके देख सकते हैं।

Comments

माना। किसी बिंदु पर, किसी को, कहीं न कहीं ऐसा करने के लिए एक लूप का निर्माण करना होगा। सौभाग्य से जावा एपीआई ऐसा करता है या हमारा कोड बहुत ही अव्यवस्थित होगा!

— फॉर्च्यूननर

Answer 7

यदि आपको एक ही तार की जांच करने की आवश्यकता है, तो आप चरित्र घटनाओं की गणना कर सकते हैं। यह एक कार्यान्वयन है जो एक लंबी सरणी में निहित बिट सरणी का उपयोग करता है:

public class FastCharacterInStringChecker implements Serializable {
private static final long serialVersionUID = 1L;

private final long[] l = new long[1024]; // 65536 / 64 = 1024

public FastCharacterInStringChecker(final String string) {
    for (final char c: string.toCharArray()) {
        final int index = c >> 6;
        final int value = c - (index << 6);
        l[index] |= 1L << value;
    }
}

public boolean contains(final char c) {
    final int index = c >> 6; // c / 64
    final int value = c - (index << 6); // c - (index * 64)
    return (l[index] & (1L << value)) != 0;
}}

Comments

मैंने आपके पास एक ऐसी ही समस्या पर आपके समाधान की कोशिश की। मेरा निकटतम समाधान string1 लंबाई 63k और string2 लंबाई 95k के लिए 1500 मील से अधिक था। आपका समाधान 3-5 मिलीसेकंड में परिणाम देता है। क्या आप स्पष्टीकरण को शामिल करने के लिए अपने समाधान को संपादित कर सकते हैं? कृप्या?

— विओरेल फ्लोरियन

Answer 8

हां, string class पर indexOf () मेथड का उपयोग करते हुए। इस विधि के लिए एपीआई प्रलेखन देखें

Answer 9

package com;
public class _index {

    public static void main(String[] args) {
        String s1="be proud to be an indian";
        char ch=s1.charAt(s1.indexOf('e'));
        int count = 0; 
        for(int i=0;i<s1.length();i++) {
            if(s1.charAt(i)=='e'){
                System.out.println("number of E:=="+ch);
                count++;
            }
        }
        System.out.println("Total count of E:=="+count);
    }
}

Comments

और forक्या अब लूप नहीं है?

— मिंडविन

Answer 10

String s="praveen";
boolean p=s.contains("s");
if(p)
    System.out.println("string contains the char 's'");
else
    System.out.println("string does not contains the char 's'");

उत्पादन

string does not contains the char 's'

Comments

पहले भी यही जवाब दिया जा चुका है।

— सर्ज बेलोव

Answer 11

static String removeOccurences(String a, String b)
{
    StringBuilder s2 = new StringBuilder(a);

    for(int i=0;i<b.length();i++){
        char ch = b.charAt(i);  
        System.out.println(ch+"  first index"+a.indexOf(ch));

        int lastind = a.lastIndexOf(ch);

    for(int k=new String(s2).indexOf(ch);k > 0;k=new String(s2).indexOf(ch)){
            if(s2.charAt(k) == ch){
                s2.deleteCharAt(k);
        System.out.println("val of s2 :             "+s2.toString());
            }
        }
      }

    System.out.println(s1.toString());

    return (s1.toString());
}

Comments

यहाँ हम String b से हर वर्ण की घटनाओं की तलाश कर रहे हैं, String a में मौजूद है और वर्णों को हटा रहे हैं।

— गणेशमणि

Answer 12

you can use this code. It will check the char is present or not. If it is present then the return value is >= 0 otherwise it's -1. Here I am printing alphabets that is not present in the input.

import java.util.Scanner;

public class Test {

public static void letters()
{
    System.out.println("Enter input char");
    Scanner sc = new Scanner(System.in);
    String input = sc.next();
    System.out.println("Output : ");
    for (char alphabet = 'A'; alphabet <= 'Z'; alphabet++) {
            if(input.toUpperCase().indexOf(alphabet) < 0) 
                System.out.print(alphabet + " ");
    }
}
public static void main(String[] args) {
    letters();
}

}

//Ouput Example
Enter input char
nandu
Output : 
B C E F G H I J K L M O P Q R S T V W X Y Z

Answer 13

नीचे आप क्या देख रहे थे?

int index = string.indexOf(character);
return index != -1 && string.lastIndexOf(character) != index;

Comments

आपके पास क्यों है && string.lastIndexOf(character) != index

— GreenAsJade

Answer 14

आप यह जांचने में सक्षम नहीं होंगे कि क्या लूप / रिकर्सन का उपयोग करने के बाद तार के ऊपर से बिना तार के कुछ तार में सब दिखाई देता है (इंडेक्सऑफ जैसे अंतर्निहित तरीके भी लूप का उपयोग करते हैं)

यदि नहीं। बार जब आप देखते हैं कि क्या एक स्ट्रिंग स्ट्रिंग x में है, तो स्ट्रिंग की लंबाई से अधिक तरीका है कि मैं एक सेट डेटा संरचना का उपयोग करने की सिफारिश करूंगा क्योंकि यह केवल उपयोग करने से अधिक कुशल होगाindexOf

String s = "abc";

// Build a set so we can check if character exists in constant time O(1)
Set<Character> set = new HashSet<>();
int len = s.length();
for(int i = 0; i < len; i++) set.add(s.charAt(i));

// Now we can check without the need of a loop
// contains method of set doesn't use a loop unlike string's contains method
set.contains('a') // true
set.contains('z') // false

सेट का उपयोग करके आप यह जांच पाएंगे कि क्या चरित्र निरंतर समय O (1) में मौजूद है, लेकिन आप अतिरिक्त मेमोरी का भी उपयोग करेंगे (स्पेस जटिलता O (n) होगी)।

Answer 15

मैंने इसके लिए string.includes () पद्धति का उपयोग किया जो स्ट्रिंग या वर्ण पाए जाने पर सही या गलत देता है। नीचे प्रलेखन देखें।

https://www.w3schools.com/jsref/jsref_includes.asp

Comments

हालांकि यह लिंक प्रश्न का उत्तर दे सकता है, लेकिन उत्तर के आवश्यक भागों को शामिल करना और संदर्भ के लिए लिंक प्रदान करना बेहतर है। लिंक-केवल उत्तर अमान्य हो सकते हैं यदि लिंक किए गए पृष्ठ बदल जाते हैं।

— एड्रियानो मार्टिंस

यह उत्तर जावास्क्रिप्ट के लिए है, यह प्रश्न विशेष रूप से जावा में कहता है

— हज़म फ़ारहत

Answer 16

// यह केवल मुख्य है ... आप बफर बफ़र्ड रीडर या स्कैनर का उपयोग कर सकते हैं

string s;
int l=s.length();
int f=0;
for(int i=0;i<l;i++)
   {
      char ch1=s.charAt(i); 
      for(int j=0;j<l;j++)
         {
          char ch2=charAt(j);
          if(ch1==ch2)
           {
             f=f+1;
             s.replace(ch2,'');
           }
          f=0;
          }
     }
//if replacing with null does not work then make it space by using ' ' and add a if condition on top.. checking if its space if not then only perform the inner loop...