दिलचस्प पोस्ट
जावास्क्रिप्ट / jQuery के माध्यम से अजाक्स सिर अनुरोध IE11 में "ब्राउज़र मोड" को कैसे वापस लाया जाए? क्या auto_ptr नापसंद है? मैं PHP स्क्रिप्ट के माध्यम से क्रॉन जॉब कैसे सेट करूं? PHP एक PowerPoint फ़ाइल से पाठ पढ़ा सकता है? आईओएस एप से फेसबुक पेज पर लिंक खोलें टोस्ट को छवि जोड़ना? पायथन परिवर्तनशील गुंजाइश त्रुटि किसी भी तरह से आईईएस काली सीमा को हटाने के लिए सक्रिय रूपों में बटन सबमिट करें? JS – base64 कोड से छवि की चौड़ाई और ऊंचाई प्राप्त करें कैसे कोड में ActionBar कार्रवाई करने के लिए सबमेनू आइटम जोड़ने के लिए? क्या HTTP पोस्ट विधियों को क्वेरी स्ट्रिंग के रूप में डेटा भेजते हैं? एक स्ट्रिंग में एक अक्षर बदलें? कैसे ठीक से jsPDF पुस्तकालय का उपयोग करें UIImagePicker केंद्र में फंसने की अनुमति देता है

स्ट्रिंग में पहला अन-दोहराया वर्ण ढूंढें

पहला चरित्र ढूंढने का सबसे तेज़ तरीका क्या है जो केवल एक स्ट्रिंग में एक बार दिखाई देता है?

Solutions Collecting From Web of "स्ट्रिंग में पहला अन-दोहराया वर्ण ढूंढें"

आप नहीं जान सकते कि जब तक आप पूरी स्ट्रिंग संसाधित नहीं कर लेते हैं, तब तक वर्ण को दोहराया नहीं जा रहा है, इसलिए मेरा सुझाव यह होगा:

def first_non_repeated_character(string): chars = [] repeated = [] for character in string: if character in chars: chars.remove(character) repeated.append(character) else: if not character in repeated: chars.append(character) if len(chars): return chars[0] else: return False 

संपादित करें: मूल रूप से पोस्ट किया गया कोड खराब था, लेकिन रयान कंप्यूटर पर काम करने के लिए यह नवीनतम स्निपेट प्रमाणित है I

यह कम से कम ओ (एन) होना चाहिए क्योंकि आपको नहीं पता कि जब तक आप सभी वर्णों को पढ़ नहीं लेते हैं, तब तक कोई वर्ण दोहराया जाएगा।

तो आप अक्षरों पर पुनरावृति कर सकते हैं और प्रत्येक वर्ण को सूची में पहली बार जोड़ सकते हैं, और आप इसे कितनी बार देख चुके हैं (अलग-अलग मानते हैं कि वास्तव में गिनती के मामले में केवल "0" , "1" या "1 से अधिक")।

जब आप स्ट्रिंग के अंत तक पहुँचते हैं, तो आपको सूची में पहले अक्षर को ढूंढना होगा, जिसकी गणना बिल्कुल एक है।


पायथन में उदाहरण कोड:

 def first_non_repeated_character(s): counts = defaultdict(int) l = [] for c in s: counts[c] += 1 if counts[c] == 1: l.append(c) for c in l: if counts[c] == 1: return c return None 

यह ओ (एन) में चलता है

क्यों नहीं एक न्यूनतम प्राथमिकता कतार के रूप में एक ढेर आधारित डेटा संरचना का उपयोग करें। जैसा कि आप स्ट्रिंग से प्रत्येक वर्ण को पढ़ते हैं, उसे स्ट्रिंग में स्थान और अब तक की संख्या की संख्या के आधार पर प्राथमिकता वाले कतार में जोड़ें। आप टकराव पर प्राथमिकताओं को जोड़ने के लिए कतार को संशोधित कर सकते हैं ताकि एक चरित्र की प्राथमिकता उस वर्ण की संख्या दिखाए जाने का योग हो। लूप के अंत में, कतार में पहला तत्व स्ट्रिंग में कम से कम अक्सर वर्ण होगा और यदि कोई संख्या == 1 के साथ कई अक्षर हैं, तो प्रथम तत्व कतार में जोड़ा गया पहला अद्वितीय चरित्र था।

