18

(अर्थ: अंग्रेजी को ब्लेलेट में बदलें)

हमने वर्षों से बकरियों की भगवान के रूप में प्रशंसा की है।

लेकिन अगर हम अंग्रेजी को 'बेलेट', बकरी भगवान की भाषा में अनुवाद नहीं कर सकते, तो हम उनसे संवाद नहीं कर सकते।

इसलिए, उनके साथ संवाद करने के लिए, हमने बकरियों की गतिविधियों पर शोध किया है, और इस पैटर्न को पुनः प्राप्त किया है, जो भाषा का मूल है।

प्रत्येक शब्द की लंबाई के लिए। ब्लेट ’कहें। इसका मतलब है कि 3 अक्षरों से अधिक लंबे शब्दों के लिए 'ई का होना चाहिए (लंबाई -3)। आप' ब्लेट 'को' ब्ल्ट 'से कम शब्दों के लिए काट देंगे। उदाहरण के लिए, 'be' 'bl' बन जाता है, लेकिन 'cat' और 'boat' 'blt' और 'blet' बन जाता है।

जैसा कि लगता है, वे वास्तव में 'Bleet' के लिए गैर-वर्णमाला वर्ण नहीं बदलते हैं। हमारे शोध से पता चला कि 'हैलो, वर्ल्ड!' ब्लेक करने के लिए है 'ब्लीड, ब्लिट!' बिलीट बिलीट ’नहीं। इसके अलावा, बकरियां इतनी समझदार नहीं हैं (कोई अपराध नहीं), इसलिए वे गैर-अस्सी के पात्रों या विशेषग्यों को बिल्कुल नहीं समझती हैं।

अब, बकरी देवताओं के साथ संवाद करने के लिए अनुवादक बनाने का समय आ गया है।

Bleeeeet (अर्थ: उदाहरण)

Hello, World! => Bleet, Bleet!
lorem ipsum dolor sit amet. => Bleet Bleet Bleet Blt Blet.
We praise the Goat God! => Bl Bleeet Blt Blet Blt!
I have a pen => B Blet B Blt
0123456789_ => 0123456789_
0te_st1 => 0Bl_Bl1

code-golf string

— मैथ्यू रो
स्रोत

1

सम्बंधित!

— जोनाथन एलन

1

और एपोस्ट्रोफिस वाले शब्दों के बारे में क्या? विल it'sबन Bltया Bl'tया Bl'B?

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

3

