वहाँ, मैंने इसे ठीक किया (टेप के साथ)

41

चुनौती:

केवल ऊपरी और / या निचले अक्षरों (जो भी आप पसंद करते हैं) युक्त एक स्ट्रिंग को देखते हुए, tapeइसे ठीक करने के लिए क्षैतिज रूप से रखें। हम वर्णमाला में दो आसन्न पत्रों के अंतर की जांच करके यह कर (अनदेखी रैप-अराउंड और केवल आगे बढ़ता हुआ), और साथ के रूप में ज्यादा जगह भरने TAPE/ tapeके रूप में हम की आवश्यकता होगी।

उदाहरण:

इनपुट: abcmnnnopstzra
आउटपुट:abcTAPETAPETmnnnopTAstTAPETzra

क्यूं कर?

  • के बीच cऔर (लंबाई 9) mहोनी चाहिए defghijkl, इसलिए हम इसे भरते हैं TAPETAPET;
  • के बीच pऔर (लंबाई 2) sहोनी चाहिए qr, इसलिए हम इसे भरते हैं TA;
  • के बीच tऔर (लंबाई 5) zहोनी चाहिए uvwxy, इसलिए हम इसे भरते हैं TAPET।

चुनौती नियम:

  • अंतर केवल आगे लागू होता है, इसलिए बीच में कोई टेप नहीं zra।
  • इसके समान आसन्न अक्षरों के कई होना संभव है nnn।
  • आपको किसी भी उचित प्रारूप में इनपुट लेने की अनुमति है। एकल स्ट्रिंग, स्ट्रिंग-सरणी / सूची, चरित्र-सरणी / सूची आदि हो सकते हैं। आउटपुट में एक ही लचीलापन है।
  • आपको किसी भी तरह से लोअरकेस और / या अपरकेस का उपयोग करने की अनुमति है। यह इनपुट, आउटपुट, और दोनों पर लागू होता है TAPE।
  • यह संभव नहीं TAPEहै कि आवश्यक नहीं है, जिस स्थिति में इनपुट अपरिवर्तित रहता है।

सामान्य नियम:

  • यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है।
    कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव कम उत्तर के साथ आने की कोशिश करें।
  • आपके उत्तर के लिए मानक नियम लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-प्रकार, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा कॉल।
  • डिफ़ॉल्ट लूपोल्स निषिद्ध हैं।
  • यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के लिए एक लिंक जोड़ें।
  • इसके अलावा, यदि आवश्यक हो तो एक स्पष्टीकरण जोड़ें।

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

Input:  "abcmnnnopstzra"
Output: "abcTAPETAPETmnnnopTAstTAPETzra"

Input:  "aza"
Output: "aTAPETAPETAPETAPETAPETAPEza"

Input:  "ghijk"
Output: "ghijk"

Input:  "aabbddeeffiiacek"
Output: "aabbTddeeffTAiiaTcTeTAPETk"

Input:  "zyxxccba"
Output: "zyxxccba"

Input:  "abccxxyz"
Output: "abccTAPETAPETAPETAPETAPExxyz"

Input:  "abtapegh"
Output: "abTAPETAPETAPETAPETtaTAPETAPETAPETApeTgh"

Input:  "tape"
Output: "taTAPETAPETAPETApe"
code-golf  string 
— केविन क्रूज़सेन
स्रोत
10
अनिश्चितता है कि हम फिक्स-अप्स के बीच कुछ को क्यों छोड़ देंगे (जैसे हम TAPETAPET के साथ फिक्स करने के बाद और TA के साथ फिक्स करने से पहले APE को छोड़ देते हैं) मुझे अच्छे TAPE की बर्बादी की तरह लगता है, लेकिन शायद यह है कि मैं कैसे (क्षमा करें)।
— जोनाथन एलन
@JonathanAllan Hehe, आप वास्तव में सही हैं कि यह 'टेप' की बर्बादी है। हम्म, कुछ मैं चुनौती के भाग 2 में उपयोग हो सकता है । ;)
— केविन क्रूज़सेन
क्या होगा अगर स्ट्रिंग टेप के साथ आती है - जैसे, abTAPEgh?
— मनश्शेख्ज़त-पुनः मोनिका
@manassehkatz यह हर दूसरे चरित्र के रूप में व्याख्या की जाएगी, इसलिए ab[TAPETAPETAPETAPET]TA[TAPETAPETAPETA]PE[T]gh( []इसे और अधिक पठनीय बनाने के लिए जोड़ा गया )।
— केविन क्रूज़सेन 15
1
@ केविनक्रूजसेन जो सुसंगत है, हालांकि ("बर्बाद कर रहे टेप" प्रश्न के साथ) 100% तार्किक नहीं है। तो शायद एक और परीक्षण मामला: इनपुट टेप, आउटपुट TATAPETAPETAPETAPE (मुझे लगता है कि मुझे यह सही मिला ...)
— manassehkatz-Reicaate Monica

