घातांक को ASCII कला में बदलें

28

कार्य

आपका काम इस तरह तार बदलना है:

abc^d+ef^g + hijk^l - M^NO^P (Ag^+)

इस तरह से तार करने के लिए:

   d   g       l    N P    +
abc +ef  + hijk  - M O  (Ag )

जो एबीसी d + ef g + hijk l - M N O P (Ag + ) का एक अनुमान है

शब्दों में, ऊपरी रेखा की ओर सीधे अक्षरों को ऊपर उठाएं, एक कैरेट के लिए एक वर्ण।

चश्मा

  • आउटपुट में अतिरिक्त अनुगामी व्हाट्सएप की अनुमति है।
  • m^n^oइनपुट की तरह कोई जंजीर नहीं दी जाएगी।
  • एक कैरेट को तुरंत एक स्थान या किसी अन्य कैरेट द्वारा पालन नहीं किया जाएगा।
  • एक कैरेट तुरंत एक स्थान से पहले नहीं होगा।
  • सभी देखभाल कम से कम एक चरित्र से पहले और कम से कम एक चरित्र द्वारा पीछा किया जाएगा।
  • इनपुट स्ट्रिंग में केवल मुद्रण योग्य ASCII वर्ण (U + 0020 - U + 007E) होंगे
  • आउटपुट की दो पंक्तियों के बजाय, आपको दो स्ट्रिंग्स के एक सरणी को आउटपुट करने की अनुमति है।

रेगेक्स बोलने वालों के लिए: इनपुट स्ट्रिंग इस रेगेक्स से मेल खाएगी:

/^(?!.*(\^.\^|\^\^|\^ | \^))(?!\^)[ -~]*(?<!\^)$/

लीडरबोर्ड

कोड स्निपेट दिखाएं

code-golf  string  ascii-art 
— लीक नन
स्रोत
2
@TimmyD "इनपुट स्ट्रिंग में केवल मुद्रण योग्य ASCII वर्ण (U + 0020 - U + 007E)" होंगे
— लीक नून
3
एक्सपट्र्स पर रोक क्यों? मुझे ऐसा कुछ चाहिए जो H_2O को संभालता है!
— नील
1
@Neil अपनी चुनौती तब बनाएं, और मैं इस चुनौती को उस डुप्लिकेट के रूप में बंद कर सकता हूं। :)
— लीकी नून
1
आपके उदाहरण के आधार पर, मैं कहूंगा कि वे सुपरइंडिस हैं , जरूरी नहीं कि वे एक्सप्लर्स हों
— लुइस
4
जो लोग रेग्युलर रेगुलर कंट्रीज से रेगेक्स हैल बोलते हैं, जहां अभिव्यक्ति की कमी है। मौत का प्रमुख कारण भयावह बैकट्रैकिंग है।
— डेविड कॉनराड

जवाबों:

19

वी , 15 14 बाइट्स

ÄÒ +òf^xxé kPj

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

एक बिल्कुल सीधा समाधान। आदर्श V के लिए चुनौती!

स्पष्टीकरण:

Ä                "Duplicate this current line
 Ò               "Replace this line with spaces
   +             "Move to the beginning of the next line
    ò         ò  "Recursively (The second ò is implicit):
     f^          "  Find a caret
       xx        "  Delete two characters. The second will be saved into the main register
         é       "  Insert a space
           k     "  Move up
            P    "  Paste from the main register
             j   "  Move down

आसानी से, रिकर्सन कैसे काम करता है, के आधार पर, यह हर एक कैरेट के लिए एक बार चलेगा।

— DJMcMayhem
स्रोत
2
vim इस चुनौती के लिए एकदम सही भाषा है। +1
— डाउनगोट
18

चेडर, 77 72 67 बाइट्स

l->l.chars.vfuse.replace("^\n"," ").lines.map(j->"%-2s"%j).turn(3)

रेगेक्स नहीं!

