चुनौती

एक प्रोग्राम लिखें, xजो एक स्ट्रिंग दिया गया है जो 10 वर्ण लंबा और एक वर्ण है y, yस्ट्रिंग में होने वाले समय चरित्र की संख्या को आउटपुट करता है x।

ऐसा करने के लिए बाइट्स में सबसे छोटा कार्यक्रम जीतता है।

उदाहरण

Input: tttggloyoi, t
Output: 3

Input: onomatopoe, o
Output: 4

code-golf string counting

— रोसलिन टैगहॉय
स्रोत

11

यह एक चुनौती के लगभग आसान लगता है। इसके अलावा इनपुट को 10 तक ही सीमित रखें, इसके बजाय कोई सीमा नहीं है?

— 9

7

जीतने की स्थिति चाहिए।

— isaacg

2

बेझिझक मेरे संपादन को रोलबैक करने के लिए बेझिझक अगर यह आपके साथ सहमत नहीं है

— बीटा डिके

8

इनपुट प्रारूप कितना लचीला है? क्या हम एक अलग सी परिसीमा का चयन कर सकते हैं, जैसे अंतरिक्ष या न्यूलाइन? क्या स्ट्रिंग उद्धरणों में हो सकती है? क्या हम पहले अक्षर को और दूसरे को स्ट्रिंग में ले जा सकते हैं? क्या अक्षर हमेशा कम अक्षर वाले होंगे? यदि नहीं, तो कौन से अन्य वर्ण हो सकते हैं?

— मार्टिन एंडर

5

यह एक सी इंटरव्यू प्रश्न की तरह संदेहास्पद लगता है ...

— क्वेंटिन

18

अजगर, 3 बाइट्स

/ww

उदाहरण रन:

$ pyth -c '/ww'
sdhkfhjkkj
k
3

बेशक, उपयोगकर्ता पहले इनपुट पर 10 या उससे अधिक अक्षरों का इनपुट कर सकता है, लेकिन उपयोगकर्ता को युक्ति का उल्लंघन करने पर क्या होता है, इसके बारे में हमें चिंता करने की आवश्यकता नहीं है।

— isaacg
स्रोत

ऐसा लगता है कि अब मान्य नहीं है?

— शुक्र

स्पष्टीकरण कृपया?

— 90

@ MilkyWay90 यहां बताया गया है कि आप इसका उपयोग कैसे कर सकते हैं: इसे ऑनलाइन आज़माएं! । /बस दूसरी इनपुट स्ट्रिंग के पहले इनपुट स्ट्रिंग में होने वाली घटनाओं की संख्या को गिना जाता है। wइनपुट की एक लाइन लेता है।

— isaacg

@ आइसाकग ओह, मैं देख रहा हूं। धन्यवाद!

— मिल्कीवेय 90

11

पायथ - 3 बाइट्स

एक अलग, कम स्पष्ट, एक ही आकार का पायथ उत्तर। यह इनपुट पर गिनती को मोड़ता है।

/FQ

टेस्ट सूट ।

— Maltysen
स्रोत

7

जावास्क्रिप्ट, 32

(p=prompt)().split(p()).length-1

— edc65
स्रोत

6

बैश, 24 वर्ण

