আরএলই ব্রেনফাক উপভাষা lect

14

আরএলই ব্রেনফাক

( বিএফ-আরএলই সম্পর্কিত )

ব্রেইনফাকের অনুমানিক আরএলই ( রান-লেংথ এনকোডিং ) উপভাষা 8 টি কমান্ডের প্রতীকগুলি গ্রহণ করে এবং সংখ্যাগুলিও গ্রহণ করে। অঙ্কগুলি কোনও কমান্ডের ক্রমাগত পুনরাবৃত্তির সংখ্যার প্রতিনিধিত্ব করতে ব্যবহৃত হয়, সুতরাং উত্স কোডের রান-লেংথ এনকোডিংয়ের অনুমতি দেয়।

8>সমান >>>>>>>>।

দৈর্ঘ্য সর্বদা কমান্ডের বাম দিকে থাকে।

আপনার কাজটি হ'ল সংক্ষিপ্ততম প্রোগ্রাম / ফাংশন লিখুন যা ইনপুট স্ট্রিং (আরএলই ব্রেইনফাক খণ্ড) নিয়মিত ব্রেনফাক প্রোগ্রামে অনুবাদ করে into

উদাহরণ স্বরূপ:

ইনপুট:

10+[>+>3+>7+>10+4<-]3>2+.>+.7+2.3+.2<2+.>15+.>.3+.6-.8-.2<+.<.

Ouptut:

++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>++.>+.+++++++..+++.<<++.>+++++++++++++++.>.+++.------.--------.<<+.<.

প্রতিটি ভাষার বাইট গণনায় সংক্ষিপ্ততম কোডটি জিতবে।

code-golf  string  brainfuck 
— গ্যালেন ইভানভ
সূত্র
10
হাই, আমি এই প্রশ্নটিকে হ্রাস করেছি কারণ আমি অনুভব করি যে এটি এক বা দুটি আরএলই ভিত্তিক রেজেক্স অ্যালগরিদম দ্বারা প্রভাবিত হতে চলেছে যা কেবলমাত্র প্রতিটি ভাষার পৃথক রেজেক্স বিন্যাসে অনুলিপি করা হয়েছে। এখানে কিছু গল্ফ করার খুব কম জায়গা আছে।
— অ্যাডমবর্কবার্ক
13
এটি দেখতে অনেকটা জেনেরিক রান-দৈর্ঘ্যের ডিকোডিং চ্যালেঞ্জের মতো লাগে । এখানে পার্থক্যটি হ'ল মাল্টিডিজিট সংখ্যাগুলি সমর্থিত। আমি মনে করি এটি এখনও একটি ডুপ, তবে আমি এটি হাতুড়ি করব না।
— xnor
4
@ এক্সনর অন্য পার্থক্যটি হ'ল অঙ্কগুলি সর্বদা উপস্থিত থাকে না - আরএলই-এর এই ফর্মটি অনেক কম কাঠামোর গ্যারান্টি দেয় এবং আইএমও আকর্ষণীয় কৌশলগুলির দিকে নিয়ে যেতে পারে (
— লিন
1
@ লিন আমি এটিকে স্পষ্টভাবে বর্ণনা করি নি, তবে উদাহরণে যেমন দেখা যায়, 1 বাদ দেওয়া হয়েছে; 0 যুক্ত করা স্ট্রিংকে ছোট করে না, সুতরাং উত্তরটি হ'ল, কোনও জেরো কোনও কমান্ড প্রিপেন্ড করতে পারে না।
— গ্যালেন ইভানভ 14
6
অন্য দিকটি আরও আকর্ষণীয় হবে বলে আমি মনে করি (অর্থাত্ সংক্ষিপ্ত সমতুল্য আরএলই ব্রেনফাক প্রোগ্রামে একটি ব্রেইনফাক প্রোগ্রামকে রূপান্তর করুন)।
— পাওলো ইবারম্যান

উত্তর:

24

পাইথন 2 , 62 61 বাইট

lambda s:eval(re.sub('(\d*)(.)',r'+1*\1*1*"\2"',s))
import re

এটি অনলাইন চেষ্টা করুন!

রেজেক্সের বিকল্পটি 3<2+-স্ট্রিংয়ে প্রসারিত :

+1*3*1*"<"+1*2*1*"+"+1**1*"-"

যা তখন evalএড। (নোট কিভাবে যখন \1খালি থাকে, আমরা পেতে 1**1 = 1।) প্রথম +একটি ইউনারী অপারেটর যা প্রথম সংখ্যা বেঁধে, এবং অন্যান্য +গুলি স্ট্রিং সংযুক্তকরণের হয়। এটি আরও স্পষ্টভাবে প্রহার করে

lambda s:re.sub('(\d+)(.)',lambda m:int(m.group(1))*m.group(2),s)
import re

14 বাইট দ্বারা সাধারনত "\2"সবসময় কাজের না, কিন্তু সৌভাগ্যক্রমে \এবং "brainfuck কমান্ড নয়।

xnor একটি বাইট সংরক্ষণ করে, 1*\1*1কৌশল সরবরাহ করে । পূর্বে আমি \1Lরেজেজেসে ছিলাম , এবং L=1ল্যাম্বডা যুক্তি হিসাবে সংজ্ঞায়িত হয়েছিল যা খুব সুন্দর: 3Lলম্বা ইন আক্ষরিক এবং Lএকটি পরিবর্তনশীল।