यह आपके ऊपर है, लेकिन अगर आप इसे रखेंगे तो मैं हर उत्तरदाता को सूचित करूंगा। यदि यह मेरे थे मुझे लगता है कि मैं शायद किसी भी व्यवहार की अनुमति देने के चाहते हैं: उन्हें पारित ( Jimmy's: Bleee't), उन्हें शब्द विभाजन के रूप में इलाज ( Jimmy's: Bleet'B), या उन्हें शब्दों के हिस्से के रूप इलाज ( Jimmy's: Bleeeet)। अगर मुझे एक का चयन करना होता तो मैं शब्द विभाजक विकल्प के साथ जाता, क्योंकि यह 6 उत्तर है।

— जोनाथन एलन

2

यह वास्तव में अच्छी चुनौती है, हमारे पास इस तरह का और अधिक होना चाहिए।

— डाउनगोट

2

@Downgoat गुणवत्ता-वार, या बकरी-वार?

— मैथ्यू रो

13

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

T`lL`e
(?<!e)e
B
Be
Bl
e(?!e)
t

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

व्याख्या

T`lL`e

सभी अक्षरों को चालू करें e।

(?<!e)e
B

eप्रत्येक रन में पहले मुड़ें B।

Be
Bl

बारी Beमें Bl।

e(?!e)
t

eप्रत्येक रन में अंतिम मोड़ t।

— मार्टिन एंडर
स्रोत

T1LTमंच "लपेटता" अनुवाद जोड़े ताकि आप को उस तरह सभी पत्र बदल सकते हैंe

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

@ ConorO'Brien यह वास्तव में एक लोअर-केस है l, नहीं1 , लेकिन मुझे यकीन नहीं है कि आप "रैप" से क्या मतलब है। लिप्यंतरण केवल लक्ष्य पैटर्न में अंतिम चरित्र को दोहराता है, इसलिए यदि यह थाT`lL`ef , आप मैप चाहते हैं aकरने के लिए eऔर अन्य सभी पत्रों को f, alternatingly नहीं करने के लिए eऔर f।

— मार्टिन एंडर

यह एक बुरा मजाक था। क्षमा करें

— कॉनर ओ'ब्रायन

4

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

s=>s.replace(/[A-Z]+/gi,x=>x.replace(/./g,(_,i)=>'Bl'[i]||'et'[+!x[i+1]]))

वैकल्पिक दृष्टिकोण, वर्तमान में 83 78 बाइट्स:

s=>s.replace(/[A-Z]+/gi,x=>`Bl${'e'.repeat((l=x.length)>3&&l-3)}t`.slice(0,l))

सबसे अच्छा मैं पुनरावर्ती कर सकता था 88 बाइट्स:

f=([c,...s],i=0,q=/^[A-Z]/i)=>c?q.test(c)?('Bl'[i]||'te'[+q.test(s)])+f(s,i+1):c+f(s):''

— ETHproductions
स्रोत

मैं साथ आया 'Blet'[i>1?2+!x[i+1]:i]लेकिन दुख की बात यह है कि यह एक ही लंबाई है।

— नील

@ नील हां, मुझे लगा कि यह उस तरह से संभव होगा, लेकिन मुझे आश्चर्य है कि जिस तरह से मैं यह कर रहा हूं, उससे लगभग कम था।

— ETHproductions

4

पीएचपी, 115 88 86 77 75 बाइट्स

preg_replace सरणियों के साथ (PHP 5.4 या बाद के संस्करण की आवश्यकता है)

echo preg_replace(["#[a-z]#i","#(?<!e)e#",_Be_,"#e(?!e)#"],[e,B,Bl,t],$argn);

इसे ऑनलाइन चलाएं echo '<string>' | php -nR '<code>'या परीक्षण करें ।

टूट - फूट

SEARCH      EXPLANATION             REPLACE     EXAMPLE
            original string                     Hello
[a-z]       every letter            e           eeeee
(?<!e)e     first letter            B           Beeee
Be          first two letters       Bl          Bleee
e(?!e)      last letter if still e  t           Bleet

संशोधन 5: मार्टिन एंडर के रेगेक्स चेन के साथ 9 बाइट्स को बचाया ।
^{(गैर-वर्णनात्मक शब्द वर्ण = अंक / अंडरस्कोर के साथ भी निश्चित मामले।)}

— टाइटस
स्रोत

3

हास्केल , 135 128 बाइट्स

b"e"="B"
b"ee"="Bl"
b('e':_:_:e)="Bl"++e++"t"
b e=e
e!(l:t)|elem l$['a'..'z']++['A'..'Z']=('e':e)!t|1<3=b e++l:""!t
e!_=[]
(""!)

इसे ऑनलाइन आज़माएं! उपयोग (""!) $ "some string"। रेगेक्स के बिना, यह काफी लंबा हो गया, शायद कुछ अन्य दृष्टिकोण छोटा है। संपादित करें: @nimi के लिए 7 बाइट्स सहेजे गए!

— Laikoni
स्रोत

1

समारोह का नाम बदल रहा bकरने के लिए aआप इसे तुरंत लागू कर सकते हैं जब जिसके परिणामस्वरूप स्ट्रिंग का निर्माण और अंतिम छोड़ देते हैं =<<: b!(l:t)|...|1<3=a b++l:""!t;b!_=a b;(""!)।

— nimi

यह जिमी के परीक्षण के लिए ऑनलाइन काम नहीं करता है, मुझे ब्ले'बी ब्लिट'बी मिलता है

— क्लेब्लांक

@cleblanc यह आवश्यकता मेरे उत्तर के बाद जोड़ी गई थी और वर्तमान उत्तरों में से अधिकांश को अमान्य कर दिया है ... मुझे ओपी से पूछना चाहिए।

— लाकोनी

@ लायकोनी राइट। मैं इस खेल के लिए देर से आया था और एपोस्ट्रोफ को संभालने के लिए एक विशेष रूप से कठिन अपवाद है।

— क्लेब्लांक

2

पर्ल ५ , 47 बाइट्स

मार्टिन एंडर के रूप में एक ही तकनीक का उपयोग करके 15 बाइट्स बचाए रेटिना जवाब । (यह उत्तर मूल रूप से अब उनके उत्तर का एक बंदरगाह है)

कोड + -pध्वज के 46 बाइट्स ।

s/\pl/e/g;s/(?<!e)e/B/g;s/Be/Bl/g;s/e(?!e)/t/g

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

पुराने संस्करण: 62 बाइट्स:

s/\pl+/$l=length$&;$_=Bl.e x($l-3).t;chop while$l<y%%%c;$_/ge

और 68 बाइट्स:

s%\pl+%$_=$&;s/./B/;s/.\K./l/;s/(?<=..).(?=.)/e/g;s/..\K.$/t/;$_%ge

— बापू
स्रोत

2

PHP, 84 बाइट्स

<?=preg_replace(["#[a-z]#i","#(?<!l)l#","#(?<=l)l#","#e(?!e)#"],[l,B,e,t],$argv[1]);

PHP, 117 बाइट्स

<?=preg_replace_callback("#[a-z]+#i",function($m){return substr(str_pad(Bl,-1+$l=strlen($m[0]),e).t,0,$l);},$argv[1]);

— जार्ग हुल्सरमन
स्रोत

एक बाइट बचाओ-1+$l=...

— टाइटस

@ टिट्स अच्छा है और मुझे एक बेहतर उपाय मिल गया है

— Jörg Hülsermann

1

ज़ेवि डममे - ईन गेडांके। :) लेकिन \blगैर-अक्षर शब्द के लिए विफल रहता है _we_:। आप एक स्पष्ट दावे की जरूरत है: (?<!l)l। उसी के लिए e\b-> e(?!e)(+7 बाइट्स)