यह करने का एक और मजेदार तरीका है। काउंटर को पायथन 2.7 या पायथन 3.1 की आवश्यकता है

 >>> from collections import Counter >>> def first_non_repeated_character(s): ... return min((k for k,v in Counter(s).items() if v<2), key=s.index) ... >>> first_non_repeated_character("aaabbbcddd") 'c' >>> first_non_repeated_character("aaaebbbcddd") 'e' 

बहुत सारे उत्तर ओ (एन) का प्रयास कर रहे हैं लेकिन वे सूची / एसोसिएटिव एरेज़ / सेटों से सम्मिलित करने और निकालने की वास्तविक लागत को भूल रहे हैं जो वे ट्रैक करने के लिए उपयोग कर रहे हैं

यदि आप मान सकते हैं कि एक अक्षर एक एकल बाइट है, तो आप चारों द्वारा अनुक्रमित सरल सरणी का उपयोग करते हैं और उसमें एक गिनती रखते हैं। यह सचमुच हे (एन) है क्योंकि सरणी के उपयोग की गारंटी O (1) है, और 1 के साथ पहले तत्व को खोजने के लिए सरणी पर अंतिम पास निरंतर समय है (क्योंकि सरणी में एक छोटा, निश्चित आकार है)।

यदि आप यह नहीं मान सकते हैं कि एक चार एक एकल बाइट है, तो मैं स्ट्रिंग सॉर्ट करने का प्रस्ताव करता हूं और फिर एक आस पास मूल्य की जांच कर रहा हूं। यह ओ (एन लॉग एन) होगा और अंतिम पास के लिए ओ (एन) के साथ क्रमबद्ध होगा। तो यह प्रभावी रूप से हे (एन लॉग एन) है, जो ओ (एन ^ 2) से बेहतर है इसके अलावा, यह वास्तव में कोई स्थान ओवरहेड नहीं है, जो ओ (एन) का प्रयास कर रहे कई उत्तरों के साथ एक अन्य समस्या है।

काउंटर को पायथन 2.7 या पायथन 3.1 की आवश्यकता है

 >>> from collections import Counter >>> def first_non_repeated_character(s): ... counts = Counter(s) ... for c in s: ... if counts[c]==1: ... return c ... return None ... >>> first_non_repeated_character("aaabbbcddd") 'c' >>> first_non_repeated_character("aaaebbbcddd") 'e' 

पहले प्रस्तावित समाधान को पुनर्संरचना करना (अतिरिक्त सूची / मेमोरी का उपयोग नहीं करना) यह दो बार स्ट्रिंग पर चला जाता है तो यह ओ (एन) भी मूल समाधान की तरह लेता है।

 def first_non_repeated_character(s): counts = defaultdict(int) for c in s: counts[c] += 1 for c in s: if counts[c] == 1: return c return None 

निम्नलिखित स्ट्रिंग का पहला गैर-वर्णित वर्ण खोजने के लिए एक रूबी कार्यान्वयन है:

 def first_non_repeated_character(string) string1 = string.split('') string2 = string.split('') string1.each do |let1| counter = 0 string2.each do |let2| if let1 == let2 counter+=1 end end if counter == 1 return let1 break end end end p first_non_repeated_character('dont doddle in the forest') 