— লিন
সূত্র
1
Lখালি স্ট্রিং পরিচালনা করতে এটি হ'ল স্মার্ট ব্যবহার । আরও একটি ছোট উপায় আছে, যদিও r'+1*\1*1*"\2"'।
— xnor
3
... import reল্যাম্বদার নীচে কেন ?
— মনিকা এর মামলা
1
ল্যাম্বডা প্রথমে রাখার অর্থ কোডটি কীভাবে চাওয়া হবে তা দেখানোর জন্য আমি টিওআরুনের শিরোলেখ / পাদচরণ বৈশিষ্ট্যটি ব্যবহার করতে পারি (আমি শিরোনামে রেখেছি f=\ - এখন ল্যাম্বদার একটি নাম আছে!)
— লিন
18

পাইথ , 2 বাইট

r9

এখানে চেষ্টা করুন!

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

r9 - সম্পূর্ণ প্রোগ্রাম STDIN এর থেকে স্ট্রিং গ্রহণ করছে।

r - পাইথের বর্ধিত স্ট্রিং ক্রিয়াকলাপগুলির সেট।
 9 - সেই সেটটির নবম কমান্ড (রান-লেংথ ডিকোড)। এটি বহু সংখ্যার সংখ্যা সমর্থন করে।
— মিঃ এক্সকোডার
সূত্র
31
প্রয়োজনীয় অনুস্মারক: তুচ্ছ সমাধানগুলি উপস্থাপন বন্ধ করুন ( এটির মতো)।
— মিঃ এক্সকোডার
4
এই আদেশটি সম্পর্কে জানার পক্ষে এটি তুচ্ছ নয়, এবং সংখ্যাটি নিখোঁজ হওয়ার সময় এটি কাজ করে তা জানতে
— লুইস মেন্ডো
1
@ মিঃ এক্সকোডার অপেক্ষা করুন, কী? কোড গল্ফের পুরো পয়েন্টটি কি সর্বনিম্ন বাইট গণনা না করে?
— ডিকন 15
4
@ ডাইকন হ্যাঁ, তবে একটি গল্ফ পাইথন উত্তর সাধারণত 2-বাইট গল্ফল্যাং উত্তরের চেয়ে অনেক বেশি শক্ত এবং মজাদার।
— স্টিফেন
8
@ ডিকন আপভোটিং কেবল সংক্ষিপ্ত সমাধানগুলিকে সমর্থন করার মতো নয়। গল্ফিং ভাষাগুলিতে তুচ্ছ সংক্ষিপ্ত সমাধানগুলির বিপরীতে আকর্ষণীয় এবং সৃজনশীল এমন সমাধানগুলি উত্সাহ দিতে ব্যবহারকারীদের সাধারণত উত্সাহ দেওয়া হয়।
— LyricLy
17

লুয়া, 65 64 63 বাইট

দুর্দান্ত! একবারের জন্য লুয়া পাইথনকে পরাজিত করে!

সম্পাদনা: @ জারহান্ডারকে একটি বাইট সংরক্ষণ করা, একটি ফলাফল কার্যকর করার জন্য কার্যকর কৌশলটির জন্য তাকে ধন্যবাদ

print(((...):gsub("(%d+)(.)",function(a,b)return b:rep(a)end)))

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

print)((...):gsub(             -- iterate over the argument and replace the strings
            "(%d+)(.)",       -- matching this pattern (at least one digit and a non-digit)
            function(a,b)     -- capture the digit and non-digit parts in separate variables
              return b:rep(a) -- repeat the non-digit a times, a being the digit part
            end)))
— Katenkyo
সূত্র
1
— লিন
@ লিন ওয়ান বাইট ডাউন, আরও 3 জন!
— কাটেনকিও
আপনি ,""মুদ্রণের পুরো আর্গুমেন্টটি মুছে ফেলা এবং বন্ধ করে একটি বাইট সংরক্ষণ করতে পারেন । পেরেনগুলিতে সংযুক্ত এক্সপ্রেশনগুলি লুয়ার একটি মানের সাথে সামঞ্জস্য করা হয় (দেখুন lua.org/manual/5.3/manual.html#3.4 )।
— ঝাড়মন্ডার
8

vim, 29 25 23 22 16 বাইট

:s/\D/a&<C-v><ESC>/g
D@"

<C-V>0x16, <ESC>0x1 বি হয়।

এটি প্রতিটি অ-অঙ্কের পরিবর্তে একটি কমান্ডের সাহায্যে কাজ করে যা সেই চরিত্রটি বাফারে যুক্ত করে। গণনাগুলি একা থাকে এবং সেই আদেশগুলি সংশোধন করে। এই মুহুর্তে, বাফার একটি ভিমস্ক্রিপ্ট প্রোগ্রাম যা কাঙ্ক্ষিত ব্রেইনফাক প্রোগ্রাম তৈরি করে, তাই আমরা এটিকে একটি রেজিস্টারে টানতে এবং এটি পরিচালনা করি।

এটি অনলাইন চেষ্টা করুন!

সম্পাদনা করুন: আকার হ্রাস পরামর্শের জন্য ধন্যবাদ: এইচ.পি.উইজ: 5, দ্য ফ্যামিলি ফ্রুট: 5, ডিজেএমসিমেহেম: 1

— রশ্মি
সূত্র
TheFamilyFroot এর একটি দুর্দান্ত গল্ফিং টিপ ছিল: আপনার ক্যাপচারিং গ্রুপ ব্যবহার করার দরকার নেই, আপনি কোনও গ্রুপ না রেখে কেবলমাত্র গ্রুপ 0 (&বা\0)ব্যবহার করতে পারেন। এছাড়াও, আমার কাছ থেকে একটি টিপ না TheFamilyFroot যা আপনি ব্যবহার করতে পারেDপরিবর্তেddজন্য-1বাইট।
— জেমস
1
সমস্ত পরামর্শ, এইচ.পি.উইজ, দ্য ফ্যামিলিফ্রুট এবং ডিজেএমসিমেহেমের জন্য ধন্যবাদ। এটি এটিকে 18 বাইট পারল সমাধানের নীচে এবং দ্বিতীয় স্থানে নিয়ে এসেছিল। এখন আমাদের আরও 15 টি বাইট খুঁজে বের করতে হবে যা থেকে আমরা মুক্তি পেতে পারি এবং এটি পাইথ বিল্টিনকে পরাস্ত করবে। :-)
— সত্যজিৎ
8

