मेरे स्क्रीनसेवर को पार्स करें!


21

प्रसिद्ध निर्माण की भाषा का एस्पेरांत लैटिन वर्णमाला का उपयोग करता है (ज्यादातर, विवरण के लिए लिंक किए गए विकिपीडिया पृष्ठ देखें)। हालांकि, उच्चारण के साथ कुछ वर्ण हैं: characters, characters, characters, characters, characters, और characters । (C-circumflex, g-circumflex, h-circumflex, j-circumflex, s-circumflex, और u- breve ।) स्वाभाविक रूप से, ये अक्षर टाइप करने के लिए बहुत कठिन हैं। यहां तक ​​कि इस प्रश्न के लिए, मुझे पात्रों के लिए यूनिकोड चयनकर्ता में खोजना पड़ा। इसके कारण, इलेक्ट्रॉनिक उपयोग के लिए "x" अक्षर का उपयोग करने वाला एक सम्मेलन विकसित किया गया है। उदाहरण के लिए, "cxu" का उपयोग ".u" के लिए किया जाता है। (नोट: अक्षर "x" का उपयोग आम तौर पर एस्पेरांतो वर्णमाला में नहीं किया जाता है। "

हालाँकि, मैं एक भाषा शुद्धतावादी हूँ! यह * हवा बोली * x बकवास मुझे मार रहा है! मुझे इसे ठीक करने के लिए एक कार्यक्रम की आवश्यकता है, अधिमानतः जितना संभव हो उतना कम ताकि मैं इसे अपने टर्मिनल में जितनी जल्दी हो सके टाइप कर सकूं!

चुनौती

अपने मिशन के लिए एक्स-कन्वेंशन का उपयोग करके एक स्ट्रिंग का आउटलुक लेना है और इसे वास्तविक स्वप्निल में बदलना है।

वास्तव में, आपको मैप करना होगा:

cx: ĉ
gx: ĝ
hx: ĥ
jx: ĵ
sx: ŝ
ux: ŭ
Cx: Ĉ
Gx: Ĝ
Hx: Ĥ
Jx: Ĵ
Sx: Ŝ
Ux: Ŭ

अन्य सभी मुद्रण योग्य ASCII वर्णों को स्वीकार किया जाना चाहिए और उन्हें बदला नहीं जाना चाहिए। यूनिकोड अच्छा होगा, लेकिन आवश्यक नहीं।

इनपुट और आउटपुट आपकी भाषा के लिए किसी भी प्रारूप में हो सकते हैं। सौभाग्य!

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

"input" : "output"
_____________
"gxi estas varma" : "ĝi estas varma"
"Cxu sxi sxatas katojn aux hundojn?" : "Ĉu ŝi ŝatas katojn aŭ hundojn?"
"Uxcxsxabcd(hxSx)efg{};" : "Ŭĉŝabcd(ĥŜ)efg{};"
"qwertyuiop" : "qwertyuiop"
" " : " "
"" : ""
"x" : "x"
"xc" : "xc"
"xcx" : "xĉ"
"cxx" : "ĉx"

स्कोरिंग

यह । उत्तर भाषा के डिफ़ॉल्ट एन्कोडिंग में सबसे छोटे बायटेकाउंट द्वारा बनाए जाते हैं।

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई देता है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

# Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

सौभाग्य, मज़े करो, और सुधार का सुझाव देने के लिए स्वतंत्र महसूस करो!

स्पष्टीकरण:

  • आपको केवल मुद्रण योग्य ASCII वर्णों के बारे में चिंता करने की आवश्यकता है ।

  • आपको केवल एक चरित्र को आउटपुट करने की आवश्यकता है जो सही आउटपुट की तरह दिखता है । हां, इसका मतलब है कि आप मानक चरित्र पर उच्चारण से निपट सकते हैं।


यहाँ ASCII का अर्थ है 20-7E प्रिंट करने योग्य वर्ण, 00-7F, या क्या?
user202729

सभी प्रिंट करने योग्य हैं।
OldBunny2800

नोट: मैंने एक स्पष्टीकरण जोड़ा है कि आप पत्र और संशोधक उच्चारण का उपयोग कर सकते हैं।
OldBunny2800

5
परिधि का संयोजन 0302 पर है ̂, और ब्रेवे का संयोजन 0306 पर है ̆
user202729

^ हर एक UTO8 में 2 बाइट्स TIO काउंट के रूप में लेता है ।
user202729

जवाबों:


9

QuadR , 65 बाइट्स

.x
3::⍵M'ĉĝĥĵŝŭĈĜĤĴŜŬ'['cghjsuCGHJSU'⍳⊃⍵M]

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

.x किसी भी वर्ण को "x" के साथ बदलें

3::⍵M इंडेक्सिंग एरर पर, मैच को वापस अनमॉडिफाइड करें,
 अब कोशिश करें:
'ĉĝĥĵŝŭĈĜĤĴŜŬ'[... ] इस स्ट्रिंग
  ⍵M में मैच के
   पहले अक्षर के
   इंडेक्स के
  'cghjsuCGHJSU' साथ इस स्ट्रिंग में इंडेक्स करें

यह Dyalog APL टैसिट फ़ंक्शन के बराबर है:

'.x'R{3::⍵.Match'ĉĝĥĵŝŭĈĜĤĴŜŬ'['cghjsuCGHJSU'⍳⊃⍵.Match]}

अच्छा जवाब! +1
OldBunny2800

मुझे यकीन नहीं है कि यहां बाइट्स कैसे गिने जाते हैं। क्या shorterR का सीधा उपयोग कम नहीं है? ('cghjsuCGHJSU',¨'x')⎕r(,¨'ĉĝĥĵŝŭĈĜĤĴŜŬ')
ngn

@ng यह है, लेकिन इससे पहले कि मुझे पोस्ट करने का मौका मिले, मेरी बैटरी खत्म हो गई।
शाम 28:17

6

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

iT`x`̂`[cghjs]x
iT`x`̆`ux

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

यह कार्यक्रम दो अनुवादों द्वारा रचा गया है। कोड में वर्णों के संयोजन होने के कारण यह बहुत अच्छी तरह से प्रस्तुत नहीं करता है, पहली पंक्ति को वास्तव में उसी तरह दिखना चाहिए iT`x`^`[cghjs]x, जहां ^खंभे के उच्चारण संयोजन के लिए खड़ा है। यह क्या कह रहा है कि इसे इनपुट में सभी s को फिर से Tविभाजित करना चाहिए , जब भी वे किसी पत्र का अनुसरण कर रहे हों ।ix^[cghjs]


नोट: TIO इस कोड को 25 बाइट्स के रूप में गलत तरीके से मापता है। दरअसल, यह रेटिना प्रोग्राम UTF-8 एन्कोडिंग का उपयोग करता है (अन्य प्रोग्राम UTF-32 या ISO 8859-1 का उपयोग कर सकते हैं) और दो संयोजन वर्णों की वर्तमान लागत 2 बाइट्स होती है।


5

सी,  173  154 बाइट्स

17 बाइट बचाने के लिए @ कोलेरा सु के लिए धन्यवाद!

p,c,i;f(char*s){for(char*l="cghjsuCGHJSU";p=*s;~c&&putchar(p))for(c=*++s,i=0;c=='x'&&l[i];++i)l[i]-p||write(1,"ĉĝĥĵŝŭĈĜĤĴŜŬ"+i*2,2,c=-1,++s);}

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

स्पष्टीकरण:

p,c,i;
f(char*s)
{
    // The outer loop and an array of characters that are modified by a trailing 'x'.
    // The array/string is used for getting the index for the accented character later.
    for (char*l="cghjsuCGHJSU";

                                // Store the current character of the input string in 'p'.
                                // If it is '\0', the loop terminates.
                                p=*s;

                                      // The last statement in the loop.
                                      // If 'c==-1', it outputs the char stored in 'p'. 
                                      ~c&&putchar(p))

        // Store the character following 'p' in 'c' and increment the string pointer.
        for(c=*++s, i=0;

                        // If 'c' is not the letter 'x', the inner loop terminates
                        // immediately. Otherwise it loops through the characters of
                        // string 'l'.
                        c=='x'&&l[i]; ++i)

            // If the character stored in 'p' is found inside the string 'l'...
            l[i]-p ||

                      // ...then print the accented character corresponding to 'p'.
                      // 'i' is the index of 'p' in 'l', and, because the characters
                      // with accents are two bytes each, the index is multiplied by 2.
                      write(1,"ĉĝĥĵŝŭĈĜĤĴŜŬ"+i*2,2,

                      // Finally set 'c' to -1 so that the non-accented character doesn't
                      // get printed too, and increment the string pointer so that the
                      // letter 'x' doesn't get printed either.
                                                    c=-1, ++s);
}

अच्छा! क्या मेरे पास स्पष्टीकरण हो सकता है?
OldBunny2800

संभवतः आप इसके बजाय शाब्दिक नल बाइट का उपयोग कर सकते हैं \0?
user202729

(लेकिन यह दुर्भाग्य से TIO पर काम नहीं करता है)
user202729

आप write(1,"..."+i*2,2)17 बाइट बचाने के लिए उपयोग कर सकते हैं । इसे ऑनलाइन आज़माएं!
कोलेरा सु

5

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

lambda s,T="cĉgĝhĥjĵsŝuŭ":eval("s"+".replace('%sx',%r)"*12%(*T+T.upper(),))

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

स्ट्रिंग उत्पन्न करता है और उसका मूल्यांकन करता है:

s.replace('cx','ĉ').replace('gx','ĝ').replace('hx','ĥ').replace('jx','ĵ').replace('sx','ŝ').replace('ux','ŭ').replace('Cx','Ĉ').replace('Gx','Ĝ').replace('Hx','Ĥ').replace('Jx','Ĵ').replace('Sx','Ŝ').replace('Ux','Ŭ')

एरिक आउटग्लोफर ने एक बाइट को बचाया।


@EriktheOutgolfer एक अच्छा, धन्यवाद!
xnor

3

/// , 75 बाइट्स

/,/\/\///>/x\,/c>ĉ,g>ĝ,h>ĥ,j>ĵ,s>ŝ,u>ŭ,C>Ĉ,G>Ĝ,H>Ĥ,J>Ĵ,S>Ŝ,U>Ŭ/

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

/
/\/\/// /x\
/c  ĉ
g   ĝ
h   ĥ
j   ĵ
s   ŝ
u   ŭ
C   Ĉ
G   Ĝ
H   Ĥ
J   Ĵ
S   Ŝ
U   Ŭ/

हालाँकि इसके लिए इनपुट में टैब या न्यूलाइन शामिल नहीं होने चाहिए।

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

क्योंकि ///आप इनपुट नहीं ले सकते हैं, आपको कोड के बाद इनपुट डालना चाहिए।

बहुत सीधा। मुझे लगता है कि यह छोटा नहीं हो सकता क्योंकि ///प्रत्येक चरित्र की विशेष हैंडलिंग की आवश्यकता होती है।

स्पष्टीकरण:

/,/\/\//       Replace all `,` in the code by `//`
               (two slashes are represented as two backslash-ed slashes)
/>/x\,         (in original code) becomes
/>/x\//        (because `,` is replaced by `//`) - replace all occurence of 
               `>` by `x/`.
/cx/ĉ//gx/ĝ//hx/ĥ//jx/ĵ//sx/ŝ//ux/ŭ//Cx/Ĉ//Gx/Ĝ//Hx/Ĥ//Jx/Ĵ//Sx/Ŝ//Ux/Ŭ/
               ^ The remaining part of the code should look like this.
               Straightforward replacement.

3

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

f=lambda x,v="cĉgĝhĥjĵsŝuŭCĈGĜHĤJĴSŜUŬ":v and f(x.replace(v[0]+"x",v[1]),v[2:])or x

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

-10 बाइट्स धन्यवाद के लिए व्हाट्सएप
-1 बाइट थैंक्यू कोलेरा सु



@ user507295 ओह स्मार्ट आइडिया। धन्यवाद!
हाइपरन्यूट्रीनो

एक-एक बाइट को बचाने के लिए उपयोग या ट्रिक: इसे ऑनलाइन आज़माएं!
कोलेरा सु

@ColeraSu ओह शांत, धन्यवाद। सुनिश्चित नहीं हैं कि यह चाल क्यों गायब हो गई:
हाइपरन्यूट्रीनो

@HyperNeutrino क्योंकि मैं उस ट्रिक के बारे में नहीं जानता था। माफ़ कीजिये!
WhatToDo



1

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

s=>[..."cghjsuCGHJSU"].reduce((a,v,i)=>a.split(v+"x").join("ĉĝĥĵŝŭĈĜĤĴŜŬ"[i]),s)

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

बाइट काउंट को कम करने के लिए यहाँ इस्तेमाल की गई स्प्लिट-जॉइन विधि की सिफारिश की जाती है क्योंकिnew RegExp(/*blah*/) कंस्ट्रक्टर ने बहुत सारे बाइट्स लिए हैं।

तुलना:

Original: a.replace(new RegExp(v+"x", "g"), "ĉĝĥĵŝŭĈĜĤĴŜŬ"[i])
New     : a.split(v+"x").join("ĉĝĥĵŝŭĈĜĤĴŜŬ"[i])

कम, संयोजन दृष्टिकोण (63 बाइट्स), लेकिन कुछ कलाकृतियों के साथ।

s=>s.replace(/([cghjs])x/gi," ̂$1").replace(/(u)x/gi," ̌$1");

फुटनोट: मैं अपने उत्तर का दावा कर रहा हूँ 92 बाइट्स क्योंकि 63-बाइट समाधान में कलाकृतियाँ हैं जो आउटपुट को प्रभावित कर सकती हैं।


1

एपीएल (डायलॉग यूनिकोड) , 57 बाइट्स

अनाम मौन कार्य। उपयोगों:

  1. स्ट्रिंग के लिए उपसर्ग फ़ंक्शन। यह स्ट्रिंग का अनुवाद करता है।

  2. तारों की सूची के लिए उपसर्ग समारोह। यह स्ट्रिंग्स का अनुवाद करता है।

  3. इन्फ़िक्स फ़ंक्शन इनपुट फ़ाइल टाई नंबर के साथ सही तर्क और आउटपुट फ़ाइल टाई नंबर बाएं तर्क के रूप में। यह आउटपुट फ़ाइल को इनपुट फ़ाइल की अनुवादित सामग्री के साथ पॉप्युलेट करता है।

('cghjsuCGHJSU',¨'x')⎕R(,¨'ĉĝĥĵŝŭĈĜĤĴŜŬ')

(... )⎕R(... ) PCRE आर eplace

'cghjsuCGHJSU' ये पत्र

,¨'x' प्रत्येक एक एक्स द्वारा पीछा किया

 … साथ में…

,¨'ĉĝĥĵŝŭĈĜĤĴŜŬ' इनमें से प्रत्येक अक्षर तार के रूप में

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


1

जे , 64 63 बाइट्स

rplc((_2]\'ĉĝĥĵŝŭĈĜĤĴŜŬ');~"1'cghjsuCGHJSU',.'x')"0

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

साथ में _2]\ मैं पुन: व्यवस्थित स्ट्रिंग 'ĉĝĥĵŝŭĈĜĤĴŜŬ' एक 12 पंक्ति स्तंभ में आदेश अन्य स्ट्रिंग के आकार फिट करने के लिए।

