पीएसी मैन इस स्ट्रिंग खा सकते हैं?

Question

खेल के आर्केड संस्करण में, पीएसी मैन पीएसी डॉट्स खाता है। हालांकि, इस चुनौती में, वह अल्फ़ान्यूमेरिक वर्णों और एक स्ट्रिंग में विराम चिह्न के लिए भूखा है।

आपका कार्य एक ऐसा कार्य बनाना है जो पीएसी-मैन को एक स्ट्रिंग खिलाता है, मूल्यांकन करता है कि क्या वह इसे खा सकता है या नहीं, और इसमें पीएसी-मैन के स्थान के साथ स्ट्रिंग लौटाता है।

पीएसी मैन ( <) बाएं से दाएं पात्रों को खाता है, प्रत्येक चरित्र के लिए एक अंडरस्कोर या स्पेस छोड़कर वह जाता है, और उसका लक्ष्य पहली स्थिति -1 से अंतिम स्थिति + 1 तक प्राप्त करना है:

1. <Pac
2. _<ac
3. __<c
4. ___<

हालांकि, पीएसी-मैन का प्राकृतिक दुश्मन, भूत, उसे रोक देगा यदि वह "GHOST" शब्द में एक पत्र का सामना करता है (मामला संवेदनशील नहीं)। आपका कार्य पीएसी-मैन के स्थान के साथ स्ट्रिंग को वापस करना चाहिए क्योंकि वह ghostचरित्र का सामना करता है:

1. <No!
2. _<o!

केवल एक चीज जो भूत को हरा सकती है, वह एक बिजली की गोली है। यदि भूत में आने से पहले पीएसी-मैन शब्द "PELLET" (संवेदनशील होने पर भी संवेदनशील नहीं है) में एक पत्र तक पहुंचता है , तो वह भूत को खाएगा और चलता रहेगा, और उस गोली का उपयोग किया जाएगा। पावर छर्रों को ढेर कर सकते हैं (यानी, ppggदोनों भूतों को खाया जाएगा)। टी चरित्र, दोनों एक भूत और एक गोली के रूप में के रूप में मौजूद है, तो यह ध्यान नहीं दिया जा सकता है (किसी अन्य पत्र के रूप में इलाज, जैसे a)।

1. <Pop
2. _<op
3. __<p
4. ___<

आगे स्पष्ट करने के लिए, स्ट्रिंग में "पीएसी-मैन यहां हार जाता है", निम्नलिखित ऑपरेशन होते हैं:

P <P, +1 Pellet (1 pellet)
a <a
c <c
- <-
M <M
a <a
n <n
  <[space]
l <l, +1 Pellet (2 pellets)
o <o, -1 Pellet (1 pellet)
s <s, -1 Pellet (0 pellets)
e <e, +1 Pellet (1 pellet)
s <s, -1 Pellet (0 pellets)
  <[space]
h <h, ghost wins, returns
e
r
e

उदाहरण

Input: Pacman wins!
Output: ____________<