আরএলই ব্রেনফাক, 204 বাইট

-3>,[[->+>+<<]>>47-3<10+<->[-<+4>->+<[>-]>[3<+<[-]4>->]5<]3>57+[-]+<<[>>-<<[3>+3<-]]3>[3<+3>-]<[>>+7<+[->11-<+[-<+]->>+[-<[->10+<]>>+]<[-4>.4<]4>[-]-3<-<+7>-7<[8>+8<-]]8>[8<+8>-]<[3<.3<[-]-6>-]7<--5>-]<,]

যেহেতু আমি এটি বুঝতে পারি ব্রেইনফাক পরিবেশের জন্য চশমাগুলি সুপার-সংজ্ঞায়িত নয়। এই প্রোগ্রামটি ধরে নিয়েছে যে টেপের কক্ষগুলি নির্বিঘ্নে বড় ধনাত্মক এবং নেতিবাচক পূর্ণসংখ্যার অনুমতি দেয়, কোনও প্রবাহ ছাড়াই। এই কোডটি নন-কমান্ডের মতামতগুলিও প্রতিলিপি করবে, তবে এটি মন্তব্যের রান-দৈর্ঘ্যের এনকোডিংকে প্রসারিত করবে (উদাঃ "3 বি দেখুন" b "দেখুন বিবিবি")। ফলস্বরূপ প্রোগ্রামটি একইভাবে চালানো উচিত, তাই আমি খুব বেশি উদ্বিগ্ন নই।

আমি নিশ্চিত যে আমি এখনও এই থেকে কয়েক বাইট বন্ধ গল্ফ করতে পারি তবে আমি এটির সাথে কাজ করে ক্লান্ত হয়ে পড়েছি।

এখানেএটি পরীক্ষার জন্য আমি যে কাস্টম ইন্টারপ্রেটার + টেস্ট ব্যবহার করছি তাআপনি যদি স্ট্যান্ডার্ড ইনপুট বাক্সে এটি ইনপুট পাস করেন তবে এটি পরীক্ষা চালানোর পরিবর্তে সেই ইনপুটটির বিরুদ্ধে চালানো উচিত।

আমার অগোছালো অবারিত ওয়ার্কপ্যাড:

->>>,
[
  [->+>+<<]>>  clone 2 into 3 and 4
  if read char is between zero and nine
  (num buffer | max | is_digit | original char | read | temp0 | temp1)
                                                   ^
  47-
  <<<10+  set max
  <->  handle gross 0 case
  [  while max
    -  max minus one
    <+  buffer plus one
    >>>>-  read minus one
    IF STATEMENT : if read is 0
    >+<
    [>-]>[<
      <<+  is_digit = 1
      <[-]>>>  max = 0
    >->]<<  back to read
    <<<     back to max
  ]

  >>>57+[-]  reset `read` (need to add first to avoid infinite negative)

  +<<  check is_digit flag
  ( end marker | 0 | is_digit | original char | temp0 | temp1 | temp2 | temp3)
  x[  IF READ WAS DIGIT
    CODE 1a
    >>temp0 -<<x
    [>>>temp1 +<<<x-]
  ]
  >>>temp1 [<<<x+>>>temp1 -]
  <temp0 [
    START CODE 2a
    >>temp2 +
    7<y+[  IF THERE IS A NUMBER PREFIX
      -
      START CODE 1b
      >11-  end marker is negativeone
      <   on smallest digit
      +[-<+]->  find largest digit
      >+[  sum digits until we hit the end marker negativeone
        -
        <[->10+<]>  h1 = ten * h0; h0 = 0
        >
        +
      ]  leave the negativeone at zero though
      num | 0 | 0 | 0 | original char
            ^
      <num
      [->>>>.<<<<]  print `original char` `num` times
      >>>>[-]-  set `char` to negativeone
      <<<- last ditch guess
      END CODE 1b
      <y+
      7>temp2 -
      7<y[8>temp3 +8<y-]
    ]
    8>temp3 [8<y+8>temp3 -]
    <temp2 [
      CODE 2b
      <<<.  print original char
      <<<[-]-  set num buffer to new left edge
      >>>>>>temp2 -
    ]
    7<y--

    END CODE 2a
    5>temp0 -
  ]
  <
  ,
]
— Orez
সূত্র
গ্রস 0 কেসটি কি কেবল প্রকৃত শূন্য গণনাগুলিকে বোঝায় বা পার্সিংয়ের সময় এটিও ঘটে 10+? যেমন ? ওপি একটি মন্তব্যে স্পষ্ট করে জানিয়েছে যে গণনা সর্বদা 0 এর চেয়ে বেশি হবে, তাই আপনি যদি পূর্বের হয় তবে কিছু বাইট ছাঁটাই করতে সক্ষম হতে পারেন।
— রায়
গ্রস 0 ক্ষেত্র হল যেকোনো 0. পার্স যেহেতু জন্য while maxলুপ সবসময় একবার অন্তত রান, এবং আমি নিঃশর্তভাবে বাফার যেখানে আমি যে লুপ অঙ্ক মান সংরক্ষণ, আমি এ -1 যে বাফার শুরু করতে upping করছি। আমি ভাবছি যদি আমি যুক্তি যে বাফার যাব দ্বারা কিছু বাইট বাঁচাতে পারে value+1যদিও 🤔
— Orez
5