मुझे यह उत्तर बहुत पसंद है क्योंकि यह चेडर की क्षमताओं का अद्भुत प्रदर्शन है। मुख्य रूप से कॉनर द्वारा जोड़े गए फ़ंक्शन को धन्यवाद। पीआर करने के लिए पीआर कभी नहीं बनाया गया था ताकि इस शाखा पर केवल प्रतिस्थापित फ़ंक्शन मौजूद हो (अद्यतन: मैंने पीआर बनाया और अब यह नवीनतम बीटा शाखा पर है जिसे आप स्थापित कर सकते हैं npm install -g cheddar-lang)

मैं इसे गोल्फ के लिए एक रास्ता मिल गया है, लेकिन दुर्भाग्य से इस में एक परिणाम हो रहा है जब आइटम लंबाई समान नहीं हैं:

["   denifednud   denifednug       denifednul    denifednuN denifednuP    denifednu+ ", "abcdenifednu +efdenifednu  + hijkdenifednu  - Mdenifednu Odenifednu  (Agdenifednu )"]

मैं regex का उपयोग करके बहुत सारे बाइट्स बचा सकता था, और वास्तव में मैंने सिर्फ Cheddar के लिए regexes बनाया ... एकमात्र समस्या यह है कि कोई regex फ़ंक्शन नहीं हैं: /

व्याख्या

l->                    // Function take input as `l`
   l.chars             // Get array of chars in input
   .vfuse              // Join with newlines
   .replace("^\n"," ") // Replace `^\n` with a space globally
   .lines              // Get the lines (see below for more details on what this returns)
   .map(j->            // Loop through each "line" `j` is arg
       "%-2s"          // C-like printf format.
                       // think of as: padRight(j, " ", 2)
                       // see below for more details
        % j            // Pass j as the string to insert
   ).turn(3)           // Turn the string 270 degrees (see below)
   .vfuse              // Vertically fuse to get result (this is not needed as we can output an array of the lines)

बेहतर समझ पाने के लिए। यह वही .linesहै जिसके लिए रिटर्न1^2

["1", " 2"]

इसे .turnघुमाएं:

1
 2

में:

 2
1

एक और उदाहरण जो इसे और स्पष्ट करेगा:

1
 2
2
 2

हो जाता है:

 2 2
1 2

प्रारूप क्यों?

क्या %-2sकर रही है बहुत आसान है। %निर्दिष्ट करता है कि हम एक "प्रारूप" शुरू कर रहे हैं, या इस बिंदु पर एक चर इस स्ट्रिंग में डाला जाएगा। -स्ट्रिंग को राइट-पैड करने का मतलब है, और 2अधिकतम लंबाई है। डिफ़ॉल्ट रूप से यह रिक्त स्थान के साथ पैड करता है। sबस यह एक स्ट्रिंग निर्दिष्ट करता है। यह देखने के लिए कि यह क्या करता है:

"%-2s" % "a"  == "a "
"%-2s" % " a" == " a"
— Downgoat
स्रोत
2
: DI हमेशा चेडर को उभारता है।
— DJMcMayhem
@DrGreenEggsandIronMan: D धन्यवाद
— 23
1
चेडर में turnतार के लिए एक विधि है?
— TuxCrafting
6
-1 इस भाषा का नाम मुझे हमेशा भूखा रखता है।
— को बंद करना बंद कर दिया
@ T @xCräftîñg केवल 2 डी सरणियों के लिए, यही वजह है कि मैंने लाइनों को प्राप्त करने के लिए .lines का उपयोग किया है।
— १
10

पर्ल, 21 + 1 = 22 बाइट्स

