ASCII अक्षरों (ऊपरी और / या निचले मामले) की एक स्ट्रिंग को देखते हुए, कच्चे MathJax को प्रत्येक वर्ण पर उस स्ट्रिंग को द्विभाजित करने के लिए आवश्यक रूप से सुपरस्क्रिप्ट और सब्सक्राइबर्स में प्रदर्शित करना आवश्यक है। उदाहरण के लिए, इनपुट catऔर horseपरिणामस्वरूप आउटपुट होंगे जो क्रमशः MathJax निम्नलिखित के रूप में प्रस्तुत करता है:

ध्यान दें कि केवल एक इनपुट लेने की आवश्यकता है - ये दोनों ऊर्ध्वाधर स्थान बचाने के लिए बस एक तरफ से सूचीबद्ध हैं।

मार्कअप अर्थ

_ एक सबस्क्रिप्ट दर्शाता है।
^ एक सुपरस्क्रिप्ट को इंगित करता है।
ब्रेसिज़ की आवश्यकता सुपरसक्रिप्टेड या सबस्क्रिप्ट किए गए सबस्ट्रिंग्स के आसपास होती है, जिसमें एक ही स्तर पर इन सभी को रोकने के लिए आगे सुपरस्क्रिप्टिंग या सबस्क्रिप्टिंग होती है।

परीक्षण के मामलों

परीक्षण के मामले प्रारूप में हैं input : output। पहला परीक्षण मामला खाली स्ट्रिंग दिखाता है क्योंकि इनपुट का परिणाम रिक्त स्ट्रिंग में आउटपुट के रूप में होना चाहिए।

"" : ""
"a" : "a"
"me" : "m_e^e"
"cat" : "c_{a_t^t}^{a_t^t}"
"frog" : "f_{r_{o_g^g}^{o_g^g}}^{r_{o_g^g}^{o_g^g}}"
"horse" : "h_{o_{r_{s_e^e}^{s_e^e}}^{r_{s_e^e}^{s_e^e}}}^{o_{r_{s_e^e}^{s_e^e}}^{r_{s_e^e}^{s_e^e}}}"
"bifurcate" : "b_{i_{f_{u_{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}^{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}}^{u_{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}^{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}}}^{f_{u_{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}^{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}}^{u_{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}^{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}}}}^{i_{f_{u_{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}^{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}}^{u_{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}^{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}}}^{f_{u_{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}^{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}}^{u_{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}^{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}}}}"

आप देख सकते हैं कि ये कैसे mathurl.com में आउटपुट पेस्ट करके प्रस्तुत किए गए हैं ।

कोई अतिरेक नहीं है

MathJax ख़ुशी से मार्कअप को प्रस्तुत करेगा, जिसमें निरर्थक ब्रेसिज़ हैं। उदाहरण के लिए, निम्नलिखित सभी जब गाया समान दिखेगा: a, {a}, {}{a}, {{{{a}}}}।

हालांकि, इस चुनौती के लिए वैध उत्पादन में कोई अतिरेक नहीं है। विशेष रूप से ध्यान दें कि आउटपुट में एकल वर्ण ब्रेसिज़ से घिरे नहीं हैं।

क्रम

सबस्क्रिप्ट और सुपरस्क्रिप्ट का क्रम महत्वहीन है। निम्नलिखित समतुल्य हैं और प्रस्तुत किए जाने पर अप्रभेद्य होंगे (और सभी समान रूप से मान्य आउटपुट हैं):

c_{a_t^t}^{a_t^t}
c_{a^t_t}^{a_t^t}
c_{a_t^t}^{a^t_t}
c_{a^t_t}^{a^t_t}
c^{a_t^t}_{a_t^t}
c^{a^t_t}_{a_t^t}
c^{a_t^t}_{a^t_t}
c^{a^t_t}_{a^t_t}

स्कोरिंग

प्रत्येक भाषा के लिए, विजेता बाइट्स में सबसे छोटा कोड होता है।

_{बहुत सारी सूचनाएं? </sub>सदस्यता समाप्त करने के लिए टाइप करें}

code-golf string

— trichoplax
स्रोत