जवाबों:

8

05AB1E , 14 12 बाइट्स

'¡ÉIÇ¥<∍‚ζJJ

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

व्याख्या

'¡É            # push the string "tape"
   I           # push input
    Ç          # convert to a list of character codes
     ¥         # calculate deltas
      <        # decrement
       ∍       # extend the string "tape" to each of these sizes
               # results in an empty string for sizes smaller than zero
        ‚ζ     # zip with input (results in a list of pairs)
          JJ   # join to a list of strings and then to a string
— Emigna
स्रोत
4
क्या आप एक स्पष्टीकरण जोड़ना चाहेंगे? मुझे लगता है कि यह काफी हद तक जेली के उत्तर के समान है, लेकिन मैं उत्सुक हूं कि परिणाम प्राप्त करने के लिए कौन से पात्रों का उपयोग किया जाता है। मेरी चुनौतियों में सामान्य नियमों में से एक: " इसके अलावा, यदि आवश्यक हो तो एक स्पष्टीकरण जोड़ें। ", जेली, 05AB1E, चारकोल, एपीएल, आदि जैसी भाषाओं के साथ, यह मानने के लिए बचा है कि ज्यादातर लोग इसे नहीं पढ़ सकते हैं और एक स्पष्टीकरण अनिवार्य है। । :)
— केविन क्रूज़सेन
@ केविनक्रूजसेन: निश्चित रूप से। मैं आमतौर पर अपने 05AB1E उत्तरों में स्पष्टीकरण जोड़ता हूं, लेकिन जब मैं इसे पोस्ट करता हूं तो मेरे पास हमेशा सही समय नहीं होता है।
— एमिगा
1
किसी भी 05AB1E TIO लिंक के तर्कों में @KevinCruijssen आप -dकच्चे स्टैक ऑपरेशन-बाय-ऑपरेशन डंप प्राप्त करने के लिए जोड़ सकते हैं जो एक स्पष्टीकरण के बदले में चल रहा है, लेकिन मैं उन्हें पोस्ट करने की कोशिश करता हूं यह विशेष रूप से कुछ पर सीधा है LOL की।
— मैजिक ऑक्टोपस Urn
10

जेली , 13 बाइट्स

OI’“¡ʂƁ»ṁ$€ż@

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

व्याख्या

OI '' "ʂƁ" »'$ € - @ - पूर्ण कार्यक्रम। कमांड लाइन तर्क के रूप में एक स्ट्रिंग लें।
ओ - साधारण। प्रत्येक वर्ण के ASCII मान प्राप्त करें।
 मैं '- वेतन वृद्धि (डेल्टास) प्राप्त करें, और प्रत्येक से 1 घटाएं।
          € - प्रत्येक अंतर के लिए मैं ...
   "“ String »- $ - इन मूल्यों के अनुसार संकुचित स्ट्रिंग" टेप "ढालना।
                मूल रूप से "टेप" को आवश्यक लंबाई तक बढ़ाता है।
           ż @ - इनपुट के साथ इंटरलेव करें।
— मिस्टर एक्सकोडर
स्रोत
यहाँ आपको 12 तक नीचे लाने की एक तरकीब है
— जोनाथन एलन
@JonathanAllan जो मुझे अमान्य लगता है। इसके abctapetapetmnnnopapstetapezraबदले आउटपुट होता है abctapetapetmnnnoptasttapetzra।
— श्री एक्सकोडर
7
ओह, हाँ यह अमान्य है - मुझे नहीं पता था कि हम रोल से टेप को बर्बाद कर रहे थे!
— जोनाथन एलन
7

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

f(x:y:r)=x:take(length[x..y]-2)(cycle"TAPE")++f(y:r)
f s=s