और यहां एक ही स्टाइल फंक्शन के जावास्क्रिप्ट कार्यान्वयन है:

 var first_non_repeated_character = function (string) { var string1 = string.split(''); var string2 = string.split(''); var single_letters = []; for (var i = 0; i < string1.length; i++) { var count = 0; for (var x = 0; x < string2.length; x++) { if (string1[i] == string2[x]) { count++ } } if (count == 1) { return string1[i]; } } } console.log(first_non_repeated_character('dont doddle in the forest')); console.log(first_non_repeated_character('how are you today really?')); 

दोनों ही मामलों में मैंने एक काउंटर का इस्तेमाल किया था कि यह जानने के लिए कि अगर अक्षर स्ट्रिंग में कहीं भी मेल नहीं खाया जाता है, तो यह केवल एक बार स्ट्रिंग में ही आ जाएगा, इसलिए मैं इसकी घटना की गिनती करता हूं

मुझे लगता है कि यह सी में करना चाहिए। यह ओ (एन) समय में सम्मिलित करने और हटाना ऑपरेटरों के आदेश के बारे में कोई अस्पष्टता नहीं है। यह एक गिनती सॉर्ट है (एक बाल्टी सॉर्ट का सरलतम रूप, जो कि एक रेडिक्स सॉर्ट का सरल रूप है)।

 unsigned char find_first_unique(unsigned char *string) { int chars[256]; int i=0; memset(chars, 0, sizeof(chars)); while (string[i++]) { chars[string[i]]++; } i = 0; while (string[i++]) { if (chars[string[i]] == 1) return string[i]; } return 0; } 

रूबी में:

(मूल क्रेडिट: एंड्रयू ए। स्मिथ)

 x = "a huge string in which some characters repeat" def first_unique_character(s) s.each_char.detect { |c| s.count(c) == 1 } end first_unique_character(x) => "u" 
 def first_non_repeated_character(string): chars = [] repeated = [] for character in string: if character in repeated: ... discard it. else if character in chars: chars.remove(character) repeated.append(character) else: if not character in repeated: chars.append(character) if len(chars): return chars[0] else: return False 

अन्य जावास्क्रिप्ट समाधान काफी सी-स्टाइल समाधान हैं जो यहां अधिक जावास्क्रिप्ट-शैली समाधान हैं।

 var arr = string.split(""); var occurences = {}; var tmp; var lowestindex = string.length+1; arr.forEach( function(c){ tmp = c; if( typeof occurences[tmp] == "undefined") occurences[tmp] = tmp; else occurences[tmp] += tmp; }); for(var p in occurences) { if(occurences[p].length == 1) lowestindex = Math.min(lowestindex, string.indexOf(p)); } if(lowestindex > string.length) return null; return string[lowestindex]; } 

सी में, यह लगभग श्लेमिएल पेंटर का एल्गोरिदम है (काफी ओ (एन!) नहीं बल्कि 0 (एन 2) से अधिक)।

