FizzBuzz-ish स्ट्रिंग मिलानकर्ता


25

कहो कि आपके पास एक स्ट्रिंग है जैसे:

abaabbbbbaabba

इनपुट स्ट्रिंग में एक निर्दिष्ट वर्ण दिखाई देने वाले समय की संख्या की गणना करें, लेकिन केवल यदि चरित्र पंक्ति में केवल एक बार प्रकट होता है । उदाहरण के लिए, यदि चरित्र है a,

abaabbbbbaabba
^ x      x   ^

कुल 2 होगा ( aaगणना नहीं होगी क्योंकि aपंक्ति में दो बार दिखाई देता है)।

यह FizzBuzz से कैसे संबंधित है?

यदि वर्ण पंक्ति में 3 (या एकाधिक 3) बार, या 5 (या 5 में से कई बार) प्रकट होता है, तो काउंटर को इसके बजाय घटाया जाता है। यदि यह 3 और 5 बार दोनों में से एक है , तो काउंटर अभी भी बढ़ा हुआ है। याद रखें कि यदि काउंटर केवल पंक्ति में एक बार दिखाई देता है, तो काउंटर को भी बढ़ा दिया जाता है, और यह अनदेखा कर दिया जाता है यदि चरित्र पंक्ति में किसी अन्य संख्या में दिखाई देता है (ऊपर वर्णित स्थितियों के अलावा)।

पुनः मिलान करने के लिए, यदि स्ट्रिंग मिलान करने के लिए है a,

input            counter (explanation)

a                 1 (single occurence)
aaa               -1(multiple of 3)
aaaaa             -1(multiple of 5)  
aaaaaaaaaaaaaaa   1 (multiple of 15)
aa                0 (none of the above)

aba               2 (two single instances)
aaba              1 (one single occurence(+1) and one double occurence(ignored))
aaaba             0 (one single occurence(+1) and one triple (-1)
aaaaaa            -1 (six is a multiple of three)

संदर्भ (ungolfed) जावा में कार्यान्वयन:

import java.util.Scanner;
import java.util.regex.*;

public class StrMatcher {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in); //Scanner to get user input
        int total = 0;//Running total of matches

        System.out.println("Enter a string: ");
        String strBeingSearched = sc.nextLine(); //String that will be searched

        System.out.println("Enter string to match with: ");
        String strBeingMatched = sc.nextLine(); //Substring used for searching

        //Simple regex matcher
        Pattern pattern = Pattern.compile("(" + strBeingMatched + ")+");
        Matcher matcher = pattern.matcher(strBeingSearched);

        while(matcher.find()){  //While there are still matches

            int length = matcher.end() - matcher.start();
            int numberOfTimes = length/strBeingMatched.length();//Calculate how many times in a row the string is matched

            if((numberOfTimes == 1)||((numberOfTimes % 3 == 0) && (numberOfTimes % 5 == 0))){
                total++; //Increment counter if single match or divisible by 15
            } else if((numberOfTimes % 3 == 0)||(numberOfTimes % 5 == 0)) {
                total--; //Decrement counter if divisible by 3 or 5 (but not 15)
            }

            strBeingSearched = strBeingSearched.substring(matcher.end());
            matcher = pattern.matcher(strBeingSearched); //Replace string/matcher and repeat
        }

        System.out.println(total);
    }   
}
  • खोजे जाने वाले तार की लंबाई कोई भी हो सकती है, लेकिन पैटर्न केवल एक ही वर्ण का होगा।
  • न ही स्ट्रिंग में रेगेक्स विशेष वर्ण होंगे।
  • यह ; बाइट्स जीत में सबसे छोटा कार्यक्रम।
  • कोई मानक खामियां नहीं हैं।

3
यदि आप कुछ और परीक्षण उदाहरण प्रदान कर सकते हैं तो यह उपयोगी होगा। विशेष रूप से वे जहां अनुक्रम में एक से अधिक अक्षर हैं।
रीटो कोराडी

मैंने कुछ मामले जोड़े- उम्मीद है कि इससे मदद मिलेगी। मुझे बताएं कि क्या मुझे और मामलों की जरूरत है- पीपीसीजी में यह मेरा पहला मौका है।
डैनियल एम।