इसे ऑनलाइन आज़माएं! फ़ंक्शन fस्ट्रिंग पर पुनरावृत्ति करता है और लगातार पात्रों को देखता है xऔर y। cycle"TAPE"अनंत स्ट्रिंग पैदा करता है "TAPETAPETAPE..."। [x..y]से पात्रों की सीमा हो जाता है xकरने के लिए y, समावेशी तो हम लंबाई से दो घटाना की जरूरत है। यदि xबाद में वर्णमाला में बाद में yया दोनों समान वर्ण होते हैं, तो हमें घटाने के बाद एक ऋणात्मक संख्या प्राप्त होती है, लेकिन सौभाग्य से takeवे भी स्वीकार करते हैं और बस कुछ नहीं लेते हैं।

— Laikoni
स्रोत
6

पर्ल 5 , -F46 बाइट्स

#/usr/bin/perl -F
use 5.10.0;
say map{((P,E,T,A)x7)[2..-$^H+($^H=ord)],$_}@F

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

— टन हास्पेल
स्रोत
2
के P,E,T,Aबजाय पूछने के बारे में क्यों था T,A,P,E, लेकिन मैं अब दो बाइट को बचाने के ((P,E,T,A)x7)[2..-$^H+($^H=ord)बजाय आप का उपयोग किया है नोटिस ((T,A,P,E)x7)[0..-$^H+($^H=ord)-2। अच्छा जवाब!
— केविन क्रूज़सेन
वाकई बहूत बढिया! मेरे naiive दृष्टिकोण से बहुत बेहतर! आप शाब्दिक ^H( \x08) का उपयोग करके 2 बाइट्स बचा सकते हैं, हालांकि!
— डोम हेस्टिंग्स
@DomHastings शाब्दिक नियंत्रण वर्ण चर पहले से ही कई पर्ल संस्करणों के लिए अक्षम कर दिए गए हैं। मैं एक पुराने पर्ल संस्करण पर एक स्कोर का दावा कर सकता था (जैसे मैंने हाल ही में किया था do$0), लेकिन यह केवल 2 बाइट्स है, इसलिए मैंने परेशान नहीं किया
— टन हास्पेल
आह, बिल्कुल! यह इसलिए है क्योंकि macOS में डिफ़ॉल्ट रूप से 5.18.2 है, इसलिए यह वह संस्करण है जिससे मैं सबसे अधिक परिचित हूं!
— डोम हेस्टिंग्स
4

सी, 84 बाइट्स

i,l;f(char*s){for(;*s;)for(putchar(l=*s++),l=s[i=0]+~l;i<l;)putchar("TAPE"[i++%4]);}

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

C (विंडोज कमांड प्रॉम्प्ट पर रन), 81 बाइट्स

i,l;f(char*s){for(;putchar(l=*s++);)for(l=s[i=0]+~l;i<l;)putchar("TAPE"[i++%4]);}

आउटपुट:

— Steadybox
स्रोत
4

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

lambda a:"".join(sum(zip(a,[("TAPE"*9)[:y>x and~ord(x)+ord(y)]for x,y in zip(a,a[1:])]),()))+a[-1]

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

-1 बाइट थैंक्स टू असोन तुहिद

— HyperNeutrino
स्रोत
@AsoneTuhid धन्यवाद मैं आपका अपना उत्तर पोस्ट करने की सलाह दूंगा क्योंकि आपने बहुत कम गोल्फिंग की है और आपने TFeld के जवाब को भी उसी चीज़ के लिए तैयार किया है, इसलिए एडिटिंग से ड्यूप्स (जो कि अस्वीकृत नहीं होता)
— HyperNeutrino
ठीक है, एक -1 बाइट है
— Asone Tuhid
@AsoneTuhid ओह ठीक है, धन्यवाद
— हाइपरनेट्रिनो
4

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

(s:String)=>s./:("z"){(o,c)=>o+("TAPE"*6).take(c-o.last-1)+c}.tail

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

व्याख्या

/: foldLeft over the string
("z") starting with a non-empty string to we don't have to handle the first iteration in a special way
"TAPE"*6 generate a long enough string of TAPETAPETA...
.take(c-o.last-1) take the difference between this character and the previous (now the last char in the output so far) characters from the TAPETAPETA... string. o.last will always be safe because we start with a non-empty string.
o+...+c append it to the output so far ... and add this character to the end
.tail get rid of the leading z we added
— जॉनी ग्राहम
स्रोत
PPCG में आपका स्वागत है, और पहला अच्छा जवाब! मुझ से +1।
— केविन क्रूज़सेन
4

PHP , 85 बाइट्स

$s=str_split($argv[1]);foreach($s as$l)echo str_pad($l,ord(next($s))-ord($l),'TAPE');

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

व्याख्या

$s = str_split($argv[1]);   // convert the parameter string to an array
foreach($s as $l)           // loop the array
echo str_pad(               // print
  $l,                       // the letter
  ord(next($s)) - ord($l),  // calculate the distance to the next letter using ASCII values
  'TAPE'                    // padding string
);                          // profit!
— M4tini
स्रोत
2
साइट पर आपका स्वागत है! :)
— DJMcMayhem
3

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

रिक हिचकोक की बदौलत 4 बाइट बच गए ।

z=(a=>[...a].reduce((x,y)=>x+[...Array((f=y[c='charCodeAt']()-x.slice(-1)[c]())>1?f-1:0)].reduce((e,r,t)=>e+"TAPE"[t%4],"")+y))

unrolled 

z = एक => [... एक] .reduce (
  (एक्स, वाई) =>
    x + [... ऐरे (
      (f = y.charCodeAt () - (x.slice (-1) .charCodeAt ()))> 1? (f-1): 0
    )]। को कम (
      (ई, आर, टी) => 
        e + "TAPE" [t% 4], "") + y
);

यहाँ मेरी समस्या यह है कि जावास्क्रिप्ट को चरित्र ए और बी के बीच की दूरी पाने का कोई साफ रास्ता नहीं था।

<script>
  z=(a=>[...a].reduce((x,y)=>x+[...Array((f=y[c='charCodeAt']()-x.slice(-1)[c]())>1?f-1:0)].reduce((e,r,t)=>e+"TAPE"[t%4],"")+y))
</script>

<main>
  <input id="input-box" type="text">
  <pre id=output>output</pre>
</main>

<script>
  inputBox = document.getElementById("input-box");
  inputBox.addEventListener("keyup", function(e){
    output.innerText = z(inputBox.value);
  });
</script>
स्निपेट का विस्तार करें

— Jhal
स्रोत
1
अच्छा लगा। आप अनुगामी अर्ध-बृहदान्त्र को हटाकर एक बाइट को बचा सकते हैं, और charCodeAtएक चर को असाइन करके कुछ और बाइट्स बचा सकते हैं : z=(a=>[...a].reduce((x,y)=>x+[...Array((f=y[c='charCodeAt']()-x.slice(-1)[c]())>1?f-1:0)].reduce((e,r,t)=>e+"TAPE"[t%4],"")+y))
— रिक हिचकॉक
धन्यवाद! मैं पूरी तरह से निराश हूं कि यह कैसे काम करता है, लेकिन यह जानना अच्छा है कि यह भविष्य के लिए करता है।
— झल
2

चारकोल , 20 बाइट्स

⭆θ⁺…TAPE∧κ⊖⁻℅ι℅§θ⊖κι

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

 θ              θ       Input string
⭆                       Map over characters
                  κ     Current index
                 ⊖      Decremented
               §        Index into string
             ι          Current character
            ℅ ℅         Ordinal
           ⁻            Subtract
          ⊖             Decremented
         κ              Current index
        ∧               Logical and
    TAPE                Literal string
   …                    Mold to length
                   ι    Current character
  ⁺                     Concatenate
                        Implicitly print
— नील
स्रोत
2

पिप , 29 बाइट्स

O@a{"TAPE"@<MX[0v-$-Ag]}.BMPa

कमांड-लाइन तर्क के रूप में इनपुट लेता है (कम- या अपरकेस, कोई फर्क नहीं पड़ता)। इसे ऑनलाइन आज़माएं!

व्याख्या

O@a{"TAPE"@<MX[0v-$-Ag]}.BMPa
                               a is 1st cmdline arg; v is -1 (implicit)
O                              Output without newline
 @a                            the first character of a
                          MPa  Map this function to pairs of successive characters of a:
                    Ag          Get the ASCII codes of the two characters
                  $-            Fold on subtraction (i.e. asc(first)-asc(second))
                v-              -1 minus the above (i.e. asc(second)-asc(first)-1)
              [0      ]         A list containing 0 and the above
            MX                  Max of the list
          @<                    The first ^ characters (with cyclic indexing)
    "TAPE"                      of this string
   {                   }.B      Concatenate the second character
— DLosc
स्रोत
2

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

f=([s,...S],t=S[0])=>t?s.padEnd((t>s)*(parseInt(s+t,36)-370)%37,'TAPE')+f(S):s

दो वर्णों के बीच की दूरी को उनके संघटन को आधार 36 में परिवर्तित करके, 370 को घटाकर, मापांक 37 से निर्धारित किया जा सकता है।

उदाहरण के लिए, (parseInt('cy',36)-370)%37 == 22।

तब हम padEndअंतराल को भरने के लिए उपयोग कर सकते हैं, और लूप को संभालने के लिए पुनरावृत्ति कर सकते हैं।

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

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

— रिक हिचकॉक
स्रोत
2

K4 , 48 बाइट्स

समाधान:

{,/_[w;x],',[1_d w:&0<d:-1+-':"j"$x;0]#\:"TAPE"}

उदाहरण:

q)k){,/_[w;x],',[1_d w:&0<d:-1+-':"j"$x;0]#\:"TAPE"}"abcmnnnopstzra"
"abcTAPETAPETmnnnopTAstTAPETzra"
q)k){,/_[w;x],',[1_d w:&0<d:-1+-':"j"$x;0]#\:"TAPE"}"aza"
"aTAPETAPETAPETAPETAPETAPEza"
q)k){,/_[w;x],',[1_d w:&0<d:-1+-':"j"$x;0]#\:"TAPE"}"zyxxccba"
"zyxxccba"
q)k){,/_[w;x],',[1_d w:&0<d:-1+-':"j"$x;0]#\:"TAPE"}"aabbddeeffiiacek"
"aabbTddeeffTAiiaTcTeTAPETk"

