बैकस्पेस-एंड-रिटाइप शब्दों की एक सूची

38

यहाँ एक स्ट्रिंग से दूसरे में बैकस्पेस और री-टाइप करने का तरीका बताया गया है :

  1. पहली स्ट्रिंग से शुरू करें।
  2. अंत में वर्ण निकालें जब तक कि परिणाम दूसरी स्ट्रिंग का उपसर्ग न हो। (इसमें 0 कदम हो सकते हैं।)
  3. अंत में वर्ण जोड़ें जब तक कि परिणाम दूसरी स्ट्रिंग के बराबर न हो जाए। (यह 0 कदम भी कर सकता है।)

उदाहरण के लिए, से पथ fooabcको fooxyzलगता है कि:

fooabc
fooab
fooa
foo
foox
fooxy
fooxyz

कार्य

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

उदाहरण के लिए, इनपुट सूची को देखते हुए ["abc", "abd", "aefg", "h"], आउटपुट होना चाहिए:

a
ab
abc
ab
abd
ab
a
ae
aef
aefg
aef
ae
a

h

नियम

आप तार की सूची, या पसंद के कुछ सीमांकक के साथ एक एकल स्ट्रिंग वापस या प्रिंट कर सकते हैं। आप वैकल्पिक रूप से प्रारंभिक और अंतिम खाली तार शामिल कर सकते हैं। इनपुट में कम से कम एक शब्द शामिल करने की गारंटी है, और प्रत्येक शब्द में केवल लोअरकेस ASCII अक्षरों ( a- z) को शामिल करने की गारंटी है । संपादित करें: इनपुट में लगातार तार एक दूसरे के बराबर नहीं होने की गारंटी है।

यह कोड-गोल्फ है ; बाइट्स में सबसे छोटा कोड जीतता है।

पायथन 3 में एक संदर्भ कार्यान्वयन: इसे ऑनलाइन आज़माएं!

code-golf  string 
— लिन
स्रोत
4
@ rahnema1> एक प्रोग्राम लिखिए जो बैकस्पेस-एंड-रिटेक को रिक्त स्ट्रिंग से
— बनाता है
3
उत्पादन कैसे होगा ["abc","abc"]?
— क्रिति लिथोस
1
@Emigna ओह, यह ठीक है लेकिन एक पाश में है! इसलिए मैं आगे जाने वाला हूं और कहता हूं कि यह उसी की नकल है।
— लिन
4
@ लियन यह एक ही बात नहीं है। यह आम उपसर्गों को पहचानना शामिल नहीं करता है, यह हमेशा एक वर्ण के नीचे जाता है।
— मार्टिन एंडर
6
टेस्ट केस:a,abc,abcde,abc,a,abc,abcde
— जर्गब

जवाबों:

9

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

कोड + -nझंडे के 42 बाइट्स ।

chop$@,say$@while!s/^$@//;s/./say$@.=$&/ge

इसे चलाने के लिए: 

perl -nE 'chop$@,say$@while!s/^$@//;s/./say$@.=$&/ge' <<< "abc
abd
aefg
h"
— बापू
स्रोत
यह प्रिंट 3 बार abc
— izabera
@izabera abc3 बार मुद्रित होने के कारण एक स्थान था (लेकिन वास्तव में, पहली और तीसरी बार यह अंतरिक्ष के बिना था)। मैंने उसे हटा दिया।
— दादा
5

जावा 8, 144 बाइट्स

यह एक संदर्भ कार्यान्वयन के समान है, लेकिन दो whileछोरों को जोड़ता है । यह एक String[]पैरामीटर स्वीकार करने वाला एक लंबोदर अभिव्यक्ति है ।

a->{String c="";int l=0,i;for(String w:a)while((i=w.indexOf(c))!=0||!c.equals(w))System.out.println(c=i!=0?c.substring(0,--l):c+w.charAt(l++));}

Ungolfed

a -> {
    String c = "";
    int l = 0, i;
    for (String w : a)
        while ((i = w.indexOf(c)) != 0 || !c.equals(w))
            System.out.println(c = i != 0 ? c.substring(0, --l) : c + w.charAt(l++));
}

स्वीकृतियाँ

  • -38 बाइट्स CAD97 के लैम्ब्डा सुझाव के लिए धन्यवाद