मैं आवश्यकताओं को बदल दूँगा ताकि अनुक्रम केवल एक ही चरित्र हो, क्योंकि कार्यान्वयन बहुत अधिक समान है, लेकिन कम भ्रामक है।
डैनियल एम।

यह 1-विरल प्रश्न जैसा है लेकिन FizzBuzz के साथ
ev3commander

जवाबों:


32

फंकिटॉन , 1840 बाइट्स

धिक्कार है, यह भाषा अजेय है।

यह प्रोग्राम इनपुट के पहले चरित्र के लिए खोज करने के लिए चरित्र होने की उम्मीद करता है, और इनपुट के बाकी के माध्यम से स्ट्रिंग को खोजने के लिए बनाता है। इसका मतलब है कि इनपुट में aaabaखोज करेंगे (और इस प्रकार आउटपुट 1)। आप उन्हें एक नई रेखा या स्थान के साथ अलग कर सकते हैं ( ) लेकिन केवल इसलिए कि अतिरिक्त नई पंक्ति / स्थान से आउटपुट पर कोई फर्क नहीं पड़ता।aaabaa aaba

यदि आप $('pre').css('line-height',1)अपने ब्राउज़र कंसोल में निष्पादित करते हैं, तो हमेशा की तरह, आप एक अच्छा दिखने वाला प्रतिपादन (लाइन रिक्ति के बिना) प्राप्त कर सकते हैं ।

      ┌───┐
      │╓─╖└─────────────┐
      └╢³╟┐    ┌─────┐ ┌┴┐╓─╖
┌─────┐╙─╜└────┤┌─╖ ┌┴╖│┌┘║¹║
│     ├───────┐└┤²╟─┤·╟┘│ ╙┬╜╔═══════╗
│    ┌┴╖╔═╗┌─╖├┐╘╤╝ ╘╤╝┌┘  └┬╢2097151║
│    │♭║║5╟┤%╟┘└─┴──┐│┌┘┌───┘╚═══════╝
│    ╘╤╝╚═╝╘╤╝╔═╗┌─╖│││┌┴┐┌────┐
│    ┌┴╖   ┌┘ ║3╟┤%╟┘││└┬┘│╔══╗└┐
│  ┌─┤·╟─┐ │  ╚═╝╘╤╝ │└┐  │║21╟┐│
│  │ ╘╤╝ ├─┘┌─────┘  └┐└┐ │╚══╝│└─┐
│ ┌┴╖┌┴╖┌┴╖┌┴╖┌─╖    ┌┴╖│ │┌─╖┌┴─╖│
│┌┤·╟┤?╟┤?╟┤?╟┤+╟────┤³║│ └┤²╟┤>>║└──┐
││╘╤╝╘╤╝╘╤╝╘╤╝╘╤╝    ╘╤╝│  ╘╤╝╘╤═╝╓─╖│
││ │ ┌┴╖┌┴╖┌┴╖┌┴╖╔═╗ ┌┴╖│  ┌┴╖ ├──╢²╟┤
││ └─┤·╟┤·╟┤?╟┤·╟╢1║┌┤·╟┘  │♯║┌┴╖ ╙─╜│
│└──┐╘╤╝╘╤╝╘╤╝╘╤╝╚═╝│╘╤╝   ╘╤╝│¹║┌───┘
└──┐│╔╧╗ └┬─┘ ┌┴╖   │┌┴─╖   │ ╘╤╝│
   ││║1║ ┌┴┐┌─┤?╟───┴┤>>╟┐ ┌┴╖┌┴╖│
   ││╚═╝ └┬┘│ ╘╤╝    ╘══╝│┌┤?╟┤=║│
   │└────┐│╔╧╗     ┌─────┘│╘╤╝╘╤╝│
╔═╗└────┐│├╢0║╔══╗┌┴╖┌─╖ ╔╧╗   └─┘
║ ║     │└┘╚═╝║21╟┤×╟┤♯╟┐║0║
╚╤╝     └──┐  ╚══╝╘═╝╘═╝│╚═╝
 │┌──┴────╖└────────────┘
 ││int→str║
 │╘══╤════╝