स्पष्टीकरण:

काफी सरल समाधान, लेकिन एक उच्च बाइट गिनती ... डेल्टास को ढूंढें, स्ट्रिंग से लें "TAPE", मूल स्ट्रिंग कट में शामिल हों जहां डेल्टास> 1 हैं।

{,/_[w;x],',[1_d w:&0<d:-1+-':"j"$x;0]#\:"TAPE"} / the solution
{                                              } / lambda
                                         "TAPE"  / the string TAPE
                                      #\:        / take each-left
           ,[                      ; ]           / join (,)
                                   0             / zero (ie append zero)           
                              "j"$x              / cast input to int
                           -':                   / deltas
                        -1+                      / subtract 1
                      d:                         / assign to d
                    0<                           / delta greater than 0?
                   &                             / indices where true
                 w:                              / assign to w
               d                                 / index into deltas at w
             1_                                  / drop first
         ,'                                      / join each-both
   _[w;x]                                        / cut input x at indices w
 ,/                                              / flatten
— streetster
स्रोत
2

एक्सेल VBA, 106 बाइट्स

एक अनाम VBE तत्काल विंडो फ़ंक्शन जो VBE तत्काल विंडो के लिए सेल A1और आउटपुट के माध्यम से एक अपरकेस स्ट्रिंग के रूप में इनपुट लेता है ।

