Ця виклик - премія 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поодинокі Ninjas, ведмеді і мавпи відповідно.

Рядок читається зліва направо.

Так, наприклад, у лінійці істот 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

Піт, 22 байти

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

Досить хакерський спосіб зберегти 1 байт, завдяки @Jakube.

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 + string.

Цей фрагмент стека написаний у еквіваленті ES5 вищевказаного коду, щоб полегшити тестування з будь-якого браузера. Це також злегка неперевершений код. Інтерфейс користувача оновлюється при кожному натисканні клавіші.

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>

Пітон 2, 78

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

Варіант відповіді Віоз . Весело з представленнями рядків 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+}%" *

На жаль, не є правильним рішенням, оскільки в поточній версії Ostrich є помилка (вона тепер виправлена, але після цього виклик був опублікований).

Ява, 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

Це суміш рішення Pyth @ isaacg та неймовірної хитрості Python @ 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

Юлія, 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 

Пітон 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;

Використання (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);

Перл, 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 (перебираючи списки, знаходячи символів), які я все-таки з’ясовую.

С, 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]);
}

С, 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 у другому-останньому рядку. Останній рядок просто знімає фунт.

КДБ (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