┌┴─╖┌┴╖┌─╖╔╗
│>>╟┤³╟┤¹╟╢║
╘═╤╝╘═╝╘═╝╚╝
╔═╧╗
║21║
╚══╝

(1840 बाइट्स जब यूटीएफ -16 के रूप में एन्कोड किया गया।)

व्याख्या

  • ¹ एक स्ट्रिंग का पहला चरित्र लौटाता है।
  • ²किसी दिए गए स्ट्रिंग की शुरुआत में एक चरित्र की घटनाओं की संख्या को गिना जाता है। उदाहरण के लिए, चरित्र दिया aऔर स्ट्रिंग aaba, यह 2. के लिए देता है aऔर baa, यह 0 देता है।
  • ³²शुरुआत में वर्णों की संख्या प्राप्त करने के लिए कॉल करता है, यह जांचता है कि क्या संख्या 3 और 5 से विभाज्य है और क्या यह 1 के बराबर है और उचित वेतन वृद्धि / गिरावट को निर्धारित करता है। यह स्ट्रिंग की शुरुआत से एक अतिरिक्त चरित्र को भी हटाता है (जैसे दिया गया aaabbaयह 3 + 1 = 4 वर्णों को हटाता है, देता है ba)। फिर यह खुद को छोटी स्ट्रिंग के साथ पुनरावर्ती कहता है और परिणाम जोड़ता है।
  • मुख्य कार्यक्रम ¹इनपुट से पहले चरित्र को हटाने के लिए कहता है ³और अलग-अलग तर्कों के रूप में उस चरित्र और बाकी स्ट्रिंग के साथ कॉल करता है।

10
मैं कभी भी Funciton को आगे नहीं बढ़ाऊंगा।
orlp

14

CJam, 40 36 35 32 30 बाइट्स