लेकिन यथोचित आकार के तार के लिए "बेहतर" एल्गोरिदम को मात देगा क्योंकि ओ बहुत छोटा है यह आपको आसानी से पहले गैर दोहराए जाने वाले स्ट्रिंग का स्थान बता सकता है।

 char FirstNonRepeatedChar(char * psz) { for (int ii = 0; psz[ii] != 0; ++ii) { for (int jj = ii+1; ; ++jj) { // if we hit the end of string, then we found a non-repeat character. // if (psz[jj] == 0) return psz[ii]; // this character doesn't repeat // if we found a repeat character, we can stop looking. // if (psz[ii] == psz[jj]) break; } } return 0; // there were no non-repeating characters. } 

संपादित करें: यह कोड मानता है कि आप लगातार दोहराए जाने वाले वर्णों का मतलब नहीं है।

ये पर्ल में एक कार्यान्वयन है (संस्करण>> 5.10) जो परवाह नहीं करता है कि दोहराए जाने वाले अक्षरे लगातार हैं या नहीं:

 use strict; use warnings; foreach my $word(@ARGV) { my @distinct_chars; my %char_counts; my @chars=split(//,$word); foreach (@chars) { push @distinct_chars,$_ unless $_~~@distinct_chars; $char_counts{$_}++; } my $first_non_repeated=""; foreach(@distinct_chars) { if($char_counts{$_}==1) { $first_non_repeated=$_; last; } } if(length($first_non_repeated)) { print "For \"$word\", the first non-repeated character is '$first_non_repeated'.\n"; } else { print "All characters in \"$word\" are repeated.\n"; } } 

इस कोड को एक स्क्रिप्ट में संग्रहीत करना (जिसे मैंने नामित किया है non_repeated.pl ) और इसे कुछ इनपुट पर चलाता है:

 jmaney> perl non_repeated.pl aabccd "a huge string in which some characters repeat" abcabc For "aabccd", the first non-repeated character is 'b'. For "a huge string in which some characters repeat", the first non-repeated character is 'u'. All characters in "abcabc" are repeated. 

Array#detect ( इस उत्तर के रूप में) का उपयोग किए बिना रूबी में एक संभव समाधान है। Array#detect उपयोग करना यह बहुत आसान बनाता है, मुझे लगता है

 ALPHABET = %w(abcdefghijklmnopqrstu vwxyz) def fnr(s) unseen_chars = ALPHABET.dup seen_once_chars = [] s.each_char do |c| if unseen_chars.include?(c) unseen_chars.delete(c) seen_once_chars << c elsif seen_once_chars.include?(c) seen_once_chars.delete(c) end end seen_once_chars.first end 

कुछ सरल उदाहरणों के लिए काम करने लगता है:

 fnr "abcdabcegghh" # => "d" fnr "abababababababaqababa" => "q" 

सुझाव और सुधार बहुत सराहना कर रहे हैं!

इस कोड को आज़माएं:

  public static String findFirstUnique(String str) { String unique = ""; foreach (char ch in str) { if (unique.Contains(ch)) unique=unique.Replace(ch.ToString(), ""); else unique += ch.ToString(); } return unique[0].ToString(); } 

गणित में एक यह लिख सकता है:

 string = "conservationist deliberately treasures analytical"; Cases[Gather @ Characters @ string, {_}, 1, 1][[1]] 
 {"v"} 

जावास्क्रिप्ट में यह स्निपेट कोड

 var string = "tooth"; var hash = []; for(var i=0; j=string.length, i<j; i++){ if(hash[string[i]] !== undefined){ hash[string[i]] = hash[string[i]] + 1; }else{ hash[string[i]] = 1; } } for(i=0; j=string.length, i<j; i++){ if(hash[string[i]] === 1){ console.info( string[i] ); return false; } } // prints "h" 

यहाँ अलग दृष्टिकोण स्ट्रिंग में प्रत्येक तत्व को स्कैन करें और प्रत्येक एंट्री के पुनरावृत्ति संख्या को संग्रहीत करने वाली एक गिनती सरणी बनाएं। अगली बार फिर से सरणी में पहले तत्व से शुरू होता है और गिनती = 1 के साथ तत्व की पहली घटना मुद्रित करता है

 C code ----- #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { char t_c; char *t_p = argv[1] ; char count[128]={'\0'}; char ch; for(t_c = *(argv[1]); t_c != '\0'; t_c = *(++t_p)) count[t_c]++; t_p = argv[1]; for(t_c = *t_p; t_c != '\0'; t_c = *(++t_p)) { if(count[t_c] == 1) { printf("Element is %c\n",t_c); break; } } return 0; } 

इनपुट = आबबद्विफ़ आउटपुट = सी है

 char FindUniqueChar(char *a) { int i=0; bool repeat=false; while(a[i] != '\0') { if (a[i] == a[i+1]) { repeat = true; } else { if(!repeat) { cout<<a[i]; return a[i]; } repeat=false; } i++; } return a[i]; } 

यहाँ एक और दृष्टिकोण है … हम एक सरणी बना सकते हैं जो कि चरित्र की पहली घटना की गिनती और सूचकांक को संग्रहित करेगा। सरणी को भरने के बाद, हम सरणी को सीधा कर सकते हैं और न्यूनतम सूचक प्राप्त कर सकते हैं, जिनकी संख्या 1 है, फिर वापस [index] वापस आ जाता है

 #include <iostream> #include <cstdio> #include <cstdlib> #include <climits> using namespace std; #define No_of_chars 256 //store the count and the index where the char first appear typedef struct countarray { int count; int index; }countarray; //returns the count array countarray *getcountarray(char *str) { countarray *count; count=new countarray[No_of_chars]; for(int i=0;i<No_of_chars;i++) { count[i].count=0; count[i].index=-1; } for(int i=0;*(str+i);i++) { (count[*(str+i)].count)++; if(count[*(str+i)].count==1) //if count==1 then update the index count[*(str+i)].index=i; } return count; } char firstnonrepeatingchar(char *str) { countarray *array; array = getcountarray(str); int result = INT_MAX; for(int i=0;i<No_of_chars;i++) { if(array[i].count==1 && result > array[i].index) result = array[i].index; } delete[] (array); return (str[result]); } int main() { char str[] = "geeksforgeeks"; cout<<"First non repeating character is "<<firstnonrepeatingchar(str)<<endl; return 0; } 

समारोह:

यह सी # फ़ंक्शन HashTable (शब्दकोश) का उपयोग करता है और एक प्रदर्शन ओ (2n) सबसे खराब केस है

 private static string FirstNoRepeatingCharacter(string aword) { Dictionary<string, int> dic = new Dictionary<string, int>(); for (int i = 0; i < aword.Length; i++) { if (!dic.ContainsKey(aword.Substring(i, 1))) dic.Add(aword.Substring(i, 1), 1); else dic[aword.Substring(i, 1)]++; } foreach (var item in dic) { if (item.Value == 1) return item.Key; } return string.Empty; } 

उदाहरण:

स्ट्रिंग एवरेड = "टीईटीईआर";

Console.WriteLine (FirstNoRepeatingCharacter (aword)); // प्रिंट: आर

मेरे दो स्ट्रिंग अर्थात् 'अद्वितीय' और 'बार-बार' हैं पहली बार प्रदर्शित होने वाला प्रत्येक चरित्र, 'अद्वितीय' में जोड़ा जाता है यदि इसे दूसरी बार दोहराया जाता है, तो इसे 'अनूठे' से हटा दिया जाता है और 'दोहराया' में जोड़ा जाता है इस तरह, हमारे पास 'अद्वितीय' में हमेशा अद्वितीय अक्षरों का एक स्ट्रिंग होगा जटिलता बड़ा ओ (एन)

 public void firstUniqueChar(String str){ String unique= ""; String repeated = ""; str = str.toLowerCase(); for(int i=0; i<str.length();i++){ char ch = str.charAt(i); if(!(repeated.contains(str.subSequence(i, i+1)))) if(unique.contains(str.subSequence(i, i+1))){ unique = unique.replaceAll(Character.toString(ch), ""); repeated = repeated+ch; } else unique = unique+ch; } System.out.println(unique.charAt(0)); } 

निम्न कोड n की जटिलता के साथ सी # में है

 using System; using System.Linq; using System.Text; namespace SomethingDigital { class FirstNonRepeatingChar { public static void Main() { String input = "geeksforgeeksandgeeksquizfor"; char[] str = input.ToCharArray(); bool[] b = new bool[256]; String unique1 = ""; String unique2 = ""; foreach (char ch in str) { if (!unique1.Contains(ch)) { unique1 = unique1 + ch; unique2 = unique2 + ch; } else { unique2 = unique2.Replace(ch.ToString(), ""); } } if (unique2 != "") { Console.WriteLine(unique2[0].ToString()); Console.ReadLine(); } else { Console.WriteLine("No non repeated string"); Console.ReadLine(); } } } } 

निम्नलिखित समाधान एक शानदार तरीका है कि नई विशेषताओं का उपयोग करके स्ट्रिंग के भीतर पहला अनूठा चरित्र ढूंढने का तरीका है जो जावा 8 के भाग के रूप में प्रस्तुत किया गया है। यह समाधान पहले प्रत्येक चरित्र की घटनाओं की संख्या की गणना करने के लिए एक नक्शा बनाने का दृष्टिकोण का उपयोग करता है। यह तब पहला नक्शा ढूंढने के लिए इस मानचित्र का उपयोग करता है जो केवल एक बार उत्पन्न होता है। यह ओ (एन) समय में चलता है

 import static java.util.stream.Collectors.counting; import static java.util.stream.Collectors.groupingBy; import java.util.Arrays; import java.util.List; import java.util.Map; // Runs in O(N) time and uses lambdas and the stream API from Java 8 // Also, it is only three lines of code! private static String findFirstUniqueCharacterPerformantWithLambda(String inputString) { // convert the input string into a list of characters final List<String> inputCharacters = Arrays.asList(inputString.split("")); // first, construct a map to count the number of occurrences of each character final Map<Object, Long> characterCounts = inputCharacters .stream() .collect(groupingBy(s -> s, counting())); // then, find the first unique character by consulting the count map return inputCharacters .stream() .filter(s -> characterCounts.get(s) == 1) .findFirst() .orElse(null); } 

ओ (एन) समय जटिलता के साथ यहां एक और समाधान है

 public void findUnique(String string) { ArrayList<Character> uniqueList = new ArrayList<>(); int[] chatArr = new int[128]; for (int i = 0; i < string.length(); i++) { Character ch = string.charAt(i); if (chatArr[ch] != -1) { chatArr[ch] = -1; uniqueList.add(ch); } else { uniqueList.remove(ch); } } if (uniqueList.size() == 0) { System.out.println("No unique character found!"); } else { System.out.println("First unique character is :" + uniqueList.get(0)); } } 

मैंने जवाबों के माध्यम से पढ़ा, लेकिन मेरी कोई पसंद नहीं देखी, मुझे लगता है कि यह जवाब बहुत सरल और तेज़ है, क्या मैं ग़लत हूं?

 def first_unique(s): repeated = [] while s: if s[0] not in s[1:] and s[0] not in repeated: return s[0] else: repeated.append(s[0]) s = s[1:] return None 

परीक्षा

 (first_unique('abdcab') == 'd', first_unique('aabbccdad') == None, first_unique('') == None, first_unique('a') == 'a') 

कैसे इस मामले के लिए एक प्रत्यय पेड़ का उपयोग करने के बारे में … पहला अपरिवर्तित चरित्र सबसे लंबे समय तक प्रत्यय स्ट्रिंग का पहला चरित्र होगा जिसमें पेड़ में कम से कम गहराई होगी ..

दो सूची बनाएँ –

  1. अनूठी सूची – केवल अद्वितीय चरित्र वाले .. उल
  2. गैर-अनूठी सूची – केवल दोहराए गए चरित्र- NUL
   के लिए (चार सी में str) {
     अगर (nul.contains (ग)) {
      //कुछ मत करो
     } और अगर (ul.contains (c)) {
       ul.remove (ग);
       nul.add (ग);
     }अन्य{
        nul.add (ग);
     }
 Another answer(Might not be so efficient but a kind of approach that we can try in c++; Time complexity:O(n) Space complexity:O(n)). char FirstNotRepeatingCharInString(char *str) { //Lets assume a set to insert chars of string char result; multiset<char> st; for(int i=0;i<strlen(str);i++) { st.insert(str[i]); } for(int i=0;i<strlen(str);i++) { if(st.count(str[i]) <=1){ result = str[i]; break; } } return result; }