say'';s/\^(.)/♥[A\1↓/

-pझंडे के साथ भागो । ♥एक कच्चे ESCबाइट ( 0x1b), और ↓एक ऊर्ध्वाधर टैब ( 0x0b) के साथ बदलें ।

ऊर्ध्वाधर टैब मार्टिन एंडर का विचार है। इससे दो बाइट बच गईं! धन्यवाद।

— लिन
स्रोत
क्या आपको प्रारंभ में कर्सर को एक पंक्ति से नीचे ले जाने की आवश्यकता नहीं होगी, ताकि घातांक अंतिम कंसोल प्रांप्ट को ओवरलैप न करें?
— मार्टिन एंडर
मुझे उस पर यकीन नहीं था, हाँ। मैंने अपनी आवश्यकता के अनुसार अधिक स्थान होने की धारणा बनाई, लेकिन शायद यह थोड़ा धोखा है। (सामान्य तौर पर, मुझे इस तरह की समस्या को हल करने के लिए कर्सर आंदोलनों का उपयोग करने पर बहुत गर्व नहीं है, लेकिन यह पहली बात है जो दिमाग में आई ...)
— लिन
2
मुझे लगता है कि यह एक अच्छा समाधान है, लेकिन परिणाम स्ट्रिंग से छपाई करने के लिए नेत्रहीन अभेद्य होना चाहिए।
— मार्टिन एंडर
1
क्या एक प्यारा समाधान
— थॉमस वेलर
7

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

s=>[/.(\^(.))?/g,/\^.(())/g].map(r=>s.replace(r,' $2'))

पाठ्यक्रम के बचाव के लिए Regexps। पहले वाला सभी वर्णों को रिक्त स्थान के साथ बदल देता है, जब तक कि यह एक कैरेट नहीं पाता है, उस स्थिति में यह कैरेट को हटा देता है और इसके बाद चरित्र को रखता है। (इन पात्रों को अस्तित्व की गारंटी दी गई है।) प्रत्येक कैरेट और उसके निम्नलिखित चरित्र को एक स्थान के साथ बदलने के लिए दूसरा स्पष्ट है।

संपादित करें: @Lynn के लिए 1 बाइट का धन्यवाद सहेजा गया, जिसने रिप्लेक्स की एक सरणी पर मैप किए जाने की अनुमति देने के लिए दूसरी जगह के लिए प्रतिस्थापन स्ट्रिंग का पुन: उपयोग करने का एक तरीका तैयार किया।

— नील
स्रोत
2
लगता s=>[/.(\^(.))?/g,/\^.(())/g].map(r=>s.replace(r,' $2'))है बाइट छोटी है।
— लिन
@ लियन यह एक बहुत चालाक स्टंट है!
— नील
7

पायथन 3, 157 101 98 85 83 74 बाइट्स

यह समाधान इस बात पर नज़र रखता है कि क्या पिछला चरित्र था ^, फिर यह तय करता है कि उस पर आधारित पहली या दूसरी पंक्ति में आउटपुट किया जाए या नहीं।

के एक सरणी के रूप में आउटपुट ['firstline', 'secondline']।

a=['']*2
l=0
for c in input():x=c=='^';a[l]+=c*x;a[~l]+=' '*x;l=x
print(a)

सहेजे गए 13 15 बाइट्स @LeakyNun को धन्यवाद!

@Joffan की बदौलत 7 बाइट्स बचाए!

— तांबा
स्रोत
1
अच्छा परिमित-राज्य ऑटोमेटन।
— लीक नून
यह बेहतर है करने के लिए किया जाएगा a=['','']और CONCATENATE ' 'और cसीधे में a[l]और a[~l]?
— जोफान
6

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

l=['']*2;p=1
for c in input():b=c!='^';l[p]+=c*b;l[~p]+=' '*b;p=b
print l

रेगेक्स नहीं। यदि पिछला चरित्र याद था ^, और वर्तमान चरित्र को उसके आधार पर ऊपर या नीचे की रेखा में रखा गया था , और दूसरे में एक स्थान।

— XNOR
स्रोत
4

पायथ, 17 बाइट्स

CcsmX~Z1j;d;cQ\^2

             Q      input string
            c \^    split on '^'
   m                map for sections d:
    X      ;          insert a space at index:
     ~Z1                the old value of Z (initially 0), before setting Z to 1
                      into:
        j;d             the section joined on spaces
  s                 concatenate
 c              2   chop into groups of 2
C                   transpose

2 स्ट्रिंग्स की एक सरणी देता है। ( jउन्हें एक नई पंक्ति में शामिल होने के लिए प्रेरित करें।)

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

— एंडर्स कसीगोर
स्रोत
1
मैं यह सोचकर नहीं रोक सकता कि आपका अंतिम नाम कैसे उच्चारित किया जाता है। : डी
— लिन
4

MATL , 18 बाइट्स

94=t1YSt~&vG*cw~Z)

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