बहुत सारी सूचनाएं? </sub>सदस्यता के लिए टाइप करें हुह किसने कहा कि मैं सदस्यता समाप्त करना चाहता हूं या कुछ और? यह देखने के लिए एक परीक्षण था कि क्या मैंने पूरी पोस्ट को सही पढ़ा है?

— आउटगॉल्फ

12

@EriktheOutgolfer नहीं यह सिर्फ एक बहुत बुरा मजाक था।

— ट्राइकोप्लाक्स

क्या हम इसके बजाय संकलित पीडीएफ परिणाम का उत्पादन कर सकते हैं? मैं शुद्ध लेटेक्स उत्तर लिखना चाहूंगा।

— गेहूं जादूगर

@HeatWizard एक अलग चुनौती की तरह लगता है। यह यहाँ एक उत्तर के रूप में मान्य नहीं होगा।

— ट्राइकोप्लाक्स

10

पायथन, 95 90 86 92 82 बाइट्स

10 बाइट्स ने @ConnerJohnston को धन्यवाद दिया

f=lambda s:s and s[0]+(s[1:]and'_{0}^{0}'.format(s[2:]and'{'+f(s[1:])+'}'or s[1]))

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

— Uriel
स्रोत

4

वाह, यह कुछ पागल पुनरावृत्ति है।

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

1

81 बाइट्स के लिए कुछ स्ट्रिंग स्वरूपण (यह सुनिश्चित नहीं करें कि टिप्पणियों में TIO लिंक अभी तक कैसे है): f = lambda s: s और s [0] + '_ {0} ^ {0}'। Format (s [2:] और ') {'+ + f (s [1:]) +'} 'या s [1:] और s [1])

— कोनर जॉनसन

1

@ConnerJohnston धन्यवाद! आप के साथ टियो लिंक डाल सकते हैं [text](link), लेकिन यह वास्तव में खराब हो रहा है;)

— यूरियल

1

79 बाइट्स ; और मुझे लगता है कि आप अनाम फ़ंक्शन ट्रिक का उपयोग नहीं करना चाहते हैं, हालांकि 2 बाइट्स बचाएंगे।

— जोनाथन फ्रेच

7

गणितज्ञ, 72 84 77 76 बाइट्स

a_±b__:={"{",a,"_",±b,"^",±b,"}"};±(a_:""):={"",a,""};""<>Most@Rest@±##&@@#&

CP-1252 (विंडोज) एन्कोडिंग का उपयोग करता है। इनपुट के रूप में वर्णों की एक सूची लेता है।

व्याख्या

a_±b__:=

फ़ंक्शन को परिभाषित करें ±, 2 या अधिक तर्कों के साथ। पहला तर्क लेबल करें a, और दूसरा और चालू b।

{"{",a,"_",±b,"^",±b,"}"}

( Listसमकक्ष पुन: मूल्यांकन किया जाता है) के बराबर एक बनाएँ ।"{a_±b^±b}"±b

±(a_:""):= ...

फ़ंक्शन को परिभाषित करें ±, 1 या 0 तर्कों के साथ। पहला तर्क लेबल करें a, अगर यह मौजूद है, और अन्यथा असाइन ""करें a।

{"",a,""}

खाली s के साथ गद्देदार के Listबराबर एक बनाएँ ।"a"String

""<>Most@Rest@±##&@@#&

एक शुद्ध फ़ंक्शन जो ±इनपुट पर लागू होता है, पहले और अंतिम तत्व को छोड़ देता है, और में कनवर्ट करता Listहै String।

— जंगहवान मिन
स्रोत

7

CJam (35 बाइट्स)

MqW%{"^{ }_{ }"{AW$,)3e<#<},S/@*+}/

यह एक पूर्ण कार्यक्रम है। ऑनलाइन डेमो ।

3 बाइट्स दुभाषिया में एक बग के आसपास काम करते हैं (नीचे देखें)।

विच्छेदन

M            e# Start building from the empty string
qW%{         e# For each character in the reversed input
  "^{ }_{ }" e#   Take a template
  {          e#   If the accumulator is of length n, remove all characters whose
    A        e#   codepoints are greater than pow(10,
    W$,)3e<  e#                                   min(n+1, 3))
    #<       e#   When the accumulator is the empty string, that's all of them.
  },         e#   When the accumulator is one character, that's {}
             e#   When the accumulator is any longer, it's none of them.
  S/@*       e#   Substitute the accumulator for the spaces.
  +          e#   Append to the new character.
}/