— टाइटस

@ टिट्स इस बीच यह स्वयं देखा गया कि मेरा विचार गलत था। और मुझे आपकी जर्मन टिप्पणी पसंद है।

— जार्ग हुल्सरमैन

2

सी, 120 151 140 111 108 105 104 92 90 बाइट्स

"इट्स जिम्मी टेस्ट" के लिए काम करना -> ब्ल'बी ब्लिट'बी बैलेट

j;f(char*m){for(;*m=!isalpha(*m++)?j=0,*(m-1):"*Blet"[isalpha(*m)?j^3?++j:j:j>1?4:++j];);}

मूल स्ट्रिंग को नष्ट करके आउटपुट अब एक साइड इफेक्ट है।

main(c,v)char**v;{
    char test[] = "The End is near Fellows!";
    f(test);puts(test);
    char test2[] = "We praise the Goat God!";
    f(test2);puts(test2);
    char test3[] = "It's Jimmy's test";
    f(test3);puts(test3);
    char test4[] = "0te_st1";
    f(test4);puts(test4);
    char test5[] = "I have a pen";
    f(test5);puts(test5);
    char test6[] = "_0123456789_";
    f(test6);puts(test6);
}

मुझे लगता है कि यह कम से कम अब सही है

Blt Blt Bl Blet Bleeeet!
Bl Bleeet Blt Blet Blt!
Bl'B Bleet'B Blet
0Bl_Bl1
B Blet B Blt
_012345678_