94=    % Take input implicitly. Create logical array of the same size that contains
       % true for carets, false otherwise
t      % Push a copy of this array
1YS    % Circularly shift 1 unit to the right. This gives an array that contains true
       % for the elements right after a caret (superindices), and false for the rest 
t~     % Push a copy and negate
&v     % Concatenate vertically. This gives a 2D, 2-row array
G*     % Push the input again, multiply with broadcast. This gives a 2D array in
       % which the first row contains the superindices (characters after a caret)
       % and 0 for the rest; and the second row contains the non-superindices and
       % 0 for the superindices
c      % Convert to char
w      % Swap. Brings to top the array containing true for carets and false otherwise
~      % Negate
Z)     % Use as logical index to remove rows that contain carets. Display implicitly
— लुइस मेंडो
स्रोत
4

रूबी, 47 + 1 ( -nध्वज) = 48 बाइट्स

puts$_.gsub(/\^(.)|./){$1||" "},gsub(/\^./," ")

इसे ऐसे चलाएं: ruby -ne 'puts$_.gsub(/\^(.)|./){$1||" "},gsub(/\^./," ")'

— मूल्य स्याही
स्रोत
मुझे लगता है कि आप उपयोग कर 1 बाइट बचा सकता है $_=$_.gsub(/\^(.)|./){$1||" "}+gsub(/\^./," ")और -pबजाय -n।
— डोम हेस्टिंग्स
1
@DomHastings की परवाह किए बिना कि यह काम करता है या नहीं, आपके कोड में एक नई रेखा नहीं है, और जोड़ने का +$/मतलब है कि यह बाइट्स को बचाने के लिए नहीं जा रहा है। तर्कों के बीच मौजूद putsहोने पर स्वचालित रूप से आपके लिए नई पंक्ति में फेंकता है ,।
— वैल्यू इंक
ओह ... मैंने परीक्षण का उपयोग किया ruby -p ... <<< 'input', लेकिन मैं सहमत हूं, अगर यह नईलाइन याद आ रही है तो यह अच्छा नहीं है! वास्तव में, हो सकता है कि मैंने पहले अपने परीक्षणों में एक नई रूपरेखा जोड़ दी हो ... यह काम पर था, हालांकि मैं जाँच नहीं कर सकता!
— डोम हेस्टिंग्स
@DomHastings इसे फिर से देखते हुए, मेरा अनुमान है कि यह इसलिए है क्योंकि getsइसमें सबसे अधिक बार नई अनुगामी शामिल है, लेकिन यदि आप किसी ऐसी फ़ाइल में पाइप लगाते हैं जिसमें अनुगामी नई रेखा नहीं है, तो यह प्रकट नहीं होगी और आउटपुट गलत होगा । ruby -p ... inputfileरूबी के साथ अपने कोड का परीक्षण करें gets, अगर यह कमांड लाइन तर्क है तो फ़ाइल पर रीडायरेक्ट करता है।
— मूल्य इंक
समझ गया, सही समझ में आता है। मुझे लगता है कि फ़ाइल में एक अनुगामी newline भी समस्या को ठीक करेगा। मैं किसी भी तरह से एक कुशल रूबीवादी नहीं हूं इसलिए मुझे लगता है कि मैंने आज इसके बारे में थोड़ा और जान लिया है। धन्यवाद!
— डोम हेस्टिंग्स
3

पायथन (2), 76 68 67 बाइट्स

-5 बाइट्स थैंक्स टू @LeakyNun