ध्यान दें कि min(n+1, 3)दुभाषिया में बग के चारों ओर काम करना है: 10 की शक्तियों में कुछ पैटर्न होना चाहिए जो कि इससे '}छोटा है, लेकिन यह स्पष्ट नहीं है ।

— पीटर टेलर
स्रोत

खाली स्ट्रिंग (प्रथम परीक्षण मामले) के लिए काम नहीं करता है।

— ट्राइकोप्लाक्स

1

@trichoplax, कि GolfScript और CJam के बीच एक सूक्ष्म अंतर के कारण था जो कभी-कभार मुझे पकड़ लेता है। अब कोड को पहले की तुलना में अधिक चतुर बनाकर केवल एक बाइट की कीमत पर तय किया गया था।

— पीटर टेलर

अब पूरी तरह से काम करता है। महान व्याख्या।

— त्रिकोप्लक्स

@PeterTaylor (कम से कम ऑनलाइन डेमो में) यह चार से अधिक अक्षरों वाले शब्दों के लिए काम नहीं करता है।

— डेसर्ट

2

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

— पीटर टेलर

7

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

f=([c,...s])=>s+s?c+`_${p=s[1]?`{${f(s)}}`:s}^`+p:c||''

~~((Len (s)) जटिलता!~~ @PeterTaylor के अनुसार, यह वास्तव में 2 (2 ^ len (s)) है, जो अभी भी सबसे अच्छा संभव है ...

— ETHproductions
स्रोत

खाली स्ट्रिंग (प्रथम परीक्षण मामले) के लिए काम नहीं करता है।

— ट्राइकोप्लाक्स

@trichoplax अभी तय होना चाहिए।

— ETHproductions

अब पूरी तरह से काम करता है।

— त्रिकोप्लक्स

1

आपके O (n) में n क्या है? मुझे लगता है कि यह आउटपुट की लंबाई है, लेकिन जब तक आप यह नहीं बताते कि यह इनपुट की लंबाई होने के लिए डिफ़ॉल्ट रूप से व्याख्या की गई है, और चूंकि आउटपुट की लंबाई इनपुट की लंबाई में घातीय है, इसलिए बहुपद समय में इसे लागू करना असंभव है।

— पीटर टेलर

@PeterTaylor मुझे लगा था कि चूंकि एल्गोरिथ्म केवल लेन (इनपुट) कदम उठाता है, कि जटिलता लेन (इनपुट) है ... अगर यह सही नहीं है तो मैं इसे पोस्ट से हटा दूंगा क्योंकि मुझे नहीं पता कि कैसे इसकी गणना करने के लिए, जब तक कि आपको पता न हो कि सही जटिलता क्या है।

— 11:10 बजे ETHproductions

6

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

f[x,y]=x:'_':y:'^':y:[]
f(x:y@(_:_))=x:"_{"++f y++"}^{"++f y++"}"
f x=x

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

अगर हमें सिर्फ वैध कोड का उत्पादन करना था तो निम्नलिखित 44 बाइट्स के लिए काम करेगा:

f[a]=[a]
f(a:b)=a:"_{"++f b++"}^{"++f b++"}"

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

— गेहूं का जादूगर
स्रोत

2

-5 बाइट्स, 44 बाइट्स संस्करण के आधार पर: इसे ऑनलाइन आज़माएं!

— जफर

@ जफरार्ड नाइस! मैं उस पोस्ट में जोड़ दूँगा।

— गेहूं जादूगर

66 बाइट्स: इसे ऑनलाइन आज़माएं!

— लकोनी

63 बाइट्स: इसे ऑनलाइन आज़माएं!

— लकोनी

59 बाइट्स: इसे ऑनलाइन आज़माएं!

— लकोनी

5

SOGL V0.12 , 21 बाइट्स

±K;{╔+;lH?"{ŗ}”}1 ^Ο+

यह कोशिश करो!

स्पष्टीकरण:

±                      reverse the string
 K                     take off the first letter - will slowly convert to the output
  ;                    get the rest of the string ontop
   {                   iterate over the rest of the characters
    ╔+                   append "_" to it
      ;                  get the output string ontop
       lH?     }         if it's length - 1 [isn't 0]
          "{ŗ}”            push the string "{ŗ}" where ŗ is replaced by the output string
                1 ^Ο     wrap "^" around with the output string
                    +    prepend to it the current character + "_"

— dzaima
स्रोत

5

पर्ल 5 , 54 + 1 (-पी) = 55 बाइट्स

s/\{(.)\}/$1/g while s/([a-z])([a-z]+)/$1_{$2}^{$2}/ig

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

कैसे?

स्थिति में प्रतिस्थापन, पहले अक्षर में कई अक्षरों की घटनाओं को तोड़ता है, इसके बाद इस तरह से ब्रेसिज़ में बाकी है:

abc -> a_{bc}^{bc}

जबकि लूप प्रतिस्थापन का निष्पादन तब तक करता है जब तक कि अधिक बहु-अक्षर अनुक्रम नहीं रहते। लूप के अंदर प्रतिस्थापन लगभग एकल अक्षरों से ब्रेसिज़ को निकालता है।

— Xcali
स्रोत

अच्छा, मैं सोच रहा था कि रेगेक्स जवाब दिखाने में कितना समय लगेगा

— Nnnes

4

रूबी , 76 73 72 68 67 57 बाइट्स

टटलमैन के लिए 4 बाइट्स की बचत के लिए लैम्ब्डा का उपयोग

f=->s{(r=s[1..-1])[0]?s[0]+?_+[r[1]??{+f[r]+?}:r]*2*?^:s}

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

Ungolfed:

def f(s)
  r = s[1..-1]
  if r.size > 0
    if r.size > 1
      x = "{" + f(r) + "}"
    else
      x = r
    end
    return s[0] + "_" + [x, x].join("^")
  else
    return s
  end
end

— Nnnes
स्रोत

एक फ़ंक्शन के बजाय, एक अनाम लंबोदा (जैसे ->s{...}) का उपयोग करें, जो 7 बाइट्स बचाता है। उसके बाद, आप की जगह 2 अधिक बाइट्स बचा सकता है "#{s[0]}_के साथ s[0]+"_। '{}'जब आप पहली बार इसका उपयोग करते हैं, तो आप एक वैरिएबल के इनलाइन असाइनमेंट को करके एक और बाइट बचा सकते हैं ।

— टटलमैन

@ टटलमैन यह पुनरावर्ती ( t=f s[1..-1]) है, इसलिए मुझे नहीं लगता कि एक अनाम फ़ंक्शन काम करेगा, और मैंने पहले ही स्ट्रिंग की शुरुआत को फिर से व्यवस्थित किया है, लेकिन मैं इनलाइन असाइनमेंट का उपयोग कर सकता हूं।

— Nnnes

1

डी 'ओह! वूप्स - मुझे विश्वास नहीं हो रहा है कि मैं चूक गया। वैसे भी, यह अभी भी एक (नाम) लैंबडा का उपयोग करने के लिए कम है: f=->s{...}4 बाइट्स बचाता है, यहां तक []कि पुनरावर्ती कॉल करते समय आपको आवश्यक अतिरिक्त के लिए लेखांकन ।

— टटलमैन

@ टटलमैन ओह, हाँ, इसे बदल दिया। अब अगर मैं उस .trगड़बड़ से बेहतर कुछ कर सकता हूं ...

— Nnnes

2

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

def b(s):q=s and(s[2:]and'{%s}'or'%s')%b(s[1:]);return s[1:]and s[0]+'^%s_'%q+q or s

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

— आउटग्रॉफर को एरिक करें
स्रोत

1

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

Ljk[hb|&ttbs[\_\{ytb"}^{"ytb\})&tbs[\_htb\^htb;

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

यह बहुत हद तक @ Uriel के Python उत्तर का सीधा पोर्ट है। यह थोड़ा नीचे गोल्फ में जा रहा है।

— आर्नोल्ड पाल्मर
स्रोत

1

PHP, 121 बाइट्स

function b($s){return $s[0].($s[1]?'_'.($s[2]?'{'.($b=b(substr($s,1))).'}^{'.$b.'}':"$s[1]^$s[1]"):'');}echo b($argv[1]);

फ़ंक्शन स्वयं 104 बाइट्स है और एक PHP नोटिस दिखाता है।

— jstnthms
स्रोत

1

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

(.)(.)$
$1¶$2
+`(.)¶(.*)
¶{$1_$2^$2}
¶{|}$

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

(.)(.)$
$1¶$2

अंतिम पात्र से फिसलकर गेंद को लुढ़काएं। (लेकिन अगर यह एकमात्र चरित्र है, तो वे इसे अकेले छोड़ देते हैं।)

+`(.)¶(.*)
¶{$1_$2^$2}

Time वर्ण को एक बार में एक कदम पीछे ले जाएं, हर बार पिछले परिणाम को लेते हुए और इसे अगले चरित्र की एक उपप्रकाश और सुपरस्क्रिप्ट बना सकते हैं।

¶{|}$

अब अनावश्यक ¶ और बाहरी {} s निकालें।

— नील
स्रोत

1

जावा (ओपनजेडके 8) , 121 बाइट्स

s->{int l=s.length;String r=--l<0?"":""+s[l];for(;l-->0;)r="{"+s[l]+"_"+r+"^"+r+"}";return r.replaceAll("^\\{|\\}$","");}

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

— ओलिवियर ग्रेजायर
स्रोत

0

जावास्क्रिप्ट, 73 बाइट्स

s=>[...s].reduceRight((m,c)=>`${c}_{${m}}^{${m}}`).replace(/{(.)}/g,'$1')

व्याख्या

s=>                                  // take the input string
    [...s]                           // split the string into an array
    .reduceRight(                    // reduce the array in reverse order
        (m,c)=>`${c}_{${m}}^{${m}}`  // storing the result of each iteration in the memo m
    )                                // and returning m at the end
    .replace(/{(.)}/g,'$1')          // replace redundant {}

क्योंकि कोई निर्दिष्ट प्रारंभिक मूल्य नहीं है m, प्रारंभिक reduceRightतत्व के sरूप में अंतिम तत्व लेता है , और सूचकांक पर पुनरावृत्ति शुरू करता है s.length-2।

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

const f=s=>[...s].reduceRight((m,c)=>`${c}_{${m}}^{${m}}`).replace(/{(.)}/g,'$1');

const input = document.querySelector('#input');
const output = document.querySelector('#output');
output.textContent = f(input.value);
input.addEventListener('keyup', e => output.textContent = f(input.value));

Enter text to bifurcate: <input type="text" id="input" value="cat" />
<br />
<span id="output"></span>

स्निपेट का विस्तार करें

— asgallant
स्रोत

s=>[...s].reduceRight((m,c)=>`{${c}_${m}^${m}}`).slice(1,-1)केवल 60 बाइट्स है।

— नील

खाली स्ट्रिंग (प्रथम परीक्षण मामले) के लिए काम नहीं करता है।

— ट्राइकोप्लाक्स

द्विभाजित पाठ

मार्कअप अर्थ

परीक्षण के मामलों

कोई अतिरेक नहीं है

क्रम

स्कोरिंग

पायथन, 95 90 86 92 82 बाइट्स

गणितज्ञ, 72 84 77 76 बाइट्स

व्याख्या

CJam (35 बाइट्स)

विच्छेदन

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

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

SOGL V0.12 , 21 बाइट्स

पर्ल 5 , 54 + 1 (-पी) = 55 बाइट्स

रूबी , 76 73 72 68 67 57 बाइट्स

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

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

PHP, 121 बाइट्स

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

जावा (ओपनजेडके 8) , 121 बाइट्स

जावास्क्रिप्ट, 73 बाइट्स

व्याख्या