নিনজাস এবং বানর এবং ভাল্লুক, ওহ আমার!

Question

এই চ্যালেঞ্জটি হ'ল আমার ব্লক বিল্ডিং বট ফ্লক জয়ের জন্য নিনজাবিয়ারমনির পুরস্কার ! ব্ল্যাক নাইট জমা দেওয়ার সাথে চ্যালেঞ্জ । অভিনন্দন নিনজাবার্মনকি!

এখানে চ্যালেঞ্জটি মোটামুটি সহজ, তবে বিভিন্ন সম্ভাব্য পন্থা রয়েছে। গল্পটি বলে যে আইসোমেট্রিক ইলিউশনগুলির বিশ্বে 6 টি বিভিন্ন ধরণের প্রাণী রয়েছে:

1. সংক্ষেপে নিনজাস N
2. ভালুক, সংক্ষিপ্ত B
3. বানর, সংক্ষিপ্ত M
4. সংক্ষেপে নিনজাবিয়ার্স NB
5. বিয়ারমোনকিস, সংক্ষেপে BM
6. সংক্ষেপে নিনজাবিয়ারমোনকিজ NBM

^{( নিনজাবিয়ারমোনকি অবশ্যই শেষ, সবচেয়ে শক্তিশালী টাইপ)}

আপনার টাস্ক একটি নিতে হয় আদমশুমারি এই প্রাণীকে তারা যখন পার্শ্ব দ্বারা প্রান্তের, অর্থাত্ আপ রেখাযুক্ত হয় যখন তাদের সংক্ষেপ স্ট্রিং ঘনিভূত হয়। সতর্কবাণীটি হ'ল আপনাকে অবশ্যই নিশ্চিত করতে হবে যে কিছু প্রাণীর অংশগুলি পৃথক প্রাণী হিসাবে সাদৃশ্যপূর্ণ হতে দেখা যায় না not প্রাণীগুলি এমনভাবে দাঁড়াবে:

• এর কোনও উদাহরণ NBMহ'ল 1 নিনজাবিয়ারমোনকি এবং অন্যান্য 0 টি প্রাণী।
• NBঅনুসরণ না করার কোনও উদাহরণ Mহ'ল 1 নিনজাবার এবং অন্যান্য 0 টি প্রাণী।
• এর BMআগে না হওয়ার কোনও উদাহরণ Nহ'ল 1 বিয়ারমনকি এবং অন্যান্য 0 টি প্রাণী।
• অন্যথায়, দৃষ্টান্ত N, Bএবং Mএকক নিনজারা, গর্ভধারণ করে এবং বানর যথাক্রমে।

লাইনটি বাম থেকে ডানদিকে পড়া হয়।

সুতরাং, উদাহরণস্বরূপ, প্রাণীদের লাইনে NBMMBNBNBM0 টি নিনজা, 1 ভাল্লুক, 1 বানর, 1 নিনজাবিয়ার, 0 বিয়ারমোনকি এবং 2 নিনজা বিয়ারমোনকি রয়েছে।

চ্যালেঞ্জ

একটি প্রোগ্রাম বা ফাংশন যা অক্ষরের একটি স্ট্রিং লাগে লিখুন N, Bএবং M, এবং কপি করে প্রিন্ট বা আয় কিভাবে প্রাণীকে 6 ধরনের প্রতিটি অনেক এতে উপস্থিত থাকে।

আউটপুট ফর্ম থাকা উচিত

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

প্রতিটি #চিহ্নকে প্রতিস্থাপন করে সংশ্লিষ্ট প্রাণীর গণনা সহ । সমস্ত cou টি সংখ্যা অবশ্যই ০. হওয়া সত্ত্বেও স্পেস দ্বারা পৃথক করে দেখানো হবে However তবে, তারা কোনও ক্রমে থাকতে পারে (যেমন, #NBMপ্রথমে আসতে পারে)।

এছাড়াও:

• ইনপুট স্ট্রিং শুধুমাত্র অক্ষর থাকতে হবে N, Bএবং M।
• যদি খালি স্ট্রিংটি ইনপুট হয় তবে সমস্ত গণনা 0 হয়।
• আউটপুটে optionচ্ছিকভাবে একটি একক শীর্ষস্থানীয় এবং / অথবা পিছনের স্থান এবং / অথবা একটি একক ট্রেলিং নিউলাইন থাকতে পারে।

বাইটস মধ্যে সংক্ষিপ্ততম জমা জয়।

উদাহরণ

ইনপুট: 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

Comments