— cleblanc
स्रोत

जिमी ?

— २०:०५ पर DLosc

@DLosc मैं पागल नहीं हुआ और अभी तक मर गया।

— क्लेब्लांक

2

अजगर 2.7, 129 118 114 109 95 91 88 बाइट्स

import re
s=re.sub
def f(i):print s(r"e\b","t",s("Be","Bl",s(r"\be","B",s("\w","e",i))))

बस एक re.subचेन

क्रमशः

उदाहरण इनपुट: " हम बकरी भगवान की प्रशंसा करते हैं! "

उपनाम उप तो हम बार-बार कॉल पर बाइट्स बचा सकते हैं

import re
s=re.sub

सभी शब्द वर्णों को "e" से बदलें

s("\w","e",i)

आउटपुट: ee eeeeee eee eeee eee!

सभी "e" को बदलें, जो कि "B" के साथ शब्द सीमा (शब्द की शुरुआत) से पहले हैं

s(r"\be","B",s("\w","e",i))

आउटपुट: Be Beeeee Bee Beee Bee!

सभी "Be" को "Bl" से बदलें

s("Be","Bl",s(r"\be","B",s("\w","e",i)))

आउटपुट: Bl Bleeee Ble Blee Ble!

"T" के साथ शब्द सीमा के बाद आने वाले सभी "e" को बदलें

s(r"e\b","t",s("Be","Bl",s(r"\be","B",s("\w","e",i))))

आउटपुट: Bl Bleeet Blt Blet Blt!

— ब्रैंडन स्टर्जन
स्रोत

PPCG में आपका स्वागत है! हम फ़ंक्शंस को उनके परिणामों को प्रिंट करने की अनुमति देते हैं, इसलिए इसके returnसाथ printबाइट को सहेजना चाहिए।

— कॉनर ओ'ब्रायन

rकच्चे स्ट्रिंग्स से आप प्रमुख को भी हटा सकते हैं यदि उनके पास कोई अन्य 3 बाइट्स बचाने के लिए कोई बैकलैश नहीं है

— कॉनर ओ'ब्रायन

धन्यवाद @ ConorO'Brien! मैं रेगेक्स के एक टुकड़े को सरल करने में सक्षम था (जो समाप्त हो गया था r) और मैंने इसे 95 बाइट्स के लिए नीचे कर दिया। सलाह के लिये धन्यवाद!

— ब्रैंडन स्टर्जन

ठीक है, मैं इसे 88 बाइट्स तक ले गया और मुझे लगता है कि मैं यहां सबसे अच्छा कर सकता हूं

— ब्रैंडन स्टर्जन

1

पिप , 28 बाइट्स

