RLE ब्रेनफक

( BF-RLE से संबंधित )

Brainfuck की काल्पनिक RLE ( रन-लेंथ एन्कोडिंग ) बोली 8 आदेशों के लिए प्रतीकों को स्वीकार करती है और साथ ही साथ स्वीकार करती है। अंकों का उपयोग एक कमांड के क्रमिक दोहराव की संख्या का प्रतिनिधित्व करने के लिए किया जाता है, इस प्रकार स्रोत कोड के रन-लंबाई एन्कोडिंग की अनुमति देता है।

8>के बराबर है >>>>>>>>।

लंबाई हमेशा कमांड के बाईं ओर होती है।

आपका कार्य सबसे छोटे प्रोग्राम / फ़ंक्शन को लिखना है जो इनपुट स्ट्रिंग (आरएलई ब्रेनफुक टुकड़ा) का नियमित ब्रेनटैक प्रोग्राम में अनुवाद करता है।

उदाहरण के लिए:

इनपुट:

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

ouptut:

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

प्रत्येक भाषा में बाइट गिनती में सबसे छोटा कोड जीत जाएगा।

code-golf string brainfuck

— गैलेन इवानोव
स्रोत

10

नमस्ते, मैंने इस प्रश्न को अस्वीकार कर दिया क्योंकि मुझे लगता है कि यह एक या दो आरएलई-आधारित रेगेक्स एल्गोरिदम पर हावी होने जा रहा है जो तब बस प्रत्येक भाषा के व्यक्तिगत रेगेक्स प्रारूपण में कॉपी किए जाते हैं। यहाँ कुछ भी करने के लिए बहुत कम जगह है।

— AdmBorkBork

13

यह एक सामान्य रन-लेंथ डिकोडिंग चुनौती की तरह दिखता है । यहां अंतर यह है कि मल्टीडिजिट नंबर समर्थित हैं। मुझे लगता है कि यह अभी भी एक डुबकी है, लेकिन मैं इसे हथौड़ा नहीं करूंगा।

— 13

4

@xnor दूसरा अंतर यह है कि अंक हमेशा मौजूद नहीं होते हैं - RLE का यह रूप बहुत कम संरचना की गारंटी देता है, और IMO दिलचस्प तकनीकों का नेतृत्व कर सकता है (लिंक चुनौती में एक के साथ यहां मेरे पायथन जवाब की तुलना करें!)

— लिन

1

@ लीन मैंने स्पष्ट रूप से इसका वर्णन नहीं किया है, लेकिन जैसा कि उदाहरण में देखा गया है, 1 ommited है; 0 जोड़ने से स्ट्रिंग छोटी नहीं होती है, इसलिए उत्तर नहीं है, कोई भी शून्य कमांड को प्रस्तुत नहीं कर सकता है।

— गैलेन इवानोव

6

दूसरी दिशा अधिक दिलचस्प होगी, मुझे लगता है (यानी कम से कम बराबर आरएलई ब्रेनफक प्रोग्राम में एक ब्रेनफक प्रोग्राम को बदलना)।

— पाओलो एबरमैन 22

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"हमेशा काम नहीं करेगा, लेकिन शुक्र है \और "आज्ञाओं को दिमाग नहीं लगा रहे हैं।

xnor ने बाइट को बचाया, 1*\1*1चाल की आपूर्ति । पहले मैं \1Lरेगेक्स में था , और L=1एक लैम्ब्डा तर्क के रूप में परिभाषित किया गया था, जो कि बहुत अच्छा है: 3Lएक लंबी Lअंतर शाब्दिक है और एक चर है।

— लिन
स्रोत

1

यह Lखाली स्ट्रिंग को संभालने के लिए एक चालाक उपयोग है । हालांकि, इसका एक छोटा तरीका है r'+1*\1*1*"\2"'।

— 14

3

... import reमेमने के नीचे क्यों है ?

— निधि मोनिका का मुकदमा

1