Input: Pacman loses wah-wah :(
Output: _______________<h-wah :(

Input: PELLET PELLET GHOST
Output: ___________________<

Input: Hello World!
Output: <Hello World!

Input: <_!@12<_<_<
Output: ___________<

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

Comments

तो छर्रों की कोई समाप्ति तिथि नहीं है?

— R

क्या आउटपुट में अनुगामी सारणियां स्वीकार की जाती हैं?

— काटेंको

इस तथ्य के लिए +1 कि "यहां" जहां पैक्मैन खोता है। चतुर परीक्षण का मामला।

— ओलिवियर दुलक

> [I] इस चुनौती के कारण, वह एक स्ट्रिंग में अल्फ़ान्यूमेरिक वर्ण और विराम चिह्न के लिए भूखा है। ... याक -मन?

— काज

अब मैं हर बार जब मैं <प्रतीक को देखता हूं तो काले होंठों वाला एक छलावा ग्रे

— पैक्मैन दिखाई देता है

Answer 1

जेली, 34 33 बाइट्स

Œl“ʋʋ“ṁḍ»ċ€Ð€IF+\‘0ṭi0ð’”_×;”<;ṫ@

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

मुझे लगता है कि मैं आखिरकार जेली को समझना शुरू कर रहा हूं। थोड़ा डर लगता है।

Comments

मुझे चिंता होगी जब आप इसे धाराप्रवाह पढ़ सकते हैं :)

— quetzalcoatl

Answer 2

रेटिना , 55 38 बाइट्स

i`^(([elp])|[^ghos]|(?<-2>.))*
$.&$*_<

इसे ऑनलाइन आज़माएं! (पहली पंक्ति सिर्फ एक बार में कई परीक्षण मामलों को चलाने की अनुमति देती है।)

व्याख्या

समस्या अनिवार्य रूप से सबसे लंबे समय तक उपसर्ग खोजने के लिए है जिसमें एक बेजोड़ समापन कोष्ठक नहीं है। सिवाय इसके कि हम या तो उपयोग कर सकते हैं e, lया pके स्थान पर (और या तो g, h, oया sके स्थान पर )।

इसलिए, यह समाधान समूहों के संतुलन का एक पाठ्यपुस्तक उदाहरण है। मैं इस बारे में बहुत अधिक विस्तार में नहीं जाऊंगा कि वे कैसे काम करते हैं, क्योंकि यह कोड अनिवार्य रूप से मानक उदाहरण के रूप में है जो आप संतुलन समूहों पर मेरे एसओ उत्तर में पढ़ सकते हैं ।

इसलिए पूरा कार्यक्रम एकल रेगेक्स प्रतिस्थापन है। iको सक्रिय करता है मामला-असंवेदनशीलता। फिर हम या तो एक पेलेट के साथ मैच करते हैं [elp]और गहराई काउंटर (समूह के कैप्चर स्टैक के रूप में 2) में वृद्धि करते हैं, या हम किसी ऐसी चीज से मेल खाते हैं जो भूत के साथ नहीं है [ghos]या हम एक भूत के साथ मेल खाते हैं .और स्टैक से पॉपिंग करके गहराई काउंटर को घटाते हैं। 2। बेशक, सिद्धांत रूप में यह [^ghos]अनुभाग के साथ एक पेलेट को मिलान करने की अनुमति देता है या अनुभाग के साथ एक गैर-भूत ., लेकिन लालची मिलान के लिए धन्यवाद और जिस तरह से रेग्जिट को वापस किया जाता है, इन संभावनाओं को रेगेक्स इंजन द्वारा कभी प्रयास नहीं किया जाता है।

तब प्रतिस्थापन दो रेटिना विशिष्ट विशेषताओं का उपयोग करता है: $*चरित्र को उसके दाईं ओर दोहराता है जितना कि उसके बाईं ओर टोकन द्वारा निर्दिष्ट किया जाता है। वह टोकन $.&जो पूरे मैच की लंबाई है। इसका मतलब यह है कि हम मैच के प्रत्येक अक्षर को एक के साथ बदल देते हैं _। और फिर हम <उन अंडरस्कोर को भी जोड़ते हैं । इनपुट का वह हिस्सा जो केवल नहीं खाया जाता है, प्रतिस्थापन द्वारा अप्रभावित रहता है।

Comments

समूहों पर कब्जा करने का अच्छा दुरुपयोग!

— लीक नून

@LeakyNun दुर्व्यवहार? यही संतुलन समूहों के लिए बनाया जाता है। : डी

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

अरे देखो, एक रेटिना जवाब यह है कि दूर से की तरह regex दिखता है मैं उपयोग

— बिल्ली

Answer 3

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

s=raw_input()
p=i=0
for c in s:
 p+=(c in'plePLE')-(c in'ghosGHOS')
 if p<0:break
 i+=1
print'_'*i+'<'+s[i:]

Comments

आपका फंक्शन लौटता है None, जवाब नहीं। और आप 107 की गिनती कैसे करते हैं? मेरी गिनती 110 है।

— स्टीफन पोचमैन

@StefanPochmann डबल-स्पेस टैब हैं और इसे वापस करने के बजाय उत्तर को प्रिंट करने की अनुमति है

— ब्लू

@ मुड्डीफिश आह, धन्यवाद। वे यहाँ टैब नहीं लगते, हालाँकि, तब भी नहीं जब मैं "एडिट" करता हूँ। और समस्या स्पष्ट रूप से "वापसी" कहती है ... क्या साइट-व्यापी नियम इसे या तो ओवररेल कर रहे हैं? (मैं यहाँ बहुत नया हूँ और नहीं जानता हूँ)

— स्टीफन पोचमैन

@StefanPochmann टैब एसई द्वारा खाए जाते हैं (सामान्य रूप से 4 स्थानों में परिवर्तित)। जब तक किसी फ़ंक्शन में स्पष्ट रूप से निर्दिष्ट मुद्रण की अनुमति नहीं है। ओपी को शायद यह ओवरराइड करने का मतलब नहीं था

— ब्लू

मुझे लगता है कि यह कहना वाजिब है कि यह हमेशा होना चाहिए अगर यह एक फ़ंक्शन है या स्टडिन और प्रिंट से पढ़ें। मैं स्टड से रीडिंग में बदलूंगा, जो वैसे भी कम होना चाहिए।

— अर्फि

Answer 4

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

कभी-कभी पायथन को एक कार्यात्मक भाषा बनाने के लिए मेरे दृढ़ संकल्प का इसके फायदे हैं।

def f(s,l=1):l+=(s[:1]in'plePLE')-(s[:1]in'ghosGHOS');return s*l and'_'+f(s[1:],l)or'<'+s

(थोड़ा सा) अपढ़:

def f(s, l=1):
    l += (s[:1] in 'plePLE') - (s[:1] in 'ghosGHOS')
    return (s * l) and ('_' + f(s[1:], l)) or ('<' + s)

पुनरावर्ती का उपयोग करके परिणाम स्ट्रिंग बनाता है। l("जीवन" के लिए) अद्यतन छर्रों के लिए 1 जोड़ता है ( True - False == 1), भूतों के लिए 1 घटाता है ( False - True == -1), और किसी अन्य वर्ण के लिए 0 जोड़ता है। यह 0 भी जोड़ता है जब sखाली स्ट्रिंग होती है, पायथन के स्लाइसिंग और इस तथ्य के लिए धन्यवाद '' in any_str == True, ताकि गोली और भूत रद्द हो जाए।

वापसी विवरण एक बाइट को बचाने test and b or aके a if test else bलिए उपयोग करता है । रिकर्सन बेस केस तब होता है जब या तो स्ट्रिंग समाप्त हो जाती है या पीएसी-मैन छर्रों से बाहर निकलता है, सफलतापूर्वक प्रतिनिधित्व किया जाता है s*p, जो या ''तो जब बराबर होता है (और इसलिए गलत का मूल्यांकन करता है) ।s == ''p == 0

Answer 5

सी #, 269 256 232 212 211 बाइट्स

पहले कभी यहाँ पर पोस्ट करें, इसलिए यह शायद बहुत लंबा है जितना कि यह हो सकता है (और शायद इसलिए कि यह C # में है)। जहाँ मैं इसे छोटा कर सकता हूँ पर कोई सुझाव बहुत अच्छा होगा!

टिप्पणी में सभी को धन्यवाद जिन्होंने मेरी मदद की!

गोल्फ संस्करण

static void p(string x){int p=0,i=0;string t='<'+x;var s=t.ToCharArray();for(;++i<s.Length;){if("PELpel".Contains(s[i]))p++;if("GHOSghos".Contains(s[i])&&--p<0)break;s[i]='<';if(i>0)s[i-1]='_';}Console.Write(s);}

अनप्लग्ड संस्करण

static void p(string x) {
 int p = 0, i = 0;
 string t = '<' + x;
 var s = t.ToCharArray();
 for (; ++i < s.Length;) {
  if ("PELpel".Contains(s[i])) p++;
  if ("GHOSghos".Contains(s[i]) && --p < 0) break;
  s[i] = '<';
  if (i > 0) s[i - 1] = '_';
 }
 Console.Write(s);
}

Comments

आप संस्करण-कीवर्ड का उपयोग करके प्रकारों को चर में बदल सकते हैं। उदा। var अस्थायी = '' + इनपुट; लूप के लिए 4 वर्णों को बचाने के लिए फिर से लिखा जा सकता है: (var i = 0; i ++ <s.Length;)

— CSharpie

आप अल्पविराम का उपयोग घोषणाओं के लिए कर सकते हैं "int i = 0, p = 0; string P =" PELpel ", G =" GHOSghos ", t = '' + x;" और @CSharpie से परिवर्तन, लूप को "के लिए (; i ++ <s.Length;)" बना रहा है। इसके अतिरिक्त, आप "Console.Write (s);" सीधे कुल 235 बाइट्स के लिए।

— निकसन

मुझे लगता है कि इसे else5 और पात्रों को बचाने के बिना भी काम करना चाहिए । और i = 1आप पर लूप शुरू करके आखिरी को निकालने में सक्षम होना चाहिए, क्योंकि कोड को हर बार निष्पादित किया जा सकता है।

— फ्रोज़न

आप अपने सी घोषणा से छुटकारा पा सकते हैं और सिर्फ s[i]5 वर्णों तक पहुंच को रोक सकते हैं।

— जस्टिनएम -

क्या यह काम करने लायक है P="PELpel"और G="GHOSghos"? आप केवल एक बार उनका उपयोग करते हैं। क्या मुझे कुछ याद आ रहा है, या वह सिर्फ 4 अतिरिक्त किरदार हैं? इसके अलावा, क्या आप की जरूरत है else? "PELpel".Contains(c)और "GHOSghos".Contains(c)पारस्परिक रूप से अनन्य होना चाहिए।

— jpmc26

Answer 6

पायथ, 53 48 44 बाइट्स

4 बाइट्स के लिए @ Pietu1998 के लिए धन्यवाद !!@-> }ट्रिक (जो केवल वे लोग जानते हैं जो पाइथ को समझ सकते हैं)

++ * Jf <@ + sM._m - !! @ d "PELpel" !! @ d "GHOSghos" Q_1T00 \ _ \ _> QJ 
++ * Jf <@ + sM._m - !! d "PEL" !! !! @ d "Ghos" rQ1_1T00 \ _ \ <> QJ
++ * जेएफ <@ + sM._m-} d "PEL"} d "Ghos" rz1_1T00 \ _ \ <> ZJ

परीक्षण सूट।

Comments

जिसे केवल वे लोग जानते हैं जो पाइथ को अच्छी तरह से समझ सकते हैं , जैसे बाकी के बहुत सारे कोड, स्वाभाविक रूप से

— लुइस मेंडेन

@LuisMendo उन लोगों के प्रति निष्पक्ष होना, जो पाइथ को नहीं जानते हैं, मुझे पूरा यकीन है कि उनमें से अधिकांश यह समझ सकते हैं कि एक एकल सेट के बीच सेट चौराहे और किसी अन्य सदस्य के एकल सेट के सदस्य के बराबर है। बड़ा सेट: P

— FryAmTheEggman

@FryAmTheEggman तो जाहिर !!@है }, के लिए सिर्फ एक ट्रिगर है , है ना? : पी

— १

Answer 7

MATL , 37 36 35 बाइट्स

tkt'ghos'mw'pel'm-Ys1=Y>&)g95*60bhh

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

व्याख्या

tkt      % Input string implicitly. Duplicate, convert to lower case, duplicate
'ghos'm  % True for "ghost" characters
w'pel'm  % Swap to bring lowercase copy to top. True for "pellet" characters
-Ys      % Subtract, cumulative sum. Pac-Man can reach until the first "1"
1=       % True for entries that equal 1
Y>       % Cumulative maximum. This gives false until the first true is found, and
         % true from there on
&)       % Split original string in two parts, given by the zeros and ones respectively
g95*     % Convert the first part into ones and multiply by 95. This gives a numerical
         % array containing number 95 (ASCII for '_')
60       % Push 60 (ASCII for '<')
b        % Bubble up second part of original string
hh       % Concatenate the three strings/arrays, automatically converting to char

Answer 8

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

s=>s.replace(/./g,c=>p<0?c:(p+=/[elp]/i.test(c)-/[ghos]/i.test(c))<0?"<"+c:"_",p=0)+"<".slice(p<0)

स्पष्टीकरण: pछर्रों की वर्तमान संख्या को बनाए रखता है। यदि यह पहले से ही नकारात्मक है, तो हम केवल चरित्र को वापस करते हैं और आगे बढ़ते हैं, ताकि बाकी स्ट्रिंग अछूता हो। अन्यथा, हम वर्तमान चरित्र की जांच करते हैं, और यदि वह pनकारात्मक हो जाता है, तो हम <चरित्र को सम्मिलित करते हैं, अन्यथा हम वर्तमान चरित्र को बदलते हैं _। अंत में, अगर pकभी नकारात्मक नहीं होता है , तो हम <स्ट्रिंग के लिए प्रत्यय देते हैं ।

Answer 9

पायथ, 47 46 44 बाइट्स

++*\_Kh+f!h=+Z-}Jr@zT0"pel"}J"ghos"Uzlz\<>zK

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

लीके नन का काफी अलग दृष्टिकोण है, और मुझे पूरा यकीन है कि इसे और आगे बढ़ाया जा सकता है।

Comments

का प्रयोग करें Zबजाय Gऔर परिवर्तन f!करने के लिएf!h

— लीकी नून

@LeakyNun बस एक और टैब में भी लगा। धन्यवाद।

— PurkkaKoodari

मुझे लगता है कि tमें "ghost"हटा दिया जाना चाहिए

— लीकी नून

यदि हम अपने समाधानों को बनाए रखते हैं, तो हमारे समाधानों के बीच अंतर क्या है?

— लीक नून

@LeakyNun मुझे यकीन नहीं है कि इनमें से कौन करीब है, लेकिन मेरा पहला प्रयास मुझे 43 बाइट्स मिला , और मुझे नहीं लगता कि मुझे तीसरा उत्तर जोड़ने की आवश्यकता है। शायद हमें पायथ चैटरूम में एक साथ काम करना चाहिए?

— FryAmTheEggman

Answer 10

लुआ, 198 190 184 185 163 बाइट्स

ठीक है, मैं मानता हूं, यह लंबा है। बहुत लम्बा। लुआ के पास तार के साथ खेलने के लिए कुछ उपकरण हैं, लेकिन यह सीमित है, वही सशर्त के लिए जाता है जो बहुत सारे स्थान लेता है।

संपादित करें: धन्यवाद @LeakyNun मुझे 9 बाइट बचाने के लिए :) एक बग को ठीक करने के लिए कुछ बाइट्स खो दिया

संपादित 2: 163 बाइट्स समाधान @LeakyNun द्वारा पाया गया

i=0p=0n=...for c in n:gmatch"."do
p=p+(c:find"[ghosGHOS]"and-1or c:find"[pelPEL]"and 1or 0)if p<0then
break else i=i+1 end end print(('_'):rep(i)..'<'..n:sub(i+1))

पुराना 185

p=0z=(...):gsub(".",function(c)p=p+(c:find"[ghosGHOS]"and-1or
c:find"[pelPEL]"and 1or 0)s=p<0 and 1or s
return s and c or'_'end)_,i,s=z:find"(_+)"print((s or'')..'<'..z:sub(1+(i or 0)))

Ungolfed

i=0                        -- number of characters eaten
p=0                        -- pellet counter
n=...                      -- shorthand for the argument
for c in n:gmatch"."       -- iterate over each characters in the input
do
  p=p+(c:find"[ghosGHOS]"  -- if the current char is a GHOST
        and-1              -- decrement the pellet counter
      or c:find"[pelPEL]"  -- if it's a PELLET
        and 1              -- increment it
      or 0)                -- else, leave it alone
  if p<0                   -- if we try to eat a ghost without pellet
  then 
    break                  -- stop iterating
  else
    i=i+1                  -- else, increment our score
  end
end

print(('_'):rep(i)         -- print i*'_'
  ..'<'                    -- appended with Pacman
  ..n:sub(i+1))            -- appended with the remaining characters if we died

Comments

d=c:lower()अपरकेस वर्णों को निकालें और खोजें

— Leaky Nun

and 1or s and 1or s s and s

— लीक नून

@LeakyNun ने यह नहीं देखा कि यह केवल सभी पत्र लिखने के लिए छोटा होगा ... धन्यवाद। इसके अलावा, दूसरी टिप्पणी में कुछ बदलाव का उल्लेख किया गया था, लेकिन केवल असंबद्ध में> _ <

— काटनेंको

print(('').rep('_',i)..','..z:sub(i+1))

— लीक नून

@ LeakyNun मैं एक समान समाधान के आस-पास काम कर रहा हूं, लेकिन समस्या इस तथ्य से आती है कि iहो सकता हैnil

— Katenkyo

Answer 11

पायथन 3, 176 157 150 149 134 133 124 बाइट्स

एक फ़ंक्शन को परिभाषित करें fजो स्ट्रिंग को तर्क के रूप में लेता है

def f(s):
 n=i=0
 for c in s:
  if c in"GgHhOoSs":
   if n:n-=1
   else:break
  n+=c in"PpEeLl";i+=1
 return"_"*i+"<"+s[i:]

शायद और अधिक गोल्फ हो सकता है

टिप्पणी करने वाले सभी को धन्यवाद: डी

Comments

﹐ x=c.upper()लोअरकेस मैचों के लिए निकालें और खोजें

— लीक नून

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

— डेनकर

n=i=0, नहीं n=0और i=0। t[i]="_"के बजाय t[i] = "_", के लिए एक ही t[i] = "<"। return''.join(t), उस जगह को हटा दें।

— 11

@LeakyNun वृषण में अपरकेस है।

— TuxCrafting

@ T @xCräftîñg नहीं, उनका मतलब है "GgHhOoSs"और "PpEeLl"।

— आउटगोल्फर

Answer 12

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

मेरा पहला कोड गोल्फ।

4 बाइट बचाने के लिए डॉ। ग्रीन एग्स और आयरन मैन का धन्यवाद।

l,x=1,0
f,y,s="ghosGHOS","pelPEL",input()
while s[x:]*l:l+=(s[x]in y)-(s[x]in f);x+=l>0
print("_"*x+"<"+s[x:])

एक तार्किक और एक गुणा करने के लिए एक और शून्य करने के लिए बूलियन के मूल्यांकन का उपयोग करता है। (0 * 0 = 0, 1 * 0 = 0, 1 * 1 = 1)। मुझे उम्मीद है कि यह एक अच्छा पहला प्रयास है।

Comments

अच्छा जवाब, और साइट पर आपका स्वागत है! अजगर का कौन सा संस्करण आप उपयोग कर रहे हैं? आप इसे निर्दिष्ट करना चाह सकते हैं। इसके अलावा, मैंने इसका परीक्षण नहीं किया है, लेकिन आप while s[x:]*l4 बाइट लेने में सक्षम हो सकते हैं ।

— DJMcMayhem

Answer 13

पॉवरशेल, 185

{$l=1;$o="";for($i=0;($i -lt $_.Length) -or (($o+="<") -and 0); $i++){if ($_[$i] -match '[pel]'){$l++}if($_[$i] -match '[ghos]'){$l--}if(!$l){$o+="<"+$_.substring($i);break}$o+="_"}$o}

Ungolfed:

("Pacman wins!",
"Pacman loses wah-wah :(",
"PELLET PELLET GHOST",
"Hello World!"
) | 
% {
    $l=1;$o="";
    for($i = 0; ($i -lt $_.Length) -or (($o+="<") -and 0); $i++) {
        if ($_[$i] -match '[pel]') { $l++ }
        if ($_[$i] -match '[ghos]') { $l--}
        if (!$l) { $o+="<"+$_.substring($i); break }        
        $o += "_"
    }
    $o
}

Answer 14

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

तर्क 's' एक तार है

def f(s):
    p=c=0
    for i in s:
        if i in "gGhHoOsS":
            if p<1:break
            else:p-=1
        if i in "pPeElL":p+=1
        c+=1
    return"_"*c + "<" + s[c:]

मैं किसी भी गोल्फ टिप्स की सराहना करूंगा क्योंकि यह मेरा पहला कोड गोल्फ प्रयास है

टिप्पणी के लिए धन्यवाद :)

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! कुछ सुझाव: ऑपरेटरों के बीच बहुत अधिक गैर-जरूरी व्हाट्सएप हैं। उन्हें हटाने से बाइट्स की एक अच्छी मात्रा बच जाएगी। इसके अलावा आप पायथन 2 का उपयोग कर सकते हैं, जो आपको पहले वाले स्तर के रूप में रिक्त स्थान का उपयोग करने की अनुमति देता है और अन्य लोगों के लिए टैब।

— डेनकर

आप पहली बार जगह ले सकता है return "_"*c + "<" + s[c:]सिर्फ एक साथ breakके रूप में है कि कोड वैसे भी पाश के लिए के बाद निष्पादित किया जाएगा।

— अरफी जूल

इसे ऑनलाइन आज़माएं! मुझे 183 बाइट्स मिलीं। वहाँ एक अनुगामी newline आप गिना जाता है?

— पावेल

Answer 15

हास्केल, 119 113 बाइट्स

6 बाइट्स के लिए डैनियल वैगनर को धन्यवाद।

p=(0!)
n!(c:s)|elem c"ghosGHOS"=if n<1then '<':c:s else(n-1)&s|elem c"elpELP"=(n+1)&s|0<1=n&s
_!_="<"
n&s='_':n!s

के रूप में बुलाओ p "Hello World!"।

1thenबढ़त मामले कि मेरे GHC (7.10) में सही ढंग से व्याख्या की है, लेकिन यह अधिकांश सिंटैक्स हाइलाइटर का फेंकता है। तो यह आपके कंपाइलर में भी अलग तरह से व्याख्या की जा सकती है।

Ungolfed:

pacman string = go 0 string

-- | In the golfed version: (!)
go _   []                   = "<"                            -- won
go pellets (char:string)
 | char `elem` "ghosGHOS"
 = if pellets < 1        then '<':char:string                -- lost
                         else nextStep (pellets - 1) string  -- ghost
 | char `elem` "elpELP"
 =                            nextStep (pellets + 1) string  -- pellet
 | otherwise
 =                            nextStep  pellets      string  -- anything else

-- | In the golfed version: (&)
nextStep pellets string = '_':(go pellets string)

Comments

आप सभी गार्ड को एक ही लाइन पर रखकर कुछ बाइट्स बचा सकते हैं, जैसे n!(c:s)|elem c"blah"=blah|elem c"blah"=blah|0<1=blah।

— डैनियल वैग्नर

@ डैनियल वैगनर अच्छा टिप, धन्यवाद!

— मैरलिन

क्या आप एक TIO लिंक जोड़ सकते हैं ? जब मैं इसे काम करने की कोशिश करता हूं तो मुझे त्रुटियाँ मिलती रहती हैं।

— पावेल

Answer 16

सी, 237 बाइट्स

#include<stdio.h>
#include<string.h>
main(p,i,j){char s[99];fgets(s,99,stdin);for(p=i=0;s[i];++i){if(strchr("GHOSghos",s[i])){if(p)p--;else break;}else if(strchr("PELpel",s[i]))p++;}j=i-(s[i]==0);while(j--)printf("_");printf("<%s",s+i);}

Answer 17

सी ++, 315 373 327 बाइट्स

(नोट: अभी भी गोल्फ)

#include <iostream>
#include <string>
using namespace std;
int main(){string input;getline(cin, input);
if(input.find("Pac-Man loses")!=string::npos||input.find("Pacman loses")!=string::npos)
    cout<<"<"<<input.substr(15,input.length()-1);
else{for(unsigned i=0;i<=input.length();++i)
    cout << "_";
cout<<"<";
}return 0;
}

Comments

पीएसी-मैन हार नहीं रहा है जब यह माना जाता है।

— tildearrow

हाय @tildearrow, मेरे कोड की समीक्षा करने के लिए धन्यवाद! मैं अपनी पोस्ट को अपडेट करूंगा।

— तच्मा

मुझे लगता है कि यह अधिक गोल्फ हो सकता है। के बाद नई-पंक्तियों / रिक्त स्थान निकालने का प्रयास करें if(), और चारों ओर रिक्त स्थानों को हटाकर !=, ||, =, -, और <=। इसके अलावा, के cin>>inputबजाय काम नहीं करता है getline? आप आस-पास घनीभूत भी कर सकते हैं ;।

— NoOneIsHere

@NoOneIsHere, आपकी टिप्पणी के लिए धन्यवाद! मैं कोड-गोल्फिंग के लिए वास्तव में नया हूं, इसलिए मैं अपने कोड को कुछ और गोल्फ करने की कोशिश करूंगा और अपनी पोस्ट को अपडेट करूंगा। यदि आपके पास कोड-गोल्फिंग पर कोई अन्य उपयोगी सलाह है, तो मैं वास्तव में इसकी सराहना करूंगा।

— तच्मा

आप C / C ++ गोल्फिंग के लिए टिप्स देख सकते हैं ।

— NoOneIsHere

Answer 18

रूबी, (119 बाइट्स)

q=i=0;a=$**" ";a.split(//).each{|c|q+=((c+?p=~/[ple]/i)^1)-((c+?g=~/[ghos]/i)^1);q<0?break : i+=1};p ?_*i+?<+a[i..-1]

वहाँ शायद कुछ चीजें मुझे याद आ रही हैं क्योंकि मैं इस के लिए नया हूँ ...

रूबी मेरी दोस्त है :)

Comments

PPCG में आपका स्वागत है!

— फ्लिपकैक

Answer 19

पर्ल, 54 (52 + 2) बाइट्स

s/([pel](?1)*[ghos]|[^ghos
])*/'_'x(length$&).'<'/ei

-pकमांड-लाइन विकल्पों में निर्दिष्ट करने की आवश्यकता है।

स्पष्टीकरण:

-pविकल्प बयान, रीड-संशोधित प्रिंट पाश, जहां प्रत्येक पाश यात्रा के दौरान, में लिपटे होने के लिए कारण बनता है $_लाइन सीमांकक सहित इनपुट की एक पंक्ति, शामिल हैं।

रेगीक्स मोटे तौर पर रेटिना के उत्तर के समान ही विचार है।

खोज पैटर्न को कॉल करें ([pel](?1)*[ghos]|[^ghos ])* "स्वीकार्य" कहें। फिर इसे निम्न रूप से परिभाषित किया जा सकता है:

एक स्ट्रिंग "स्वीकार्य" है यदि:

• यह एक पात्र को PELLETछोड़कर है T, इसके बाद स्वीकार्य स्ट्रिंग है, इसके बाद एक चरित्र को GHOSTछोड़करT ।
• यह एक ऐसा पात्र है जिसमें नहीं है GHOST सिवाय इसके Tकि ।
• यह स्वीकार्य तारों के किसी भी संख्या (0 सहित) का एक संयोजन है।

यह परिभाषा भूत की तुलना में अधिक छर्रों की अनुमति देती है: ए PEL चरित्र को या तो एक गोली चरित्र, या एक गैर-भूत चरित्र के रूप में मिलान किया जा सकता है।

खाली स्ट्रिंग स्वीकार्य माना जाता है, इसलिए रेगेक्स को स्थिति 0 पर मैच करने की गारंटी दी जाती है, जहां सबसे लंबे समय तक स्वीकार्य सबस्ट्रिंग का मिलान किया जाएगा।

इस सबसे लंबे समय तक स्वीकार्य विकल्प को फिर से बराबर लंबाई के अंडरस्कोर द्वारा मिलान किया जाता है, उसके बाद <।

Comments

iirc झंडे की तरह -p एक बाइट के रूप में गिनती।

— पावेल

@Pavel यह जटिल है। यदि -pपहले से उपयोग किए बिना सामान्य आह्वान -, जैसे perl -e-> perl -pe, तो -नि: शुल्क है। लेकिन मुझे लगता है कि perl -eउद्धृत करने के कारण संस्करण लंबा है, इसलिए मुझे लगता है कि मैं यहां इसका उपयोग नहीं कर सकता।

— hvd