0llcf=e`::*{(_g+Y13515Yb+=(+}/

1 बाइट को बंद करने के लिए @ मार्टिनबटनर को धन्यवाद!

2 बाइट को बंद करने के लिए @AndreaBiondo को धन्यवाद और 3 और के लिए मार्ग प्रशस्त!

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

यह काम किस प्रकार करता है

0          e# Push a 0 (accumulator).
l          e# Read a line from STDIN.
lc         e# Read a second line and keep only the first character.
f=         e# Check each character from the first line for equality.
           e# This results in 1 for the specified character and 0 for others.
e`         e# Perform run-length encoding.
::*        e# Multiply each element by its number of repetitions.
{          e# For each remaining integer I:
  (_!      e#   Subtract 1, copy and push sign(I-1).
  +        e#   Add the results.
           e#     If I == 0, I-1 + sign(I-1) =  -1 + -1 = -2.
           e#     If I == 1, I-1 + sign(I-1) =   0 +  0 =  0.
           e#     If I >= 2, I-1 + sign(I-1) = I-1 +  1 =  I.
  Y        e#   Push 2.
  13515Yb  e#   Convert 13515 into the array of its binary digits.
  +        e#   Concatenate 2 and the array.
           e#   This pushes [2 1 1 0 1 0 0 1 1 0 0 1 0 1 1].
  =        e#   Retrieve the digit at (index I-1 + sign(I-1))%15.
           e#     If I == 0, this pushes 1.
           e#     Else, if I == 1, this pushes 2.
           e#     Else, if I%15 == 0, this pushes 2.
           e#     Else, if I%3==0 or I%5==0, this pushes 0.
           e#     Else, this pushes 1.
  (        e#   Decrement the result.
  +        e#   Add it to the accumulator.
}/         e#

आप बेस-इनकोडेड लुकअप टेबल और मॉड्यूलर इंडेक्सिंग के साथ एक और 2 बाइट्स बचा सकते हैं: llcf=e`::*0-{(_!\6563282Zb:(=}%1b33 बाइट्स हैं।
एंड्रिया बियोनडो

@AndreaBiondo जिसने वास्तव में 3 बाइट्स बचाए हैं। धन्यवाद!
डेनिस

7

सी, 160 126 125 119 114 109 104 100 बाइट्स

main(int q,char **z){int i=0,t=0,s=0,a=z[1][0],c;do{if((c=z[2][i])!=a){s+=(!!t)*((t==1)-!(t%3)-!(t%5)+3*!(t%15));t=0;}else{++t;}++i;}while(c);printf("%d\n",s);}

शायद बेहतर बनाया जा सकता है ... यह कमांड लाइन तर्कों से इनपुट लेता है (पहला तर्क पैटर्न है, दूसरा स्ट्रिंग है)। NULL char (\ x00) के पैटर्न की खोज का समर्थन नहीं करता है।

संपादित करें ** 126 125 119 114 109 104 100 बाइट्स **: डेनिस के सुझावों, और कुछ अतिरिक्त विचारों को शामिल करने के बाद (! हटाया बाकी खंड है, जबकि एक ही बयान और के बजाय इस्तेमाल किया घटाव में = संयुक्त)। लूप के लिए अतिरिक्त अर्धविराम को भी हटा दिया (जो वास्तव में डेनिस के सुझाव का हिस्सा था)। चर 'i' और 'a' को हटाकर और भी छोटा किया।

t,s;main(c,z)char**z;{for(;c;t++)if((c=*z[2]++)-*z[1])s+=!!t*((t<2)-!(t%3)-!(t%5)+3*!(t%15)),t=-1;printf("%d",s);}

यदि और नकारात्मक ('!') ऑपरेटरों को टर्नरी ऑपरेटर को गाली देकर हटा दिया। उस बिटवाइज़ का उपयोग करके मॉड्युलैरिटी जाँच से प्रभावित होता है 'और' एक डबल && ट्रिक करता है क्योंकि बिटवाइज़ 'और' में बग होता है, और टर्नरी ऑपरेटरों के अंदर (t <2) तुलना डालते हैं। बदलकर !! t * (...) को ले जाकर !! ternary ऑपरेटर में t, इस प्रकार मुझे कोष्ठक को हटाने की अनुमति मिलती है।

यार, मैं वास्तव में इसे 100 बाइट के निशान से नीचे लाना चाहता हूं: एस

t,s;main(c,z)char**z;{for(;c;)(c=*z[2]++)-*z[1]?s+=t%15?t%3&&t%5?t<2:-1:!!t,t=0:t++;printf("%d",s);}

TATATIVE समाधान: मुझे यकीन नहीं है कि अगर इन्हें वैध माना जाएगा, लेकिन मैं प्रिंट ("% d", s) के बजाय निकास (ओं) का उपयोग करने पर 93 वर्ण तक नीचे जा सकता हूं। लेकिन तब आउटपुट दिखाई नहीं देगा, बल्कि यह एक रिटर्न कोड होगा। यदि आउटपुट वास्तव में आवश्यक है, तो मैं इसे 98 बाइट्स तक भी प्राप्त कर सकता हूं, लेकिन इसके लिए अंतिम उत्तर के साथ ही सभी मध्यवर्ती मूल्यों को प्रिंट करने की आवश्यकता होगी ...


3
प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! मैंने इसका पूरी तरह से परीक्षण नहीं किया है, लेकिन i,t,s,a;main(c,z)char**z;{a=*z[1];while(c){if((c=z[2][i])!=a)s+=(!!t)*((t<2)-!(t%3)-!(t%5)+3*!(t%15)),t=0;else++t;++i;}printf("%d",s);}साथ ही साथ काम करना चाहिए (और यह 23 बाइट्स छोटा है)।
डेनिस

ओह, एक बयान में अगर () {} खंड को मोड़ने के साथ अच्छी बात है!
टोब एर्नैक

कुछ और बाइट्स: यदि आप mainसाथ शुरू करते हैं for(a=*z[1];c;i++), तो आपको इफ {}... के आसपास की आवश्यकता नहीं है।
डेनिस

4

रूबी, 111 103 96 बाइट्स

->s,m{s.chars.chunk{|x|x}.reduce(0){|x,(c,g)|l=g.size
x+(c!=m ?0:l<2||l%15<1?1:l%3*l%5<1?-1:0)}}

यह चुनौती रूबी के लिए थी Enumerable#chunk, इसलिए मुझे यह पोस्ट करना पड़ा। :)

ऑनलाइन टेस्ट: http://ideone.com/pG4mAn

कोड बहुत सीधा है। यहाँ एक अधिक पठनीय संस्करण है: http://ideone.com/ub3siA


4

पायथन 3, 361, 300, 296, 263, 256, 237, 229, 188, 178 , 164 बाइट्स।

SOPython से तिजोरी के लिए धन्यवाद 15 बाइट्स बचाता है।
SOPython से जो किंग्टन के लिए 9 बाइट्स को सहेजा गया।
SOPython से DSM के लिए धन्यवाद 11 बाइट्स सहेजे गए।

यह मेरा जवाब प्रस्तुत करने का पहला मौका है, इसलिए मुझे यकीन है कि यह बहुत कम हो सकता है। यह इनपुट के लिए पहली प्रतिक्रिया के रूप में परीक्षण स्ट्रिंग लेता है, और दूसरे के रूप में खोज चार।

t=input()
m=input()
c=u=0
g=iter(t)
while g:
 r=next(g,0)
 if r==0:print(c);g=0
 while r==m:u+=1;r=next(g,0)
 if u:b=u%3<1;v=u%5<1;c+=((0,-1)[b|v],1)[u<2or b&v];u=0

Ungolfed संस्करण:

import sys
test = sys.argv[1]
match_char = sys.argv[2]
counter = char_counter = 0
char_generator = (c for c in test)
while char_generator:
    try:
        char = next(char_generator)
    except StopIteration:
        print(counter)
        break
    while char == match_char:
        char_counter += 1
        try:
            char = next(char_generator)
        except StopIteration:
            break
    if char_counter == 0:
        continue
    counter += 1 if char_counter == 1 or (char_counter % 3 == 0 and char_counter % 5 == 0) else -1 if char_counter % 3 == 0 or char_counter % 5 == 0 else 0
    char_counter = 0

पता चला कि मैं परीक्षण मामलों में से एक को विफल कर रहा था।



3

जावा, 146 152 143 138 139 136 बाइट्स

  1. एक बग तय किया।
  2. %3&%5चेकों के लिए बिटवाइज़ ऑपरेटर पर स्थानांतरित किए गए ऑपरेशन, स्थानांतरित किए गए ।
  3. छोटा i<2तुलना।
  4. एक बग फिक्स्ड ( %3&%5विचार के रूप में काम नहीं कर रहा है)।
  5. @ W0lf के रूबी उत्तर में देखे गए गुणन शॉर्टकट का उपयोग किया ।

BiFunction<String, String, Integer>जावा 8 में एक के रूप में लागू किया गया है , मुझे बताएं कि क्या यह एक पूर्ण कार्यक्रम होना आवश्यक है (या यदि मैं java.util.regexनीचे दिए गए पैकेज उपसर्ग को छोड़ भी सकता हूं )।

ऊपर की बाइट की गणना में नीचे दी गई नई पंक्ति शामिल नहीं है, जो इस साइट पर प्रारूपण प्रयोजनों के लिए बस जोड़ी गई है।

(a,b)->java.util.regex.Pattern.compile("[^"+b+"]").splitAsStream(a)
.mapToInt(v->v.length()).map(i->i<2?i:i%15<1?1:i%3*i%5<1?-1:0).sum();

रफ स्पष्टीकरण:

  1. रेगेक्स को उस पैटर्न के साथ लागू करें जो मेल नहीं खाता b, यानी "[^"+b+"]"
  2. प्रत्येक टोकन की लंबाई प्राप्त करें (जैसे "a" -> 1)।
  3. वांछित मानचित्रण को लागू करें -1, 0और 1
  4. sum() जवाब पाने के लिए।

2

जावास्क्रिप्ट, 206 बाइट्स

function f(n,e){var t=n.match(new RegExp(e,"g")).length,g=n.match(new RegExp(e+"{2,}","g"));return null!==g&&g.forEach(function(n){t-=n.length,n.length%15==0?t+=1:(n.length%3==0||n.length%5==0)&&(t-=1)}),t}

विस्तारित:

function funkyFizzb(n, c) {
    var score = n.match(new RegExp(c, "g")).length; 
    var repeatOccurence = n.match(new RegExp(c + "{2,}", "g"));

    if(repeatOccurence !== null) {
        repeatOccurence.forEach(function(v,i){
            // remove multiple occurrence counts
            score -= v.length;

            if(v.length % 15 == 0) {
                score += 1;
            }

            else if(v.length % 3 == 0 || v.length % 5 == 0) {
                score -= 1;
            }
        });
    }

    return score;
};

स्पष्टीकरण:

मैं एक वर्ण प्रकट होने के लिए रेगेक्स का उपयोग कर रहा हूं, फिर समूह में दिखाई देने वाले सभी समय से घटाएं। अंत में, मैं समूहों के माध्यम से जाता हूं और फ़िज़ बज़ को बढ़ा / घटाता हूं।

प्रश्न में दिए गए परीक्षण मामलों को पास करता है:

funkyFizzb("aaa", "a") => -1

और इसी तरह


निकालें new, के execबजाय का उपयोग करें match, और उपनाम length, और आप अच्छा होना चाहिए।
मामा फन रोल

2

पर्ल, 82 65 63 59 बाइट्स

58 बाइट्स + 1 बाइट कमांड लाइन पैरामीटर

विशेष रूप से छोटा नहीं है, लेकिन यह एक शुरुआत है - इसे छोटा करना जारी रखेगा।

$l=y///c,$i+=!($l>1&&$l%15)||-!($l%3*$l%5)for/$^I+/g;$_=$i

मान लिया -iजा सकता है कि इनपुट स्ट्रिंग को एक उदाहरण उपयोग के लिए निम्नानुसार दिया जा सकता है:

echo "aaabaaa" | perl -pi"a" entry.pl


0

gawk, 140

p=$2{b="[^"$1"]";for($0=2;$i-->0;){sub("^"b"*",_,p);p=substr(p,$++i=match(p,b))}for($i=length(p);$++j;)s+=$j%5?$j%3?$j<2:-1:$j%3?-1:1}$0=s""

इनपुट के रूप में "चार अंतरिक्ष स्ट्रिंग", जैसे

echo "x axxbxcxdexxxfffghixxj" | awk 'p=$2{b="[^"$1"]";for($0=2;$i-->0;){sub("^"b"*",_,p);p=substr(p,$++i=match(p,b))}for($i=length(p);$++j;)s+=$j%5?$j%3?$j<2:-1:$j%3?-1:1}$0=s""'

Ungolfed

p=$2{
    #i=j=s=0                # make reusable
    b="[^"$1"]";           # pattern "not matching char"
    $0=2;                  # help starting the while loop
    while($i-->0){         # match didn't return -1; dec stack top
        sub("^"b"*",_,p);  # remove not matching chars at head of string
        $++i=match(p,b);   # push index of first occurence of not matching char
        p=substr(p,$i)     # remove matching chars from head of string
    };
    $i=length(p);          # get last value
    while($++j)            # sometimes last value on stack is 0
        s+=$j%5?$j%3?$j<2:-1:$j%3?-1:1

        # if $j%5!=0
        #   if $j%3!=0     (not divisible by 5 AND 3)
        #     s+=($j==1)   (single character)
        #   else           (divisible by 3 but not by 5)
        #     s-=1
        # else             (divisble by 5)
        #   if $j%3!=0
        #     s-=1         (divisible by 5 but not by 3)
        #   else
        #     s+=1         (divisible by 3 AND 5)

}$0=s"" # output

0

पायथ, 27 बाइट्स

sm|!JPdx,02+}3J}5JhMf}zTrw8

परीक्षण सूट

उदाहरण के लिए इनपुट:

a
aaaba

स्पष्टीकरण:

sm|!JPdx,02+}3J}5JhMf}zTrw8
                               z = input() (The match character)
                         w     input() (The string)
                        r 8    Run length encode
                    f}zT       Filter for the runs z is in.
                  hM           Take their lengths
 m|                            Map (d) to the logical or of
    Pd                         Find all prime factors of the current run length
   J                           Save them in J
  !                            Take the logical negation. This will be 1 if
                               d is 1, and 0 otherwise.
           +}3J                If d wasn't 1, add up 1 if 3 is in J
               }5J             and 1 if 5 is in J.
       x,02                    Then, take the index of the result in [0,2]
                               so 0 -> 0, 2 -> 1, 1 -> -1 (not found)
s                              Sum up the values for each run.
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.