,. 'cjjsuCGHJSU' स्ट्रिंग के प्रत्येक वर्ण में 'x' जोड़ता है और 2 कॉलम सरणी द्वारा 12 पंक्ति बनाता है

;~"1' उपरोक्त पंक्ति के बॉक्सिंग जोड़े की एक सूची बनाता है, "1 - रैंक 1 - प्रत्येक पंक्ति पर लागू होता है।

┌──┬──┐
│cx│ĉ │
├──┼──┤
│gx│ĝ │
├──┼──┤
│hx│ĥ │
├──┼──┤
│jx│ĵ │
├──┼──┤
│sx│ŝ │
├──┼──┤
│ux│ŭ │
├──┼──┤
│Cx│Ĉ │
├──┼──┤
│Gx│Ĝ │
├──┼──┤
│Hx│Ĥ │
├──┼──┤
│Jx│Ĵ │
├──┼──┤
│Sx│Ŝ │
├──┼──┤
│Ux│Ŭ │
└──┴──┘

rplc इन बॉक्स वाली वस्तुओं का उपयोग बाएं बॉक्स वाले आइटम की प्रत्येक घटना को दाईं ओर से जोड़े से बदलने के लिए करता है।

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


1

Befunge , 2x48 +1 = 99 बाइट्स

>~:1+!#@_:"x"-v>$ 11p0"cghjsuCGHJSU"1\ >\31p11g-v
^ # #, : ++$\ _^#1"x"0*4!-"u"g11*"ʊ"!\_^#!:\*g13<

