このチャレンジは、ブロックビルディングボットフロックを獲得したNinjaBearMonkeyの賞です！ブラックナイトの提出に挑戦してください。おめでとうございます、NinjaBearMonkey！

ここでの課題は非常に単純ですが、さまざまなアプローチが可能です。物語は、等尺性錯覚の世界には、6種類のクリーチャーがいるということです。

1. 忍者、略称 N
2. クマ、略称 B
3. サル、略称 M
4. NinjaBears、略称 NB
5. BearMonkeys、略称 BM
6. NinjaBearMonkeys、略称 NBM

^{（NinjaBearMonkeyは、もちろん最後の、最も強力なタイプです。）}

あなたの仕事は、これらのクリーチャーが並んでいるとき、つまり略語の文字列が連結されているとき、これらのクリーチャーの人口調査を取ることです。警告は、いくつかのクリーチャーの一部を偶然似ているように見える別個のクリーチャーとして数え過ぎないようにする必要があることです。クリーチャーは次のように並んでいます：

• のインスタンス NBMは、1つのNinjaBearMonkeyと0の他のクリーチャーです。
• がNB続かないインスタンスMは1匹のNinjaBearと0匹の他のクリーチャーです。
• BMが前にないインスタンスNは、1 BearMonkeyと0他のクリーチャーです。
• そうでない場合は、のインスタンスN、BおよびMそれぞれ単一忍者、クマ、サルです。

行は左から右に読み取られます。

だから、例えば、生き物のラインで NBMMBNBNBM、0の忍者、1つのクマ、1つの猿、1つのNinjaBear、0のBearMonkeys、および2つのNinjaBearMonkeyがあります。

チャレンジ

文字の文字列を取り込みプログラムや関数を書く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

Pyth、22バイト

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

@Jakubeのおかげで、1バイトを節約する非常にハック的な方法です。

Pyth、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.

JavaScript ES6、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し、より長いものから始まり、優先度が高くなります。特定の文字列が出現するたびに検索して削除します（この場合、現在のカウントに置き換えて、再び一致しないようにします）。最後に、各部分文字列をカウント+文字列で置き換えます。

このスタックスニペットは、上記のコードに相当するES5で記述されており、ブラウザーからのテストを容易にします。また、わずかに未使用のコードです。UIはキーストロークごとに更新されます。

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>

Python 2、78

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

Vioz-の答えの変形。Python 2の文字列表現をお楽しみください！

部分文字列を分割し、部分を数え、1を減算することにより、部分文字列の出現を間接的にカウントします。部分文字列をフィラーシンボルで置き換える代わりに、split生成されたリストで文字列を置き換えます。次に、文字列表現を使用する場合、各部分はスペースとコンマで区切られます。

ルビー、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!）。今ではループになっています（そもそもなぜそれを考えなかったのかわからない）ので、これらは同じ方法で行われます。

ダチョウで同様のソリューション、54 51文字：

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

現在のダチョウバージョンにはバグがあるため、残念ながら有効なソリューションではありません（現在修正されていますが、このチャレンジが投稿された後）。

Java、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],".");
}

とても簡単に機能します。トークンをループ処理し、ドットに置き換えて、入力に含まれている限りカウントします。最初に大きいものを数えるので、小さいものはそれを台無しにしません。

私はもともとすべてを一度に置き換えて、長さの違いを数えようとしましたが、そのようにいくつかの文字がさらにかかりました:(

CJam、36 32 31バイト

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

1バイトのゴルフをしてくれた@Optimizerに感謝します。

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.

R、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 
> 

Pyth、19バイト

jd+Ltl=zc`zd_.:"NBM

これは、@ isaacgのPythソリューションと@xnorの信じられないほどのPythonトリックの混合です。

オンラインで試す：デモンストレーションまたはテストハーネス

説明

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

ジュリア、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->...ます。

Ungolfed +説明：

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 

Python 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

SAS、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;

使用法（sysparmに7バイト追加）：

$ 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

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);}

アプローチは基本的です：

• 文字列をクリーチャーの名前に分割します
• 要素の数を数える
• 1を引きます（空の文字列は1つの要素を持つ配列になります）
• カウントとクリーチャー名を出力します
• 空の文字列を使用してすべてを結合します（文字列を減らして最後のクリーチャーを削除します）

簡単ですね。

JavaScript、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);

Perl、46

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

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 / Sinclair BASIC（リストをループし、キャラクターを見つける）に対していくつかの素晴らしいタッチを持っています。

C、 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]);
}

C、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]);
}  

Haskell-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

（インターネットのネクロマンシーはこちらでごめんなさい。）

Haskellプラットフォームにはインポートなしの文字列検索はありません。検索文字列がすべて1つのサブ文字列（繰り返しなし）であるという事実を誇示して活用したいので、互いにフォローfします。これがここで行われます。

必要に応じて、l平等をチェックして正確に表示するために最後に完全なリストが必要ですが、可能性のある発生回数をwords任意の順序で報告することだけが課題ではありませんでした。

バッシュ-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

rs、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のバグのため（修正して失格になるリスクはありませんでした）、空のシーケンスはに変換され(^^)、最後から2番目の行で0に置き換えられます。最後の行は単にポンドを削除します。

KDB（Q）、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"

Haskell：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