मेरे बेटे को उसके पत्र खोजने में मदद करें

Question

पृष्ठभूमि

एक खेल के आधार पर मेरे चार वर्षीय अपने रब्बी से मिला।

"लक्ष्य" किसी दिए गए क्रम में अक्षरों को "ढूंढना" है, जैसे aecdb। आपको पत्र कार्डों का ढेर दिया जाता है, जैसे daceb। आप केवल दिए गए क्रम में स्टैक के माध्यम से खोज सकते हैं, यद्यपि यह चक्रीय रूप से है। जब आपको किसी पत्र की जरूरत होती है, तो आप उसे स्टैक से निकाल लेते हैं।

उद्देश्य

एक आदेश और एक स्टैक (एक-दूसरे के डुप्लिकेट-मुक्त क्रमपरिवर्तन) को देखते हुए, शीर्ष स्टैक अक्षरों का अनुक्रम ढूंढें (यह सभी मुद्रण योग्य ASCII है) जो आप गेम खेलते समय देखते हैं।

चरण-दर-चरण उदाहरण

हमें aecdbस्टैक को देखते हुए ऑर्डर ढूंढना होगा daceb:

स्टैक का शीर्ष d: वह नहीं जिसे हम ढूंढ रहे हैं ( a), इसलिए हम इसे अनुक्रम में जोड़ते हैं: dऔर स्टैक प्राप्त करने के लिए घुमाएँ acebd:।

ढेर का शीर्ष a: हाँ! इसलिए हम इसे अनुक्रम में जोड़ते हैं: daऔर इसे स्टैक से हटा दें:cebd:।

स्टैक का शीर्ष c: वह नहीं जिसे हम ढूंढ रहे हैं ( e), इसलिए हम इसे अनुक्रम में जोड़ते हैं: dacऔर स्टैक प्राप्त करने के लिए घुमाएँ ebdc:।

ढेर का शीर्ष e: हाँ! इसलिए हम इसे अनुक्रम में जोड़ते हैं: daceऔर इसे स्टैक से हटा दें bdc:।

स्टैक का शीर्ष b: वह नहीं जिसे हम ढूंढ रहे हैं ( c), इसलिए हम इसे अनुक्रम में जोड़ते हैं: dacebऔर स्टैक प्राप्त करने के लिए घुमाएँ dcb:।

स्टैक का शीर्ष d: वह नहीं जिसे हम ढूंढ रहे हैं ( c), इसलिए हम इसे अनुक्रम में जोड़ते हैं: dacebdऔर स्टैक प्राप्त करने के लिए घुमाएँ cbd:।

ढेर का शीर्ष c: हाँ! इसलिए हम इसे अनुक्रम में जोड़ते हैं: dacebdcऔर इसे स्टैक से हटा दें bd:।

स्टैक का शीर्ष b: वह नहीं जिसे हम ढूंढ रहे हैं ( d), इसलिए हम इसे अनुक्रम में जोड़ते हैं: dacebdcbऔर स्टैक प्राप्त करने के लिए घुमाएँ db:।

ढेर का शीर्ष d: हाँ! इसलिए हम इसे अनुक्रम में जोड़ते हैं: dacebdcbdऔर इसे स्टैक से हटा दें b:।

ढेर का शीर्ष b: हाँ! इसलिए हम इसे अनुक्रम में जोड़ते हैं: dacebdcbdbऔर इसे स्टैक से हटा दें :।

और हम कर रहे हैं। परिणाम है dacebdcbdb।

संदर्भ कार्यान्वयन

def letters(target, stack):
    string = ''
    while stack:
        string += stack[0]
        if stack[0] == target[0]:
            stack.pop(0)
            target = target[1:]
        else:
            stack.append(stack.pop(0))
    return string

print letters('aecdb', list('daceb'))

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

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

try, yrt→yrtyry

1234, 4321→4321432434

ABCDEFGHIJKLMNOPQRSTUVWXYZ, RUAHYKCLQZXEMPBWGDIOTVJNSF→RUAHYKCLQZXEMPBWGDIOTVJNSFRUHYKCLQZXEMPWGDIOTVJNSFRUHYKLQZXEMPWGIOTVJNSFRUHYKLQZXMPWGIOTVJNSRUHYKLQZXMPWIOTVJNSRUYKLQZXMPWOTVNSRUYQZXPWOTVSRUYQZXPWTVSRUYQZXWTVSRUYZXWTVSUYZXWTVUYZXWVYZXWYZXYZ