कोशिश करके देखो (टीआईओ बीफुन्गे के बारे में सुपर अजीब है और मैं इस पर काम करने के लिए अपने किसी भी समाधान को प्राप्त नहीं कर सका)

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

>~:1+!@_

यदि यह अंत है तो इनपुट और जांच प्राप्त करता है। कार्यक्रम अंत में अगर ऐसा है

          "x"-v>
^ # #, : ++$\ _^

जाँचता है कि क्या चरित्र "x" है। यदि नहीं, तो चरित्र की एक प्रति रखें और उसे प्रिंट करें।

               >$ 11p0"cghjsuCGHJSU"1\

अंतिम चरित्र को (1,1) स्टोर करें। ढेर में जाँच करने के लिए सभी वर्ण डालता है।

                                       >\31p11g-v
                                      _^#!:\*g13<

स्टैक में सभी मानों के विरुद्ध अंतिम वर्ण की तुलना करें।

                 1"x"0*4!-"u"g11*"ʊ"!\

चेक (0 या 1) को un (यूनिकोड मान 650) से गुणा करें। जाँच करें कि क्या चरित्र au (breve के लिए) था और यदि ऐसा है तो 4 को जोड़ देता है। अंत में, x (100) के ascii मान को भी जोड़ें। कुल जरूरत पड़ने पर सही लहजे में जुड़ जाता है या नहीं तो सिर्फ "x"।

