37

यह चुनौती मेरे ब्लॉक बिल्डिंग बोट फ्लक्स को जीतने के लिए निंजाबियरमोनकी पुरस्कार है ! ब्लैक नाइट प्रस्तुत करने के साथ चुनौती । बधाई हो NinjaBearMonkey!

यहां चुनौती काफी सरल है, लेकिन विभिन्न प्रकार के संभावित दृष्टिकोण हैं। कहानी यह है कि आइसोमेट्रिक भ्रम की दुनिया में , 6 अलग-अलग प्रकार के जीव हैं:

निनजास, संक्षिप्त N
आँसू, संक्षिप्त B
बंदर, संक्षिप्त M
NinjaBears, संक्षिप्त NB
BearMonkeys, संक्षिप्त BM
NinjaBearMonkeys, संक्षिप्त NBM

^{( NinjaBearMonkey , निश्चित रूप से, अंतिम, सबसे शक्तिशाली प्रकार है।)}

आपका काम इन जीवों की जनगणना लेना है, जब वे साइड-बाय-साइड होते हैं, अर्थात जब उनके संक्षिप्त तारों को संक्षिप्त किया जाता है। चेतावनी यह है कि आपको यह सुनिश्चित करने की आवश्यकता है कि कुछ प्राणियों के हिस्सों को अलग-अलग न गिना जाए जो कि समान दिखने वाले अलग-अलग जीव हैं। प्राणियों को इस तरह पंक्तिबद्ध किया जाएगा:

NBM1 निंजाबियरमंकी और 0 अन्य प्राणियों का कोई भी उदाहरण है।
NBइसके बाद नहीं आने का कोई भी उदाहरण M1 निंजाबियर और 0 अन्य जीव हैं।
किसी भी उदाहरण से BMपहले नहीं Nहै 1 BearMonkey और 0 अन्य जीव।
अन्यथा, के उदाहरण N, Bऔर Mएकल निन्जा, भालू, और बंदरों क्रमशः रहे हैं।

पंक्ति को बाएं से दाएं पढ़ा जाता है।

तो, उदाहरण के लिए, प्राणियों की पंक्ति में NBMMBNBNBM, 0 निन्जा, 1 भालू, 1 बंदर, 1 निंजाबियर, 0 भालूमोनकी, और 2 निंजाबोरोनिक्स हैं।

चुनौती

एक प्रोग्राम या समारोह है कि वर्णों की स्ट्रिंग में लेता लिखें N, Bऔर M, और प्रिंट या रिटर्न कैसे प्राणियों के 6 प्रकारों में से प्रत्येक के कई यह में मौजूद हैं।

आउटपुट में फॉर्म होना चाहिए

#N #B #M #NB #BM #NBM

प्रत्येक #चिन्ह की जगह संबंधित प्राणी गणना के साथ । सभी 6 गणनाओं को रिक्त स्थान द्वारा अलग-अलग दिखाया जाना चाहिए, भले ही वे 0. हों। हालांकि, वे किसी भी क्रम में हो सकते हैं (जैसे #NBMपहले आ सकते हैं)।

इसके अलावा:

इनपुट स्ट्रिंग केवल अक्षर शामिल होंगे N, Bऔर M।
यदि रिक्त स्ट्रिंग इनपुट है, तो सभी गणना 0 हैं।
आउटपुट में वैकल्पिक रूप से एक एकल अग्रणी और / या अनुगामी स्थान हो सकता है, और / या एक एकल अनुगामी न्यूलाइन हो सकती है।

बाइट्स में सबसे कम सबमिशन जीतता है।

उदाहरण

इनपुट: NB
आउटपुट:0N 0B 0M 1NB 0BM 0NBM

इनपुट: NBM
आउटपुट:0N 0B 0M 0NB 0BM 1NBM

इनपुट: NBMMBNBNBM(ऊपर से उदाहरण)
आउटपुट:0N 1B 1M 1NB 0BM 2NBM

इनपुट: MBNNBBMNBM
आउटपुट:1N 1B 1M 1NB 1BM 1NBM

इनपुट: NNNMNBMMBMMBMMMNBMNNMNNNBNNNBNBBNBNMMNBBNBMMBBMBMBBBNNMBMBMMNNNNNMMBMMBM
आउटपुट:17N 6B 14M 5NB 8BM 3NBM

code-golf string

— केल्विन के शौक
स्रोत

53

मैं इस चुनौती का अनुमोदन करता हूं।

— NinjaBearMonkey

बस पुष्टि करने के लिए: यदि आपके पास 2 निंजाबियरमोनकीज़ थे, तो आप एक लाइन नहीं बना सकते हैं? क्योंकि वे एक दूसरे के बगल में नहीं खड़े हो सकते?