पहले लैंबडा डालने का मतलब है कि मैं tio.run के हैडर / फूटर फीचर का उपयोग करके दिखा सकता हूं कि कोड को कैसे लागू किया जाना चाहिए (मैंने f=\ हैडर में डाल दिया है - अब लैम्बडा का एक नाम है!)

— Lynn

18

अजगर , 2 बाइट्स

r9

यहाँ यह कोशिश करो!

यह काम किस प्रकार करता है

r9 - पूर्ण कार्यक्रम STDIN से स्ट्रिंग प्राप्त कर रहा है।

आर - विस्तारित स्ट्रिंग ऑपरेशन के पायथ का सेट।
 9 - उस सेट की नौवीं कमान (रन-लंबाई डिकोड)। यह बहु-अंकीय संख्याओं का समर्थन करता है।

— मिस्टर एक्सकोडर
स्रोत

31

आवश्यक अनुस्मारक: तुच्छ समाधान (जैसे यह) को रोकना ।

— बजे मिस्टर एक्सकोडर

4

यह उस आदेश के बारे में जानने के लिए इतना तुच्छ नहीं है, और यह जानने के लिए कि यह संख्या कब गायब है

— लुइस मेंडो

1

@ Mr.Xcoder रुको, क्या? क्या सबसे कम बाइट की गिनती के लिए कोड गोल्फ का पूरा बिंदु नहीं है?

— Deacon

4

@ डीकॉन हाँ, लेकिन एक गोल्फ पाइथन का उत्तर आमतौर पर बनाने के लिए बहुत कठिन होता है और 2-बाइट वाले गोल्फलैंग उत्तर की तुलना में अधिक दिलचस्प होता है।

— स्टीफन

8

@Deacon Upvoting केवल लघु समाधानों को उभारने के बारे में नहीं है। उपयोगकर्ताओं को आम तौर पर उन समाधानों को उभारने के लिए प्रोत्साहित किया जाता है जो दिलचस्प और रचनात्मक होते हैं क्योंकि गोल्फिंग भाषाओं में तुच्छ लघु समाधानों के विपरीत।

— LyricLy

17

लुआ, 65 64 63 बाइट्स

~~महान ! एक बार, लूआ ने अजगर को पीटा!~~

संपादित करें: @Jarhmander के लिए एक बाइट के लिए धन्यवाद, उपयोगी परिणाम के लिए उसे एक परिणाम के लिए मजबूर करने के लिए धन्यवाद

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 और जाने के लिए!

— केटेनको

आप ,""संपूर्ण प्रिंट तर्क को हटाकर और संलग्न करके एक बाइट बचा सकते हैं । Parens में संलग्न अभिव्यक्तियों को Lua (देखें lua.org/manual/5.3/manual.html#3.4 ) में एक मान में समायोजित किया गया है ।

— जगरामंदर

11

स्काला , 73 69 बाइट्स

"(\\d+)(.)".r.replaceSomeIn(_:String,m=>Some("$2"*m.group(1).toInt))

इसे ऑनलाइन आज़माएं!

— oowekyala
स्रोत

2

यह एक अच्छा जवाब है! साइट पर आपका स्वागत है। :)

— जेम्स

10

पर्ल 5 , 18 बाइट्स

17 बाइट्स कोड + 1 के लिए -p।

s/\d+(.)/$1x$&/ge

इसे ऑनलाइन आज़माएं!

— डोम हेस्टिंग्स
स्रोत

8

vim, 29 25 23 22 16 बाइट्स

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

<C-V>0x16 है, <ESC>0x1b है।

यह प्रत्येक गैर-अंक को कमांड के साथ बदलकर काम करता है जो उस चरित्र को बफर में जोड़ता है। गिनती अकेले छोड़ दी जाती है और उन आदेशों को संशोधित किया जाता है। इस बिंदु पर, बफ़र एक विम्सस्क्रिप्ट प्रोग्राम है जो वांछित ब्रेनफक प्रोग्राम का उत्पादन करता है, इसलिए हम इसे एक रजिस्टर में खींचते हैं और इसे चलाते हैं।