আমি এই চ্যালেঞ্জ অনুমোদিত।

— নিনজা বিয়ারমোনকি

কেবলমাত্র নিশ্চিত করার জন্য: আপনার সমস্ত কিছু যদি 2 নিনজাবিয়ারমোনকি হয় তবে আপনি একটি লাইন তৈরি করতে পারবেন না? কারণ তারা একে অপরের পাশে দাঁড়াতে পারে না?

— অ্যালান ক্যাম্পবেল

@ অ্যালান ক্যাম্পবেল নং NBMNBMপুরোপুরি বৈধ ইনপুট হবে। এটি বাম থেকে ডানে পড়ার জন্য স্পষ্টভাবে 2 নিনজাবিয়ারমোনকি রয়েছে।

— ক্যালভিনের

Answer 1

পাইথ, 22 বাইট

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

1 জ্যাকেট সংরক্ষণের বেশ হ্যাকিশ উপায়, ধন্যবাদ জাকুবেকে।

---

পাইথ, 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.

Answer 2

জাভাস্ক্রিপ্ট 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 তে লেখা রয়েছে। এটি কিছুটা অবারিত কোডও। প্রতিটি কীস্ট্রোকের সাথে ইউআই আপডেট হয়।

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>

Comments

আপনি কি রেজেক্স অংশটি এমন জায়গায় পরিবর্তন করতে পারবেন 'NBM<newline>BM<newline>...<newline>N'.replace(/./g, ...)'যেখানে <newline>এসগুলি আক্ষরিক নিউলাইন এবং 'এসগুলি ব্যাকটিকস রয়েছে, ES6 টেম্পলেট স্ট্রিং গঠন করে? রেজেক্সে দুটি বাইট সংরক্ষণ করুন ( .নতুন লাইনের সাথে মেলে না)।

— wchargin

@WChargin দুর্ভাগ্যক্রমে, না, কারণ আউটপুটটি অবশ্যই স্থান-পৃথক হতে হবে।

— নিনজা বিয়ারমনেকি

Answer 3

পাইথন 2, 78

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

ভায়োজ-এর উত্তরের একটি রূপ । পাইথন 2 স্ট্রিং উপস্থাপনার সাথে মজা করুন!

সাবটারিংকে অপ্রত্যক্ষভাবে তার উপর বিভাজন, অংশগুলি গণনা এবং বিয়োগ করে ঘটনাগুলি গণনা করে 1 split. তারপরে, যখন আমরা এর স্ট্রিং প্রতিনিধিত্ব করি, অংশগুলি স্পেস এবং কমা দ্বারা পৃথক করা হয়।

Comments

এটা পাগলামি! দুর্দান্তভাবে উন্মাদ, তবে এখনও উন্মাদ।

— Sp3000

চমৎকার কাজ! সে সম্পর্কে ভাবেন নি :)

— কেড

Answer 4

রুবি, 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!)। এখন এটি একটি লুপ (জানি না কেন আমি এটি প্রথম স্থানে ভেবে দেখিনি), সুতরাং এটি একই পদ্ধতিতে সম্পন্ন হয়।

---

অস্ট্রিচ-এ একই রকম সমাধান , ৫৫ টি চর :

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

দুর্ভাগ্যক্রমে বৈধ সমাধান নয়, কারণ বর্তমান অস্ট্রিচ সংস্করণে একটি বাগ রয়েছে (এটি এখন ঠিক করা হয়েছে, তবে এই চ্যালেঞ্জ পোস্ট হওয়ার পরে)।

Comments

আপনি অ্যারে স্বরলিপি ব্যবহার করে %w(NBM BM NB M B N)এবং বিভাজনটি সরিয়ে 3 টি অক্ষর সংরক্ষণ করতে পারেন ।

— ডিকিবয়

@ ডিকিবয় আসলে 4 টি চর; ধন্যবাদ!

— ডুরকনবব

আহা, বিন্দু!

— ডিকিবয়

Answer 5

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

এটি বেশ সহজভাবে কাজ করে। টোকেনগুলির উপর কেবল লুপ করুন, বিন্দুগুলির সাথে তাদের প্রতিস্থাপন করুন এবং ইনপুটটিতে যতক্ষণ না কিছু থাকবে ততক্ষণ গণনা করুন। প্রথমে বড়গুলি গণনা করে, তাই ছোটরা এতে বিচলিত হয় না।