-3 बाइट्स @ केविनलाउ-नॉटकेनी को धन्यवाद

-1 बाइट धन्यवाद @ValueInk को

-0 बाइट्स @DrGreenEggsandIronMan के लिए धन्यवाद

import re
lambda i,s=re.sub:[s("(?<!\^).\^?"," ",i),s("\^."," ",i)]

यह अनाम लैंबडा फ़ंक्शन इनपुट स्ट्रिंग को अपने एकमात्र तर्क के रूप में लेता है और दो आउटपुट लाइनों को एक नई रेखा से अलग करता है। इसे कॉल करने के लिए इसे पहले "f =" लिखकर एक नाम दें।

बिल्कुल स्पष्ट regex: पहले भाग की जगह एक रिक्ति से निम्नलिखित: किसी भी चरित्र और एक गाजर कैरट या केवल एक चार है, लेकिन केवल वहाँ उनके सामने कोई कैरट है यदि। दूसरा भाग स्ट्रिंग में किसी भी कैरेट और उसके बाद एक स्थान द्वारा चार को बदल देता है।

— KarlKastor
स्रोत
@ लीकन्यू: मैं किसी कारण से सोच रहा था कि 1. अगर मैं पुस्तकालयों का आयात करता हूं तो यह भी है। नकल कर रहा था 2. इस सवाल में अभी जब मैंने आपकी टिप्पणी देखी। आपको और केविन को धन्यवाद!
— कार्ल कस्तोर
आप एक बाइट बंद साथ ले सकता हैfrom re import*
— DJMcMayhem
@DrGreenEggsandIronMan यह बाइट्स के बिल्कुल समान संख्या का उपयोग करने के लिए लगता है। (ऊपर देखें)
— see:२। पर कार्ल २or
पुराना आयात विवरण रखें और lambda i,s=re.sub:[s("(?<!\^).\^?"," ",i),s("\^."," ",i)]-1 बाइट के लिए करें
— वैल्यू इंक
2

रेटिना, 16 बाइट्स