a=90:For i=1To[Len(A1)]:c=Mid([A1],i,1):b=Asc(c):For j=2To b-a:?Mid("peta",j Mod 4+1,1);:Next:?c;:a=b:Next
— टेलर स्कॉट
स्रोत
2

रूबी , 59 53 बाइट्स

->s{s.reduce{|x,y|x+y.rjust(y.ord-x[-1].ord,"TAPE")}}

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

यह वास्तव में बहुत सीधा है - हम इनपुट को स्ट्रिंग के एक सरणी में विभाजित करते हैं (इसे बाहर इंगित करने के लिए असोन तुहिद के लिए धन्यवाद) के रूप में इनपुट लेते हैं और कम ऑपरेशन को लागू करते हैं, जहां हम भराव स्ट्रिंग "TAPE" का उपयोग करके प्रत्येक लंबाई को आवश्यक लंबाई तक सही ठहराते हैं।

— किरिल एल।
स्रोत
प्रश्न कहता है कि आप वर्णों के एक सरणी के रूप में इनपुट ले सकते हैं। ( 53 बाइट्स )
— आसोन तुहिद
2

के (ओके) , 33 बाइट्स

{,/((0|-1+0,1_-':x)#\:"TAPE"),'x}

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

{ } अनाम फ़ंक्शन तर्क के साथ x

-':x प्रत्येक पूर्व घटाएं (पहले आइटम से पहले एक काल्पनिक 0 का उपयोग करें)

1_ पहला आइटम गिराओ

0, पूर्वसर्ग करना ०

-1+ -1 जोड़ें

0| अधिकतम (0, ...)

(... बाईं ओर सूची से प्रत्येक आइटम के )#\:"TAPE"लिए स्ट्रिंग "TAPE"को फिर से खोलें

(... प्रत्येक पुन: आकारित स्ट्रिंग ),'xसे संबंधित वर्ण जोड़ेंx

,/ सभी को सम्‍मिलित करें

— NGN
स्रोत
2

रूबी , 78 77 64 62 बाइट्स

केविन क्रूज़सेन के लिए धन्यवाद

f=->s,*t{t[0]?s+('TAPE'*6)[0,[0,t[0].ord+~s.ord].max]+f[*t]:s}

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

— आसोन तुहिद
स्रोत
आप एक बाइट बदलते बचा सकते हैं ord-l[-1].ord-1करने के लिए ord+~l[-1].ord। हालांकि अच्छा जवाब है। मुझ से +1।
— केविन क्रूज़सेन
2

जावा (JDK) , 91 बाइट्स

s->{var p='z';for(var c:s)System.out.print("ETAP".repeat(9).substring(1,c>p?c-p:1)+(p=c));}

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

व्याख्या

s->{                       // char[]-accepting lambda consumer, printing a String
 var p='z';                //  store the previous character
 for(var c:s){             //  for each character of the string
  System.out.print(        //   print...
   "ETAP".repeat(9)        //    "ETAP" repeated 9 times (to go above 26 chars)
    .substring(1,          //     of which, we substring c-p -1 characters
     c>p?c-p:1             //
    )                      //
   +(p=c)                  //    and append c, while also storing the previous character
  );

क्रेडिट

  • -2 बाइट्स आरएम के लिए धन्यवाद
  • -4 बाइट्स सीलिंगकैट के लिए धन्यवाद , जावा 10+ में अपग्रेड करके और प्रकारों को स्विच करने के लिएvar
  • -3 बाइट्स केविन क्रूज़सेन की बदौलत , मेरे (पहले) वैकल्पिक संस्करण के परिणाम को प्रिंट करने के बजाय इसे वापस लौटा दिया
— ओलिवियर ग्रेजायर
स्रोत
int p=123एक चरित्र को बचाएंगे। इससे कोई फर्क नहीं पड़ता कि pपहली पुनरावृत्ति में क्या है, जब तक कि यह पहले वर्ण से बड़ा या बराबर है। पहला वर्ण जो सबसे बड़ा हो सकता है वह है 'z'== ASCII 122, इसलिए 123 पर्याप्त अच्छा है। इसके अलावा, यदि आप बड़े अक्षरों का उपयोग करते हैं, तो आप 123 के बजाय 91 का उपयोग कर सकते हैं, एक और चरित्र को बचा सकते हैं।
— आरएम
@ आरएम धन्यवाद, वास्तव में वह काम करता है!
— ओलिवियर ग्रेगोइरे
1
अपने वैकल्पिक विधि में सीधे प्रिंट करके -3 बाइट्स ।
— केविन Cruijssen
1

सी # (.NET कोर) , 122 111 बाइट्स

सहेजे गए 11 बाइट्स @KevinCruijssen की बदौलत

s=>{var r=""+s[0];for(int i=1,e,d;i<s.Length;r+=s[i++])for(e=d=s[i]-s[i-1];d-->1;)r+="ETAP"[(e-d)%4];return r;}

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

स्पष्टीकरण:

s => 
{
    var r = "" + s[0];                  //Declare string for the result and initialize with the first character from the input.
    for (                               //Loop over the input,
        int i = 1, e, d;                //starting with the second character, also declare helper variables.
        i < s.Length;                   //Loop until the end of the input is reached.
        r += s[i++])                    //Add the current character to the result and increase the counter.
        for (                           //Loop for adding the TAPE.
            e = d = s[i] - s[i - 1];    //Calculate the differnce between the current and the previous character.
            d-- > 1;)                   //Loop until the difference is 1.
            r += "ETAP"[(e - d) % 4];   //Add a character from the TAPE to the result.
    return r;                           //Return the result.
}
— raznagul
स्रोत
1
मुझसे अच्छा जवाब, +1। आप whileएक को बदलकर forऔर कोष्ठक को हटाकर 4 बाइट बचा सकते हैं for(int i=1,e,d;i<s.Length;r+=s[i++])for(e=d=s[i]-s[i-1];d-->1;r+=t[(e-d)%4]);:। :) ओह, और के बाद से उपयोग कर रहे हैं t="ETAP"केवल एक बार, तो आप सीधे उपयोग कर सकते हैं, और परिवर्तन stringकरने के लिए var7 अधिक बाइट्स को बचाने के लिए: s=>{var r=""+s[0];for(int i=1,e,d;i<s.Length;r+=s[i++])for(e=d=s[i]-s[i-1];d-->1;r+="ETAP"[(e-d)%4]);return r;}।
— केविन क्रूज़सेन
@ केविनक्रूजसेन: धन्यवाद, मैंने सामान को पाश के लिए स्थानांतरित करके कोष्ठक से छुटकारा पाने के बारे में नहीं सोचा होगा। इसके अलावा अगर मुझे लगता है कि मैं "ETAP" का सीधे उपयोग कर सकता हूँ, के लिए बेवकूफ महसूस करता हूँ।
— राजनागुल
आपका उत्तर अभी भी बहुत अच्छा है, इसलिए इसके बारे में चिंता न करें। :) मुझे लगभग हर बार जब मैं खुद एक उत्तर देता हूं तो मुझे गोल्फ-टिप्स मिलते हैं .. और यह एक मौजूदा जवाब को आगे बढ़ने से पहले गोल्फ से भी आसान है कि यह शुरुआत से ही पूरी तरह से गोल्फ हो। पुनश्च: आपने पहले ही उन्हें देखा होगा, लेकिन सी # में कोड-गोल्फिंग के लिए टिप्स और <सभी भाषाओं में गोल्फिंग के लिए टिप्स> के माध्यम से पढ़ने के लिए दिलचस्प हो सकता है अगर आपने अभी तक नहीं किया है।
— केविन क्रूज़सेन
1

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

p,o=' ',''
for t in input():y=(ord(t)-ord(p)-1)*(p!=' ');o+=('TAPE'*y)[0:y]+t;p=t
print(o)

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

— Dat
स्रोत
नमस्ते, मैंने आपका शीर्षक तय कर दिया **title**है #title। इसके अलावा, क्या आप परीक्षण कोड के साथ TryItOnline- लिंक जोड़ना चाहेंगे ?
— केविन क्रूज़सेन
1

क्लोजर, 139 119 बाइट्स

#(reduce-kv(fn[r x c](let[a(cycle "TAPE")i int d(-(i(nth(cycle %)(inc x)))(i c))](str r(if(> d 1)(apply str c(take(dec d)a))c))))""(vec %))

अनाम फ़ंक्शन जो स्ट्रिंग को लेता है और टैप किए गए एक को लौटाता है। हमेशा की तरह, क्लजुरे का प्रदर्शन बहुत अच्छा नहीं रहा। क्या मैं वास्तव में बाहर काम नहीं कर सकता था एक छोटे तरीके से अगले चार ले रहा है। अंतिम चार पर मुझे एक OutOfBoundsExceptionस्पष्ट कारण मिलेगा । इसलिए मैंने cycleइसके चारों ओर लगा दिया । शायद एक और अधिक सुंदर समाधान है।

Ungolfed

#(reduce-kv
  (fn [r x c]
    (let [a (cycle "TAPE")
          i int
          d (-
             (i (nth (cycle %) (inc x)))
             (i c))]
      (str r
           (if (> d 1)
             (apply str c (take (dec d) a))
             c))))
  ""
  (vec %))

अद्यतन करें

कुछ बाइट्स से दूर होने का प्रबंधन किया। ifअंतर को कम करके pesky के बयान से छुटकारा पा लिया । takeयदि संख्या 0 या उससे कम है तो रिक्त सूची तैयार करता है जिसके परिणामस्वरूप रिक्त स्ट्रिंग होती है।

#(reduce-kv(fn[r x c](let[d(-(int(nth(cycle %)(inc x)))(int c)1)](str r c(apply str(take d(cycle "TAPE"))))))""(vec %))

Ungolfed

#(reduce-kv
  (fn [r x c]
    (let [d (-
             (int (nth (cycle %) (inc x)))
             (int c)
             1)]
      (str
       r
       c
       (apply
        str
        (take
         d
         (cycle "TAPE"))))))
  ""
  (vec %))
