Bu zorluk, NinjaBearMonkey'in Blok Oluşturma Bot Sürülerimi kazanma ödülü ! Kara Şövalye teslimi ile meydan . Tebrikler NinjaBearMonkey!

Buradaki zorluk oldukça basittir, ancak çeşitli olası yaklaşımlar vardır. Hikaye, İzometrik İllüzyonlar dünyasında , 6 farklı yaratık türü olduğunu gösteriyor:

1. Ninjalar, kısaltılmış N
2. Kısaltılmış ayılar B
3. Kısaltılmış maymunlar M
4. NinjaBears, kısaltılmış NB
5. BearMonkeys, kısaltılmış BM
6. NinjaBearMonkeys, kısaltılmış NBM

^{( NinjaBearMonkey , elbette en son, en güçlü türdür.)}

Göreviniz, yan yana dizildiklerinde, yani kısaltma dizilimleri birleştirildiğinde, bu canlıların sayımını almaktır . Dikkat, bazı canlıların parçalarını benzer görünen ayrı yaratıklar olarak saymadığınızdan emin olmanız gerektiğidir. Yaratıklar şu şekilde sıralanacaktır:

• Herhangi bir örneği NBM1 NinjaBearMonkey ve 0 başka canlı.
• NBTakip edilmeyen herhangi bir örnek M1 NinjaBear ve 0 başka canlıdır.
• Öncesi BMolmayan herhangi bir örnek N, 1 BearMonkey ve 0 başka canlıdır.
• Aksi takdirde, örnekleri N, Bve Mtek Ninjalar, ayılar, ve maymun sırasıyla.

Satır soldan sağa okunur.

Örneğin, yaratıklar doğrultusunda NBMMBNBNBM, 0 Ninja, 1 Ayı, 1 Maymun, 1 NinjaBear, 0 BearMonkey ve 2 NinjaBearMonkey vardır.

Meydan okuma

Karakter dizesi alır bir program veya fonksiyon yazın N, Bve M, ve baskılar veya yaratıkların 6 türlerinin her çoğunun içinde bulunduğu nasıl getiri.

Çıktı biçiminde olmalıdır

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

Her bir #işaretin yerine ilgili yaratık sayısı ile . 6 sayının tümü, 0 olduklarında bile boşluklarla ayrılmış olarak gösterilmelidir. Ancak, herhangi bir sırayla #NBMolabilirler (örneğin önce gelebilir).

Ayrıca:

• Girdi dizesi yalnızca karakter olacak N, Bve M.
• Boş dizge giriş ise, tüm sayılar 0'dır.
• Çıktı isteğe bağlı olarak bir tek öncü ve / veya arkadaki boşluk ve / veya bir arkadaki yeni hat içerebilir.

Bayt cinsinden en kısa gönderme kazanır.

Örnekler

Giriş: NB
Çıkış:0N 0B 0M 1NB 0BM 0NBM

Giriş: NBM
Çıkış:0N 0B 0M 0NB 0BM 1NBM

Giriş: NBMMBNBNBM(yukarıdan örnek)
Çıkış:0N 1B 1M 1NB 0BM 2NBM

Giriş: MBNNBBMNBM
Çıkış:1N 1B 1M 1NB 1BM 1NBM

Giriş: NNNMNBMMBMMBMMMNBMNNMNNNBNNNBNBBNBNMMNBBNBMMBBMBMBBBNNMBMBMMNNNNNMMBMMBM
Çıkış:17N 6B 14M 5NB 8BM 3NBM

Pyth, 22 bayt

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

@Jakube sayesinde 1 byte tasarruf etmenin son derece zor bir yolu.

Pyth, 23 bayt

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

Gösteri.

Bir boşluk ile ve sonunda yeni satır olmadan ters sırada yazdırır.

.:"NBM")tüm alt diziler, _onları doğru sıraya koyar, /zNoluşumları sayar ve =:zNdyerinde dizinin her oluşumunu bir boşlukla değiştirir.

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 bayt

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