টেক্স, 124 বাইট

\newcount\n\def\b{\afterassignment\r\n0}\def\r#1{\ifx;#1\else\p#1\expandafter\b\fi
}\def\p#1{#1\ifnum\n>1\advance\n-1\p#1\fi}

(দৃশ্যমান হতে দুটি লাইনে লিখেছিলেন, তবে কোডটি একটি লাইনে লেখা যেতে পারে)

এটি এমন ম্যাক্রো সংজ্ঞায়িত করে \bযা ফর্মটিতে ইনপুট নেয় \b<input>;এবং নথিতে আউটপুটটি প্রিন্ট করে।

— ম্যানুয়েল
সূত্র
5

রেটিনা , 28 23 বাইট

-২ বাইটের জন্য @ লিওকে ধন্যবাদ

\d+
$*
+`1(1\D)
$1$1
1

এটি অনলাইন চেষ্টা করুন!

— ovs
সূত্র
আপনি কি \bদ্বিতীয় রেনেক্সে কেবলমাত্র 1প্রতি রানের সাথে একটির সাথে মেলে 1?
— নিল
অথবা আপনি ভালো কিছু করতে পারে এই
— লিও
4

পাইওন , 66 বাইট

print(re.sub("\d+.",lambda k:(int(k.group()[:-1])*k.group()[-1]),a

এটি অনলাইন চেষ্টা করুন!

পাইওন কেবলমাত্র পাইথন, তবে এটি সংক্ষিপ্ত কারণ reআপনি এটি ব্যবহার করার সময় স্বয়ংক্রিয়ভাবে আমদানি করা হয় এবং aস্বয়ংক্রিয়ভাবে কোনও যুক্তি বা ইনপুটতে সেট করা থাকে

-4 বাইটস মিঃ এক্সকোডারকে ধন্যবাদ

— HyperNeutrino
সূত্র
আপনি পরিবর্তন করা উচিত g[0]কাছে g[:-1](প্রদত্ত পরীক্ষা কেস বা কোন সংখ্যা 9 বেশী ব্যর্থ)।
— মিঃ এক্সকোডার 13
যাইহোক আপনি এমনকি কেন এমন একটি প্রয়োজন lambdaযা আসলে বাইটগুলি অপচয় করে? গল্ফড এবং 66 বাইটের
— মিস্টার এক্সকোডার
@ মিঃ এক্সকোডার হুফ, আমি কী ভাবছিলাম তা নিশ্চিত নন ... ধন্যবাদ
— হাইপারনিউটারিনো
@ মিঃ এক্সকোডার ওহ হ্যাঁ আমি অনেক কিছু গল্ফ করার চেষ্টা করি যা শেষ পর্যন্ত উগল্ফদের এক্সডি হয়ে যায়
— হাইপারনিউটারিনো
4

পাইথন 2 , 100 93 89 বাইট

-7 মিঃ এক্সকোডারকে ধন্যবাদ দিয়ে

n=b=""
for y in input():
 if"/"<y<":":n+=y
 elif""==n:b+=y
 else:b+=y*int(n);n=""
print b

এটি অনলাইন চেষ্টা করুন!

— ElPedro
সূত্র
93 বাইটের জন্য কয়েকটি গল্ফ । এটি আরও গল্ফ করা যেতে পারে যদিও।
— মিঃ এক্সকোডার
3

আর , 121 106 90 বাইট

function(s,a=strsplit)cat(rep(el(a(gsub("\\d","",s),"")),pmax(el(a(s,"\\D")),"1")),sep="")

এটি অনলাইন চেষ্টা করুন!

rep()সংখ্যার জন্য বাধ্য করবে যে বুঝতে পেরে 15 বাইট সংরক্ষণ করা হয়েছে। মূলত pmaxখালি স্ট্রিংগুলি প্রতিস্থাপনের ব্যবহার থেকে জিউসেপিকে আরও 16 ধন্যবাদ সংরক্ষণ করা হয়েছে1

function(s) {
  x <- el(strsplit(s,"\\D")) # Split the string on anything that is not a digit...
  x <- pmax(x, "1")          # ... and replace any empty strings with 1. This gets us the numbers of repeats
  y <- gsub("\\d","",s)      # Remove all digits from the original string...
  y <- el(strsplit(y))       # ... and split into individual units. This gets us the symbols to repeat
  z <- rep(y, x)             # Implement the repeats. x is coerced to numeric
  cat(z, sep = "")           # Print without separators
}
— user2390246
সূত্র
খুব সুন্দর! আমি বিশ্বাস করি ifelse(x>"",x,1)একটি বাইট সংক্ষিপ্ত, এবং \\Dএর সমতুল্য [^\\d] এবং সর্বোত্তম, আপনার প্রয়োজন নেই perl=T, সুতরাং এটি একটি মিষ্টি 99 বাইট । আমি সত্যিই ভাবিনি যে এটি 100 বাইটের চেয়ে কম হতে পারে!
— জিউসেপ
— জিউসেপ
@ জিউজ্পে pmaxএকটি দুর্দান্ত বড় উন্নতি দেওয়ার খুব চতুর ব্যবহার - ধন্যবাদ!
— ব্যবহারকারী 2390246
প্রতিস্থাপন "1"সঙ্গে 1যেমন pmaxকরতে বাধ্য হবে characterতুলনা জন্য।
— জিউসেপ
এলিয়াসগুলি পরিবর্তন করে 85 বাইট
— জিউসেপ্প
2

পাওয়ারশেল , 66 62 বাইট

-join("$args"-split'\b'|%{(,$(,$_[0]*$n+$_))[!!($n=$($_-1))]})

এটি অনলাইন চেষ্টা করুন!

ভাঙ্গন

কী এলোমেলো!

$argsআরএলইআর স্ট্রিং যুক্ত একক উপাদান অ্যারে থেকে শুরু করে , আমি এটিকে উদ্ধৃত করে একটি প্রকৃত স্ট্রিংয়ে জোর করছি।

তারপরে এটিকে শব্দের বাউন্ডারি দিয়ে ভাগ করুন ( \bরেগেজেমে)। এটি আমাকে স্ট্রিংগুলির একটি অ্যারে দেবে, যেখানে প্রতিটি উপাদান হয় একটি সংখ্যা বা বিএফ টোকেন (গুলি) যে সংখ্যার পরে আসে। সুতরাং উদাহরণস্বরূপ, এই বিভক্ত অ্যারের প্রথম 4 উপাদান 10, +]>+>, 3, +>(সমস্ত স্ট্রিং আছে)।

পরবর্তী, আমি নল যে মধ্যে ForEach-Object( %) প্রতিটি সঙ্গে মোকাবিলা করার জন্য উপাদান ।

মাঝখানে হ'ল একটি সুপরিচিত পাওয়ারশেল গল্ফিজম; এটি মূলত একটি ডিআইওয়াই টেরিনারি অপারেটর, যাতে আপনি একটি 2 এলিমেন্ট অ্যারে তৈরি করেন তারপরে আপনি যে বুলিয়ান এক্সপ্রেশনটি পরীক্ষা করতে চান তা ব্যবহার করে সূচক তৈরি করে যার ফলস্বরূপ একটি মিথ্যা ফলাফল আপনাকে উপাদান 0 দেয় এবং সত্য ফলাফল আপনাকে উপাদান 1 দেয়।

এই ক্ষেত্রে, আমি আসলে অ্যানারি কমা ,অপারেটরের সাথে একটি একক উপাদান অ্যারে তৈরি করি , কারণ আমি সত্যিকারের ক্ষেত্রে আউটপুট চাই না।

প্রথমে সূচকের দিকে নজর দেওয়া যাক যদিও পরে এটি কার্যকর করা হয়।

এর ধারণাটি হ'ল $_(বর্তমান উপাদান) হয় একটি বৈধ সংখ্যা বা অন্য কোনও স্ট্রিং হতে পারে। যদি এটি একটি সংখ্যা হয় তবে আমি $nসেই সংখ্যাটি বিয়োগ 1 এর মান হতে চাই (একটি সংখ্যা হিসাবে স্ট্রিং নয়)। যদি এটি না হয়, আমি চাই$n মিথ্যা-ওয়াই হতে ।

পাওয়ারশেল সাধারণত বাম পাশের ধরণের দিকে ডান-হাতের মানকে চাপিয়ে দেওয়ার চেষ্টা করে তবে এটি অপারেশনের উপর নির্ভর করতে পারে। অতিরিক্ত হিসাবে, "10"+5আপনাকে একটি নতুন স্ট্রিং দেবে "105", যেখানে 10+"5"আপনাকে একটি পূর্ণসংখ্যা দেবে (15 ) দেবে।

তবে স্ট্রিংগুলি বিয়োগ করা যাবে না তার পরিবর্তে পাওয়ারশেল বিয়োগের বাম পাশে একটি স্ট্রিং সহ স্বয়ংক্রিয়ভাবে সংখ্যার মানটি নির্ধারণ করতে পারে, তাই "10"-5দেয় 5।

সুতরাং, আমি দিয়ে শুরু করি $_-1, যা $_আসলে একটি নম্বর হওয়ার পরে আমাকে যে নম্বরটি দিতে চাইবে তা দেবে, কিন্তু যখন এটি না হয় আমি কিছুই পাই না। পৃষ্ঠতলে, "কিছুই" মিথ্যা নয়, তবে সমস্যাটি হ'ল এই কার্যভারটি কার্যকর করা বন্ধ করে দেয়, সুতরাং $nএর আগের মানটি ধরে রাখতে হবে; আমি যা চাই না!

আমি যদি এটি একটি সুপ্রেসপ্রেসনে আবদ্ধ করি, তবে যখন এটি ব্যর্থ হয়, আমি আমার মিথ্যা মান পাই: $($_-1) ।

যে সমস্ত নির্ধারিত হয়ে যায় $nএবং যেহেতু সেই অ্যাসাইনমেন্টটি নিজেই প্রথম বন্ধনীতে আবৃত হয়, তাই যে মূল্য নির্ধারিত হয়েছিল $nতা পাইপলাইনেও যায়।

যেহেতু আমি এটি সূচকটিতে ব্যবহার করছি এবং আমি চাই 1যে রূপান্তরটি সফল হয়েছে, আমি এই বুলিয়ানকে রূপান্তর করতে দুটি বুলিয়ান- notএক্সপ্রেশন ব্যবহার করি !!। একটি সফল সংখ্যার রূপান্তর সত্য হিসাবে শেষ হয়, যদিও মিথ্যা কিছুই না আমাদের সেই মিষ্টি, মিষ্টি 0দেয় যা সেই ভুয়া টর্নারি অ্যারেতে কেবলমাত্র উপাদান ফেরত দেয়।

সেই অ্যারেটিতে ফিরে আসার উপাদানটি হ'ল: $("$($_[0])"*$n*$_) $(,$_[0]*$n+$_)

"$($_[0])"- এটি বর্তমান উপাদানটির প্রথম চরিত্রটি পাওয়ার জন্য একটি বিরক্তিকর দীর্ঘ পথ (আসুন বলে নেওয়া যাক, +থেকে পেয়ে যাচ্ছি +[>+) তবে স্ট্রিং হিসাবে এবং কোনও [char]অবজেক্ট হিসাবে নয় । আমার এটি স্ট্রিং হওয়া দরকার কারণ আমি এটির সদৃশ করার জন্য একটি স্ট্রিংটিকে একটি সংখ্যা দ্বারা গুণ করতে পারি, তবে আমি এটি একটি অক্ষর দিয়ে করতে পারি না।

প্রকৃতপক্ষে আমি [char]স্ট্রিংয়ের পরিবর্তে অ্যারে ব্যবহার করে 4 টি অক্ষর সংরক্ষণ করতে সক্ষম হয়েছি (অন্য একটি কমা কমা ব্যবহার করে ,), তাই আমি উদ্ধৃতিগুলি এবং অতিরিক্ত উপ-এক্সপ্রেশনটি সরিয়ে ফেলতে সক্ষম হয়েছি। আমি পারি অ্যারের উপাদানগুলি নকল একটি অ্যারের গুণ । এবং যেহেতু এই পুনরাবৃত্তির পুরো ফলাফলটি যাইহোক অ্যারে হয়ে শেষ হয় এবং -joinএড করা দরকার, এখানে অ্যারে ব্যবহার করে কোনও অতিরিক্ত ব্যয় হয় না।

তারপর, আমি সংখ্যাবৃদ্ধি যে স্ট্রিং দ্বারা অ্যারে $n, এটা অনুরূপ $nবার। মনে আছে$n হতে পারে $nullবা এটি পূর্ববর্তী অঙ্কগুলির বিয়োগের মান হতে পারে।

তারপরে +$_সেই উপাদানটির সদৃশ প্রথম অক্ষরটির শেষে বর্তমান উপাদান যুক্ত করুন। এই জন্য$n মাইনাস এক।

এই ভাবে, 9 এর 10+[>+সমাপ্তি দিয়ে শেষ হবে $n, তারপরে আমরা 9 +এর তৈরি করব এবং এটি আবার যুক্ত করব+[>+ প্রয়োজনীয় স্ট্রিংটিতে প্রয়োজনীয় 10 টি পেতে, পাশাপাশি যাত্রার জন্য অন্যান্য একক উপাদানগুলি যুক্ত করি।

উপাদানটি একটি subexpression মধ্যে আবৃত $()কারণ যখন $nহয় $null, সম্পূর্ণ এক্সপ্রেশন ব্যর্থ হয়, তাই অ্যারের তৈরি ব্যর্থ হয়, তাই সূচক কখনও চলবে না, তাই$n কখনই বরাদ্দ দেওয়া হয় না।

কারণ আমি এই তিন কৌতুক ব্যবহারের ইঙ্গিত নিজস্ব চালচলন এক কারণ: একটি বাস্তব তিন অপারেটর মতো অভিব্যক্তি উপাদান সংজ্ঞায়িত না যে বিষয়টি জন্য মূল্যায়ন পেতে থাকুক বা না থাকুক তারা "নির্বাচিত" হয়, এবং প্রথম।

যেহেতু আমাকে নিয়োগ এবং তারপরে $nপৃথক পুনরাবৃত্তিগুলি ব্যবহার করা দরকার , এটি সহায়ক। পূর্বের পুনরাবৃত্তির $nমানটির সাথে ত্রৈমাসিক অ্যারে উপাদানটির মানটি মূল্যায়ন হয়, তারপরে সূচকটি $nবর্তমান পুনরাবৃত্তির জন্য পুনরায় বরাদ্দ দেয়।

তাহলে ForEach-Object লুপগুলি তার অনুমিত সমস্ত কিছু আউটপুট করে শেষ করে দেয় (ত্রুটিগুলির একটি গোছা আমরা উপেক্ষা করি), তবে নতুন স্ট্রিংগুলির অ্যারে হিসাবে।

সুতরাং পুরো জিনিসটি প্রথম বন্ধনীতে আবৃত হয় এবং তারপরে -joinআউটপুট স্ট্রিং দেওয়ার জন্য অ্যানারি দ্বারা পূর্বে ।

— briantist
সূত্র
1
দুর্দান্ত ব্যাখ্যা, একা ইতিমধ্যে একটি উত্সর্গের পরোয়ানা।
— মাস্তে
1
ধন্যবাদ @ মাস্ট, এবং আপনার মন্তব্যের কারণে আমি আমার উত্তরটি আবার দেখলাম এবং বুঝতে পারলাম কীভাবে আমি 4 বাইট সংরক্ষণ করতে পারি।
— ব্রিটিশবাদী
2

কোয়াডআর , 17 বাইট

\d+.
¯1((⍎↓)⍴↑)⍵M

এটি অনলাইন চেষ্টা করুন!

কোডটির সঠিক সংস্করণ সরবরাহ করার জন্য অ্যাডমকে ধন্যবাদ ।

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

\d+.          ⍝ Regex to match any sequence of digits followed by a character.
¯1((⍎↓)⍴↑)⍵M  ⍝ Transformation line
¯1(      )⍵M  ⍝ Arguments: -1 and the matching expression
   ( ↓)       ⍝ 'Drop' the last item (-1) from the match (⍵M), yielding a string which is a sequence of digits.
    ⍎         ⍝ Execute. In this case, it transforms a string into a number.
        ↑     ⍝ 'Take' the last item (-1) from the match (⍵M), yielding a character.
       ⍴      ⍝ Reshape it. That will take the character resulting from the 'Take' operation and repeat it n times,
              ⍝ where n is the result from the 'Drop' and 'Execute' operations.
— জে স্যালা
সূত্র
এপিএল ফাংশনের সমতুল্য'\d+.'⎕R{¯1((⍎↓)⍴↑)⍵.Match}
— অ্যাডাম
1

জাভা 8, 148 বাইট

s->{for(s=s.format(s.replaceAll("(\\d+)","%1\\$0$1d"),0);!s.matches("\\D+");s=s.replaceAll("0(\\D)","$1$1"));return s.replaceAll("((.)+)\\2","$1");}

গ্যামন জাভা রেগেক্সগুলি কখনও কখনও এতটা বেহুদা হয় .. গতবার এটিকোনও কিছুর জন্যক্যাপচার গ্রুপটি ব্যবহার করার অভাব"$1"ছিল, এখন এটি .. আমিওয়ান-লাইনারের3cসাথেcccবা এর000cসাথেপ্রতিস্থাপন করতে চাইccc, তবে দুর্ভাগ্যক্রমে জাভা এটি ছাড়া কোনওভাবেই করার উপায় রাখেনি has লুপ. আহ ভালো.

ব্যাখ্যা:

এখানে চেষ্টা করুন।

s->{                          // Method with String as both parameter and return-type
  for(s=s.format(s.replaceAll("(\\d+)","%1\\$0$1d"),0);
                              //  Replace every numbers of that many zeroes
                              //  (i.e. "3>2+" -> "000>00+")
      !s.matches("\\D+");     //  Loop as long as the String contains zeroes
    s=s.replaceAll("0(\\D)",  //   Replace every 0 followed by a non-0 character,
                   "$1$1")    //   with two times this captured non-0 character
  );                          //  End of loop
  return s.replaceAll("((.)+)\\2","$1");
                              //  Reduce every repeated character amount by 1,
                              //  and return this as result
}                             // End of method
— কেভিন ক্রুইজসেন
সূত্র
1
হাই কেভিন, আপনাকে এখানে দেখতে ভাল, টুইস্টি বাদে অন্য ধাঁধা নিয়ে কাজ করে :)
— গ্যালেন ইভানোভ
@ গ্যালেনিভানভ ওহ, হাই! আপনি পিপিসিজিতে সক্রিয় ছিলেন কিনা আমার ধারণা ছিল না।
— কেভিন ক্রুইজসেন
আমি সাম্প্রতিককালেই ছিলাম না :) আমি জে শিখছি এবং সিদ্ধান্ত নিয়েছি যে এটি আমার দক্ষতা পরীক্ষা করার জন্য একটি ভাল সুযোগ।
— গ্যালেন ইভানভ 10
1

হাস্কেল , 84 বাইট

f s@(x:r)|(n:m,x:r)<-span(`elem`['0'..'9'])s=(x<$[1..read$n:m])++f r|1<3=x:f r
f e=e

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা:

span(`elem`['0'..'9'])sপ্রদত্ত স্ট্রিংটি sডিজিটের একটি উপসর্গ এবং বাকী অংশগুলিতে বিভক্ত করে । প্যাটার্নে ফলাফলের সাথে মিলছে(n:m,x:r) নিশ্চিত করে যে অঙ্কের উপসর্গটি খালি নয় এবং এর সাথে অঙ্কগুলি xএবং বাকি অংশটি অক্ষরের পরে আবদ্ধ করে r। x<$[1..read$n:m]সংখ্যা n:mহিসাবে স্ট্রিং পড়তে এবং xবহু বার যে পুনরাবৃত্তি । ফলাফলটি বাকী স্ট্রিংগুলির পুনরাবৃত্ত চিকিত্সার সাথে সংঘবদ্ধ হয় r।

— Laikoni
সূত্র
1

আর , 151 বাইট

ব্যবহারকারী 2390246 দ্বারা আউটগল্ফড ! এটি এখন তুলনায় মূলত এটি একটি আবর্জনা পদ্ধতির, তবে আমি এটির উন্নতি অবিরত করব।

function(s,G=substr)for(i in el(strsplit(gsub("(\\d+.)","!\\1!",s),"!")))cat("if"(is.na(g<-as.double(G(i,1,(n=nchar(i))-1))),i,rep(G(i,n,n),g)),sep='')

এটি অনলাইন চেষ্টা করুন!

সতর্কতার একগুচ্ছও প্রকাশ করে।

function(s){
s <- gsub("(\\d+.)","!\\1!",s)               # surround groups with !
X <- el(strsplit(s,"!"))                   # split to groups
for( i in X ){                             # iterate over groups
 n <- nchar(i)                             # length of group
 r <- substr(i,1,n-1)                      # potential number (first n-1 chars)
 d <- substr(i,n,n)                        # last character
 if( is.na(as.double(r)) ){                # if it's not a number
   cat(i)                                  # print out the whole string
  } else {
   cat(rep(d,as.double(r)),sep="")         # repeat d r times, and print with no separator
  }
 }
}

এরপরে, কোনওটি ব্যবহার করা grepতার চেয়ে বেশি দক্ষ কিনা তা দেখুনsubstr

— : Giuseppe
সূত্র
— ব্যবহারকারী 2390246
1

জাভাস্ক্রিপ্ট (ES6), 46 বাইট

a=>a.replace(/(\d+)(.)/g,(_,n,b)=>b.repeat(n))

খুব সহজ ব্যাখ্যা:

a=>a.replace(/(\d+)(.)/g,                      // Match globally the following: a number N followed by a character
                         (_,n,b)=>b.repeat(n)) // Replace each occurrence by the matched character repeated N times
— XavCo7
সূত্র
1

অবিরত লাম্বদা ক্যালকুলাস , 452 বাইট

(λp.λq.(λb.λg.(λi.(λp.λq.λb.p q b)(q(λq.λj.λl.j((λq.λj.qλq.λl.(λu.g i j(λp.u)(g j(λq.λg.q(b(p(λp.λq.p q))(p(λp.λq.p(p q)))q g))(λp.u)(λu.u qλq.λu.g j i q(b l(p(λp.λq.p(p(p(p q)))))q u))))λp.p(λp.λb.q p((λp.λq.l(λp.l)(λp.λq.p q)(λq.p j q)q)p b))λp.λp.p)l q))(λp.p)(λp.p(λp.λp.p)λp.λp.p)(λp.λq.p)))(b(p(λp.λp.p))(p(λp.λq.p(p q)))))(λp.λq.λb.p(q b))λp.λq.q(λp.λq.λb.p(λp.λb.b(p q))(λp.b)λp.p)p)λp.λq.λb.q(q(q(q(q(q(p q b))))))

ইনপুট এবং আউটপুট চার্চ এনকোডযুক্ত ডান ভাঁজ তালিকার সমন্বিত অক্ষর কোডগুলির , উদাহরণস্বরূপ একটি নতুন লাইনের চরিত্র কোড 10 তাই গির্জার এনকোডিং হবে λf.λx.f(f(f(f(f(f(f(f(f(f x)))))))))। "এবিসিডি" কে তালিকায় রূপান্তরিত করা দেখে মনে হচ্ছেλf.λx.f 65 (f 66 (f 67 (f 68 x))) চার্চ-এনকোডযুক্ত সংখ্যার সাথে ।

প্রোগ্রামটিতে একটি এনকোডযুক্ত স্ট্রিং প্রয়োগ করা এবং এটি সমস্তভাবে হ্রাস করা আপনাকে আরএলই প্রয়োগ করে একটি এনকোডড আউটপুট স্ট্রিং দেয়।

— PixelToast
সূত্র
1
হ্যালো এবং সাইটে আপনাকে স্বাগতম! এটি একটি আকর্ষণীয় সমাধানের মতো দেখায় তবে আমরা ভাষাগুলির একটি বৈধ দোভাষী চাইবেন, আপনার কি অনটাইপড ল্যাম্বদা ক্যালকুলাস আছে?
— পোস্ট রক গার্ফ হান্টার
এছাড়াও, qλqস্বরলিপি বলতে কী বোঝায়? আমি এর আগে কখনও দেখিনি।
— জাকারিয়া
1

সি ++, 239 235 বাইট

-4 বাইট জ্যাকারি ধন্যবাদ

#include<regex>
using s=std::string;std::regex m("[0-9]*[<>+.,\\[\\]-]");s t(s r){s d,h;std::sregex_iterator i(r.begin(),r.end(),m),e;while(i!=e){h=(*i)[0];int g=std::strtol(h.data(),NULL,10);g+=!g;d+=s(g,h[h.size()-1]);++i;}return d;}
— HatsuPointerKun
সূত্র
1
আপনি কি পরিবর্তন g=(g?g:1)করতে পারেন g+=!g? যদি এটি কাজ না করে, আপনি চারপাশে বন্ধনীগুলি সরাতে পারবেন নাg?g:1
— জাকারিয়া ý
0

ডার্ট, by 78 বাইট (রিজেক্স সহ), ১০২ বাইট (রেজেক্স ছাড়াই)

রিজেক্স সহ:

(i)=>i.splitMapJoin(new RegExp(r"(\d+)(.)"),onMatch:(m)=>m[2]*int.parse(m[1]))

রেজেক্স ছাড়াই:

(i,[n=0,d=0])=>i.codeUnits.map((c)=>i[d++]*((c-=48)>=0&&c<10?0*(n=n*10+c):n<1?1:(n=0*(c=n))+c)).join()

উভয়ই পছন্দ করা উচিত (<code here>)("input string") ।

রেজেক্স ওয়ান বেশ স্ট্যান্ডার্ড তবে রেজেক্স-কম একটি বেশ বিশেষ।

"একক রিটার্ন" ফাংশনে স্থানীয় ভেরিয়েবলগুলি বরাদ্দ দেওয়ার জন্য রিজেক্স-কম অপব্যবহার alচ্ছিক পরামিতি, অন্যথায় আপনাকে একটি ব্লক তৈরি করতে হবে এবং রিটার্ন কীওয়ার্ডটি রাখতে হবে। প্রতিটি কোড ইউনিটের জন্য, কোড ইউনিট 0 এবং 9 এর মধ্যে থাকলে এটিতে জমা হয় nএবং একটি খালি স্ট্রিং ফিরে আসে। অন্যথায়, অক্ষরটির মান দ্বারা গুণিত হয় n(বিশেষ কেস যদি n == 0 হয়, সেই ক্ষেত্রে এটি সর্বদা 1 টি অক্ষর নির্গত হয়) এবং n0 এ (n=0*(c=n))+cসেট করা হয়, চার কোড কোডটি আর্গুমেন্ট n, গুণক n/ c0 দিয়ে মান সেট করে , 0 থেকে স্টোর করে n, তারপর যুক্ত করেc । এটি nবিবৃতি প্রসঙ্গে না হয়ে আমাদের পুনরায় সেট করে।

— ডোয়াইন স্লেটার
সূত্র
0

পাইথন 3, 96 বাইট

s,r=input(),""
while s:
 d=0
 while"/"<s[d]<":":d+=1
 r+=int(s[:d] or 1)*s[d];s=s[d+1:]
print(r)

আমি পাইথনে আরেকটি প্রয়োগের চেষ্টা করেছি, তবে আমি /codegolf//a/146923/56846 :(

— user285259
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.