— यहोशू
स्रोत
1

APL (Dyalog Classic) , 30 बाइट्स

{∊⍵,¨⍨⍴∘'TAPE'¨0,0⌈-1+2-/⎕a⍳⍵}

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

{ } अनाम फ़ंक्शन तर्क के साथ ⍵

⎕a⍳⍵ वर्णमाला में इसके वर्णों के सूचक मिलते हैं

2-/ जोड़ीदार अंतर (अगले शून्य से पहले)

1+ 1 जोड़ें

- निगेट

0⌈ अधिकतम (0, ...)

0, पूर्वसर्ग करना ०

⍴∘'TAPE'¨'TAPE'प्रत्येक चक्र को चक्रीय रूप से फेरबदल करें

⍵,¨⍨ प्रत्येक चर को तर्क से संबंधित फेरबदल स्ट्रिंग में जोड़ें

∊ समतल करना

— NGN
स्रोत
1

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

q_:i2ew.{:-~0e>_"TAPE"*<}

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

दूर, अन्य गोल्फिंग भाषाओं से दूर, लेकिन मुझे इस गोल्फ पर वैसे भी गर्व है।

व्याख्या

q                            Read the input
     ew                      And take windows of size
    2                          2
   i                           from the code points
  :                            of each of its characters.
        {               }    For each of these windows:
         :                     Reduce with
          -                      subtraction.
                                 Since there are only 2 elements, this just subtracts them.
             e>                Take the maximum
           ~                     of this difference's bitwise negation
            0                    and zero.
                                 This returns -n-1 if n is negative, and 0 otherwise.
                                 Call this new value m.
                      *        Repeat
                "TAPE"           the string "TAPE" m times.
               _       <       And then take the first m elements.
                             The result of this will be an array of strings which consist of
                             the string "TAPE" repeated the proper amount of times.
       .                     Zip this array with the original input.
                             Since the original input is one element longer than this array,
                             the nothing is pushed after the final character.
                             Implicitly print everything.