x=${1//[^$2]}
echo ${#x}

नमूना रन:

bash-4.3$ bash letter-count.sh tttggloyoi t
3

bash-4.3$ bash letter-count.sh onomatopoe o
4

— आदमी काम पर है
स्रोत

6

रेटिना , 12 बाइट्स

(.)(?=.*\1$)

बस एक रेगेक्स जो एक चरित्र से मेल खाता है जो इनपुट में अंतिम चरित्र के बराबर है (खुद को छोड़कर)। जब एक एकल रेगेक्स दिया जाता है, तो रेटिना केवल मैचों की संख्या लौटाती है।

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

वाह, मैं यहाँ पर आर एस के साथ सभी प्रकार के फैंसी सामान करने की कोशिश कर रहा हूं , और आपने मुझे लाहाहिद के साथ हराया। +1

— kirbyfan64sos

4

भूलभुलैया , 32 29 27 24 बाइट्स

),}{)-
@ ,  +);__
!-`{:}

यह पहले एकल वर्ण को पढ़ता है, उसके बाद स्ट्रिंग जिसमें गिनती करना है, और यह मानता है कि स्ट्रिंग में कोई नल-बाइट्स नहीं हैं।

व्याख्या

कोड के साथ शुरू होता है ),}, जो स्टैक के निचले भाग को सेट करता 1है, पहले वर्ण को पढ़ता है और इसे भविष्य के उपयोग के लिए सहायक स्टैक में ले जाता है। 1हमारे काउंटर हो जाएगा (1 की भरपाई बाद में रद्द कर दिया जाएगा और आईपी आवश्यक बारी-बारी से करने के लिए आवश्यक है)।

IP अब खोज स्ट्रिंग के पहले वर्ण को पढ़ने के लिए नीचे जाएगा ,। `सही मोड़ वाला व्यवहार प्राप्त करने के लिए मान को फिर से नकार दिया जाता है । जब हम STDIN के पात्रों को पढ़ रहे हैं, तो IP अब इस लूप का अनुसरण करेगा:

  }{)-
  ,  +);__
  `{:}

{:}संग्रहीत वर्ण कोड की एक प्रति बनाता है और +इसे वर्तमान मूल्य में जोड़ता है। यदि परिणाम है 0(यानी वर्तमान चरित्र वह है जिसे हम खोज रहे हैं), तो आईपी सीधे आगे बढ़ता है: -बस से छुटकारा मिलता है 0, )काउंटर बढ़ाता है, {}एक नो-ऑप है।

हालाँकि, यदि परिणाम +गैर-शून्य है, तो हम वर्तमान वर्ण को गिनना नहीं चाहते हैं। इसलिए IP इसके बजाय राइट-टर्न लेता है। यह एक मृत-अंत है, इसलिए उस कोड को दो बार निष्पादित किया जाता है, एक बार आगे और एक बार पीछे। यही है, इस मामले में वास्तविक कोड बन जाता है );___;)+-){}। );बस उस गैर-शून्य अंतर से छुटकारा ___पाती है, 3 शून्य को धक्का देती है, लेकिन ;उनमें से एक को त्याग देती है। )शेष दो दो शून्य +में से एक को बढ़ाता है , उन्हें एक में जोड़ता है 1, -इसे काउंटर से घटाता है और काउंटर को )बढ़ाता है। दूसरे शब्दों में, हमने बहुत विस्तृत नो-ऑप बनाया है।

When we hit EOF, , pushes -1, which ` turns into 1 and the IP takes a right-turn. - subtracts the 1 from the counter (cancelling the initial offset). ! prints the counter and @ terminates the program.

— Martin Ender
स्रोत

4

Python 3, 29 bytes

print(input().count(input()))

Meh, this was easy. Assumes that input is a ten letter string.

— Beta Decay
स्रोत

4

You copied me! :D

— isaacg

1

@isaacg Great minds think alike? ;D

— Beta Decay