আমি মূলত একবারে সবগুলি প্রতিস্থাপন এবং দৈর্ঘ্যের পার্থক্য গণনা করার চেষ্টা করেছি, তবে এটি আরও কয়েকটি অক্ষর নিয়েছিল :(

Comments

একটি জাভা দেব হিসাবে, আমি এই সংক্ষিপ্ত করতে চাই এবং জাভা একটি পরিবর্তনের জন্য জয় দেখতে চাই। কিছুক্ষণ দেখার জন্য এটিকে আরও খাটো করার উপায় খুঁজে পাইনি to

— ডেডচেক্স

ওয়েল এটি অবশ্যই সামগ্রিকভাবে জিততে পারে না । বর্তমান নেতাটি 22 বাইট এবং এর আকারের জাভাতে অর্থবহ কিছু করার কোনও উপায় নেই। আমার printlnবক্তব্য একার চেয়ে বড় larger আমি এটা দিয়ে সন্তুষ্ট করছি, যদিও: ডি

— Geobits

আমি কিছুটা দেরি করেছি তবে আমি একটি উপায় পেয়েছি ... এতে পরিবর্তন String q[]=করুনString[]q=

— ডেডচেক্স

নিস! বিশ্বাস করতে পারছি না যে আমি এটি মিস করেছি, এটি দেখার জন্য আমার স্ট্যান্ডার্ড তালিকায় রয়েছে :)

— জিওবিটস

আমি কেবল এটি একটি জাভাদেভ হিসাবে কোড গল্ফে প্রবেশ করার চেষ্টা করার পরে আবিষ্কার করেছি, আপনি করতে পারেন এমন কিছু জিনিস দেখে আমি বেশ অবাক হয়েছি

— ডেডচেক্স

Answer 6

সিজেম, 36 32 31 বাইট

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

1 বাইট বন্ধ করে গল্ফ করার জন্য @ অপ্টিমাইজারকে ধন্যবাদ

সিজেএম ইন্টারপ্রেটারে এটি অনলাইনে চেষ্টা করুন ।

কিভাবে এটা কাজ করে

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.

Comments

N*-> `যথেষ্ট হওয়া উচিত।

— অপ্টিমাইজার

@ অপ্টিমাইজ: এটি ভাল কাজ করে। ধন্যবাদ।

— ডেনিস

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

Answer 8

পাইথ, 19 বাইট

jd+Ltl=zc`zd_.:"NBM

এটি @ isaacg এর পাইথ সলিউশন এবং @ 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

Answer 9

জুলিয়া, 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 

Answer 10

পাইথন 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

Comments

আপনি পরে স্থানটি মুছে ফেলতে পারেন in।

— isaacg

পাইথন 2 এ, আপনি string x` দিয়ে স্ট্রিং উপস্থাপনায় রূপান্তর করতে পারেন `

— xnor

Answer 11

এসএএস, 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

Comments

আপনি cats('s/',z,'/x/')জায়গায় ব্যবহার করে একটি দম্পতি বাইট সংরক্ষণ করতে পারেন 's/'||strip(z)||'/x/'।

— অ্যালেক্স এ

দুর্দান্ত, এটি ১৩৯ এর পিছনে বেশ ভ্রমণ ছিল :)

— ভাজা ডিম

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

— অ্যালেক্স এ

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

— অ্যালেক্স এ

তবে আপনি আধুনিক স্টাইলের ম্যাক্রো ব্যবহার করে 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;

— অ্যালেক্স এ

Answer 12

PHP4.1, 92 বাইট

সংক্ষিপ্ততম নয়, তবে পিএইচপি থেকে আপনি আর কী আশা করবেন?

এটি ব্যবহার করতে, একটি কুকি, পোস্ট, জিইটি, সেশনে একটি কী সেট করুন ...

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

সংজ্ঞাটি মৌলিক:

• প্রাণীদের নামগুলিতে স্ট্রিং বিভক্ত করুন
• সেখানে কতগুলি উপাদান রয়েছে তা গণনা করুন
• বিয়োগ 1 (একটি খালি স্ট্রিং 1 টি উপাদান সহ একটি অ্যারে দেবে)
• গণনা এবং প্রাণীর নাম আউটপুট করুন
• একটি খালি স্ট্রিং ব্যবহার করে এটির সাথে একসাথে যোগ দিন (যা স্ট্রিং হ্রাস করবে এবং শেষ প্রাণীটি সরিয়ে ফেলবে)

সহজ, তাই না?

Answer 13

জাভাস্ক্রিপ্ট, 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);

Comments

কাজ করে না: All 6 counts must be shown, separated by spaces, even when they are 0.। পরীক্ষার কেস:N

— edc65