— फल तोड़ना
स्रोत
0

जावा, 213 166 153 बाइट्स

i->{String o="";for(int a=0,l=i.length;++a<=l;){char u=i[a-1],n;o+=u;if(a<l){n=i[a];o+="TAPETAPETAPETAPETAPETAPET".substring(0,n-u>0?n+~u:0);}}return o;}

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

    String o = "";
    for (int a = 0, l = i.length; ++a <= l; ) {              // for each character
        char u = i[a - 1];                                    //  current character
        o += u;                                               //  add current character to output string 
        if (a < l) {                                          //  if it's not the last one
            char n = i[a];                                    //  next character
            o += "TAPETAPETAPETAPETAPETAPET".substring(0, n - u > 0 ? n +~ u : 0); // fill with enough tape but only forward
        }
    }
    return o;

कृपया इसे बेहतर बनाने में मेरी मदद करें।

व्हॉट्सएप पर टिप के लिए @cairdcoinheringaahing को धन्यवाद। टेप स्ट्रिंग पर टिप के लिए @RM को धन्यवाद। लैम्बडा और एक्सप्रेशन टिप्स के लिए @KevinCruijssen को धन्यवाद।

— अमीर एम
स्रोत
1
साइट पर आपका स्वागत है! आप इस उत्तर को गोल्फ के लिए बहुत सारे व्हाट्सएप से हटा सकते हैं और जावा में गोल्फिंग के लिए इन सुझावों की जांच करना सुनिश्चित करें !
— caird coinheringaahing
1
आपको चर t बनाने की आवश्यकता नहीं है, क्योंकि आप केवल एक बार इसका उपयोग कर रहे हैं। आप बस कर सकते हैं "TAPETAPETAPETAPETAPETAPET".substring...।
— आरएम
PPCG में आपका स्वागत है! क्या के अलावा @RM ने कहा, यदि आप गोल्फ में कुछ और बातें कर सकते हैं: int a=1,l=i.length;a<=l;a++हो सकता है int a=0,l=i.length;++a<=l;, char u=i[a-1];o+=u;if(a<l){char n=हो सकता है char u=i[a-1],n;o+=u;if(a<l){n=, (n-u)कोष्ठक की जरूरत नहीं है, और n-u-1हो सकता है n+~u। साथ ही, आपका जवाब किसी फ़ंक्शन के बजाय वर्तमान में स्निपेट है। इसे लंबोदर बनाने के लिए आपको i->{आगे और }अंत में जोड़ना होगा। तो कुल में: यह ऑनलाइन प्रयास करें। 153 बाइट्स
— केविन क्रूज़सेन
— सीलिंगकैट
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.