(Sadece buna cevap vermek zorunda kaldım.) Daha NBMuzun olanlardan başlayarak daha yüksek önceliğe sahip olan her alt dizeden geçer . Belirli bir dizgenin her oluşumunu arar ve kaldırır (bu durumda onu geçerli sayıyla değiştirerek yeniden eşleştirilmemesini sağlar). Sonunda her bir alt dizgiyi count + string ile değiştirir.

Bu Yığın Parçacığı, herhangi bir tarayıcıdan sınamayı kolaylaştırmak için yukarıdaki kodun ES5 eşdeğeriyle yazılmıştır. Aynı zamanda biraz ungolfed kodudur. UI, her tuş vuruşu ile güncellenir.

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-'in cevabının bir çeşidi . Python 2 string gösterimleri ile eğlenceli!

Alt tabakanın oluşumlarını dolaylı olarak üzerine bölerek, parçaları sayarak ve çıkartarak sayar split. Sonra, onun dize gösterimini aldığımızda, parçalar boşluklar ve virgüller ile ayrılır.

Ruby, 166 80 72 68 karakter

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

Açıklama:

• Sayım tersten yapılır. Bunun nedeni daha uzun ninjalar ve ayılar ve maymunların, kısa olanlardan daha öncelikli olmasıdır.

• Çünkü NBM, BMve NB, bu dizilerin gsub!kaç tanesinin bulunduğunu saymak için diziler orijinal dizginin dışındadır (evet, işlev argümanını değiştirir).

  • Aksi Ancak, bunlar, hiçbir şey ile değiştirilemez BNBMMolarak sayılır NBMve BMyerine B, NBMve M(ne zaman çünkü NBMkaldırılıyordu, bu koyardı Bve Mbirlikte ve onu ayırt etmek için bir yol var olmaz). Başlangıçta tek bir karakter dizgisi ( .gsub!('NBM'){c+=1;?|}) döndürdüm , ama sadece sonucunu döndürdüğümü farkettim +=(sayıdır, yani herhangi biri olamaz N B M).

• Çünkü M, Bve N, countdizgide bunlardan kaç tane bulunduğunu söyleyebilirim (onları silmeye gerek yok gsub!). Şimdi bir döngü (neden bunu ilk önce düşünmedim bilmiyorum), bu yüzden bunlar aynı şekilde yapılır.

Devekuşu'ndaki benzer çözüm , 54 51 karakter :

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

Geçerli Devekuşu sürümünde bir hata olduğundan maalesef geçerli bir çözüm değil (şimdi düzeltildi, ancak bu zorluğun yayınlanmasından sonra).

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

Ve birkaç satır sonu ile:

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

Oldukça basit çalışıyor. Belirteçlerin üzerinde döngü yapın, bunları noktalarla değiştirin ve giriş bazılarını içerdiği sürece sayın. Önce büyük olanları sayar, böylece küçük olanlar karışmaz.

Başlangıçta hepsini bir kerede değiştirmeyi ve uzunluktaki farkı saymayı denedim, ancak bu şekilde birkaç karakter daha aldı :(

CJam, 36 32 31 bayt

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

1 bayt golf oynamak için @ Optimizer sayesinde.

CJam tercümanında çevrimiçi olarak deneyin .

Nasıl çalışır

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

Bu çok daha hızlı bir şekilde uzadı ama umarım birkaçını tıraş edebilirim. Giriş STDIN'dir ve STDOUT'a çıkar.

Tack değişikliklerini düzenleyin. Bölünmüş ipten ve sayma parçalardan kurtuldum. Şimdi parçaları, parçadan daha kısa bir dizeyle değiştiriyorum. Dize uzunlukları arasındaki fark çıktı için toplanır.

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),'')

açıklama

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
  ,'')

Test sürüşü

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