— एलन कैंपबेल

3

@AlanCampbell No. NBMNBMपूरी तरह से वैध इनपुट होगा। इसे बाएं से दाएं पढ़ने पर स्पष्ट रूप से 2 निंजाबियरमॉन्की हैं।

— केल्विन के शौक

20

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

 f|pd+/zTT=:zTd_.:"NBM

1 बाइट को बचाने के लिए काफी आसान तरीका, @Jakube के लिए धन्यवाद।

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

FN_.:"NBM")pd+/zNN=:zNd

प्रदर्शन।

अनुगामी स्थान और कोई अनुगामी न्यूलाइन के साथ रिवर्स ऑर्डर में प्रिंट।

.:"NBM")सभी सबस्ट्रिंग हैं, _उन्हें सही क्रम में /zNरखता है, घटनाओं को गिनता है, और =:zNdएक जगह के साथ प्रश्न में स्ट्रिंग की प्रत्येक घटना को प्रतिस्थापित करता है।

FN_.:"NBM")pd+/zNN=:zNd
FN                         for N in                            :
  _                                 reversed(                 )
   .:     )                                  substrings(     )
     "NBM"                                              "NBM"
           pd              print, with a space at the end,
              /zN          z.count(N)
             +   N                    + N
                  =:zNd    replace N by ' ' in z.

— isaacg
स्रोत

23

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

f=s=>'NBM BM NB M B N'.replace(/\S+/g,e=>(i=0,s=s.replace(RegExp(e,'g'),_=>++i))&&i+e)

(मुझे सिर्फ इसका जवाब देना था।) यह प्रत्येक विकल्प के माध्यम से जाता NBMहै, जो लंबी अवधि के साथ शुरू होता है, जो उच्च प्राथमिकता लेता है। यह उस विशेष स्ट्रिंग की प्रत्येक घटना को खोजता है और इसे हटा देता है (इस मामले में इसे वर्तमान गणना के साथ बदल दिया जाता है ताकि यह फिर से मेल न खाए)। यह अंत में प्रत्येक प्रतिस्थापन को गणना + स्ट्रिंग के साथ बदल देता है।

यह स्टैक स्निपेट किसी भी ब्राउज़र से परीक्षण करना आसान बनाने के लिए उपरोक्त कोड के ईएस 5 समकक्ष में लिखा गया है। यह थोड़ा असम्बद्ध कोड भी है। यूआई हर कीस्ट्रोके साथ अपडेट करता है।

f=function(s){
  return'NBM BM NB M B N'.replace(/\S+/g,function(e){
    i=0
    s=s.replace(RegExp(e,'g'),function(){
      return++i
    })
    return i+e
  })
}

run=function(){document.getElementById('output').innerHTML=f(document.getElementById('input').value)};document.getElementById('input').onkeyup=run;run()

<input type="text" id="input" value="NBMMBNBNBM" /><br /><samp id="output"></samp>

स्निपेट का विस्तार करें

— NinjaBearMonkey
स्रोत

क्या आप रेगेक्स भाग को बदल सकते हैं 'NBM<newline>BM<newline>...<newline>N'.replace(/./g, ...)', जहां <newline>एस शाब्दिक नई रूपरेखाएँ हैं और 'एस बैकटिक्स हैं, जो ईएस 6 टेम्पलेट स्ट्रिंग बनाते हैं? रेगेक्स में दो बाइट्स बचाता है ( .नईलाइनों से मेल नहीं खाता)।

— व्रचगिन

@Chargin दुर्भाग्य से, नहीं, क्योंकि आउटपुट को अंतरिक्ष-पृथक होना चाहिए।

— निंजाबेरोनकी

17

अजगर 2, 78

n=input()
for x in"NBM BM NB M B N".split():n=`n`.split(x);print`len(n)-1`+x,

Vioz- के उत्तर का एक प्रकार । अजगर 2 स्ट्रिंग प्रतिनिधित्व के साथ मज़ा!

अप्रत्यक्ष रूप से सबस्ट्रिंग की गणना को इस पर विभाजित करके, भागों को गिनकर, और घटाकर 1. एक भराव प्रतीक द्वारा सब्सट्रिंग्स को प्रतिस्थापित करने के बजाय, splitउत्पादित की गई सूची द्वारा स्ट्रिंग को प्रतिस्थापित करता है । फिर, जब हम इसका स्ट्रिंग प्रतिनिधित्व लेते हैं, तो भागों को रिक्त स्थान और अल्पविराम द्वारा अलग किया जाता है।

— XNOR
स्रोत

5