If you don't need to read input, wouldn't f=lambda x,y:x.count(y) be shorter? (Sorry if this doesn't work, I'm on mobile and can't check)

— cole

@mbomb007 My mistake, thanks for clarifying.

— cole

1

ब्रैकेट को प्रिंट के आसपास हटाने से आपको एक चरित्र print input().count(input())या a,b=input();print a.count(b)एक ही राशि मिलती है

— Willem

4

Snowman 1.0.2, 16 characters

~vgvgaSaLNdEtSsP

Surprisingly short. Explanation:

~      make all vars active (even though we only need two, we don't really care)
vgvg   get two lines of input
aS     split first line on second line
aL     length of the new array
NdE    decrement (because ex. "axbxc""x"aS -> ["a" "b" "c"] which is length 3)
tSsP   to-string and print

— Doorknob
स्रोत

अच्छा काम! मुझे नहीं लगा होगा कि स्नोमैन में एक समाधान संभव है।

— एलेक्स ए।

4

C++ Template-Metaprogramming, 160 154 116 bytes

Just for the giggles.

Thanks to ex-bart for golfing it down!

template<int w,int x,int y,int...s>class A:A<w+(x==y),x,s...>{};A<0,'t','t','t','t','g','g','l','o','y','o','i',0>a;

Usage: The first char in the template instanciation is the character to search.

Clang -std = c ++ 11 -c -> के साथ शिकायत त्रुटि संदेश की शुरुआत में होती है।

Occurences.cpp:1:66: error: too few template arguments for class template 'A'
template<int w,char x,char y,char...s>class A{static const int a=A<w+((x==y)?1:0),x,s...>::a;};
                                                             ^
Occurences.cpp:1:66: note: in instantiation of template class 'A<3, 't', '\x00'>' requested here
template<int w,char x,char y,char...s>class A{static const int a=A<w+((x==y)?1:0),x,s...>::a;};

Gcc -std = c ++ 11 -c -> के साथ शिकायत त्रुटि संदेश के निचले भाग में है।

Occurences.cpp: In instantiation of ‘const int A<3, 't', '\000'>::a’:
Occurences.cpp:1:64:   recursively required from ‘const int A<1, 't', 't', 't', 'g', 'g', 'l', 'o', 'y', 'o', 'i', '\000'>::a’
Occurences.cpp:1:64:   required from ‘const int A<0, 't', 't', 't', 't', 'g', 'g', 'l', 'o', 'y', 'o', 'i', '\000'>::a’
Occurences.cpp:2:62:   required from here
Occurences.cpp:1:64: error: wrong number of template arguments (2, should be at least 3)

A < 3 , 't', '\ 000'> और A < 3 के लिए खोजें, 't', '\x00'>

154 बाइट संस्करण

template<int w,char x,char y,char...s>class A{static const int a=A<w+(x==y),x,s...>::a;};                          
int a=A<0,'t','t','t','t','g','g','l','o','y','o','i','\0'>::a;

160 बाइट संस्करण:

template<int w,char x,char y,char...s>class A{static const int a=A<w+((x==y)?1:0),x,s...>::a;};                          
int a=A<0,'t','t','t','t','g','g','l','o','y','o','i','\0'>::a;

— Otomo
स्रोत

You can shorten ((x==y)?1:0) to just (x==y) to save about 6 bytes (I think).

— kirbyfan64sos

Thanks--wanted to be sure that it is defined behaviour, because I wasn't sure what the standard said about bool to int conversion.

— Otomo

It's defined behavior.

— kirbyfan64sos

हां, अब मुझे पता है कि, भी। :) आपका बहुत बहुत धन्यवाद। (मुझे लगा कि शायद यह कार्यान्वयन पर निर्भर होगा।)

— ओटोमो

1

128 बाइट्स: enumइसके बजाय अनाम का उपयोग करें static const। समाप्त करने के 0बजाय उपयोग करें '\0'। के intबजाय का उपयोग करें char। अलग करने के लिए थोड़ा अलग घोषणा का उपयोग करें। सुपरफ्लॉस न्यूलाइन निकालें।

template<int w,int x,int y,int...s>class A{enum{a=A<w+(x==y),x,s...>::a};};A<0,'t','t','t','t','g','g','l','o','y','o','i',0>a;

। G ++ और क्लैंग के साथ जांचा गया।

— भूतपूर्वकालीन

3

बैश + जीआरपी, 26 बाइट्स

grep -o "$1"<<<"$2"|wc -l

— Tarod
स्रोत

3

जावास्क्रिप्ट (ईएस 6), 26 बाइट्स

(a,b)=>a.split(b).length-1

यह quick'n'easy समाधान एक अनाम फ़ंक्शन को परिभाषित करता है। इसका उपयोग करने के लिए, शुरुआत में एक चर घोषणा जोड़ें। कोशिश करके देखो:

कोड स्निपेट दिखाएं

z=(a,b)=>(a.split(b)||[0]).length-1;

input1=document.getElementById("input1");
input2=document.getElementById("input2");
p=document.getElementById("a");
q=function(){
  setTimeout(function(){
    p.innerHTML=z(input1.value,input2.value)||0;
  },10);
};
input1.addEventListener("keydown",q);
input2.addEventListener("keydown",q);

<form>Text to search: <input type="text" id="input1" value="hello world!"/><br>Char to find: <input type="text" id="input2" value="l"/></form>

<h3>Output:</h3>
<p id="a">3</p>

Expand snippet

संपादित करें: ओह, मैं देख रहा हूँ कि पहले से ही एक बहुत ही समान समाधान है। मुझे आशा है कि यह ठीक है।

— ETHproductions
स्रोत

3

हास्केल, 21 बाइट्स

a!b=sum[1|x<-a,x==b]

— Otomo
स्रोत

3

सी ++, 78 बाइट्स

int main(int,char**v){int c=0,i=0;while(i<10)v[1][i++]==*v[2]&&++c;return c;}

इस तरह से कॉल करें:

$ g++ -std=c++14 -O2 -Wall -pedantic -pthread main.cpp && ./a.out tttggloyoi t; echo $?
3

— पूर्व बार्ट
स्रोत

3

तत्व , 23 बाइट्स

__);11'[)\
~="0 1@][+]`