?, ?→?

a, a →a a

abcd, abcd→abcd

Answer 1

तीन बिल्कुल अलग तरीके बराबर बाइट काउंट दे रहे हैं।

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

s,t=input()
for c in s*99:
 if c in t:print c;t=t.lstrip(c)

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

प्रत्येक वर्ण को अपनी पंक्ति में छापता है।

---

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

lambda s,t:[c==t[0]and t.pop(0)or c for c in s*99if c in t]

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

सूची को इनपुट के रूप में लेता है, और एक सूची को आउटपुट करता है।

---

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

def f(s,t):
 for c in t:p,q=s.split(c);s=q+p;print(end=p+c)

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

Comments

हम्म, मुझे पहले दो संस्करणों पर संदेह है ... 99विशेष रूप से क्यों ?

— आउटगॉल्फ

@EriktheOutgolger यह कम से कम मुद्रण योग्य ASCII वर्णों की संख्या है, और इसलिए प्रत्येक इनपुट की लंबाई कम से कम है।

— xnor

Answer 2

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

∊⊢,⊢∘⊂~¨(,\⊣⊂⍨1,2>/⍋)

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

यह एक ट्रेन के बराबर है {∊⍵,(⊂⍵)~¨(,\⍺⊂⍨1,2>/⍺⍋⍵)}

⍋सही तर्क के क्रमचय देता ⍵बाईं बहस में⍺

1,2>/>एक के साथ लगातार जोड़े की तुलना करें और एक प्रीपेंड करें

⍺⊂⍨⍺समूहों में विभाजित करने के लिए उपरोक्त बूलियन मास्क का उपयोग करें ; मास्क में 1s एक नए समूह की शुरुआत को चिह्नित करता है

,\ समूहों का संचयी संयोजन

(⊂⍵)~¨ सम्मान के साथ प्रत्येक के पूरक ⍵

⍵, आगे जोड़ते ⍵

∊ एक स्ट्रिंग के रूप में समतल करें

Answer 3

बैच, 155 बाइट्स

@set/pt=
@set/ps=
@set r=
:l
@set c=%s:~,1%
@set r=%r%%c%
@if %c%==%t:~,1% set t=%t:~1%&set c=
@set s=%s:~1%%c%
@if not "%t%"=="" goto l
@echo %r%

STDIN पर इनपुट के रूप में लक्ष्य और स्टैक लेता है।

Answer 4

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

लक्ष्य को एक स्ट्रिंग के रूप में और ढेर को वर्णों के रूप में लेता है। एक स्ट्रिंग लौटाता है।

f=(t,[c,...s])=>t&&c+f(t.slice(c==t[0]||!s.push(c)),s)

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

f=(t,[c,...s])=>t&&c+f(t.slice(c==t[0]||!s.push(c)),s)

console.log(f('try',[...'yrt']))
console.log(f('1234',[...'4321']))
console.log(f('aecdb',[...'daceb']))
console.log(f('ABCDEFGHIJKLMNOPQRSTUVWXYZ',[...'RUAHYKCLQZXEMPBWGDIOTVJNSF']))
console.log(f('?',[...'?']))
console.log(f(' a',[...'a ']))
console.log(f('abcd',[...'abcd']))

कैसे?

प्रत्येक पुनरावृत्ति पर, हम cस्टैक के शीर्ष पर वर्ण को निकालते हैं और इसे अंतिम परिणाम के लिए जोड़ते हैं। हम फिर से एक पुनरावर्ती कॉल करते हैं, जिसके पैरामीटर परिणाम के आधार पर निर्भर करते हैं कि अगला अपेक्षित चरित्र c == t[0]कहां t[0]है।

यदि cमेल खाता है t[0]:

• हम cपास करके लक्ष्य स्ट्रिंग से निकालते हैंt.slice(1)
• हम अपरिवर्तित cहोकर स्टैक से निकालते sहैं

यदि cमेल नहीं खाता है t[0]:

• हम लक्ष्य स्ट्रिंग को अपरिवर्तित करते हैं t.slice(0)
• हम cस्टैक के अंत में वापस धक्का देते हैं

Answer 5

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

f=lambda o,s,S='':s and f(o[s[0]==o[0]:],s[1:]+s[:s[0]!=o[0]],S+s[0])or S

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

मुझे संदेह है कि यह बहुत उच्च गोल्फ है।

Answer 6

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

f=lambda o,s:o and s[0]+f(o[s[0]==o[0]:],s[1:]+s[0]*(s[0]!=o[0]))

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