jd+Ltl=zc`zd_.:"NBM

Bu, @ isaacg'ın Pyth çözümünün ve @ xnor'ın inanılmaz Python numarasının bir karışımı.

Çevrimiçi deneyin: Gösteri veya Test koşum

açıklama

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

Julia, 106 97 bayt

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

Bu, girdi olarak bir dize alan ve sonucu tek bir iz bırakma alanı olan ve izleyen yeni satır olmadan STDOUT'a yazdıran adsız bir işlev oluşturur. Aramak için bir isim verin, örneğin f=b->....

Ungolfed + açıklama:

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

Örnekler:

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

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

Python 2, 93 88 89 84 Bayt

Basit bir yaklaşımla.

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

Öyle arayın:

f("NBMMBNBNBM")

Çıktı şöyle:

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;

Kullanım (sysparm için 7 bayt eklendi):

$ 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

veya

%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;

Kullanımı:

data;%f(NNNMNBMMBMMBMMMNBMNNMNNNBNNNBNBBNBNMMNBBNBMMBBMBMBBBNNMBMBMMNNNNNMMBMMBM)

Sonuç:

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

PHP4.1, 92 bayt

En kısa değil, fakat PHP'den başka ne beklenir ki?

Kullanmak için, bir COOKIE, POST, GET, SESSION üzerine bir anahtar ...

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

Apporach temeldir:

• Dize yaratıkların adlarına böl
• Kaç tane eleman olduğunu say
• Çıkart 1 (boş bir dize 1 elemanlı bir dizi verir)
• Sayımı ve yaratık adını çıktılayın
• Boş bir dizge kullanarak hepsine katılın (dizgiyi azaltacak ve son yaratığı kaldıracak)

Kolay değil mi?

JavaScript, 108 116 bayt

Sadece basit bir yaklaşım, şık bir şey değil

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$

Diğerleriyle aynı yaklaşımı kullanır. Satır 4, dize üzerinde döngü oluşturmaya devam eder (ilk önce en büyükten), bulunursa yerini alır.

SpecBAS, hala öğrendiğim orijinal ZX / Sinclair BASIC (listelerde döngü, karakter bulma) üzerinde bazı hoş dokunuşlara sahip.

C, 205 186 184 bayt

Durum makinesine dayanan biraz farklı bir yaklaşım. tdevlet nerede .

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

Expanded

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

Test fonksiyonu

#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 bayt (ithalat olmadan)

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

(Buradaki internet sorunu için özür dilerim.)

Haskell Platformunun içe aktarma işlemi olmadan dizge araması yoktur ve aranan dizelerin hepsinin birinin alt dizisi olduğunu (tekrarlama olmadan) göstermek ve istismar etmek istedim, böylece gruplandırma karakterleri izin verilen çiftleri tanımlayarak yapılabilir. birbirlerini takip edin f, burada ne var.

lEşitliği kontrol etmek ve tam olarak gerektiği gibi görüntülemek için hala tüm listeye ihtiyacım var , ancak zorunluluk, mümkün wordsolan herhangi bir sıradaki olayların sayısını rapor etmekti .

Bash - 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\ ;}

Dizeyi ilk argüman olarak iletin.

bash nmb.sh MBNNBBMNBM 

Biraz açıklandı:

# 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 bayt

(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
 #/

Canlı demo ve testler.

Çalışmalar basit ama biraz garip:

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

Bu, girişi şöyle çevirmek için yaratıcı bir şekilde grupları kullanır:

NBMBM

içine

aNBMbcdeBMfghijkl

Bir sonraki satır:

[A-Z]+/_

Bu, büyük harflerin dizilerini alt çizgilerle değiştirir.

#

Bu sadece satırın başına bir sayı işareti ekler.

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

Bu başlangıç ​​serin kısmı. Temel olarak küçük harflerin ve alt çizgi dizilerini alır, bunları büyük harflere dönüştürür, birlikte gruplandırır ve yerleştirilen pounddan önce yerleştirir. Pound'un amacı, daha önce işlenmiş olan sekansları yönetmektir.

#

Pound satırın başına tekrar yerleştirilir.

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

Büyük harfler, metinlerin eş değerleriyle ilişkili sayımlarla değiştirilir. Rs'deki bir hata nedeniyle (düzeltme ve diskalifiye olma riskini almak istemedim), boş diziler (^^), ikinci-son satırda 0 ile değiştirilene dönüştürülür . Son satır basitçe poundu kaldırır.

KDB (Q), 76 bayt

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

açıklama

                                                   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

Ölçek

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 bayt

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