@ edc65 ওহো আমি শুধু সেই অংশটি মিস করেছি missed যে ইশারা জন্য ধন্যবাদ। এটি 8chars এর জন্য নির্ধারণ করুন

— C5H8NNaO4

Answer 14

পার্ল, 46

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

Comments

এটি কিভাবে কাজ করে তার ব্যাখ্যা?

— কেইন

Answer 15

স্পেসবিএএস - 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 স্ট্রিংয়ের উপরে লুপিং রাখে (বৃহত্তম থেকে শুরু করে), পাওয়া গেলে এটি প্রতিস্থাপন করে।

স্পেসবিএসের মূল জেডএক্স / সিনক্লেয়ার বেসিকের (তালিকার মধ্য দিয়ে লুপিং করা, অক্ষরগুলি সন্ধান করা) কিছু সুন্দর স্পর্শ রয়েছে যা আমি এখনও খুঁজে পাচ্ছি।

Answer 16

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

Comments

কিছু বাইট সংরক্ষণ করার for(;;*s++){...}পরিবর্তে ব্যবহার করবেন না do{...}while(*s++);? এছাড়াও, আপনার মধ্যে নতুন লাইনের চরিত্রের প্রয়োজন নেই printf।

— স্পিক্যাট্রিক্স

আমার মনে হয় আপনি বোঝানো for(;*s;s++)। তবে আমার শেষ নাল চরিত্রটি লুপ করা দরকার। সংরক্ষণের জন্য ভাল কল \n, যা প্রয়োজন হয় না।

— কিছু ব্যবহারকারী

Answer 17

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

Answer 18

হাস্কেল - 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কোনও ক্রমেই সম্ভব হওয়ার সংখ্যার রিপোর্ট করা হত ।

Answer 19

বাশ - 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

Answer 20

আরএস , 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
#.*/

এটি শুরুতে দুর্দান্ত অংশ। এটি মূলত ছোট হাতের অক্ষর এবং আন্ডারস্কোরের ক্রম নেয়, এগুলিকে মূল অক্ষরে রূপান্তরিত করে, তাদের একসাথে দলবদ্ধ করে এবং themোকানো পাউন্ডের আগে রাখে। পাউন্ডের উদ্দেশ্য হ'ল ইতিমধ্যে প্রক্রিয়া করা সিক্যুয়েন্সগুলি পরিচালনা করা।

#

পাউন্ডটি লাইনের শুরুতে পুনরায় .োকানো হয়।

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

মূল অক্ষরগুলি সংশ্লিষ্ট পাঠ্যগুলির সাথে তাদের পাঠ্য সমতুল্য দ্বারা প্রতিস্থাপিত হয়। আরএসে একটি বাগের কারণে (আমি এটি সংশোধন এবং অযোগ্য বলে ঝুঁকি নিতে চাইনি), খালি সিকোয়েন্সগুলিতে রূপান্তরিত হয় (^^), যা দ্বিতীয় থেকে শেষ লাইনে 0 দ্বারা প্রতিস্থাপিত হয়। খুব শেষ লাইনটি কেবল পাউন্ড সরিয়ে দেয়।

Answer 21

কেডিবি (কিউ), 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"

Answer 22

হাস্কেল: 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

Comments

কিছু পরামর্শ: আপনি pএবং sশুধুমাত্র একবার ব্যবহার করছেন , সুতরাং এটির নাম দেওয়ার দরকার নেই (-> a#[]=[]:a#"NBM", এর জন্য একই p)। বিটিডাব্লু: words"N B M NB BM NBM"স্ট্রিংগুলির তালিকার পরিবর্তে অতিরিক্ত বাইট সংরক্ষণ করে। importশুধুমাত্র জন্য intercalate, এটা খাটো Te এটি পুনরায় বাস্তবায়ন: ...putStrLn.tail.((' ':)=<<)$map...এবং পরিত্রাণ পেতে import। সমস্ত গার্ডদের |সংজ্ঞাটিতে #একটি একক লাইনে রাখুন এবং এর 1<2পরিবর্তে ব্যবহার করুন True: ...#(b:m)|a==b=...l#m|1<2=[]......

— নিমি

... ?একটি তালিকা ধী সঙ্গে খাটো সংজ্ঞায়িত করা যেতে পারে: c?t=sum[1|x<-c,x==t]। আবার, আপনি ব্যবহার করছেন ?শুধুমাত্র একবার, তাই শরীর সরাসরি ব্যবহার করুন: ...show(sum[1|x<-l#[],x==t])।

— নিমি