— जेकब
स्रोत
क्या class Bइसके बजाय उपयोग करना सस्ता नहीं है interface B? आप एक पैकेज-निजी वर्ग से चला सकते हैं। इसके अलावा, एक लैम्ब्डा का उपयोग करने पर विचार करें क्योंकि आपने जावा 8 को पहले ही निर्दिष्ट कर दिया है।
— ९
@ CAD97 इससे interface B{static void mainछोटा है class B{public static void main।
— केविन क्रूज़सेन
@ CAD97 मैं इस में लैम्ब्डा लाने का तरीका नहीं सोच सकता, लेकिन मैंने कल ही उनके बारे में सीखा। कोई विचार?
— जैकब
1
आह, मैं कठोर हूँ। आपको ऐसा करने में सक्षम होना चाहिए a->{/*your code*/}, जो एक प्रकार के चर को निर्दिष्ट करेगा java.util.function.Consumer<String[]>। मैं हालांकि, इस समय परीक्षण नहीं कर सकता।
— सीएडी 97
1
@JakobCornell डिफ़ॉल्ट रूप से PPCG पूर्ण कार्यक्रम या फ़ंक्शन सबमिशन की अनुमति देता है। अनाम फ़ंक्शंस (लैम्ब्डा) वाली भाषाओं के लिए, अपने आप ही अनाम फ़ंक्शन एक स्वीकार्य उत्तर है (इस प्रकार आपको इसे स्टोर करने के लिए वैरिएबल को शामिल नहीं करना है)। (हालांकि जावा सबमिशन में यह
— लंबोदर
4

गणितज्ञ, 149 बाइट्स

Reap[Fold[n=NestWhile;s=StringMatchQ;r=StringReplace;n[k=#2;Sow@r[k,#~~a_~~___:>#<>a]&,n[Sow@r[#,a___~~_:>a]&,#,!s[k,#~~___]&],k!=#&]&,"",#]][[2,1]]&
— जंगवान मिन
स्रोत
3

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

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

M!&r`.+
%)`\G.
¶$`$&
+`((.*).¶)\2¶\1
$1

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

इनपुट और आउटपुट लाइनफीड-सेपरेटेड लिस्ट हैं। आउटपुट में अग्रणी और अनुगामी खाली स्ट्रिंग शामिल है।

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

जेली , 31 29 26 बाइट्स

⁷œ|;\
ÇṚðfḢṭḟ;ḟ@ḊðÇ}
⁷;ç2\

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

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

⁷;ç2\           Main link. Argument: A (string array)

⁷;              Prepend a linefeed to A. 
                This is cheaper than prepending an empty string.
  ç2\           Reduce all overlapping pairs by the second helper link.


ÇṚðfḢṭḟ;ḟ@ḊðÇ}  Second helper link. Arguments: s, t (strings)

Ç               Call the first helper link with argument s.
 Ṛ              Reverse the results.
            Ç}  Call the first helper link with argument t.
  ð        ð    Combine everything in between into a dyadic chain, and call it
                with the results to both sides as arguments.
                Let's call the arguments S and T.
   f            Filter; get the common strings of S and T.
    Ḣ           Head; select the first one.
      ḟ         Filterfalse; get the strings in S that do not appear in T.
     ṭ          Tack; append the left result to the right one.
        ḟ@      Filterfalse swap; get the strings in T that do not appear in S.
       ;        Concatenate the results to both sides.
          Ḋ     Dequeue; remove the first string.


⁷œ|;\           First helper link. Argument: s (string)

⁷œ|             Linefeed multiset union; prepend a linefeed to s unless it already
                has a linefeed in it (the first string does).
   ;\           Concatenate cumulative reduce; generate all prefixes of the result.
— डेनिस
स्रोत
2

हास्केल , 102 93 91 90 बाइट्स

(?)=take.length
a!x@(b:c)|a==b=b!c|a/=a?b=a:init a!x|d<-'?':a=a:d?b!x
_!x=x
(""!).(++[""])

अंतिम पंक्ति एक अनाम फ़ंक्शन है, जो स्ट्रिंग की सूची लेती है और वापस करती है। इसे ऑनलाइन आज़माएं!

व्याख्या

मेरा समाधान पुनरावर्ती है। सबसे पहले, ?एक हेल्पर इनफ़िक्स फ़ंक्शन होता है: a?bका पहला length aअक्षर देता है b, या bयदि पूरा aलंबा हो। अगले मैं एक infix फ़ंक्शन को परिभाषित करता हूं !। विचार यह है कि a!x, जहां aएक स्ट्रिंग है और xतार की एक सूची है, aपहले स्ट्रिंग से अंदर की ओर पथ बनाता है xऔर की पूंछ पर पुनरावृत्ति करता है x। अंतिम पंक्ति पर मैं एक अनाम फ़ंक्शन को परिभाषित करता हूं जो खाली स्ट्रिंग को जोड़ता है, फिर !खाली स्ट्रिंग और इनपुट पर लागू होता है।

का स्पष्टीकरण !:

a!x@(b:c)        -- a!x, where x has head b and tail c:
  |a==b          -- If a equals b,
    =b!c         -- recurse to x.
  |a/=a?b        -- If a is not a prefix of b,
    =a:          -- produce a and
    init a!x     -- continue with one shorter prefix of a.
  |              -- Otherwise a is a proper prefix of b.
   d<-'?':a      -- Let d be a with an extra dummy element,
    =a:          -- produce a and
    d?b!x        -- continue with one longer prefix of b.
_!x=x            -- If x is empty, return x.
— Zgarb
स्रोत
2

पायथन 2, 118 107 103 97 93 92 बाइट्स

s=''
for i in input()+[s]:
 while i.find(s):s=s[:-1];print s
 while i>s:s+=i[len(s)];print s

इनपुट के रूप में ['abc', 'abcdef', 'abcfed'], या [के रूप में दिया जाता है "abc", "abcdef", "abcfed"]।

संशोधन 1: -11 बाइट्स। क्रेडिट पायथन गोल्फिंग टिप्स पर अपने पोस्ट के लिए @xnor को जाता है, और मेरे लिए टिप खोजने के लिए @ लियन को, और मुझे स्मार्ट होने के लिए। दो बदलाव किए गए: इसके बजाय not s.startswith(i), मैंने उपयोग किया s.find(i), और इसके बजाय i!=sमैंने उपयोग किया i>s।

संशोधन 2: -4 बाइट्स। क्रेडिट मुझे यह एहसास दिलाता है कि मैंने वास्तव में गूंगा गलती की है। सिंगल-टैब और डबल-टैब इंडेंटेशन का उपयोग करने के बजाय, मैंने सिंगल-स्पेस और सिंगल-टैब इंडेंटेशन का उपयोग किया।

संशोधन 3: -6 बाइट्स। सिंगल लाइन पर व्हेल डालने के सुझाव के लिए क्रेडिट @ mbomb007 पर जाता है। मैं भी एक बग को बदलकर तय s.find(i)किया i.find(s)।

संशोधन 4: -4 बाइट्स। साकार करने के लिए श्रेय @xnor को जाता है कि मुझे इनपुट को एक चर में संग्रहीत करने की आवश्यकता नहीं थी।

संशोधन 5: -1 बाइट। क्रेडिट मुझे यह महसूस करने के लिए जाता है कि ['']यह उसी तरह है [s]जब इसे इनपुट में जोड़ा जाता है।

— HyperNeutrino
स्रोत
रखो whileरों प्रत्येक एक पंक्ति पर। इसके अलावा, आप के <1बजाय उपयोग कर सकते हैं not।
— mbomb007
अच्छा जवाब! बचने केstartswith तरीके पर xnor द्वारा एक अच्छी टिप है ।
— लिन
@ लियन ओह, लिंक के लिए धन्यवाद! मुझे यह वास्तव में मददगार लगा!
— हाइपरनेत्रिनो
@ mbomb007 मुझे क्षमा करें, मुझे whileएक लाइन पर एस लगाने से आपका क्या मतलब है । क्या आपका मतलब है while s.find(i):s=s[:-1];print s? इसके अलावा, के बारे में सुझाव के लिए धन्यवाद <1, लेकिन मैं पायथन टिप्स थ्रेड पर xnor के सुझावों में से एक के लिए भी कम धन्यवाद में बदल गया हूं।
— हाइपरनेत्रिनो
@AlexL। हाँ, जबकि समय की तरह है।
— mbomb007
1

GNU M4, 228 या 232 बाइट्स

(File इस पर निर्भर करता है कि फाइल को खत्म करना है dnl\nया नहीं — मैं अभी भी गोल्फ और एम 4 दोनों के लिए नया हूं)

define(E,`ifelse(index($2,$1),0,`T($1,$2)',`$1
E(substr($1,0,decr(len($1))),$2)')')define(T,`ifelse($1,$2,,`$1
T(substr($2,0,incr(len($1))),$2)')')define(K,`ifelse($2,,$1,`E($1,$2)K(shift($@))')')define(M,`K(substr($1,0,1),$@)')

इसके अतिरिक्त, 3 बाइट्स को रिक्त स्ट्रिंग substrसे दूसरे तर्क के स्थान पर बदलकर बचाया जा सकता है 0, लेकिन यह स्टैडर पर बहुत सारी चेतावनी देगा।

Ungolfed:

define(erase_til_prefix, `dnl arguments: src dst; prints src and chops one char off of it until src == dst, at which point it calls type_til_complete instead
ifelse(dnl
index($2, $1), 0, `type_til_complete($1, $2)',dnl
`$1
erase_til_prefix(substr($1, 0, decr(len($1))), $2)dnl
')')dnl
define(type_til_complete, `dnl arguments: src dst; types src, does not type `dst' itself
ifelse(dnl
$1, $2, ,dnl
`$1
type_til_complete(substr($2, 0, incr(len($1))), $2)'dnl
)')dnl
define(main_, `dnl
ifelse(dnl
$2, , $1, dnl no arguments left
`erase_til_prefix($1, $2)main_(shift($@))'dnl
)')dnl
define(main, `main_(substr($1, 0, 1), $@)')dnl

उपयोग:

$ m4 <<<"include(\`backspace-golfed.m4')M(abc, abd, aefg, abcdefg, h)"
— थ्रिलर
स्रोत
1

PHP, 116 111 101 83 बाइट्स

नोट: Windows-1252 एन्कोडिंग का उपयोग करता है।

for(;$w=$argv[++$i];)for(;$c!=$w;)echo$c=($c^$c^$w)==$c?$c.ÿ&$w:substr($c,0,-1),~õ;

इस तरह से चलाएं:

php -r 'for(;$w=$argv[++$i];)for(;$c!=$w;)echo$c=($c^$c^$w)==$c?$c.ÿ&$w:substr($c,0,-1),~õ;' -- abc abd aefg h 2>/dev/null
> a
> ab
> abc
> ab
> abd
> ab
> a
> ae
> aef
> aefg
> aef
> ae
> a
>
> h

व्याख्या

for(                       # Outer loop.
  ;
  $w=$argv[++$i];          # Loops over the input words.
)
  for(                     # Second inner loop.
    ;
    $c!=$w;                # Loop until the word was output.
  )
    echo $c=
      ($c^$c^$w)==$c?      # Check if last output string is a substring
                           # match with the next word to output.
        $c.ÿ&$w:           # ... If yes, suffix the string with the next
                           # char of the word, and output the result.
        substr($c,0,-1),   # ... If not, remove a char and output.
      ~õ;                  # Output newline.

बदलाव

  • trim($c^$w,"\0")इसके स्थान पर विकल्प मिलान के लिए जांच करने के लिए 5 बाइट्स सहेजे गए $c&&strpos($w,$c)!==0।
  • के ~ÿबजाय NUL बाइट के साथ एक स्ट्रिंग उपज का उपयोग करके 2 बाइट्स सहेजे गए"\0"
  • अगले चार के साथ $c=$c.ÿ&$wप्रत्यय का उपयोग करके 8 बाइट्स $cबचाए$w
  • एक ही लूप में 2 इनर लूप के लॉजिक को मिलाकर 18 बाइट्स बचे
  • टिप्पणियों से एक टेस्टकेस के साथ एक बग फिक्स्ड, बाइट गिनती में कोई बदलाव नहीं
— aross
स्रोत
1

बैच, 296 291 बाइट्स

@echo off
set f=
set t=%1
:t
set f=%f%%t:~,1%
set t=%t:~1%
echo(%f%
if not "%t%"=="" goto t
shift
set t=%1
set s=%f%
set p=
:h
if %s:~,1%==%t:~,1% set p=%p%%t:~,1%&set s=%s:~1%&set t=%t:~1%&goto h
:b
set f=%f:~,-1%
echo(%f%
if not "%f%"=="%p%" goto b
if not "%1"=="" goto t

सामान्य उपसर्ग को समझना बोझिल था।

— नील
स्रोत
0

PHP, 153 बाइट्स

गज़ब लम्बा :(

for($s=$argv[$k=1];$t=$argv[++$k];){for(;$s>""&&strstr($t,$s)!=$t;$s=substr($s,0,-1))echo"$s
";for($i=strlen($s);$s<$t;$s.=$t[$i++])echo"$s
";echo"$s
";}

के साथ भागो php -nr '<ode>' <text1> <text2> ...।

— टाइटस
स्रोत
0

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

दिलचस्प चुनौती! उपयोग: g(["abc", "abd", "aefg", "h"])। मैं इसे एक फ़ंक्शन के रूप में लिखकर किसी भी बाइट को सहेजने के लिए प्रतीत नहीं कर सकता, इसलिए यह दो है। बाइट्स की गिनती में शामिल नहीं नईं।

f=a=>console.log(([,...z]=[x,y]=a)[0])||
y?f(a=(x==y.slice(0,-1))?z:([y.match(x)
?x+y[x.length]:x.slice(0,-1),...z])):1;
g=a=>f(['',...a])

मुझे यकीन है कि यह बहुत कम हो सकता है। बाद में ungolfed संस्करण जोड़ देगा।

— क्रिस एम
स्रोत
0

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

a=>{c="",l=0;for(w of a)while((i=w.indexOf(c))!=0||c!=w)alert(c=i!=0?c.substring(0,--l):c+w[l++])}

जैकब के जावा उत्तर का पोर्ट

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