Answer 7

हास्केल , 49 46 बाइट्स

q@(a:b)#(c:d)|a==c=a:b#d|e<-d++[c]=c:q#e
a#_=a

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

काफी सरल। वामपंथी तर्क "लक्ष्य" है और दाईं ओर ढेर है। यदि गोल का शीर्ष स्टैक के शीर्ष से मेल खाता है, तो हम इसे पूर्व निर्धारित करते हैं, और शेष लक्ष्य और स्टैक के साथ पुनरावृत्ति करते हैं (शीर्ष पर फिर से आइटम को जोड़े बिना)। अन्यथा हम शीर्ष आइटम को पूर्व निर्धारित करते हैं और एक ही लक्ष्य के साथ पुनरावृत्ति करते हैं, शीर्ष आइटम को स्टैक के अंत तक पढ़ते हैं। जब लक्ष्य खाली होता है तो पैटर्न मिलान दूसरी पंक्ति चुनता है और खाली सूची वापस आ जाती है।

EDIT: -3 बाइट्स @GolfWolf और @Laikoni को धन्यवाद!

Comments

47 वर्ण

— क्रिस्टियान लुपस्कु

इसके अलावा 47

— क्रिस्टियन लुपस्कु

46 बाइट्स

— लॉकोनी

@GolfWolf आपका दूसरा समाधान (और लकोनी का) काम नहीं करता है। यह ऑपरेटर के साथ (:) और (#)

— user1472751

Answer 8

साफ , 85 बाइट्स

import StdEnv
g l[u:v][a:b]|a==u=g[a:l]v b=g[a:l][u:v](b++[a])
g l[]_=reverse l
f=g[]

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

आंशिक कार्य fलेने को परिभाषित करता है [Char]और [Char], जहां पहला तर्क लक्ष्य है और दूसरा स्टैक है।

Answer 9

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

a->b->{for(int c:a)for(char t=0;c!=t;System.out.print(t)){t=b.poll();if(c!=t)b.add(t);}}

के रूप में इनपुट char[]और java.util.LinkedList<Character>( java.util.Queueकार्यान्वयन)

स्पष्टीकरण:

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

a->b->{                        // Method with two parameters and no return-type
  for(int c:a)                 //  Loop over the characters of the char-array
    for(char t=0;c!=t;         //   Inner loop until we've found the character in the queue
        System.out.print(t)){  //     After every iteration: print the char `t`
      t=b.poll();              //    Remove the top of the queue, and save it in `t`
      if(c!=t)                 //    If this is not the character we're looking for:
        b.add(t);}}            //     Add it at the end of the queue again

Answer 10

> <> , 38 32 बाइट्स

संपादित करें: चैती श्रोणि में यहां बहुत बेहतर ><>दृष्टिकोण है जो इनपुट विधियों को स्वैप करता है

0[i:0(1$.
\~~l]1+{$[&
/?=&:&:o:{

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

के माध्यम से पत्र का क्रम लेता है -sध्वज के , और इनपुट के माध्यम से स्टैक।

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

0[.... Creates a new empty stack
...... This puts the order of the letters safely away
......

..i:0(1$. Takes input until EOF (-1). This means input is in reverse
..~...    And then teleports to the ~ on this line
......

......      Gets the first character from the beginning of the order
\.~l]1+{$[& And stores it in the register before going to the next line
/.....

......     Output the bottom of the stack
......     Checks if the bottom of the stack is equal to the current character
/?=&:&:o:{ If so, go to the second line, else cycle the stack and repeat

0.....      Pop the extra 0 we collected
\~~l]1+{$[& Pop the value that was equal and get the next character from the order
/.....      And go down to the last line. This will end with an error (which could be avoid with a mere 4 extra bytes

Answer 11

पर्ल 5 , 42 + 2 ( -pl) = 44bytes

for$i(<>=~/./g){/$i/;$\.=$`.$i;$_=$'.$`}}{

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

Answer 12

> <> , 21 16 बाइट्स

i$\~~
=?\$:{::o@

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

रिक्त स्थानों का उपयोग करने और अतिरिक्त कोड रीरूटिंग को हटाने के लिए प्रवाह बदल गया। (-5 बाइट्स) - @JoKing को धन्यवाद

> <> , 21 बाइट्स

i:{:@=?v:o$!
o~i00. >

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

अन्य> <> उत्तर पाया जा सकता है यहां है।

व्याख्या

स्टॉक्स अक्षर के प्रारंभिक सेट के साथ -s ध्वज का उपयोग करके शुरू होता है। इनपुट उपयोगकर्ता द्वारा दिया गया वर्ण क्रम है। यह स्पष्टीकरण कोड के प्रवाह का पालन करेगा।

i$\        : Take input, swap the top 2 stack items then move to line 2;
             [1,2,3] -> [1,2,4,3]
  \$:      : Swap the top 2 stack items then duplicate the top item;
             [1,2,4,3] -> [1,2,3,4,4]
     {::o  : Move the stack items 1 left then duplicate the stack top twice and print one;
             [1,2,3,4,4] -> [2,3,4,4,1,1]
=?\      @ : Swap the top three stack items left 1 then do an equal comparison, if equality move to line 1 else continue;
             [2,3,4,4,1,1] -> [2,3,4,1,1,4] -> [2,3,4,1]
  \~~      : Remove the top 2 stack items;
             [2,3,4,1] -> [2,3]

Comments

अरे हाँ, इसे इस तरह से इनपुट करना अधिक समझदारी देता है

— जो किंग

लगभग 17 बाइट्स कैसे ?

— जो राजा

@JoKing - उन अनावश्यक रूटिंग को दूर करने के लिए बहुत अच्छा परिवर्तन, मैं एक अतिरिक्त बाइट लेने पर विरोध नहीं कर सका, हालांकि: पी

— चैले पेलिकन

Answer 13

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

sub{$_=$_[1];for$x(@{$_[0]}){/\Q$x\E/;$z.="$`$&";$_="$'$`"}$z}

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

Ungolfed:

sub {
    $_ = $_[1];
    for $x (@{$_[0]}) {
        /\Q$_\E/;
        $z.="$`$&";
        $_ = "$'$`"
    }
    $z
}

आपने कभी सोचा है कि उन सभी अस्पष्ट रेगेक्स चर क्या थे? जाहिर है, वे इस सटीक चुनौती के लिए डिज़ाइन किए गए थे। हम वर्तमान चरित्र पर मेल खाते हैं $x(जो दुर्भाग्य से बच निकलने की स्थिति में यह एक विशेष चरित्र है)। यह आसानी से "मैच से पहले" $`, "मैच" $&, और "मैच के बाद" में स्ट्रिंग को विभाजित करता है $'। चक्रीय खोज में, हमने मैच से पहले प्रत्येक चरित्र को स्पष्ट रूप से देखा और उन्हें वापस स्टैक में डाल दिया। हमने वर्तमान चरित्र भी देखा, लेकिन इसे वापस नहीं रखा। इसलिए हम "मैच से पहले" को "देखी गई" सूची में जोड़ते हैं $zऔर "मैच के बाद" के बाद "मैच से पहले" के बाद स्टैक का निर्माण करते हैं।

Answer 14

SNOBOL4 (CSNOBOL4) , 98 बाइट्स

	S =INPUT
	L =INPUT
R	S LEN(1) . X REM . S	:F(END)
	OUTPUT =X
	L POS(0) X =	:S(R)
	S =S X	:(R)
END

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

प्रत्येक पत्र को एक नई रेखा पर प्रिंट करता है। एक ही लाइन पर प्रिंट करने के लिए सब कुछ पाने के लिए इस संस्करण का उपयोग करें । इनपुट को स्टैक के रूप में लेता है, फिर लक्ष्य, एक नई रेखा द्वारा अलग किया जाता है।

	S =INPUT			;*read stack
	L =INPUT			;*read letters
R	S LEN(1) . X REM . S	:F(END)	;*set X to the first letter of S and S to the remainder. If S is empty, goto END.
	OUTPUT =X			;*output X
	L POS(0) X =	:S(R)		;*if the first character of L matches X, remove it and goto R
	S =S X	:(R)			;*else put X at the end of S and goto R
END

Answer 15

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

के लिए शामिल +4है-lF

STDIN पर इनपुट को लक्ष्य के रूप में दें फिर स्टैक करें (यह उदाहरणों से रिवर्स ऑर्डर है):

(echo daceb; echo aecdb) | perl -lF -E '$a=<>;say,$a=~s/^\Q$_//||push@F,$_ for@F'

यदि आपको इस 40काम में कोई नई बात याद नहीं है :

(echo daceb; echo aecdb) | perl -plE '$_=<>=~s%.%s/(.*)\Q$&//s;$_.=$1;$&%reg'