aR+XA{Y'eX#a-3\"Bl\yt\"@<#a}

कमांड-लाइन तर्क के रूप में इनपुट लेता है। इसे ऑनलाइन आज़माएं!

व्याख्या

यह मजेदार था - मुझे रेगेक्स संशोधक और स्ट्रिंग प्रक्षेप का उपयोग करने के लिए मिला।

                              a is 1st cmdline arg; XA is the regex `[A-Za-z]` (implicit)
aR                            In a, replace
   XA                          the regex XA
  +                            wrapped in (?:  )+
     {                     }  with this callback function:
          #a-3                 Length of argument - 3
       'eX                     Repeat e that many times (empty string if #a-3 is negative)
      Y                        Yank that string into the y variable
              \"Bl\yt\"        An escaped string, which interpolates the value of y
                       @<#a    Take first len(a) characters
                              After the replacement, the string is autoprinted

— DLosc
स्रोत

1

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

मुझे पता है कि यह लंबे समय तक है और मैं सुझाव का स्वागत करता हूं कि लंबाई को कैसे कम किया जाए।

def f(s):
 b=[];t='';f=[];a=list.append
 for c in s:
  if c.isalpha():t+='e'
  else:
   if t:a(b,t);t=''
    a(b,c)
 if t:a(b,t)
 for i in b:
  i=[*i]
  if i[0]=='e':
   i[0]='B';i[-1]=[i[-1],'t'][len(i)>2]
   if len(i)>2:i[1]='l'
  a(f,''.join(i))
 return ''.join(f)

— केर्ड सिक्काहिरिंग
स्रोत

साइट पर आपका स्वागत है! मुझे एक युगल गोल्फ दिखाई देता है जिसे आप बना सकते हैं। आप पायथन में गोल्फिंग के लिए उपयोगी सुझावों की सूची के लिए हमारे सुझाव पृष्ठ पर जा सकते हैं ।

— पोस्ट रॉक गार्फ हंटर

इसके बजाय x.append(y)या आपके मामले में a(x,y), आप कर सकते हैं x+=y,(अल्पविराम की आवश्यकता)

— Cyoce

1

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

'\l+'{!n size 2-:4\^5*1+3/\1<-4 tb 0\,'Blet'\#''join}repl

इसे ऑनलाइन आज़माएं! स्टैक के ऊपर से इनपुट लेता है।

चलो एक ( एन ) = A136412 ( n - 2) = (5 × 4 ^{n - 2} + 1) ÷ 3. परिवर्तित एक ( एन आधार 4 पैदावार के लिए):

a (3) = 13 ₄ 
a (4) = 123 ₄ 
a (5) = 1223 ₄ 
(6) = 12223 ₄
...

मैपिंग इंडेक्स 0..3 स्ट्रिंग के लिए Blet, हमें मिलता है:

a (3) = लेफ्टिनेंट
a (4) = चलो
a (5) = लेट
a (6) = लीट
...

अब, प्रीपेडिंग Bहमें लंबाई को देखते हुए वांछित स्ट्रिंग देता है। अधिकतर। केवल n ≤ 2 के लिए विशेष मामलों को संभालने की आवश्यकता है । मेरे मामले में, इसे न्यूट्रल बूलियन के रूप में घटाकर ( n - 2 <1) हल किया जाता है (1 "सच" के लिए और 0 "झूठी" के लिए)।

उत्तर की बारीकियों के लिए:

'\l+'{! ... }repl
             repl    replace all
'\l+'                alphanumeric strings ("letters")
     {!     }        applying this function to the result.

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

1

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

def f(s,r='',l=-3):
 for c in s+'\0':
	if c.isalpha():l+=1
	else:r+=('Bl%st'%('e'*l))[:l+3*(l>=0)]+c;l=-3
 print r

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

— फेलिप नारदी बतिस्ता
स्रोत

0

जावा 7, 201 बाइट्स

String c(String s){String r="",z="e([^e]|$)";char p=0;int x;for(char c:s.toCharArray()){x=c&~32;p=x>64&x<91?p==66?'l':p>100&p<109?'e':66:c;r+=p;}return r.replaceAll("l"+z,"lt$1").replaceAll(z,"et$1");}

वास्तव में इसके साथ खुश नहीं है, और निश्चित रूप से कुछ और गोल्फ हो सकता है ..

स्पष्टीकरण:

String c(String s){               // Method with String parameter and String return-type
  String r="",                    //  The return-String
         z="e([^e]|$)";           //  Partial regex String that's used twice ('e' followed by non-'e' or nothing)
  char p=0;                       //  The previous character
  int x;                          //  Another temp value
  for(char c : s.toCharArray()){  //  Loop over the characters of the input String
    x = c&~32;                    //   Make every lowercase character uppercase (this returns an integer, hence the integer temp value, which is shorter than a cast to char)
    p = x>64 & x<91 ?             //   If the current character is a letter:
         p == 66 ?                //    And if the previous character is 'B':
          'l'                     //     Set the character value to 'l'
         : p>100&p<109 ?          //    Else if the previous character is either an 'e' or 'l':
            'e'                   //     Set the character value to 'e'
           :                      //    Else:
            66                    //     Set the character value to 'B'
         :                        //   Else (not a letter):
          c;                      //    Set the character to the current character
    r += p;                       //   Append the result-String with this character
  }                               //  End loop
  return r                        //  Return the result-String
    .replaceAll("l"+z,"lt$1")     //   After we've replaced all occurrences of "le." with "lt." (where "." can be anything else, including nothing at the end of a line)
    .replaceAll(z,"et$1")         //   And also replaced all occurrences of "ee." with "et." (where "." can again be anything else)
}                                 // End of method

टेस्ट कोड:

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

class M{
  static String c(String s){String r="",z="e([^e]|$)";char p=0;int x;for(char c:s.toCharArray()){x=c&~32;p=x>64&x<91?p==66?'l':p>100&p<109?'e':66:c;r+=p;}return r.replaceAll("l"+z,"lt$1").replaceAll(z,"et$1");}

  public static void main(String[] a){
    System.out.println(c("Hello, World!"));
    System.out.println(c("lorem ipsum dolor sit amet."));
    System.out.println(c("We praise the Goat God!"));
    System.out.println(c("I have a pen"));
    System.out.println(c("0123456789_"));
    System.out.println(c("0te_st1"));
  }
}

आउटपुट:

Bleeet, Bleeet!
Bleeet Bleeet Bleeet Blt Bleet.
Bl Bleeeet Blt Bleet Blt!
B Bleet B Blt
0123456789_
0Bl_Bl1

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

s.split("")इसके बजाय s.toCharArray()कुछ का मानना है कि मुझे विश्वास है

— क्रिकेई लिथोस

@KritiiLithos मैंने इसे आज़माया, लेकिन फिर मेरे पास जाँच का मुद्दा है कि स्ट्रिंग एक अक्षर है ( x=c&~32स्ट्रिंग पर काम नहीं करेगा, और x>64&x<91दोनों अब काम नहीं करेंगे)। यदि आप इसे विभाजन के साथ कम कर सकते हैं तो मुझे बताएं, हालांकि।

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

0

05AB1E , 36 बाइट्स

lDAsSå.¡€g£vyAySåPigÍ<'e×"Blÿt"yg£}J

इसे ऑनलाइन आज़माएं! या एक के रूप में टेस्ट सूट के रूप में

व्याख्या

इनपुट तैयार करें:

lD                                    # convert input to lower-case and duplicate
  As                                  # push lower-case alphabet and swap input to the top
    Så                                # check each char in input for 
                                      # membership in the alphabet
      .¡                              # split into chunks of equal elements
        €g                            # get length of each chunk
          £                           # split input into chunks of those lengths

यह इस तरह के रूप में एक सूची बनाता है ['hello', ', ', 'world', '!'] इनपुट के लिएHello, World!

सूची के अनुसार Iterate:

v                          # for each element in the list
 y                         # push current element
  AySåPi               }   # if all members of current element are letters
        gÍ<'e×             # repeat string "e" len(element)-3 times
              "Blÿt"       # replace "ÿ" with the e's in the string "Blÿt"
                    yg£    # take the first len(element) chars of the string
                        J  # join to string

— Emigna
स्रोत

ब्लीच ब्लीकेट ब्ली!

Bleeeeet (अर्थ: उदाहरण)

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

व्याख्या

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

पीएचपी, 115 88 86 77 75 बाइट्स

हास्केल , 135 128 बाइट्स

पर्ल ५ , 47 बाइट्स

PHP, 84 बाइट्स

PHP, 117 बाइट्स

सी, 120 151 140 111 108 105 104 92 90 बाइट्स

अजगर 2.7, 129 118 114 109 95 91 88 बाइट्स

क्रमशः

पिप , 28 बाइट्स

व्याख्या

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

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

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

जावा 7, 201 बाइट्स

05AB1E , 36 बाइट्स