न्यूलाइन कार्यक्रम का हिस्सा है। मैं वास्तव में इसे एक चर नाम के रूप में उपयोग कर रहा हूं ।

यह प्रोग्राम मूल रूप से टारगेट के शीर्ष पर वर्तमान स्ट्रिंग को रखते हुए, और फिर "चॉप, कंपेयर, और मूव रिजल्ट को आगे" प्रक्रिया में लाकर, अंत में परिणाम जोड़ते हुए, एक चर में लक्ष्य चरित्र को स्टोर करके काम करता है।

एक चर नाम के रूप में नई पंक्ति इनपुट के अंत में नई पंक्ति का उपयोग करके इसे काट कर और इसमें संग्रहीत करके आती है। कोड में नई पंक्ति वह जगह है जहां से मैंने इसे पढ़ा है।

इनपुट इस प्रकार है:

qqqqwwweee
q

आउटपुट इस तरह है

— PhiNotPi
स्रोत

3

जूलिया, 26 25 बाइट्स

f(s,c)=endof(findin(s,c))

findinसमारोह पहला तर्क है, जिस पर दूसरा तर्क वेक्टर के रूप में पाया जाता है में सूचकांक देता है। वेक्टर की लंबाई घटनाओं की संख्या है।

ग्लेन ओ को एक बाइट थैंक्स कहा।

— एलेक्स ए।
स्रोत

endofके स्थान पर आपको एक बाइट बचाएगा length।

— ग्लेन ओ

3

एपीएल, 7 3 बाइट्स

+/⍷

यह एक फंक्शन ट्रेन बनाता है। यह शून्य के वेक्टर को बनाने और उन सूचकांकों के अनुरूप काम करता है जिस पर स्ट्रिंग में चरित्र दिखाई देता है ( ⍷)। सदिश को फिर अभिव्यक्त किया गया है ( +/)।

बचाया 4 बाइट्स kirbyfan64sos और NBZ के लिए धन्यवाद!

— एलेक्स ए।
स्रोत

क्या एपीएल के जैसा होता है K? मुझे लगता है कि आप +/⍷तब कुछ कर सकते हैं (मुझे एपीएल नहीं पता है, इसलिए मैं गलत हो सकता हूं)।

— kirbyfan64sos

@ kirbyfan64sos केवल करी मुझे पता है कि भोजन है तो मुझे यकीन नहीं है। लेकिन मैं इस पर गौर करूंगा। सलाह के लिये धन्यवाद!

— एलेक्स ए।

@ kirbyfan64sos हाँ, इसे एक फ़ंक्शन ट्रेन कहा जाता है , इसलिए + / by वास्तव में काम करेगा, लेकिन जब से हम एक एकल चार्ट की तलाश कर रहे हैं, तो कोई instead के बजाय = का उपयोग कर सकता है।

— आदम

3

पर्ल, 21 16 वर्ण

(13 वर्ण कोड + 3 वर्ण कमांड लाइन विकल्प।)

$_=0+s/$^I//g

नमूना रन:

bash-4.3$ perl -it -pe '$_=0+s/$^I//g' <<< tttggloyoi
3

bash-4.3$ perl -io -pe '$_=0+s/$^I//g' <<< onomatopoe
4

bash-4.3$ perl -i5 -pe '$_=0+s/$^I//g' <<< 1234
0

— आदमी काम पर है
स्रोत

साथ नीट छल <>!

— ThisSuitIsBlackNot

आप एक बाइट को छोड़ने -lऔर यह सुनिश्चित करने से बचा सकते हैं कि आपके इनपुट में कोई नई सीमा नहीं है:echo -en 'onomatopoe\no' | perl -pe '$_=eval"y/".<>."//"'

— ThisSuitIsBlackNot

1

और आप अपने कुल को 16 तक गिरा सकते हैंperl -pe '$_+=s/${\<>}//g'

— ThisSuitIsBlackNot

यह संदर्भित चाल अविश्वसनीय है। धन्यवाद, @ThisSuitIsBlackNot

— मैनटवर्क

क्यों +=जरूरी है? =बस के रूप में अच्छी तरह से काम करने लगता है (और अभी भी काम करना चाहिए जब इनपुट कुछ अंकों के साथ शुरू होता है)।

— पूर्व-

3

PHP, 36 35 बाइट्स

<?=substr_count($argv[1],$argv[2]);

उपयोग:
स्क्रिप्ट को दो तर्कों के साथ कॉल करें।
php script.php qwertzqwertz q

PHP, 23 बाइट्स

यदि आप वैश्विक चर (केवल PHP 5.3 और नीचे में संभव है) दर्ज करते हैं, तो आप 12 बाइट्स ( मार्टिज़न के लिए धन्यवाद ) बचा सकते हैं

<?=substr_count($a,$b);

उपयोग:
स्क्रिप्ट को कॉल करें और वैश्विक चर घोषित करेंphp script.php?a=qwertzqwertz&b=q

— jrenk
स्रोत

1

आप एक बाइट कम करने के लिए अल्पविराम के बाद एक जगह निकाल सकते हैं

— Voitcus

1

यदि आपके पास रजिस्टर ग्लोबल्स हैं जो आप कर सकते हैं script.php?a=qwertzqwertz&b=q, और कर सकते हैं <?=substr_count($a,$b);, 23 चर

— मार्टिज़न

@Martijn अच्छा विचार धन्यवाद!

— ग्रेनेक

3

Dyalog एपीएल , 3 बाइट्स

+/=

Ie "बराबर बाइट्स का योग"। उदाहरण के लिए:

      f ← +/=
      'onomatopoe' f 'o'
4

या केवल

      'onomatopoe'(+/=)'o'
4

K इस बार APL को नहीं हराता है।

इसे ऑनलाइन आज़माएं।

— एडम
स्रोत

कृपया एक साथ दर्जनों पोस्ट संपादित न करें। आप सामने वाले पृष्ठ को पूरी तरह से भर रहे हैं। यदि ऐसे कई पोस्ट हैं, जिन्हें संपादन की आवश्यकता है (जो कभी-कभार होता है, जैसे कि क्योंकि एक नया टैग जोड़ा जाता है), तो यह आम तौर पर केवल उनमें से 3 को एक बार में करना अच्छा होता है और फिर कम से कम 12 घंटे प्रतीक्षा करें ताकि वे सामने से हट सकें पृष्ठ।

— मार्टिन एंडर