इसे ऑनलाइन आज़माएं!

संपादित करें: आकार में कटौती सुझाव के लिए धन्यवाद: H.PWiz: 5, TheFamilyFroot: 5, DJMcMMayhem: 1

— रे
स्रोत

TheFamilyFroot में एक अच्छा गोल्फ टिप था: आपको कैप्चरिंग समूह का उपयोग करने की आवश्यकता नहीं है, आप केवलकोष्ठक के साथसमूह 0 (&या\0) काउपयोग कर सकते हैं। इसके अलावा, मेरे पास एक टिप, TheFamilyFroot नहींहै कि आपबाइटDकेddलिएउपयोग कर सकते हैं-1।

— जेम्स

1

सभी सुझावों के लिए धन्यवाद, H.PWiz, TheFamilyFroot, और DJMcMayhem। यह 18 बाइट पर्ल समाधान के नीचे और दूसरे स्थान पर लाया। अब हमें बस एक और 15 बाइट्स खोजने की ज़रूरत है जिससे हम छुटकारा पा सकते हैं और यह पाइथ बिलिन को हरा देगा। :-)

— रे

8

RLE ब्रेनफक, 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 बी देखें "→" बीब देखें ")। परिणामी कार्यक्रम को समान चलना चाहिए, इसलिए मैं बहुत चिंतित नहीं हूं।

मुझे पूरा यकीन है कि मैं अभी भी इस पर कुछ बाइट कर सकता हूं लेकिन मैं इसके साथ काम करने से थक गया हूं।

यहाँ कस्टम दुभाषिया + परीक्षण है जो मैं इसका परीक्षण करने के लिए उपयोग कर रहा हूं। यदि आप इसे मानक इनपुट बॉक्स में इनपुट पास करते हैं तो इसे परीक्षणों को चलाने के बजाय उस इनपुट के विरुद्ध चलना चाहिए।

मेरा गन्दा काम करने वाला अधमरा:

->>>,
[
  [->+>+<<]>>  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 मामला किसी भी पार्सिंग के लिए है। चूंकि while maxलूप हमेशा कम से कम एक बार चलता है, और मैं बिना शर्त बफरिंग कर रहा हूं जहां मैं उस लूप में अंकों के मूल्य को संग्रहीत करता हूं, मुझे उस बफर को -1 पर शुरू करने की आवश्यकता है। मुझे आश्चर्य है कि अगर मैं उस बफ़र को तार्किक रूप से value+1tes

— Orez

6

स्टैक्ड , 24 बाइट्स

['(\d+)(.)'[\#~*]3/repl]

इसे ऑनलाइन आज़माएं!

व्याख्या

['(\d+)(.)'[\#~*]3/repl]
[                      ]   anonymous function, taking string as argument
 '(\d+)(.)'                for all matches of this regex:
           [    ]3/repl      replace (stack = (whole match, digit, repetend))
            \#~              convert digit to number
               *             repeat the character by that digit

— कोनोर ओ ब्रायन
स्रोत

5

TeX, 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 बाइट्स

-5 बाइट्स के लिए @Leo को धन्यवाद

\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 की तुलना में अधिक के लिए विफल रहता है)।

— श्री एक्सकोडर

वैसे भी तुम भी lambdaजो वास्तव में अपशिष्ट बाइट्स की आवश्यकता होगी ? गोल्फ और 66 बाइट्स के

— श्री एक्सकोडर

@ Mr.Xcoder हूप्स, निश्चित नहीं कि मैं क्या सोच रहा था ... धन्यवाद

— HyperNeutrino

@ Mr.Xcoder ओह, हाँ, मैं बहुत सी चीजें हैं जो अंत में ungolfs जा रहा है गोल्फ के लिए कोशिश करते हैं

— HyperNeutrino

4

पायथन 2 , 100 93 89 बाइट्स

-7 के साथ Mr.Xcoder को धन्यवाद

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

हास्केल , 60 बाइट्स

f(a:b)|[(c,d:e)]<-reads$a:b=(<$)d[1..c]++f e|1<2=a:f b
f a=a

इसे ऑनलाइन आज़माएं!

— लिन
स्रोत

3

आर , 121 106 90 बाइट्स

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

इसे ऑनलाइन आज़माएं!

15 बाइट्स को यह एहसास rep()कराकर सहेजा जाता है कि यह संख्यात्मक के लिए बाध्य करेगा। Giuseppe के लिए एक और 16 धन्यवाद बचा, मुख्य रूप से pmaxखाली तारों को बदलने के उपयोग से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 बाइट्स से कम हो सकता है!

— गिउसेप्पे 19

90 बाइट्सpmax

— Giuseppe

@Giuseppe pmaxएक अच्छा बड़ा सुधार देने का बहुत चतुर उपयोग - धन्यवाद!

— user2390246

तुलना के लिए के रूप में के "1"साथ बदलना होगा । 1pmaxcharacter

— Giuseppe

उपनाम बदलकर 85 बाइट्स

— Giuseppe

2

पॉवरशेल , 66 62 बाइट्स

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

इसे ऑनलाइन आज़माएं!

टूट - फूट

क्या झंझट है!

$argsआरईएल स्ट्रिंग से युक्त एक एकल तत्व सरणी है, जिससे शुरू करते हुए , मैं इसे कोट करके एक वास्तविक स्ट्रिंग में मजबूर कर रहा हूं।

फिर इसे शब्द सीमा ( \bरेगेक्स में) से विभाजित करें । इससे मुझे एक तार मिलेगा, जहां प्रत्येक तत्व एक संख्या या बीएफ टोकन है जो संख्या के बाद आते हैं। तो उदाहरण में, यह विभाजन सरणी के पहले 4 तत्व हैं 10, +]>+>, 3, +>(सभी स्ट्रिंग हैं)।

अगला, मैं प्रत्येक तत्व से निपटने के लिए ForEach-Object( %) में पाइप करता हूं ।

मध्य एक प्रसिद्ध पॉवरशेल गोल्फवाद है, जिसमें एक मोड़ है; यह अनिवार्य रूप से एक DIY टर्नरी ऑपरेटर है, जिसमें आप एक 2 तत्व ऐरे बनाते हैं, फिर उस बूलियन एक्सप्रेशन का उपयोग करके, जिसे आप परीक्षण करना चाहते हैं, जिसमें इंडेक्स एक गलत परिणाम आपको तत्व 0 देता है और एक सही परिणाम आपको तत्व 1 देता है।

इस मामले में, मैं वास्तव में यूरी कॉमा ,ऑपरेटर के साथ एक एकल तत्व सरणी बनाता हूं , क्योंकि मैं सच्चे मामले में आउटपुट नहीं चाहता हूं।

पहले आइए इंडेक्सर को देखें, भले ही इसे बाद में निष्पादित किया जाए।

इसका विचार यह है कि $_(वर्तमान तत्व) या तो एक वैध संख्या हो सकती है, या कुछ अन्य स्ट्रिंग। यदि यह एक संख्या है, तो मैं $nउस संख्या का मान 1 होना चाहता हूं 1 (संख्या के रूप में, स्ट्रिंग नहीं)। यदि यह नहीं है, तो मैं $nझूठे-वाई बनना चाहता हूं ।

PowerShell आमतौर पर दाएं-हाथ के मूल्य को बाईं ओर के प्रकार के लिए जोर देने की कोशिश करता है, लेकिन यह ऑपरेशन पर निर्भर कर सकता है। इसके अलावा, "10"+5आपको एक नया स्ट्रिंग देगा "105", जबकि 10+"5"आपको पूर्णांक ( 15) देगा।

लेकिन स्ट्रिंग्स को घटाया नहीं जा सकता है इसलिए इसके बजाय पावरशेल, न्यूट्रल मूल्य को स्वचालित रूप से घटाव के बाईं ओर एक स्ट्रिंग के साथ अनुमान लगा सकता है, इसलिए "10"-5देता है 5।

एसओ, मैं शुरू करता हूं $_-1, जो मुझे वह नंबर देगा जो मैं चाहता हूं कि $_वास्तव में एक नंबर है, लेकिन जब यह नहीं है तो मुझे कुछ भी नहीं मिलेगा। सतह पर, "कुछ भी नहीं" गलत है, लेकिन समस्या यह है कि उस असाइनमेंट का निष्पादन बंद हो जाता है, इसलिए $nइसका पिछला मूल्य बरकरार रहेगा; मुझे नहीं चाहिए!

अगर मैं इसे एक सबडिप्रेशन में लपेटता हूं, तो जब यह विफल हो जाता है, तो मुझे अपना गलत मूल्य मिल जाता है $($_-1):।

यह सब सौंपा गया है $nऔर चूंकि असाइनमेंट स्वयं को कोष्ठक में लिपटे हुए हैं, इसलिए जो मूल्य सौंपा गया था, $nवह पाइपलाइन से भी होकर गुजरता है।

चूंकि मैं इसे अनुक्रमणिका में उपयोग कर रहा हूं, और मैं चाहता हूं कि 1यदि रूपांतरण सफल हुआ, तो मैं इस मूल्य को बूलियन में बदलने के लिए दो बूलियन- notअभिव्यक्तियों !!का उपयोग करता हूं । एक सफल संख्या रूपांतरण सत्य के रूप में समाप्त होता है, जबकि फाल्सी नॉटनेस हमें वह मीठा, मीठा 0देता है जो उस नकली टर्नरी सरणी में एकमात्र तत्व को वापस करने की अनुमति देता है।

उस सरणी पर वापस जाना, तत्व यह है: ~~$("$($_[0])"*$n*$_)~~ $(,$_[0]*$n+$_)

"$($_[0])"- यह वर्तमान तत्व का पहला चरित्र प्राप्त करने का एक कष्टप्रद लंबा रास्ता है (चलो कहते हैं, से हो रहा +है +[>+), लेकिन एक स्ट्रिंग के रूप में और एक [char]वस्तु के रूप में नहीं । मुझे इसकी एक स्ट्रिंग की आवश्यकता है क्योंकि मैं इसे डुप्लिकेट करने के लिए एक स्ट्रिंग को संख्या से गुणा कर सकता हूं, लेकिन मैं एक चरित्र के साथ ऐसा नहीं कर सकता।

वास्तव में मैं [char]एक स्ट्रिंग के बजाय (एक और unary अल्पविराम का उपयोग करके ,) एक सरणी का उपयोग करके 4 वर्णों को बचाने में कामयाब रहा , इसलिए मैं उद्धरण और अतिरिक्त उप-अभिव्यक्ति को निकालने में सक्षम था। मैं इसके तत्वों को डुप्लिकेट करने के लिए एक सरणी को गुणा कर सकता हूं । और चूंकि इस पुनरावृत्ति का पूरा परिणाम किसी भी तरह से एक सरणी के रूप में समाप्त होता है और इसे -joinसंपादित करने की आवश्यकता होती है , यहाँ एक सरणी का उपयोग करने से कोई अतिरिक्त लागत नहीं आती है।

फिर, मैं उस ~~स्ट्रिंग~~ सरणी को गुणा करके $n, इसे $nबार डुप्लिकेट करने के लिए । याद है कि $nहो सकता है $nullया यह पूर्ववर्ती अंकों का मान शून्य हो सकता है।

फिर +$_उस तत्व के डुप्लिकेट पहले वर्ण के अंत में वर्तमान तत्व जोड़ता है। इसलिए $nमाइनस एक है।

इस तरह, 9 के बराबर 10+[>+समाप्त होता है $n, फिर हम 9 बनाते हैं +और +[>+आवश्यक 10 प्राप्त करने के लिए उस स्ट्रिंग को वापस जोड़ते हैं , साथ ही सवारी के लिए अन्य एकल तत्व।

तत्व एक सब-डेक्सप्रेशन में लिपटे हुए है $()क्योंकि जब $nहोता है $null, तो संपूर्ण अभिव्यक्ति विफल हो जाती है, इसलिए सरणी बनाना विफल हो जाता है, इसलिए अनुक्रमणिका कभी नहीं चलती है, इसलिए $nकभी भी असाइन नहीं किया जाता है।

कारण मैं इस त्रिगुट चाल का इस्तेमाल किया अपनी विशेषताओं में से एक की वजह से है: एक असली त्रिगुट ऑपरेटर के विपरीत, भाव है कि तत्वों को परिभाषित करते हैं उस बात के लिए मूल्यांकन करने के लिए किया जाए या नहीं वे "चयनित" कर रहे हैं, और पहले।

चूंकि मुझे $nअलग-अलग पुनरावृत्तियों पर असाइन करने और फिर उपयोग करने की आवश्यकता है , इसलिए यह सहायक है। टर्नेरी ऐरे एलिमेंट वैल्यू का मूल्यांकन पिछले पुनरावृत्ति $nमूल्य के साथ किया जाता है , फिर इंडेकर $nवर्तमान पुनरावृत्ति के लिए पुन: असाइन करता है ।

तो ForEach-Objectछोरों को अपना सब कुछ आउटपुट करना होता है (त्रुटियों का एक समूह जिसे हम अनदेखा करते हैं), लेकिन नए तार की एक सरणी के रूप में।

इसलिए यह पूरी चीज कोष्ठक में लिपटी है और फिर -joinआउटपुट स्ट्रिंग देने के लिए यूनरी द्वारा पूर्ववर्ती है ।

— briantist
स्रोत

1

महान व्याख्या, कि अकेले पहले से ही एक विद्रोह वारंट।

— मस्त

1

धन्यवाद @ मैस्ट, और आपकी टिप्पणी के कारण मैंने अपने उत्तर को फिर से देखा और महसूस किया कि मैं 4 बाइट कैसे बचा सकता हूं।

— 21

2

QuadR , 17 बाइट्स

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

इसे ऑनलाइन आज़माएं!

कोड का सही संस्करण प्रदान करने के लिए Adá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.

— जे। सल्ल
स्रोत

APL फ़ंक्शन के बराबर'\d+.'⎕R{¯1((⍎↓)⍴↑)⍵.Match}

— Adám

1

प्रोटॉन , 50 बाइट्स

x=>/\d+./.sub(k=>int((e=k.group())[to-1])*e[-1],x)

इसे ऑनलाइन आज़माएं!

— HyperNeutrino
स्रोत

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

^{^{^Gdamn}} जावा regexes तो बेकार कभी कभी .. पिछली बार यह थापर कब्जा समूह का उपयोग कर की कमी"$1"भी चीज के लिए, अब यह .. मैं बदलना चाहते हैं3cके साथcccया000cके साथcccएक एक लाइनर के रूप में, लेकिन दुर्भाग्य से जावा एक के बिना ऐसा करने का कोई तरीका नहीं है पाश। ठीक है।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

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

हाय केविन, यहाँ आपको देखने के लिए अच्छा है, ट्विस्टी के अलावा अन्य पहेलियों से निपटना :)

— गैलन इवानोव

@GalenIvanov ओह, हाय! मुझे नहीं पता था कि आप पीपीसीजी पर भी सक्रिय थे।

— केविन क्रूज़सेन

मैं हाल तक नहीं था :) मैं जे सीख रहा हूं और तय किया कि यह मेरे कौशल का परीक्षण करने का एक अच्छा अवसर है।

— गैलेन इवानोव

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 बाइट्स

User2390246 द्वारा बहिष्कृत ! यह अब मूल रूप से उस एक की तुलना में एक कचरा दृष्टिकोण है, लेकिन मैं इसे सुधारना जारी रखूंगा।

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

— ग्यूसेप
स्रोत

एक अलग दृष्टिकोण

— 16:23 पर user2390246

1

जावास्क्रिप्ट (ईएस 6), 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

रूबी , 35 बाइट्स

->s{s.gsub(/(\d+)(.)/){$2*$1.to_i}}

इसे ऑनलाइन आज़माएं!

— एलेक्स
स्रोत

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

प्रोग्राम के लिए एन्कोडेड स्ट्रिंग को लागू करना और इसे सभी तरह से कम करना आपको लागू किए गए RLE के साथ एन्कोडेड आउटपुट स्ट्रिंग देना चाहिए।

— PixelToast
स्रोत

1

नमस्कार और साइट पर आपका स्वागत है! यह एक दिलचस्प समाधान की तरह दिखता है, लेकिन हम भाषाओं को एक वैध दुभाषिया होने की उम्मीद करते हैं, क्या आपके पास अनकैप्ड लैम्ब्डा कैलकुलस है?

— रॉक गार्फ हंटर

इसके अलावा, qλqसंकेतन का क्या अर्थ है? मैंने पहले कभी नहीं देखा।

— Zacharý

1

फंकी , 42 बाइट्स

s=>s::gsub("(\\d+)(.)",(_,a,b)=>b::rep(a))

इसे ऑनलाइन आज़माएं!

— Ataco
स्रोत

1

सी ++, 239 235 बाइट्स

-4 बाइट्स Zacharý की बदौलत

#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

— Zacharý

208 बाइट्स

— छत

0

डार्ट, 78 बाइट्स (रेगेक्स के साथ), 102 बाइट्स (रेगेक्स के बिना)

रेगेक्स के साथ:

(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")।

रेगेक्स एक काफी मानक है, लेकिन रेगेक्स-कम एक काफी खास है।

रेगेक्स-कम "सिंगल रिटर्न" फ़ंक्शन में स्थानीय चर आवंटित करने के लिए वैकल्पिक मापदंडों का दुरुपयोग करता है, अन्यथा आपको एक ब्लॉक बनाने और रिटर्न कीवर्ड की आवश्यकता होगी। प्रत्येक कोड इकाई के लिए, यदि कोड इकाई 0 और 9 के बीच है, तो यह जम जाता है nऔर एक रिक्त स्ट्रिंग वापस आ जाती है। अन्यथा, चरित्र के मान से गुणा किया जाता है n(विशेष आवरण यदि n == 0 है, तो उस स्थिति में यह हमेशा 1 वर्ण का उत्सर्जन करेगा) और n0. के (n=0*(c=n))+cलिए चार कोड तर्क को nगुणन के साथ n/ गुणा पर सेट करता है। c, 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
स्रोत

RLE Brainfuck बोली

RLE ब्रेनफक

पायथन 2 , 62 61 बाइट्स

अजगर , 2 बाइट्स

यह काम किस प्रकार करता है

लुआ, 65 64 63 बाइट्स

स्पष्टीकरण

स्काला , 73 69 बाइट्स

पर्ल 5 , 18 बाइट्स

vim, 29 25 23 22 16 बाइट्स

RLE ब्रेनफक, 204 बाइट्स

स्टैक्ड , 24 बाइट्स

व्याख्या

TeX, 124 बाइट्स

रेटिना , 28 23 बाइट्स

पायोन , 66 बाइट्स

पायथन 2 , 100 93 89 बाइट्स

हास्केल , 60 बाइट्स

आर , 121 106 90 बाइट्स

पॉवरशेल , 66 62 बाइट्स

टूट - फूट

QuadR , 17 बाइट्स

यह काम किस प्रकार करता है:

प्रोटॉन , 50 बाइट्स

जावा 8, 148 बाइट्स

हास्केल , 84 बाइट्स

आर , 151 बाइट्स

जावास्क्रिप्ट (ईएस 6), 46 बाइट्स

रूबी , 35 बाइट्स

अनकैप्ड लैम्ब्डा कैलकुलस , 452 बाइट्स

फंकी , 42 बाइट्स

सी ++, 239 235 बाइट्स

डार्ट, 78 बाइट्स (रेगेक्स के साथ), 102 बाइट्स (रेगेक्स के बिना)

पायथन 3, 96 बाइट्स