यह पागलपन है! उत्कृष्ट रूप से पागल, लेकिन अभी भी पागल है।

— Sp3000

अच्छा काम! कि :) के बारे में सोच नहीं था

— Kade

14

रूबी, 166 80 72 68 वर्ण

f=->s{%w(NBM BM NB M B N).map{|t|c=0;s.gsub!(t){c+=1};c.to_s+t}*' '}

स्पष्टीकरण:

उल्टी गिनती होती है। ऐसा इसलिए है क्योंकि नन्हें नन्हे और भालू और बंदर कम उम्र के लोगों के बारे में अधिक जानकारी लेते हैं।
इसके लिए NBM, BMऔर NB, अनुक्रमों को gsub!मूल स्ट्रिंग से बाहर डी ब्लॉक किया जाता है ताकि यह पता लगाया जा सके कि इनमें से कितने अनुक्रम मौजूद हैं (हाँ, फ़ंक्शन इसके तर्क को संशोधित करता है)।
- हालांकि, वे कुछ भी नहीं के साथ बदला नहीं जा सकता क्योंकि अन्यथा BNBMMरूप में गिना जाएगा NBMऔर BMके बजाय B, NBMहै, और M(क्योंकि जब NBMहटा दिया जाएगा, इसे रखा जाएगा Bऔर Mएक साथ और वहाँ अलग करने के लिए एक तरह से नहीं होगा)। मूल रूप से मैंने एक एकल चरित्र स्ट्रिंग ( .gsub!('NBM'){c+=1;?|}) लौटाया , लेकिन मुझे एहसास हुआ कि मैं सिर्फ +=(जो एक संख्या है, इसलिए यह किसी का भी नहीं हो सकता है N B M) का परिणाम लौटा सकता है ।
के लिए M, Bऔर N, मैं बस countउनमें से कितने स्ट्रिंग में हैं (उन्हें हटाने की आवश्यकता नहीं है gsub!)। अब यह एक लूप है (पता नहीं क्यों मैंने पहली बार में ऐसा नहीं सोचा था), इसलिए ये उसी तरह से किए जाते हैं।

Ostrich में इसी तरह के समाधान , 54 51 वर्ण :

:s;`NBM BM NB M B N`" /{:t0:n;s\{;n):n}X:s;nt+}%" *

दुर्भाग्य से एक वैध समाधान नहीं है, क्योंकि वर्तमान शुतुरमुर्ग संस्करण में एक बग है (जो अब तय हो गया है, लेकिन इस चुनौती के बाद पोस्ट किया गया था)।

— Doorknob
स्रोत

आप सरणी संकेतन का उपयोग करके %w(NBM BM NB M B N)और विभाजन को हटाकर 3 वर्णों को बचा सकते हैं ।

— डिकिएबॉय

@ डॉकीबॉय वास्तव में 4 वर्ण हैं; धन्यवाद!

— दरवाज़े

आह हाँ, डॉट!

— डिकिएबॉय

14

जावा, 166 162

void f(String a){String[]q="NBM-NB-BM-N-B-M".split("-");for(int i=0,c;i<6;System.out.print(c+q[i++]+" "))for(c=0;a.contains(q[i]);c++)a=a.replaceFirst(q[i],".");}

और कुछ लाइन टूटने के साथ:

void f(String a){
    String[]q="NBM-NB-BM-N-B-M".split("-");
    for(int i=0,c;i<6;System.out.print(c+q[i++]+" "))
        for(c=0;a.contains(q[i]);c++)
            a=a.replaceFirst(q[i],".");
}

यह बहुत सरलता से काम करता है। टोकन पर बस लूप करें, उन्हें डॉट्स के साथ प्रतिस्थापित करें और जब तक इनपुट में कुछ हो तब तक गिनें। सबसे पहले बड़े लोगों को गिना जाता है, इसलिए छोटे लोग इसे गड़बड़ नहीं करते हैं।

मैंने मूल रूप से सभी को एक साथ बदलने और लंबाई में अंतर को गिनने की कोशिश की, लेकिन इसने कुछ और चरित्रों को लिया:

— Geobits
स्रोत

2

एक जावा देव के रूप में, मैं इसे कम करना चाहता हूं और एक बदलाव के लिए जावा जीतना देखता हूं। थोड़ी देर के लिए इसे घूरने के बाद मुझे अभी तक इसे छोटा बनाने का तरीका नहीं मिला है।

— डेडशेक्स

1

खैर यह निश्चित रूप से कुल मिलाकर जीतने वाला नहीं है । वर्तमान नेता 22 बाइट्स है और उस आकार में जावा में कुछ भी सार्थक करने का कोई तरीका नहीं है। मेरा printlnकथन अकेले इससे बड़ा है। मैं इसके साथ संतुष्ट हूँ, यद्यपि: D