>~:1+!#@_  
^ # #, : ++$\ _^#

स्टैक में सभी मान एक साथ जोड़ें, इसे प्रिंट करें और एक डुप्लिकेट रखें। अगले इनपुट के लिए वापस जाएं।


1

आर , 75 70 बाइट्स

function(s)gsub('([cghjs])x','\\1\U302',gsub('(u)x','\\1\U306',s,T),T)

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

-5 बाइट्स ग्यूसेप के लिए धन्यवाद

व्याख्या

  • gsub('(u)x','\\1\U306',s,T): sएक अपरकेस या लोअरकेस की प्रत्येक घटना में "u" ( ignore.case=TRUEचौथे तर्क के माध्यम से उपयोग करके T) को एक "x" और उसके बाद यूनिकोड द्वारा एक breve के लिए बदलें
  • gsub('([cghjs])x','\\1\U302',gsub('(u)x','\\1\U306',s,T),T)उस का परिणाम ले लो और एक अपरकेस या लोअरकेस की हर घटना को बदलें ( ignore.case=TRUEचौथे तर्क के माध्यम से T) "c", "g", "h", "j", या "s" और उसके बाद एक "x" के साथ खतना के लिए यूनिकोड द्वारा पीछा किया गया पत्र

नामकरण के बजाय तर्क क्रम का उपयोग करने से 3 बाइट्स की बचत होती है, और एक और दो प्रमुख शून्य से छुटकारा पा लेते हैं ( \U0302और \U0306: इसे ऑनलाइन आज़माएं!
Giuseppe

@Giuseppe - महान विचार, धन्यवाद!
duckmayr

1

QuadR , 25 बाइट्स

डायक्टिक्स संस्करण का संयोजन।

ux
([cghjs])x
 ̆&
 ̂\1

i झंडा

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

बदलने के…

(u)x         u followed by x and
([cghjs])x   any of these letters followed by x 
 ̆\1          by a breve followed by the first group (the u) and
 ̂\1          a circumflex followed by the first group (the letter)

मामला मैं nsensitively

निम्नलिखित Dyalog APL कोड के बराबर:

'(u)x' '([cghjs])x'R' ̆\1' ' ̂\1'

यह 28 और 24 बाइट्स क्यों नहीं है?
को आउटगॉल्फ को एरिक

@EriktheOutgolfer TIO के SBCS काउंटर ने मुझे भ्रमित किया। फिक्स्ड। धन्यवाद। रुको, क्या इसका मतलब है कि मैं जीतता हूं?
एडम

हुह, अब ऐसा लग रहा है कि यह 27 बाइट्स (TIO से कॉपी) है, लेकिन यहाँ से कॉपी करने पर 24 बाइट्स मिलते हैं। QuadR की एन्कोडिंग क्या है, और कौन सी सही है?
आउटगॉल्फ

@EriktheOutgolfer दोनों लिंक 24 को मेरे FFQ / Win10 पर रिपोर्ट करते हैं। QuadR Dyalog Classic या किसी भी यूनिकोड का उपयोग करता है।
Adám

तो यह 24 बाइट्स या क्या है?
निकोलगर्फ़

1

सी, 145 144 बाइट्स

एक और सी दृष्टिकोण। इस तथ्य का उपयोग करके वापसी करें कि इस तथ्य का उपयोग करके कि परिधि / ब्रेवे 2 बाइट्स हैं।

-1 बाइट्स स्टेडीबॉक्स की बदौलत

i,t;f(char*s){for(t=1;*s;s++)if(*s^'x')for(i=12,t=1;i--;)t="cghjsuCGHJSU"[i]-*s?t:i*2;else t^1&&memcpy(s-1,"ĉĝĥĵŝŭĈĜĤĴŜŬ"+t,2),t=1;}

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


1
एक बाइट बचाने के t^1&&memcpy(s-1,"ĉĝĥĵŝŭĈĜĤĴŜŬ"+t,2),t=1;बजाय का उपयोग करना t^1?memcpy(s-1,"ĉĝĥĵŝŭĈĜĤĴŜŬ"+t,2),t=1:0;इसे ऑनलाइन आज़माएं!
स्टेडीबॉक्स

1

गणितज्ञ, 81 बाइट्स या 57 बाइट्स

StringReplace[RemoveDiacritics@#<>"x"->#&/@Characters@"ĉĝĥĵŝŭĈĜĤĴŜŬ"]

यह एक प्रतिस्थापन नियम लागू करता है जहां "एक्स" के साथ टोपी के बिना पत्र को पत्र द्वारा बदल दिया जाता है।

यहाँ जोड़ा लहजे चरित्र का उपयोग कर एक विकल्प है: StringReplace[{"ux"->"ŭ","Ux"->"Ŭ",c_~~"x":>c<>"̂"}]


1

पर्ल 5 , 49 + 2 ( -p -C) = 61 51 बाइट्स

s/[CGHJScghjs]\Kx/\x{0302}/g;s/[Uu]\Kx/\x{0306}/g

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

सहेजे गए 10 बाइट्स नाहुएल फोइउलुल के लिए धन्यवाद


7 बाइट्स बचा सकता है:s/[CGHJScghjs]\Kx/\x{0302}/g;s/[Uu]\Kx/\x{0306}/g
नहुएल फौलीउल

यह सिर्फ के साथ भी काम करता है लगता है -Cऔर बिना -Cचेतावनी (साथ Wide character in print)
Nahuel Fouilleul

1
पेरलुन से-C on its own (not followed by any number or option list), or the empty string "" for the PERL_UNICODE environment variable, has the same effect as -CSDL.
नहुएल फौलीउल

0

सीजेएम , 51 बाइट्स

q"ĉĝĥĵŝŭĈĜĤĴŜŬ""cghjsuCGHJSU".{'x+@\/*}

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

स्पष्टीकरण:

q                   Read input
"ĉĝĥĵŝŭĈĜĤĴŜŬ"      String literal
"cghjsuCGHJSU"      Another string literal
.{                  Iterate over the strings in parallel
  'x+                 Add an 'x to the normal character
  @                   Rotate to bring the input to the top of stack
  \                   Swap to bring the "cx" to the top
  /                   Split the input on instances of "cx"
  *                   Join the input on instances of the accented character
}

क्या यह वास्तव में 39 बाइट्स है? मैं 39 पात्रों की गिनती करता हूं और मुझे नहीं लगता कि सीजेएम में एक विशेष एन्कोडिंग है।
user202729

@ user202729 बदला (किसी कारण से TIO गिने गए बाइट्स वर्ण के रूप में)
Esolanging Fruit

क्योंकि TIO का मानना ​​है कि सभी गोल्फिंग भाषाओं में विशेष वर्ण कोडपेज होते हैं, और यह जाँच नहीं करता है कि सभी वर्ण सही कोड पृष्ठ में हैं।
user202729

0

सेड, 108 बाइट्स

s/cx/ĉ/g
s/gx/ĝ/g
s/hx/ĥ/g
s/jx/ĵ/g
s/sx/ŝ/g
s/ux/ŭ/g
s/Cx/Ĉ/g
s/Gx/Ĝ/g
s/Hx/Ĥ/g
s/Jx/Ĵ/g
s/Sx/Ŝ/g
s/Ux/Ŭ/g

आप द्वारा कोड के रूप में कोड को स्वरूपित करना चाहिए `...`या <pre><code>...</code></pre>या 4 इंडेंट।
user202729 14

@ user202729 मुझे स्पष्ट रूप से पता था कि। मैं अपने एंड्रॉइड फोन से सबमिट कर रहा था इसलिए मैंने इसे सही तरीके से प्रारूपित नहीं किया।
आईबग

2
ऐसा लग रहा है कि यह 119 बाइट लंबा है।
निकोलगर्फ़

0

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

यह 54 अक्षर है और इसे PowerShell ISE में सहेजना इसे बनाता है 58 बाइट्स के लिए UTF-8 + BOM । यह एक ब्राउज़र में अच्छी तरह से प्रस्तुत नहीं करता है:

$args-replace'(?<=u)x','̆'-replace'(?<=[cghjs])x','̂'

regex @ user202729 की टिप्पणी से यूनिकोड वर्णों के संयोजन के साथ x को प्रतिस्थापित करता है।

जैसे

PS C:\> .\eo.ps1 "Cxu vi sxatas la cxapelliterojn? Mi ankaux."
Ĉu vi ŝatas la ĉapelliterojn? Mi ankaŭ.

0

क्लोजर, 126 115 बाइट्स

-11 बाइट्स एक स्ट्रिंग के विभाजन के लिए प्रतिस्थापन नक्शा बदलकर।

#(reduce(fn[a[f r]](clojure.string/replace a(str f\x)(str r)))%(partition 2"cĉgĝhĥjĵsŝuŭCĈGĜHĤJĴSŜUŬ")) 

प्रतिस्थापनों के मानचित्र पर एक कमी, जिसे देखने के लिए, और उन्हें किसके साथ बदलना है।

अभी भी प्रतिस्थापन मानचित्र को संपीड़ित करने के तरीके पर काम कर रहा है।

(defn translate [^String esperanto]
  (reduce (fn [acc [f r]] (clojure.string/replace
                            acc ; Replace the translation so far by
                            (str f \x) ; adding a x after each character, search for it in the string,
                            (str r))) ; and replace it with a stringified accented char

          esperanto ; Before the reduction happens, the accumulator is the original string

          ; A list of [char-to-find what-to-replace-with] pairs
          (partition 2"cĉgĝhĥjĵsŝuŭCĈGĜHĤJĴSŜUŬ")))))


0

स्काला , 110 बाइट्स

बोरिंग रेगेक्स समाधान:

def?(s:String)="(.)x".r.replaceAllIn(s,m=>m.group(0)(0)+(if(m.group(0)(0).toUpper=='U')"\u0306"else"\u0302"))

पुराना स्कैला विलयन (116 बाइट्स)

def?(s:String)=s.foldLeft("")((r,c)=>if(c=='x')r.init+r.last+(if(r.last.toUpper=='U')"\u0306"else"\u0302")else r+c)

Ungolfed

def?(s:String)=
  s.foldLeft("")((r,c)=>  // 'Fold' string with empty string as first result
    if(c=='x')            // If current character is x
      r.init+             // Take the every character from result but the last
        r.last+           // The last character from result and add
          (if(r.last.toUpper=='U')
            "\u0306"      // combining breve if 'u' or 'U'
          else"\u0302")   // combining circumflex in any other case
 else r+c                 // Otherwise return result + character
)

0

जावास्क्रिप्ट, 35 चार्ट, 36 बाइट्स

s=>s.replace(/([cghjsu])x/gi,"$1̂")

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