@ मार्टिनबटनर हाँ, मुझे उस समय एहसास नहीं हुआ था। :-( नियमित उपयोगकर्ताओं के पास "माइनर एडिट" विकल्प नहीं है ... मुझे पता है कि यह हर किसी के लिए उपलब्ध क्यों नहीं हो सकता है।

— Adám

दुर्भाग्य से, ऐसा कोई विकल्प बिल्कुल नहीं है, यहां तक कि मध्यस्थों के लिए भी नहीं।

— मार्टिन एंडर

3

टी-एसक्यूएल, 99 40 बाइट्स

SELECT 11-LEN(REPLACE(s,c,'')+'x')FROM t

बस इनपुट स्ट्रिंग और हटाए गए चरित्र के साथ स्ट्रिंग के बीच अंतर करता है। टेबल टी से इनपुट लेता है

गिनती के रिक्त स्थान के साथ एक समस्या को दूर करने के लिए और SQL के लिए वर्तमान स्वीकार्य इनपुट्स को ध्यान में रखते हुए संपादित करें । धन्यवाद @BradC सभी परिवर्तनों और बचत के लिए

— MickyT
स्रोत

आप सभी मचान की जरूरत नहीं है, बस करना चाहिए SELECT LEN(s)-LEN(REPLACE(s,c,''))FROM t, जहां खेतों के साथ t एक पूर्व आबादी इनपुट तालिका हैs और c।

— ब्रैडॉक

एक अन्य नोट पर, यह कोड स्ट्रिंग्स के लिए गलत उत्तर देता है जैसे A B C D कि रिक्त स्थान में (यदि आपसे रिक्त स्थान की गणना करने के लिए कहा जाए), क्योंकि LENट्रैप रिक्त स्थान को अनदेखा करता है।

— ब्रैडॉक

@ BradC मुझे लगता है कि रास्ता फिर, जो स्वीकार्य था, उसके आसपास के नियम, विशेष रूप से SQL के आसपास प्रतिबंधात्मक और अस्पष्ट थे। मेरे पास spaceथोड़ा समय होने पर इस मुद्दे को ठीक करने पर एक नज़र

— डालेंगे

मैं आमतौर पर सिर्फ पैड को समाप्त करता हूं और एक को घटाता हूं; इस मामले में इनपुट बिल्कुल 10 वर्णों की गारंटी है, आप इसे केवल हार्ड कोड के रूप में देख सकते हैंSELECT 11-LEN(REPLACE(s,c,'')+'x')FROM t

— ब्रैड ऑक्ट

@ ब्रैड हाँ, इसे फिर से देख कर, निश्चित नहीं कि मैंने चर लंबाई की अनुमति क्यों दी। परिवर्तन करना।

— मिकट

2

ऑक्टेव / मतलाब, 33 बाइट्स

sum(input('','s')==input('','s'))

— लुइस मेंडो
स्रोत

2

जे, 5 बाइट्स

+/@:=

मुझे ऐसा लगता है कि J के पास इसके लिए बिल्ट-इन होगा, लेकिन मैं एक खोजने में सक्षम नहीं हुआ हूं - शायद सक्रिय J उपयोगकर्ताओं में से एक मुझे बता सकता है। इसलिए इसके बजाय यह पहले =इनपुट पर लागू होता है, प्रत्येक वर्ण को बदल देता है 1यदि यह अनुरोधित एक या 0अन्यथा के बराबर है । फिर +/उस सूची के योग की गणना करता है।

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

2

बैच फ़ाइल, 121 बाइट्स

क्योंकि मैं मर्दवादी हूं ...

SET c=0
SET e=_
SET t=%1%%e%
:l
SET a=%t:~0,1%
IF "%a%"=="%2" SET /A c+=1
SET t=%t:~1%
IF NOT "%t%"=="%e%" GOTO l
ECHO %c%

चेतावनी: मान लें कि `_`इनपुट स्ट्रिंग में नहीं होती है। यदि यह करता है, तो चर`e` को उचित रूप से समायोजित करने की आवश्यकता है।

यह हमारे इनपुट वैरिएबल को सेट करता है c, और _हमारे इनपुट स्ट्रिंग को लागू करने से पहले और हमारे %1समवर्ती स्ट्रिंग को सेट करने के लिए, जैसा कि हमारे स्ट्रिंग स्ट्रिंग का सीमांकन करता है t। फिर, हम लूप में प्रवेश कर रहे हैं :l, हम एक अस्थायी कैरेक्टर वैरिएबल aको पहले कैरेक्टर के रूप में सेट करते हैं t, यह जाँचते हैं कि क्या यह हमारे दूसरे इनपुट स्ट्रिंग %2और इन्क्रीमेंट से मेल खाता है cयदि सही है, तो पहले कैरेक्टर को ट्रिम करेंt । हमारे एंड-ऑफ-लूप की स्थिति tहमारे एंड-ऑफ-स्ट्रिंग सीमांकन के खिलाफ जांच करती है, और यदि नहीं तो वापस लूप। फिर हमecho अपने काउंटर का मूल्य निकालते हैं।

संभवत: FORइसके बजाय लूप का उपयोग करना संभव होगा , लेकिन इसके लिए DelayedExpansion को सक्षम करने की आवश्यकता होगी , जो मुझे लगता है कि वास्तव में इससे बाइट-वार होगा। उस का सत्यापन पाठक को एक अभ्यास के रूप में छोड़ दिया जाता है।

— AdmBorkBork
स्रोत

2

सीजाम, 5 बाइट्स

ll/,(

व्याख्या

l      e# read x
 l     e# read y
  /    e# split x by y
   ,   e# count
    (  e# subtract one

— Ypnypn
स्रोत

2

पॉवरशेल, 32 बाइट्स

एक चार के लिए! और वे सभी एक ही लंबाई के हैं! :)

($args[0]-split$args[1]).Count-1

या

param($a,$b)($a-split$b).Count-1

वैकल्पिक रूप से,

$args[0].Split($args[1]).Count-1

या

param($a,$b)$a.Split($b).Count-1

पहले दो स्टाइल इनलाइन ऑपरेटर का उपयोग करते हैं -split, जबकि दूसरा दो स्पष्ट रूप से स्ट्रिंग के रूप में पहला तर्क देता है और .Split()स्ट्रिंग-आधारित ऑपरेटर का उपयोग करता है । सभी उदाहरणों में एक सरणी वापस आ जाती है, जहाँ हमें एक-एक करके गिनती में कमी करनी चाहिए, क्योंकि हम दूसरे तर्क की घटनाओं की तुलना में एक और सरणी वस्तु वापस पा रहे हैं।

_{यह एक थोड़े मजेदार था ...}

— AdmBorkBork
स्रोत

2

जूलिया, 21 बाइट्स

f(s,c)=sum(i->c==i,s)

ध्यान दें कि इसके लिए cएक चार वर्ण नहीं, बल्कि चार होना चाहिए । तो आप इसे f("test me",'e')(जो 2 लौटाते हैं) के रूप में उपयोग करते हैं और नहीं f("test me","e")(जो 0 देता है, क्योंकि 'e'!="e")।

— ग्लेन हे
स्रोत

2

> <> (मछली) , 30 बाइट्स

0&v
=?\ilb
=?\:@=&+&l1
n&/;

स्ट्रिंग लेता है, फिर चरित्र को गिनता है। इनपुट अलग नहीं किया गया है (कम से कम ऑनलाइन दुभाषिया में)। इसे ऑनलाइन इंटरप्रेटर पर आज़माएं: http://fishlanguage.com मैंने हाथ से बाइट्स गिना, तो मुझे बताएं कि क्या मैं गलत हूं।

व्याख्या

सबसे पहले,> <> 2 आयामी है और एक पंक्ति या स्तंभ के माध्यम से छोरों जब तक यह एक हिट नहीं करता है ; त्रुटि या । इसका मतलब यह है कि अगर यह बाएं से दाएं चल रहा है (जैसे यह एक कार्यक्रम की शुरुआत में होता है), तो यह पंक्ति के चारों ओर लपेटेगा यदि यह अंत तक पहुंचता है और इसे स्थानांतरित करने या प्रोग्राम को रोकने के लिए नहीं कहा जाता है। प्रति पंक्ति कुछ वर्ण दोहराए जाएंगे क्योंकि उनके पास सूचक की दिशा के आधार पर अलग-अलग कार्य हैं, और चौथी पंक्ति में वर्ण उल्टे क्रम में होंगे क्योंकि सूचक दाएं से बाएं चलता है।

कार्यक्रम का सारांश नीचे दिया गया है। को देखो > <esolangs पर> लिए दिए गए निर्देशों क्या प्रत्येक व्यक्ति के चरित्र करता है देखने के लिए।

पंक्ति 1: 0&v

0&v -put 0 into the register and change direction to down-up

लाइन 2: =?\ilb

(जहां लाइन 1 पॉइंटर को तीसरे अक्षर पर ले जाती है)

\ -reflect the pointer and make it move left-right
i -read input
lb=?\ -reflect downwards if there are 11 values in the stack

पंक्ति 3: =?\:@=&+&l1

(तीसरे चरित्र पर शुरू)

:@ -duplicate y and shift the stack e.g. ['x','y','y'] -> ['y','x','y']
=&+& -increment the register if the character popped from x = y
l1=?\ -reflect downwards if there is 1 value in the stack

पंक्ति 4: n&/;

(तीसरे चरित्र पर शुरू)

/ -reflect right-left
&n; -print value of the register

— गोभी
स्रोत

2

रूबी, 22 20 बाइट्स

p gets.count(gets)-1

डेमो: http://ideone.com/MEeTd2

-1 तथ्य के कारण है कि getsइनपुट को पुनः प्राप्त किया जाता है, साथ ही एक नई लाइन वर्ण। रूबी केString#count तर्क में किसी भी वर्ण के स्ट्रिंग में होने की संख्या गिना जाती है ।

उदाहरण के लिए, इनपुट [ test\n, t\n] के लिए, tदो बार और होता है\n एक बार होता है, और इसे घटाया जाना चाहिए।

— क्रिस्टियन लुपस्कू
स्रोत

आप $><<4 बाइट निकाल और कम कर सकते हैं ।

— वासु अडारी

@VasuAdari लेकिन मुझे किसी भी तरह परिणाम को प्रिंट करने की आवश्यकता है ...

— क्रिश्चियन लुपस्क्यू

क्या आप ऐसा नहीं कर सकते? ->p gets.count(gets)-1

— वासु अडारी

@VasuAdari आप सही कह रहे हैं; फिलहाल मैंने सोचा था कि आउटपुट के चारों ओर क्यूटो लगाएगा, लेकिन यह संख्यात्मक है इसलिए यह ठीक है। धन्यवाद!

— क्रिस्टियन लुपस्कू

2

रूबी, 18 बाइट्स

->s,c{p s.count c}

उपयोग:

->s,c{p s.count c}.call 'tttggloyoi', 't'

->s,c{p s.count c}.call 'onomatopoe', 'o'

— वासु अडारी
स्रोत

2

जाप , 2 बाइट्स

èV

इसे ऑनलाइन आज़माएं!

— randomdude999
स्रोत

एक इनपुट स्ट्रिंग में एक चरित्र की घटनाओं का पता लगाएं

चुनौती

उदाहरण

अजगर, 3 बाइट्स

पायथ - 3 बाइट्स

जावास्क्रिप्ट, 32

बैश, 24 वर्ण

रेटिना , 12 बाइट्स

भूलभुलैया , 32 29 27 24 बाइट्स

व्याख्या

Python 3, 29 bytes

Snowman 1.0.2, 16 characters

C++ Template-Metaprogramming, 160 154 116 bytes

बैश + जीआरपी, 26 बाइट्स

जावास्क्रिप्ट (ईएस 6), 26 बाइट्स

हास्केल, 21 बाइट्स

सी ++, 78 बाइट्स

तत्व , 23 बाइट्स

जूलिया, 26 25 बाइट्स

एपीएल, 7 3 बाइट्स

पर्ल, 21 16 वर्ण

PHP, 36 35 बाइट्स

PHP, 23 बाइट्स

Dyalog एपीएल , 3 बाइट्स

टी-एसक्यूएल, 99 40 बाइट्स

ऑक्टेव / मतलाब, 33 बाइट्स

जे, 5 बाइट्स

बैच फ़ाइल, 121 बाइट्स

सीजाम, 5 बाइट्स

व्याख्या

पॉवरशेल, 32 बाइट्स

जूलिया, 21 बाइट्स

> <> (मछली) , 30 बाइट्स

रूबी, 22 20 बाइट्स

रूबी, 18 बाइट्स

उपयोग:

जाप , 2 बाइट्स