S`^
\^(.)
♥[A$1↓

मेरे पर्ल उत्तर का एक पोर्ट, मार्टिन एंडर द्वारा इंगित किया गया। ♥एक कच्चे ESCबाइट ( 0x1b) और ↓एक ऊर्ध्वाधर टैब ( 0x0b) के साथ बदलें ।

— लिन
स्रोत
2

शेल + टीएक्स + कैटडवी, 51 43 बाइट्स

tex '\empty$'$1'$\end'>n;catdvi *i|head -n2

texकुछ सुंदर गणित टाइप करने के लिए उपयोग करता है, और फिर catdviएक पाठ प्रतिनिधित्व बनाने के लिए उपयोग करता है। हेड कमांड कबाड़ को हटाता है (पृष्ठ क्रमांकन, अनुगामी newlines) जो अन्यथा मौजूद है।

संपादित करें: /dev/nullजब आप साइडइफ़ेक्ट्स को अनदेखा कर सकते हैं और एकल पत्र फ़ाइल पर लिख सकते हैं , तो लंबी, उचित, चीज़ और रीडायरेक्ट क्यों करें ?

उदाहरण

इनपुट: abc^d+ef^g + hijk^l - M^NO^P (Ag^+)

TeX आउटपुट (समीकरण के लिए काट दिया गया): "सुंदर" गणित! अंतिम आउटपुट:

   d   g     l  N P   +
abc +ef +hijk -M O (Ag )

मान्यताओं: खाली dir में शुरू करें (या विशेष रूप से एक dir जिसका नाम "i" में समाप्त नहीं होता है)। इनपुट शेल स्क्रिप्ट के लिए एक एकल तर्क है। इनपुट एक खाली स्ट्रिंग नहीं है।

कोई मुझे बताए कि क्या यह विशेष रूप से दुरुपयोग है catdvi।

— algmyr
स्रोत
2

हास्केल, 74 56 55 बाइट्स

g('^':c:r)=(c,' '):g r
g(c:r)=(' ',c):g r
g x=x
unzip.g

एक जोड़ी तार देता है। उपयोग उदाहरण: unzip.g $ "abc^d+e:qf^g + hijk^l - M^NO^P: (Ag^+)"->(" d g l N P + ","abc +e:qf + hijk - M O : (Ag )")

gजोड़े की एक सूची बनाता है, जहां पहला तत्व ऊपरी लाइन में चार है और दूसरा तत्व निचली लाइन में चार है। unzipइसे सूचियों की एक जोड़ी में बदल देता है।

संपादित करें: @xnor ने सुझाव दिया है unzipजो 18 बाइट बचाता है। @ लैकोनी को बचाने के लिए एक और बाइट मिली। धन्यवाद!

— nimi
स्रोत
क्या आप कर सकते हैं j=unzip.g?
— xnor
@xnor: ओह, मुझे खुद को नहीं देखने के लिए कितना बेवकूफ है! आपका बहुत बहुत धन्यवाद!
— nimi
आप बदल सकते हैं g[]=[]के साथ g x=xएक बाइट को बचाने के लिए।
— लकोनी
@ लिकोनी: अच्छी तरह से देखा! धन्यवाद!
— nimi
1

पर्ल, 35 बाइट्स

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

$_=s/\^(.)|./$1||$"/ger.s/\^./ /gr

प्रयोग

perl -pe '$_=s/\^(.)|./$1||$"/ger.s/\^./ /gr' <<< 'abc^d+ef^g + hijk^l - M^NO^P (Ag^+)'
   d   g       l    N P    + 
abc +ef  + hijk  - M O  (Ag )

नोट: यह बिल्कुल वैसा ही है जैसा कि इंक का जवाब जो मैंने बाद में जासूसी किया। जरूरत पड़ने पर निकाल देंगे क्योंकि यह वास्तव में रूबी समाधान में नहीं जोड़ता है।

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

जावा 8 लैम्ब्डा, 132 128 112 अक्षर

i->{String[]r={"",""};for(char j=0,c;j<i.length();j++){c=i[j];r[0]+=c==94?i[++j]:32;r[1]+=c==94?32:c;}return r;}

अनगुल्ड संस्करण इस तरह दिखता है:

public class Q86647 {

    static String[] printExponents(char[] input) {
        String[] result = {"",""};
        for (char j = 0, c; j < input.length(); j++) {
            c = input[j];
            result[0] += c == 94 ? input[++j] : 32;
            result[1] += c == 94 ? 32 : c;
        }
        return result;
    }
}

एक सरणी के रूप में आउटपुट, बस यह जांचना कि क्या कोई कैरेट है और यदि ऐसा है तो अगले वर्ण को ऊपरी पंक्ति में रखा जाएगा, अन्यथा एक स्थान होगा।

अपडेट

4 वर्णों को बचाने के लिए उनके एससीआई मूल्यों के साथ बदल दिए गए वर्ण।

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

इसके अलावा स्विच करने के लिए @KevinCruijssen करने के लिए धन्यवाद intकरने के लिए charकुछ और पात्रों को बचाने के लिए।

— Frozn
स्रोत
आप यह देखने के लिए इनपुट char[]और उपयोग for(char c:i)करने का प्रयास कर सकते हैं कि क्या बाइट-काउंट कम हो सकता है।
— लीक नन
इनपुट के i->{String[]r={"",""};for(char j=0,c;j<i.length;j++){c=i[j];r[0]+=c==94?i[++j]:32;r[1]+=c==94?32:c;}return r;}साथ : आप इसे 110 बाइट्स तक थोड़ा सा नीचे कर सकते हैं "abc^d+ef^g + hijk^l - M^NO^P (Ag^+)".toCharArray()। ( इन परिवर्तनों का आईडॉन। )
— केविन क्रूज़सेन
1

नारियल , 122 114 96 बाइट्स

संपादित करें: लीकी नन की मदद से 8 26 बाइट्स नीचे।

def e(s,l)=''==l and s or"^"==l[0]and l[1]+e(s+' ',l[2:])or' '+e(s+l[0],l[1:])
f=print..e$('\n')

इसलिए जैसा कि मैंने आज सीखा कि अजगर के पास एक टर्नरी सशर्त संचालक है, या वास्तव में उनमें से दो हैं: <true_expr> if <condition> else <false_expr>और <condition> and <true_expr> or <false_expr>पिछले एक के साथ एक चार कम आ रहा है।
एक अजगर अनुरूप संस्करण जा सकती है ideoned ।

पहला प्रयास: 

def e(s,l):
 case l:
  match['^',c]+r:return c+e(s+' ',r)
  match[c]+r:return' '+e(s+c,r)
 else:return s
f=print..e$('\n')

f("abc^d+ef^g + hijk^l - M^NO^P (Ag^+)")प्रिंट के साथ बुला रहा है

   d   g       l    N P    +
abc +ef  + hijk  - M O  (Ag )

किसी ने अभी तक नारियल में गोल्फ की कोशिश की? यह ..ऊपर प्रयोग किए गए पैटर्न मिलान और फ़ंक्शन कॉन्फैटिनेशन (साथ ) जैसी अधिक कार्यात्मक प्रोग्रामिंग अवधारणाओं के साथ अजगर को समृद्ध करता है। के रूप में यह नारियल पर मेरी पहली कोशिश है, किसी भी सुझाव की सराहना की जाएगी।

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

— Laikoni
स्रोत
मुझे लगता है कि आप x and y or zबदलने के लिए टर्नरी ऑपरेटरों ( ) का उपयोग कर सकते हैं case।
— लीकी नून
तुम भी के s[0]=="^"बजाय उपयोग कर सकते हैंmatch['^',c]+r in l
— लीक नून
@LeakyNun मैं की जगह जब match['^',c]+rसाथ s[0]=="^"है, तो cऔर rनहीं रह गया है बाध्य कर रहे हैं। यह कैसे मदद करेगा?
— लकोनी
आप उपयोग कर सकते हैं s[1]बदलने के लिए cऔर s[2:]बदलने के लिए r।
— लीक नन
तो आप अब टर्नरी का उपयोग कर सकते हैं।
— लीक नून
0

डायलाग एपीएल, 34 बाइट्स

{(0 1=⊂b/¯1⌽b){⍺\⍺/⍵}¨⊂⍵/⍨b←⍵≠'∧'}

यह दो लाइनों के साथ एक दो-तत्व वेक्टर देता है

सैंपल रन (सामने की ओर बढ़ने पर दो-एल का निर्माण होता है। मानव उपभोग के लिए वेक्टर):

      ↑{(0 1=⊂b/¯1⌽b){⍺\⍺/⍵}¨⊂⍵/⍨b←⍵≠'∧'}'abc∧d+ef∧g + hijk∧l - M∧NO∧P (Ag∧+)'
   d   g       l    N P    + 
abc +ef  + hijk  - M O  (Ag )
— lstefano
स्रोत
कोड कुछ भी नहीं करने के बारे में मेरे सवाल पर आपकी टिप्पणी के लिए: हाँ, वह कोड जिसे आप मायने रखते हैं।
— हयकम
0

PowerShell v2 +, 88 83 बाइट्स

-join([char[]]$args[0]|%{if($c){$_;$b+=' '}elseif($_-94){$b+=$_;' '}$c=$_-eq94});$b

दूसरों की तुलना में थोड़ा लंबा, लेकिन थोड़ा पॉवरशेल जादू और थोड़ा अलग तर्क दिखाता है।

अनिवार्य रूप से पायथन के जवाब के रूप में एक ही अवधारणा - हम इनपुट चरित्र-दर-चरित्र पर पुनरावृति करते हैं, याद रखें कि क्या पिछला एक कैरेट ( $c) था, और वर्तमान चरित्र को उचित स्थान पर रखा। हालांकि, यह निर्धारित करने के लिए तर्क और विधि जहां आउटपुट को थोड़ा अलग तरीके से संभाला जाता है, और बिना टपल या अलग-अलग चर के - हम परीक्षण करते हैं कि क्या पिछला चरित्र एक कैरेट था, और यदि ऐसा है तो पाइप लाइन के लिए चरित्र को आउटपुट करें और एक स्थान को अलग करें। $b। अन्यथा हम जांचते हैं कि क्या वर्तमान चरित्र एक कैरेट है elseif($_-94)और जब तक यह नहीं है, हम वर्तमान चरित्र को चालू $bकरते हैं और पाइपलाइन के लिए एक स्थान का उत्पादन करते हैं। अंत में, हम यह निर्धारित करते हैं कि वर्तमान चरित्र अगले गो-राउंड के लिए एक कैरेट है या नहीं।

हम उन पात्रों को पाइपलाइन से एक साथ परेंस में इकट्ठा करते हैं, उन्हें एनकैप्सुलेट करते हैं, -joinजो उन्हें एक स्ट्रिंग में बदल देता है, और $bपाइप लाइन पर छोड़ देता है । अंत में आउटपुट एक नई लाइन इनबेटीइन के साथ निहित है।

तुलना के लिए, यहां 85 बाइट्स पर @ xnor के पायथन जवाब का सीधा पोर्ट है :

$a=,''*2;[char[]]$args[($l=0)]|%{$a[!$l]+="$_"*($c=$_-ne94);$a[$l]+=' '*$c;$l=!$c};$a
— AdmBorkBork
स्रोत
0

गेमा, ४२ ४१ अक्षर

\^?=?@set{s;$s }
?=\ @append{s;?}
\Z=\n$s

Gema इनपुट को स्ट्रीम के रूप में संसाधित करता है, इसलिए आपको इसे एक पास में हल करना होगा: पहली पंक्ति को तुरंत संसाधित के रूप में लिखा जाता है, दूसरी पंक्ति को चर $ s में एकत्र किया जाता है, फिर अंत में आउटपुट होता है।

नमूना रन:

bash-4.3$ gema '\^?=?@set{s;$s };?=\ @append{s;?};\Z=\n$s' <<< 'abc^d+ef^g + hijk^l - M^NO^P (Ag^+)'
   d   g       l    N P    +  
abc +ef  + hijk  - M O  (Ag )
— आदमी काम पर है
स्रोत
0

दालचीनी गोंद, 21 बाइट्स

0000000: 5306 6533 bd92 d1db 8899 8381 a2f8 8f8c  S.e3............
0000010: 1230 249e a1                             .0$..

गैर-प्रतिस्पर्धा। इसे ऑनलाइन आज़माएं।

व्याख्या

मैं रेगेक्स गोल्फर से ज्यादा नहीं हूं इसलिए ऐसा करने का एक बेहतर तरीका है।

स्ट्रिंग को विघटित करता है:

S(?<!\^)[^^]& &\^&`S\^.&

(अनुगामी स्थान पर ध्यान दें)

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

Perl psuedo-code में:

$first_stage_sub_1 = ($input =~ s/(?<!\^)[^^]/ /gr);
$first_stage_sub_2 = ($first_stage_sub_1 =~ s/\^//gr);
print $first_stage_sub_2, "\n";

$second_stage_sub = ($input =~ s/\^./ /gr);
print $second_stage_sub, "\n";
— एक स्पैगेटो
स्रोत
0

जे , 28 27 बाइट्स

0|:t#]{."0~_1-_1|.t=.'^'~:]

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

                  t=.'^'~:]    0 for ^, 1 for the rest, define t
              _1|.             Shift right, now zeroes are for superscripts         
     ]{."0~_1-                 Prepend that many spaces to each character
   t#                          Remove the rows with carets
0|:                            Transpose

इसके लिए अवश्य ही एक बेहतर तरीका होना चाहिए...

— FrownyFrog
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.