这个挑战是NinjaBearMonkey赢得我的Block Building Bot群的奖励！挑战黑骑士的作品。恭喜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个NinjaBearMonkeys。

挑战

写一个程序或函数，它在字符的字符串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，从较长的子字符串开始，优先级更高。它会搜索该特定字符串的每次出现并将其删除（在这种情况下，将其替换为当前计数，因此不会再次匹配）。最后，它将每个子字符串替换为count +字符串。

该Stack Snippet是使用与上述代码等效的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- Answer的变体。Python 2字符串表示形式很有趣！

通过对子字符串进行拆分，计数和减1间接计数子字符串的出现，而不是用填充符替换子字符串，而是用split生成的列表替换字符串。然后，当我们使用它的字符串表示形式时，部分之间用空格和逗号分隔。

Ruby，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+}%" *

不幸的是，这不是有效的解决方案，因为当前的Ostrich版本存在一个错误（现已修复，但已发布此挑战）。

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;

感谢@Optimizer高尔夫球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.

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->...。

取消+说明：

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平台没有没有导入的字符串搜索功能，我想展示和利用这样一个事实，即搜索到的字符串都是一个的子字符串（无重复），因此可以通过识别允许对的对来完成分组字符。跟着彼此，这就是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中有一个错误（我不想冒险修复它并失去资格），因此将空序列转换为(^^)，在倒数第二行中将其替换为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