— जियोबिट्स

1

मैं थोड़ा देर हो रही है, लेकिन मैं एक तरह से ... परिवर्तन पाया String q[]=करने के लिएString[]q=

— DeadChex

1

अच्छा! विश्वास नहीं कर सकता कि मैं चूक गया, यह मेरी चीजों की मानक सूची पर है :)

— Geobits

मैंने इसे केवल जावा गोल्फ के रूप में कोड गोल्फ में लाने की कोशिश करने के बाद खोजा, मुझे आपके द्वारा किए गए कुछ सामान पर काफी आश्चर्य हुआ

— डेडचेक्स

11

CJam, 36 32 31 बाइट्स

l[ZYX]"NBM"few:+{A/_,(A+S@`}fA;

1 बाइट को बंद करने के लिए @ ऑप्टिमाइज़र का धन्यवाद।

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

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

l                                e# Read a line L from STDIN.
 [ZYX]"NBM"                      e# Push [3 2 1] and "NBM".
           few                   e# Chop "NBM" into slices of length 3 to 1.
              :+                 e# Concatenate the resulting arrays of slices.
                {          }fA   e# For each slice A:
                 A/              e#   Split L at occurrences of A.
                   _,(           e#   Push the numbers of resulting chunks minus 1.
                      A+         e#   Append A.
                        S        e#   Push a space.
                         @`      e#   Push a string representation of the split L.
                              ;  e# Discard L.

— डेनिस
स्रोत

N*-> `पर्याप्त होना चाहिए।

— ऑप्टिमाइज़र

@Optimize: यह अच्छी तरह से काम करता है। धन्यवाद।

— डेनिस

7

आर, 153 134 118

यह वास्तव में जल्दी हो गया, लेकिन उम्मीद है कि मैं कुछ शेव कर पाऊंगा। इनपुट STDIN है और STDOUT में आउटपुट है।

परिवर्तन का संपादन करें । विभाजन स्ट्रिंग और गिनती भागों से छुटकारा पा लिया। अब मैं भागों को एक स्ट्रिंग से बदल देता हूं जो भाग से छोटा होता है। स्ट्रिंग लंबाई के बीच का अंतर आउटपुट के लिए एकत्र किया जाता है।

N=nchar;i=scan(,'');for(s in scan(,'',t='NBM BM NB M B N'))cat(paste0(N(i)-N(i<-gsub(s,strtrim('  ',N(s)-1),i)),s),'')

व्याख्या

N=nchar;
i=scan(,'');                     # Get input from STDIN
for(s in scan(,'',t='NBM BM NB M B N'))  # Loop through patterns
  cat(                           # output
    paste0(                      # Paste together
      N(i) -                     # length of i minus
      N(i<-gsub(                 # length of i with substitution of
        s,                       # s
        strtrim('  ',N(s)-1)     # with a space string 1 shorter than s
        ,i)                      # in i
      ),
      s)                         # split string
  ,'')

परीक्षण चालन

> N=nchar;i=scan(,'');for(s in scan(,'',t='NBM BM NB M B N'))cat(paste0(N(i)-N(i<-gsub(s,strtrim('  ',N(s)-1),i)),s),'')
1: NNNMNBMMBMMBMMMNBMNNMNNNBNNNBNBBNBNMMNBBNBMMBBMBMBBBNNMBMBMMNNNNNMMBMMBM
2: 
Read 1 item
Read 6 items
3NBM 8BM 5NB 14M 6B 17N 
> N=nchar;i=scan(,'');for(s in scan(,'',t='NBM BM NB M B N'))cat(paste0(N(i)-N(i<-gsub(s,strtrim('  ',N(s)-1),i)),s),'')
1: NBMMBNBNBM
2: 
Read 1 item
Read 6 items
2NBM 0BM 1NB 1M 1B 0N 
>

— MickyT
स्रोत

7

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

jd+Ltl=zc`zd_.:"NBM

यह @ isaacg के Pyth समाधान और @ xnor के अविश्वसनीय पायथन ट्रिक का मिश्रण है।

इसे ऑनलाइन आज़माएं: प्रदर्शन या टेस्ट हार्नेस

व्याख्या

jd+Ltl=zc`zd_.:"NBM   implicit: z = input string
             .:"NBM   generate all substrings of "NBM"
            _         invert the order
  +L                  add left to each d in ^ the following:
         `z             convert z to a string
        c  d            split at d
      =z                assign the resulting list to z
    tl                  length - 1
jd                    join by spaces and implicit print

— Jakube
स्रोत

6

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

b->for s=split("NBM BM NB M B N") print(length(matchall(Regex(s),b)),s," ");b=replace(b,s,".")end

यह एक अनाम फ़ंक्शन बनाता है जो इनपुट के रूप में एक स्ट्रिंग लेता है और परिणाम को एक एकल अनुगामी स्थान और कोई अनुवर्ती रेखा के साथ STDOUT में प्रिंट करता है। इसे कॉल करने के लिए, इसे एक नाम दें, उदा f=b->...।

असंगठित + स्पष्टीकरण:

function f(b)
    # Loop over the creatures, biggest first
    for s = split("NBM BM NB M B N")

        # Get the number of creatures as the count of regex matches
        n = length(matchall(Regex(s), b))

        # Print the number, creature, and a space
        print(n, s, " ")

        # Remove the creature from captivity, replacing with .
        b = replace(b, s, ".")
    end
end

उदाहरण:

julia> f("NBMMBNBNBM")
2NBM 0BM 1NB 1M 1B 0N 

julia> f("NNNMNBMMBMMBMMMNBMNNMNNNBNNNBNBBNBNMMNBBNBMMBBMBMBBBNNMBMBMMNNNNNMMBMMBM")
3NBM 8BM 5NB 14M 6B 17N

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

4

पायथन 2, 93 88 89 84 बाइट्स

सीधा-सीधा तरीका अपनाते हुए।

def f(n):
 for x in"NBM BM NB M B N".split():print`n.count(x)`+x,;n=n.replace(x,"+")

ऐसे करें कॉल:

f("NBMMBNBNBM")

आउटपुट ऐसा है:

2NBM 0BM 1NB 1M 1B 0N

— Kade
स्रोत

आप के बाद अंतरिक्ष निकाल सकते हैं in।

— ईसैक

पायथन 2 में, आप `x` के साथ एक स्ट्रिंग प्रतिनिधित्व में बदल सकते हैं।

— xnor

4

एसएएस, 144 142 139 129

data;i="&sysparm";do z='NBM','NB','BM','N','B','M';a=count(i,z,'t');i=prxchange(cats('s/',z,'/x/'),-1,i);put a+(-1)z@;end;

उपयोग (7 बाइट्स sysparm के लिए जोड़ा गया):

$ sas -stdio -sysparm NNNMNBMMBMMBMMMNBMNNMNNNBNNNBNBBNBNMMNBBNBMMBBMBMBBBNNMBMBMMNNNNNMMBMMBM << _S
data;i="&sysparm";do z='NBM','NB','BM','N','B','M';a=count(i,z,'t');i=prxchange(cats('s/',z,'/x/'),-1,i);put a+(-1)z@;end;
_S

या

%macro f(i);i="&i";do z='NBM','NB','BM','N','B','M';a=count(i,z,'t');i=prxchange(cats('s/',z,'/x/'),-1‌,i);put a+(-1)z@;end;%mend;

उपयोग:

data;%f(NNNMNBMMBMMBMMMNBMNNMNNNBNNNBNBBNBNMMNBBNBMMBBMBMBBBNNMBMBMMNNNNNMMBMMBM)

परिणाम:

3NBM 5NB 8BM 17N 6B 14M

— तला हुआ अंडा
स्रोत

के cats('s/',z,'/x/')स्थान पर उपयोग करके आप कुछ बाइट्स बचा सकते हैं 's/'||strip(z)||'/x/'।

— एलेक्स ए।

1

नाइस, यह काफी हद तक वापस 139 :)

— फ्राइड एग

1

126 बाइट्स:

macro a i="&sysparm";do z='NBM','NB','BM','N','B','M';a=count(i,z,'t');i=prxchange(cats('s/',z,'/x/'),-1,i);put a+(-1)z@;end;%

— एलेक्स ए।

1

122:

data;i="&sysparm";do z='NBM','NB','BM','N','B','M';a=count(i,z,'t');i=prxchange(cats('s/',z,'/x/'),-1,i);put a+(-1)z@;end;

। चूंकि आप पहले से पढ़ रहे हैं sysparm, इसलिए आप इसे केवल डेटा चरण के रूप में चला सकते हैं। और अगर आप बैच में चल रहे हैं, तो आपको जरूरत नहीं है run;।

— एलेक्स ए।

1

लेकिन आप एक आधुनिक शैली के मैक्रो का उपयोग करके 129 प्राप्त कर सकते हैं जो कमांड लाइन तर्क से नहीं पढ़ता है:

%macro a(i);i="&i";do z='NBM','NB','BM','N','B','M';a=count(i,z,'t');i=prxchange(cats('s/',z,'/x/'),-1,i);put a+(-1)z@;end;%mend;

— एलेक्स ए।

3

PHP4.1, 92 बाइट्स

कम से कम एक नहीं है, लेकिन आप PHP से और क्या उम्मीद करेंगे?

इसका उपयोग करने के लिए, COOKIE, POST, GET, SESSION पर एक कुंजी सेट करें ...

<?foreach(split(o,NBMoNBoBMoMoBoN)as$a){echo count($T=split($a,$S))-1,"$a ";$S=join('',$T);}

Apporach बुनियादी है:

जीवों के नाम में स्ट्रिंग विभाजित करें
गणना करें कि कितने तत्व हैं
घटाव 1 (एक खाली स्ट्रिंग 1 तत्व के साथ एक सरणी देगा)
गिनती और प्राणी का नाम आउटपुट
एक खाली तार (जो स्ट्रिंग को कम करेगा और अंतिम प्राणी को हटा देगा) का उपयोग करके इसे एक साथ मिलाएं

आसान है, है ना?

— इस्माइल मिगुएल
स्रोत

2

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

बस एक सीधे आगे दृष्टिकोण, कुछ भी नहीं फैंसी

o="";r=/NBM|NB|BM|[NMB]/g;g={};for(k in d=(r+prompt()).match(r))g[d[k]]=~-g[d[k]];for(k in g)o+=~g[k]+k+" ";alert(o);

— C5H8NNaO4
स्रोत

1

काम नहीं करता है All 6 counts must be shown, separated by spaces, even when they are 0.:। टेस्ट केस:N

— edc65

@ edc65 Woah मुझे बस वो हिस्सा याद आ गया। यह बात बताने के लिए धन्यवाद। 8chars की लागत के लिए इसे निर्धारित किया गया

— C5H8NNO4

2

पर्ल, ४६

#!perl -p
$_="NBM BM NB M B N"=~s/\w+/~~s!$&!x!g.$&/ger

— nutki
स्रोत

यह कैसे काम करता है पर स्पष्टीकरण?

— कैन

1

SpecBAS - 164

1 INPUT s$
2 FOR EACH a$ IN ["NBM","BM","NB","M","B","N"]
3 LET n=0
4 IF POS(a$,s$)>0 THEN INC n: LET s$=REPLACE$(s$,a$,"-"): GO TO 4: END IF
5 PRINT n;a$;" ";
6 NEXT a$

दूसरों के रूप में एक ही दृष्टिकोण का उपयोग करता है। पंक्ति 4 स्ट्रिंग (सबसे बड़े पहले से) पर लूपिंग रखती है, अगर मिला तो इसे बदल देती है।

SpecBAS में मूल ZX / सिनक्लेयर BASIC (सूचियों के माध्यम से लूपिंग, वर्ण खोजने) पर कुछ अच्छे स्पर्श हैं, जो मुझे अभी भी पता चल रहा है।

— ब्रायन
स्रोत

1

सी, 205 186 184 बाइट्स

राज्य मशीन पर आधारित थोड़ा अलग दृष्टिकोण। tराज्य कहाँ है

a[7],t,i;c(char*s){do{i=0;t=*s==78?i=t,1:*s-66?*s-77?t:t-4?t-2?i=t,3:5:6:t-1?i=t,2:4;i=*s?i:t;a[i]++;}while(*s++);printf("%dN %dB %dM %dNB %dBM %dNBM",a[1],a[2],a[3],a[4],a[5],a[6]);}

विस्तारित

int a[7],t,i;

void c(char *s)
{
    do {
        i = 0;
        if (*s == 'N') {
            i=t; t=1;
        }
        if (*s == 'B') {
            if (t==1) {
                t=4;
            } else {
                i=t;
                t=2;
            }
        }
        if (*s == 'M') {
            if (t==4) {
                t=6;
            } else if (t==2) {
                t=5;
            } else {
                i=t;
                t=3;
            }
        }
        if (!*s)
            i = t;
        a[i]++;
    } while (*s++);
    printf("%dN %dB %dM %dNB %dBM %dNBM",a[1],a[2],a[3],a[4],a[5],a[6]);
}

परीक्षण समारोह

#include <stdio.h>
#include <stdlib.h>

/*
 * 0 : nothing
 * 1 : N
 * 2 : B
 * 3 : M
 * 4 : NB
 * 5 : BM
 * 6 : NBM
 */
#include "nbm-func.c"

int main(int argc, char **argv)
{
    c(argv[1]);
}

— कुछ उपयोगकर्ता
स्रोत

कुछ बाइट बचाने के for(;;*s++){...}बजाय का उपयोग नहीं करेगा do{...}while(*s++);? इसके अलावा, आप में न्यू लाइन चरित्र की जरूरत नहीं है printf।

— स्पिकट्रिक्स

मुझे लगता है कि आपका मतलब था for(;*s;s++)। लेकिन मुझे उस आखिरी अशक्त चरित्र के साथ पाश करने की आवश्यकता थी। बचाने के लिए अच्छा कॉल \n, जिसकी आवश्यकता नहीं है।

— कुछ उपयोगकर्ता

1

सी, 146

f(char*s)
{
  char*p,*q="NBM\0NB\0BM\0N\0B\0M",i=0,a=2;
  for(;i<6;q+=a+2,a=i++<2)
  {
    int n=0;
    for(;p=strstr(s,q);++n)*p=p[a>1]=p[a]=1;
    printf("%d%s ",n,q);
  }
}

// Main function, just for testing
main(c,a)char**a;{
  f(a[1]);
}

— edc65
स्रोत

1

हास्केल - 177 बाइट्स (आयात के बिना)

n s=c$map(\x->(show$length$filter(==x)(words$c$zipWith(:)s([f(a:[b])|(a,b)<-zip s(tail s)]++[" "])))++x++" ")l
f"NB"=""
f"BM"=""
f p=" "
l=["N","B","M","NB","BM","NBM"]
c=concat

(इंटरनेट नेक्रोमेंसी के लिए यहां क्षमा करें।)

हास्केल प्लेटफ़ॉर्म में आयात के बिना स्ट्रिंग खोज नहीं है, और मैं इस तथ्य को दिखाना और दोहन करना चाहता था कि खोजे गए तार सभी एक (पुनरावृत्ति के बिना) के सबस्ट्रिंग हैं, ताकि समूहिंग वर्णों को उन जोड़ों की पहचान करके किया जा सके जिन्हें अनुमति है एक-दूसरे का अनुसरण करें, जो fयहां है।

मुझे अभी भी lसमानता के लिए जांच करने और आवश्यकता के अनुसार प्रदर्शन करने के लिए अंत में पूरी सूची की आवश्यकता है, लेकिन ऐसा नहीं होगा, केवल wordsकिसी भी क्रम में संभावित घटनाओं की संख्या की रिपोर्ट करने के लिए चुनौती नहीं थी ।

— लीफ़ विलर्ट्स
स्रोत

0

बैश - 101

I=$1
for p in NBM BM NB M B N;{ c=;while [[ $I =~ $p ]];do I=${I/$p/ };c+=1;done;echo -n ${#c}$p\ ;}

पहले तर्क के रूप में स्ट्रिंग पास करें।

bash nmb.sh MBNNBBMNBM

थोड़ा समझाया:

# We have to save the input into a variable since we modify it.
I=$1

# For each pattern (p) in order of precedence
for p in NBM BM NB M B N;do
    # Reset c to an empty string
    c=

    # Regexp search for pattern in string
    while [[ $I =~ $p ]];do
        # Replace first occurance of pattern with a space
        I=${I/$p/ }
        # Append to string c. the 1 is not special it could be any other
        # single character
        c+=1
    done

    # -n Suppress's newlines while echoing
    # ${#c} is the length on the string c
    # Use a backslash escape to put a space in the string.
    # Not using quotes in the golfed version saves a byte.
    echo -n "${#c}$p\ "
done

— डैनियल वेकफील्ड
स्रोत

0

आरएस , 275 बाइट्स

(NBM)|(NB)|(BM)|(N)|(B)|(M)/a\1bc\2de\3fg\4hi\5jk\6l
[A-Z]+/_
#
+(#.*?)a_b/A\1
+(#.*?)c_d/B\1
+(#.*?)e_f/C\1
+(#.*?)g_h/D\1
+(#.*?)i_j/E\1
+(#.*?)k_l/F\1
#.*/
#
#(A*)/(^^\1)NBM #
#(B*)/(^^\1)NB #
#(C*)/(^^\1)BM #
#(D*)/(^^\1)N #
#(E*)/(^^\1)B #
#(F*)/(^^\1)M #
\(\^\^\)/0
 #/

लाइव डेमो और परीक्षण।

कामकाज सरल है लेकिन थोड़ा अजीब है:

(NBM)|(NB)|(BM)|(N)|(B)|(M)/a\1bc\2de\3fg\4hi\5jk\6l

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

NBMBM

में

aNBMbcdeBMfghijkl

अगली पंक्ति:

[A-Z]+/_

यह अंडरस्कोर के साथ बड़े अक्षरों के क्रम को बदलता है।

यह बस लाइन की शुरुआत में एक पाउंड साइन सम्मिलित करता है।

+(#.*?)a_b/A\1
+(#.*?)c_d/B\1
+(#.*?)e_f/C\1
+(#.*?)g_h/D\1
+(#.*?)i_j/E\1
+(#.*?)k_l/F\1
#.*/

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

पाउंड को लाइन की शुरुआत में फिर से डाला जाता है।

#(A*)/(^^\1)NBM #
#(B*)/(^^\1)NB #
#(C*)/(^^\1)BM #
#(D*)/(^^\1)N #
#(E*)/(^^\1)B #
#(F*)/(^^\1)M #
\(\^\^\)/0
 #/

पूँजी अक्षरों को उनके पाठ समकक्षों द्वारा संबंधित गणनाओं के साथ बदल दिया जाता है। Rs में बग के कारण (मैं इसे ठीक करने और अयोग्य होने का जोखिम नहीं उठाना चाहता था), खाली अनुक्रमों को परिवर्तित किया जाता है (^^), जिसे दूसरी से अंतिम पंक्ति में 0 से बदल दिया जाता है। बहुत अंतिम पंक्ति बस पाउंड को हटा देती है।

— kirbyfan64sos
स्रोत

0

केडीबी (क्यू), 76 बाइट्स

{" "sv string[-1+count@'enlist[x]{y vs" "sv x}\l],'l:" "vs"NBM NB BM N B M"}

व्याख्या

                                                   l:" "vs"NBM NB BM N B M"     / substrings
                        enlist[x]{y vs" "sv x}\l                                / replace previous substring with space and cut
              -1+count@'                                                        / counter occurrence
       string[                                  ],'                             / string the count and join to substrings
{" "sv                                                                     }    / concatenate with space, put in lambda

परीक्षा

q){" "sv string[-1+count@'enlist[x]{y vs" "sv x}\l],'l:" "vs"NBM NB BM N B M"}"NNNMNBMMBMMBMMMNBMNNMNNNBNNNBNBBNBNMMNBBNBMMBBMBMBBBNNMBMBMMNNNNNMMBMMBM"
"3NBM 5NB 8BM 17N 6B 14M"
q){" "sv string[-1+count@'enlist[x]{y vs" "sv x}\l],'l:" "vs"NBM NB BM N B M"}""
"0NBM 0NB 0BM 0N 0B 0M"

— वूइकेंट ली
स्रोत

0

हास्केल: 244 बाइट्स

import Data.List
s="NBM"
[]#_=[[]]
a#[]=[]:a#s
l@(a:r)#(b:m)
 |a==b=let(x:y)=r#m in((a:x):y)
 |True=[]:l#m
c?t=length$filter(==t)c
p=["N","B","M","NB","BM","NBM"]
main=getLine>>= \l->putStrLn.intercalate " "$map(\t->show((l#[])?t)++t)p

— जेरेमी सूची
स्रोत

कुछ सुझाव: आप उपयोग कर रहे हैं pऔर sकेवल एक बार, इसलिए इसे कोई नाम देने की आवश्यकता नहीं है (-> a#[]=[]:a#"NBM", उसी के लिए p)। BTW: words"N B M NB BM NBM"स्ट्रिंग्स की सूची के बजाय अतिरिक्त बाइट्स बचाता है। के importलिए ही है intercalate, यह छोटा है इसे फिर से लागू करें: ...putStrLn.tail.((' ':)=<<)$map...और छुटकारा पाएं import। सभी गार्डों |को #एक ही लाइन की परिभाषा में रखें और 1<2इसके बजाय उपयोग करें True: ...#(b:m)|a==b=...l#m|1<2=[]......

— nimi

... ?एक सूची समझ के साथ कम परिभाषित किया जा सकता है c?t=sum[1|x<-c,x==t]:। फिर, आप ?केवल एक बार उपयोग कर रहे हैं , इसलिए सीधे शरीर का उपयोग करें ...show(sum[1|x<-l#[],x==t]):।

— निमि १

निन्जा और बंदर और भालू, ओह माई!

चुनौती

उदाहरण

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

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

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

अजगर 2, 78

रूबी, 166 80 72 68 वर्ण

जावा, 166 162

CJam, 36 32 31 बाइट्स

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

आर, 153 134 118

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

व्याख्या

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

पायथन 2, 93 88 89 84 बाइट्स

एसएएस, 144 142 139 129

PHP4.1, 92 बाइट्स

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

पर्ल, ४६

SpecBAS - 164

सी, 205 186 184 बाइट्स

सी, 146

हास्केल - 177 बाइट्स (आयात के बिना)

बैश - 101

आरएस , 275 बाइट्स

केडीबी (क्यू), 76 बाइट्स

व्याख्या

परीक्षा