इस चुनौती में, पीएसी-मैन से भूतों की एक सूची दी गई है, आपको आउटपुट देना चाहिए कि कौन से भूत गायब हैं। आपको इसे कम से कम बाइट्स में करना चाहिए

इनपुट

इनपुट में एक स्ट्रिंग या सूची शामिल होगी, जिसमें कई भूत शामिल होंगे, जिसमें शामिल हो सकते हैं;

ब्लिंकी
रोशनाई पोता हुआ
कनिष्ठा
क्लाइड

हालाँकि, इनपुट में Pac-Man (विराम चिह्न के साथ) भी शामिल हो सकता है। तो, किसी सूची में अधिकतम आइटम किसी भी क्रम में पाँच होंगे। यह माना जा सकता है कि सूची में कोई भी अमान्य आइटम नहीं होगा

उत्पादन

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

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

input: Clyde
output: Blinky, Inky, Pinky
alternate output: Inky, Pinky, Blinky
or one of the other 4 permutations

input: Clyde, Blinky # or however you delimit it
output: Inky, Pinky
alt: Pinky, Inky

input: Pac-Man, Clyde
Output: Blinky, Inky, Pinky, Clyde
or you could output one of the other 23 permutations

input:[null]
Output: Blinky, Inky, Pinky, Clyde
or you could output one of the other 23 permutations

यह कोडगॉल्फ है, इसलिए बाइट कम है, बेहतर है।

code-golf string

— विनाशकारी नींबू
स्रोत

यदि कोई भूत नहीं हैं, तो क्या इनपुट एक खाली स्ट्रिंग है, या [null]?

— Zizouz212

1

यह एक खाली स्ट्रिंग है।

— विनाशकारी नींबू

5

क्या इनपुट और आउटपुट प्रारूप सख्ती से स्ट्रिंग प्रकार हैं, या हम एक सूची का उपयोग कर सकते हैं? चश्मा कहते हैं कि वे तार हैं, लेकिन फिर उन्हें सूचियों के रूप में संदर्भित किया जाता है।

— एटलसोलॉजिस्ट

6

आम सहमति यह है कि बोझिल / सख्त इनपुट और आउटपुट प्रारूपों से बचा जाना चाहिए । शब्दों को विभाजित करने और जुड़ने से कोड अधिक लंबा हो जाता है और यह वास्तव में मुख्य चुनौती के लिए कुछ भी नहीं जोड़ता है।

— डेनिस

1

पीएसी मैन के साथ आउटपुट गलत नहीं है? क्या आप स्पष्ट कर सकते हो? धन्यवाद

— Hastur

3

जेली , 25 22 बाइट्स

Ff”-ȯ⁸“JLKqḤṢ&F⁻ı»ṣ⁶¤ḟ

यह एक मोनडिक कार्य है। I / O सूचियों के रूप में है। इसे ऑनलाइन आज़माएं!

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

Ff”-ȯ⁸“JLKqḤṢ&F⁻ı»ṣ⁶¤ḟ  Monadic link. Argument: A (list of strings)

F                       Flatten A.
 f”-                    Filter it with the string "-" to detect "Pac-Man".
    ȯ⁸                  Flat logical OR with A. This yields A if there is no '-'
                        in the input, the string "-" otherwise.
                    ¤   Combine the three links to the left into a niladic chain.
      “JLKqḤṢ&F⁻ı»        Yield "Blinky Inky Pinky Clyde", using Jelly's built-in
                          English dictionary.
                  ṣ⁶      Split at spaces to yield
                          ["Blinky", "Inky", "Pinky", "Clyde"].
                     ḟ  Filter-false; removing all elements from that list that
                        appear in A or "-". This is a noop if A contains "Pac-Man".

— डेनिस
स्रोत

आपने किस शब्दकोश का उपयोग किया जिसमें "पिंकी" आदि हैं? XD

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

1

डिफ़ॉल्ट एक जो मेरे ओएस के साथ आया था। पिंकी का मतलब होता है छोटी उंगली का घेरा, इसलिए इसे ज्यादातर शब्दकोशों में मौजूद होना चाहिए। मैं का निर्माण करने के लिए किया था ब्लिंकी के रूप में बी + पंक्ति हालांकि। यकीन नहीं होता कि क्या कड़ी है ...

— डेनिस

15

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

A`-
$
,;BliNClyde,INPiN
N
nky,
D`\w+,
.*;|,$

अनुगामी लाइनफीड महत्वपूर्ण है। इनपुट और आउटपुट अल्पविराम से अलग किए गए हैं।

इसे ऑनलाइन आज़माएं! (पहली पंक्ति एक लाइनफ़ीड-पृथक परीक्षण सूट को सक्षम करती है।)

व्याख्या

मुझे इतनी जल्दी रेटिना के नवीनतम जोड़ (कटौती चरण) को दिखाने में सक्षम होने की उम्मीद नहीं थी, लेकिन यह वास्तव में इस चुनौती के लिए सहायक है। :)

चरण 1: एंटी-ग्रीप

A`-

एंटी-जीआरपी चरण सभी रेखाओं को त्याग देते हैं जो दिए गए रेग्ज से मेल खाते हैं। रेगेक्स बस है -और इनपुट हमेशा एक ही लाइन होता है, इसलिए यह इनपुट होने पर सभी भूतों को हटा देता है Pac-Man।

चरण 2: प्रतिस्थापन

$
,;BliNClyde,INPiN

यह केवल निश्चित स्ट्रिंग को जोड़ता है ,;BliNClyde,INPiN। यह कुछ सफाई के बाद आउटपुट में भूतों की सूची होगी।

चरण 3: प्रतिस्थापन

N
nky,

ध्यान दें कि हमने तीन *nkyभूतों Nको पिछले चरण में लिखा है (और उनके बाद अल्पविराम छोड़ दिया गया है), और अब हम इस शॉर्टहैंड का विस्तार करते हैं, जो एक-दो बाइट्स बचाता है। हर एक भूत के बाद अब एक अल्पविराम होता है, और हमें इनपुट भूत और अर्ध भूत द्वारा अलग किए गए सभी भूतों की सूची मिली है।

चरण 3: डिडुप्लीकेशन

D`\w+,

यह नया हिस्सा है। Deduplication चरणों दिए गए regex के सभी उदाहरणों को ढूंढते हैं और सभी मिलान किए गए सबस्ट्रिंग को त्याग देते हैं जो पहले से मेल खाते हुए प्रतिस्थापन के बराबर हैं। रीगेक्स बस सभी भूतों से मेल खाता है, दोनों इनपुट में और संभावित आउटपुट की सूची में। यदि इनपुट में भूत है, तो उसी भूत को दूसरी सूची में फिर से मिलान किया जाएगा और उसे छोड़ दिया जाएगा। अन्यथा, भूत को दूसरी सूची में पहली बार मिलान किया जाता है और रखा जाता है। तो इसके बाद, अर्धविराम के बाद की सूची हमारा वांछित आउटपुट है। जो कुछ बचा है वह थोड़ा साफ है:

चरण 5: प्रतिस्थापन

.*;|,$

हम बस अर्धविराम के साथ-साथ स्ट्रिंग के अंत में अल्पविराम तक सब कुछ मेल खाते हैं और उन्हें हटा देते हैं।

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

पीएसी मैन मामले के बारे में क्या?

— वैल्यू इंक

2

@ केविनलाउ-केकेनी पहले चरण का स्पष्टीकरण देखें।

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

7

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

lambda s:[x for x in['Blinky','Inky','Pinky','Clyde']if(x in s)<1or'-'in s]

इनपुट एक अल्पविराम से अलग किया गया स्ट्रिंग है, और आउटपुट एक सूची होगी।

— atlasologist
स्रोत

4

if(x in s)<1भाग चालाक है! +1

— डैनियल

6

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

एक अनाम फ़ंक्शन के रूप में

a=>["Blinky","Inky","Pinky","Clyde"].filter(c=>!a.includes(c)|a.some(v=>v[6]))

आज मैंने इस filterफंक्शन के बारे में जाना । मज़ा!

15 बाइट्स ने नील को धन्यवाद दिया।

उपयोग:

(a=>["Blinky","Inky","Pinky","Clyde"].filter(c=>!a.includes(c)||a.includes("Pac-Man")))(["Pac-Man"])
> ["Blinky","Inky","Pinky","Clyde"]
(a=>["Blinky","Inky","Pinky","Clyde"].filter(c=>!a.includes(c)||a.includes("Pac-Man")))(["Pinky"])
> ["Blinky","Inky","Clyde"]
(a=>["Blinky","Inky","Pinky","Clyde"].filter(c=>!a.includes(c)||a.includes("Pac-Man")))([])
> ["Blinky","Inky","Pinky","Clyde"]

— charredgrass
स्रोत

1

Pac-Manफ़िल्टर के बाहर विशेष आवरण के बजाय , मुझे लगता है कि आप इसे a.includes("Pac-Main")||!a.includes(c)फ़िल्टर के रूप में जोड़ सकते हैं , जिस बिंदु पर आपके पास केवल इसका एक उपयोग है gऔर इसलिए इसे इनलाइन कर सकते हैं और अपने ब्लॉक को एक अभिव्यक्ति में बदल सकते हैं और इस प्रकार returnकथन से बच सकते हैं ।

— नील

@ नील महान विचार। मैं बाहर काट करने में सक्षम था returnऔर {}और बाइट्स की एक टन बचा लिया है, धन्यवाद!

— चार

आप अपने बाइट a.includesको a[z="includes"](पहले) और a[z](दूसरे) के साथ बदलकर एक बाइट भी बचा सकते हैं । इसके अलावा, मुझे लगता है कि आप |तार्किक या ( ||) के बजाय अपने बूलियन परिणामों पर बिटवाइज़ OR ( ) का उपयोग करके एक और बाइट बचा सकते हैं ।

— अप्सिलर्स

2

वास्तव में, के बाद से Pac-Manसबसे लंबे समय तक संभव इनपुट है (और गलत निविष्टियों असंभव है), हम के लिए परीक्षण करने के लिए एक सातवें चरित्र के अस्तित्व के लिए परीक्षण कर सकते हैं Pac-Man: c=>!a.includes(c)||a.some(v=>v[6])।

— बिटवाइज के

@apsillers ऊह, यह एक महान है, लंबाई की जांच करने के लिए कभी नहीं सोचा होगा। मैं बिटवाइज़ में बदल गया या जोड़ा, धन्यवाद!

— charredgrass

3

रूबी, 55 49 बाइट्स

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

-MartinEnder से -6 बाइट्स

->a{%w"Blinky Inky Pinky Clyde"-(a*''=~/-/?[]:a)}

रूबी सरणियाँ सेट घटाव से गुजर सकती हैं, जिससे उपयुक्त भूतों को निकालना बहुत आसान हो जाता है।

— मूल्य स्याही
स्रोत

पीएसी मैन के साथ यह कैसा व्यवहार करता है?

— नील

@ यह प्रयोग करके सरणी को एक साथ जोड़ देता है a*''और regex- -नाम में वर्तमान से तुलना करता है Pac-Man। यदि यह मौजूद है, तो यह भूतों की सूची से कुछ भी नहीं घटाता है, और यदि ऐसा नहीं है, तो यह इनपुट सूची को घटाता है (इसलिए इनपुट सूची के प्रत्येक तत्व को भूतों की सूची से हटा दिया जाता है)

— मूल्य इंक

3

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

50 बाइट्स कोड + 1 के लिए -n

for$@(Blinky,Inky,Pinky,Clyde){print$@if/-/|!/$@/}g}

प्रयोग

perl -ne 'for$@(Blinky,Inky,Pinky,Clyde){print$@if/-/|!/$@/}' <<< 'Pac-Man, Clyde'
BlinkyInkyPinkyClyde

यदि आवश्यक हो तो आउटपुट में संशोधन कर सकता हूं, प्रत्येक भूत के बाद एक स्थान जोड़कर, + 3 बाइट्स के print$@साथ प्रतिस्थापित किया जा सकता है print"$@ "।

-6 बाइट्स @MartinEnder को धन्यवाद !

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

51 बाइट्स कोड + 2 के लिए -na

स्मार्टमैच ऑपरेटर का उपयोग करके एक वैकल्पिक समाधान:

print grep/-/~~@F|!($_~~@F),Blinky,Inky,Pinky,Clyde

प्रयोग

इनपुट के लिए अलग स्थान की सूची की आवश्यकता होती है:

perl -nae 'print grep/-/~~@F|!($_~~@F),Blinky,Inky,Pinky,Clyde' <<< 'Clyde Pinky Inky'
Blinky
perl -nae 'print grep/-/~~@F|!($_~~@F),Blinky,Inky,Pinky,Clyde' <<< 'Clyde Pinky Inky Pac-Man'
BlinkyInkyPinkyClyde'

— डोम हेस्टिंग्स
स्रोत

3

पायथ - 45 38 35 बाइट्स

~~=GwI!:G"a")j-["inky""pinky""blinky""clyde")cG~~

I!:=Gw"a")j-c:" p bl clyde"d"inky "dcG

j-c:" p bl clyde"d"inky "d?:z\aZYcz

-1 और बाइट लेकी नन को धन्यवाद!

इनपुट स्थान सीमांकित होना चाहिए, सभी लोअरकेस; पीएसी-मैन इनपुट में होने तक अलग-अलग लाइनों पर भूतों को गायब करता है।

— KoreanwGlasses
स्रोत

आप "पैक-मैन" को भूल गए

— जैक्स मारैस

@JacquesMarais नहीं, यह काम करता है। Z: अगर इनपुट में "a" है तो z \ _ का पता लगाता है, और इनपुट iff pac-man इनपुट में "a" होगा, इनपुट में है

— कोरियाईवग्लास

मैंने Pyth लिंक पर क्लिक किया और जब मैंने "Pac-Man" में प्रवेश किया तो यह काम नहीं किया। जब "पीएसी-मैन" दर्ज किया जाता है, तो उसे सभी नामों को दिखाना चाहिए, उनमें से कोई भी नहीं।

— जैक्स मारैस

@JacquesMarais मेरी गलती। फिक्स्ड।

— कोरियाईवैलग्लास

}\azzपत्र भी शामिल है, तो परीक्षण करता है a। 1 बाइट छोटी।

— जकुबे

3

सी, 171 बाइट्स

स्ट्रिंग्स के एक पूर्ण-समाप्त सरणी को पास करें f(), और यह लापता नामों को प्रिंट करेगा।

*a[]={"Blinky","Inky","Pinky","Clyde",0},**s,**r,n;f(int**p){for(r=p;*p;)r=strcmp(*p++,"Pac-Man")?r:a+4;for(s=a;*s;++s){for(p=r,n=1;n&&*p;)n=strcmp(*s,*p++);n&&puts(*s);}}

इसे आइडोन पर आज़माएं।

— owacoder
स्रोत

2

PowerShell v4 +, 107 बाइट्स

param($n)((($n+($x='Pinky','Inky','Blinky','Clyde')|group|?{$_.count-eq1}).Name),$x)['-'-in[char[]]-join$n]

दूसरों की तुलना में थोड़ा क्लंकी, क्योंकि पावरशेल में एक टर्नरी ऑपरेटर या किसी प्रकार के map-स्टाइल ऑपरेटर का अभाव है । नतीजतन, हम अपना खुद का निर्माण करते हैं।

इनपुट $nको स्ट्रिंग्स के एक स्पष्ट सरणी के रूप में लेता है (उदाहरण के लिए, .\which-ghosts-are-missing.ps1 @('Clyde','Blinky')बाकी प्रोग्राम एक छद्म-टर्नरी है जो एक सरणी से बना है जिसे हम कुछ तर्क के माध्यम से अनुक्रमित करते हैं [...]। तर्क बस यह है कि क्या -चरित्र कहीं भी इनपुट सरणी -joinएड में है। ऑपरेटर charका उपयोग करने के लिए एक स्ट्रिंग में और फिर एक सरणी के रूप में फिर से कास्ट करें -in। इस प्रकार, यदि Pac-Manइनपुट सरणी में है, तो यह होगा $TRUEऔर छद्म-त्रिगुटी सरणी का दूसरा तत्व चुना जाएगा, और पहली इच्छा चुना जाए।

यदि यह ऐसा मामला है जो Pac-Manसरणी में नहीं है, तो छद्म-त्रिगुटी सरणी का पहला भाग आउटपुट है। यह $nसभी भूतों के एक सरणी के साथ संक्षिप्त इनपुट इनपुट का एक संयोजन है (में सहेजा गया $x)। हम पाइप कि नई सरणी में Group-Objectजो आइटम की तरह इच्छा समूह को एक साथ, तो का उपयोग कर चयन Where-Object(के माध्यम से एलियास |?{...}केवल आइटम जहां उनकी .countहै -eqकरने के लिए UAL 1। यही कारण है कि सभी एक कोष्ठक में समझाया है, और हम का चयन .Nameसंपत्ति। यह जहां v4 आवश्यकता में आता है, v4 के तहत आप कुछ का उपयोग करने के बजाय इस तरह से हैशटेबल लेबल को संदर्भित कर सकते हैं |Select Name, जो कई बाइट्स को बचाता है।

अन्यथा, चूंकि Pac-Manइनपुट सरणी में है, हमें सभी भूतों को आउटपुट करने की आवश्यकता है। शुक्र है कि हमने पहले ही उन लोगों को बचा लिया $x, इसलिए इस मामले में यह पसंद है। किसी भी तरह से, पाइपलाइन में अब भूतों का एक स्ट्रिंग सरणी है, और आउटपुट निहित है।

उदाहरण

PS C:\Tools\Scripts\golfing> .\which-ghosts-are-missing.ps1 @('Clyde')
Pinky
Inky
Blinky

PS C:\Tools\Scripts\golfing> .\which-ghosts-are-missing.ps1 @('Pac-Man','Clyde')
Pinky
Inky
Blinky
Clyde

PS C:\Tools\Scripts\golfing> .\which-ghosts-are-missing.ps1 @()
Pinky
Inky
Blinky
Clyde

PS C:\Tools\Scripts\golfing> .\which-ghosts-are-missing.ps1 @('Clyde','Blinky')
Pinky
Inky

— AdmBorkBork
स्रोत

2

पायथन 2, 66 61 96 बाइट्स

g={"Blinky","Inky","Pinky","Clyde"};i=set(input());print",".join(g-i if not"Pac-Man"in i else g)

इनपुट की एक सूची होनी चाहिए, आउटपुट ए द्वारा अलग किए गए नामों की एक स्ट्रिंग होगी ,।

61 बाइट्स संस्करण जो Pac-Man को नहीं संभालते:

print",".join({"Blinky","Inky","Pinky","Clyde"}-set(input()))

— acrolith
स्रोत

8

इस प्रविष्टि में पीएसी-मैन को संभाला नहीं गया है।

— विनाशकारी नींबू

आप की जरूरत नहीं है set[...]। बस एक {...}सेट शाब्दिक का उपयोग करें ।

— डेनिस

मैं वास्तव में 3 बार चुनौती पढ़ने के बाद भी पीएसी-मैन बात पर ध्यान नहीं दिया ... मैं अपना कोड ठीक करूँगा।

— एक्रोलिथ

2

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

import Data.List
p l=(if elem"Pac-Man"l then id else(\\l))["Blinky","Inky","Pinky","Clyde"]

इनपुट स्ट्रिंग्स की एक सूची है। यह निर्णय करता है कि "पीएसी मैन" की उपस्थिति के आधार पर सूची का उपयोग करना है या नहीं।

अतिरिक्त मज़ा के लिए, यहाँ कोई पीएसी मैन नहीं है:

import Data.List
(["Blinky","Inky","Pinky","Clyde"]\\)

जल्द ही इस जवाब में सुधार किया जाएगा, क्या यह देर रात सुपर हो गया।

— Lazersmoke
स्रोत

2

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

lambda i:[g for g in"Blinky Inky Pinky Clyde".split()if g not in i or"-"in i]

यहाँ 89 बाइट्स पर एक और जवाब है कि मैं के साथ खेल रहा था, लेकिन बाहर काम नहीं किया :(

lambda i:[g for g in[s+"nky"for s in"Bli I Pi".split()]+["Clyde"]if g not in i or"-"in i]

और यहाँ 85 बाइट्स पर मूल है:

lambda i,n="Blinky Inky Pinky Clyde":([g for g in n.split()if g not in i],n)["-"in i]

ये सभी रिक्त स्थान / अल्पविराम द्वारा अलग किए गए नामों की एक स्ट्रिंग लेते हैं।

— डैनियल
स्रोत

2

05AB1E, 47 44 बाइट्स

•1g!Z~÷kÅ]°%Ï0›K/•35B0¡™svy'-åi,q}}v¹ykÌiy)˜

explaination

•1g!Z~÷kÅ]°%Ï0›K/•35B0¡™                      # push list of the 4 ghosts
                        svy'-åi,q}}           # if Pac-Man is in input, quit and output list of all 4 ghosts
                                  v¹ykÌiy)˜   # otherwise, generate the list of ghosts missing from input

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

— Emigna
स्रोत

2

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

जैसा कि पहले से ही सेट्स और स्ट्रिंग्स का उपयोग करते हुए पायथन के जवाब हैं, मैंने खुद को सूचियों के साथ काम करने के लिए प्रतिबंधित करने का फैसला किया, जो कि बहुत लंबा और असुविधाजनक निकला। हालाँकि, जैसा कि लिया गया दृष्टिकोण भिन्न है जैसा कि आम इस्तेमाल किया जाता है, यहाँ यह है:

o=['Blinky','Clyde','Inky','Pinky']
p=lambda x:[l for l in reduce(lambda z,x:z+[y+[x]for y in z],o,[[]])if sorted(l+x)==o][0]if'Pac-Man'not in x else o

जहां अपेक्षित इनपुट तार की एक सूची है।

दृष्टिकोण 0,1,2,3 और 4 तत्वों के सभी संभावित संयोजनों (खाते में आदेश के बिना) को रोकना है। इसके द्वारा किया जाता है

reduce(lambda z,x:z+[y+[x]for y in z],o,[[]])

जो लौटता है

[[], ['Clyde'], ['Pinky'], ['Clyde', 'Pinky'], ['Inky'], ['Clyde', 'Inky'],
['Pinky', 'Inky'], ['Clyde', 'Pinky', 'Inky'], ['Blinky'], ['Clyde', 'Blinky'],
['Pinky', 'Blinky'], ['Clyde', 'Pinky', 'Blinky'], ['Inky', 'Blinky'],
['Clyde', 'Inky', 'Blinky'], ['Pinky', 'Inky', 'Blinky'], 
['Clyde', 'Pinky', 'Inky', 'Blinky']]

और जो भूत की पूरी सूची में इनपुट सूची के परिणाम के अलावा, एक पाते हैं।

फिर यह जांचा जाता है कि क्या स्ट्रिंग 'Pac-Man'इनपुट का हिस्सा है और, यदि यह है, तो भूतों की पूरी सूची वापस आ जाती है। यदि नहीं, तो केवल जो इनपुट का हिस्सा नहीं हैं उन्हें वापस लौटा दिया जाता है।

ध्यान दें कि सभी भूत नामों ( o) वाली सूची को वर्णानुक्रम में क्रमबद्ध किया गया है और उसी के रूप में निर्मित सूची के लिए जाता है ( sorted(l+x))। यह इस तथ्य के कारण है कि पायथन ['a','b']==['b','a']में मूल्यांकन किया जाता है, Falseजबकि ['a','b']==['a','b']मूल्यांकन किया जाता है True।

3 बाइट्स को बचाया जा सकता है अगर इसे सूची की सूची के रूप में जवाब वापस करने की अनुमति है ( [0]पहली सूची समझ के अंत में हटाकर )। लेकिन जैसा कि मुझे यकीन नहीं है कि यह एक वैध आउटपुट है जिसे मैं उन्हें गिन रहा हूं।

— Ioannes
स्रोत

2

ऑब्जेक्ट पास्कल, 204 200 बाइट्स

दो छोरों, एक बाइनरी का उपयोग करके यह पता लगाने के लिए कि कौन से भूत + पेसमैन मौजूद हैं। कमांडलाइन से तर्क लेता है। कुछ और बाइट्स बचाने के लिए @manatwork का शुक्रिया!

var a:array[1..4]of string=('Blinky','Inky','Pinky','Clyde');i,s:Byte;begin for i:=1to ParamCount do s:=1<<Pos(ParamStr(i)[4],'nykd-')or s;for i:=1to 4do if(1<<i and s=0)or(s>31)then WriteLn(a[i])end.

Ungolfed:

var
  a: array[1..4] of string = ('Blinky', 'Inky', 'Pinky', 'Clyde');
  i, s: byte;
begin
  for i:=1 to ParamCount do
    s := 1 << pos(ParamStr(i)[4], 'nykd-') or s; // fill bits by shifting, check for unique 4th char of names, '-' in 'pac-man', could also use the 3rd char
  for i:=1 to 4 do
    if (1 << i and s=0) or (s>31) then    // check if bits are on
      writeln(a[i]);
end.

एक सेट का उपयोग करके पुराना संस्करण, 227 209 बाइट्स

दो छोरों, एक सेट का उपयोग करके यह पता लगाने के लिए कि कौन से भूत + पेसमैन मौजूद हैं। कमांडलाइन से तर्क लेता है।

var a:array[1..4]of string=('Blinky','Inky','Pinky','Clyde');i:byte;s:set of 1..5;begin for i:=1to ParamCount do s:=s+[pos(ParamStr(i)[4],'nykd-')];for i:=1to 4do if not(i in s)or(5in s)then writeln(a[i]);end.

Ungolfed:

var
  a: array[1..4] of string = ('Blinky', 'Inky', 'Pinky', 'Clyde');
  i: byte;
  s: set of 1..5;
begin
  for i:=1 to ParamCount do
    s := s + [pos(ParamStr(i)[4], 'nykd-')]; // fill set with indxs
  for i:=1 to 4 do
    if not(i in s) or (5 in s) then    // check indx not in set or pac-man is
      writeln(a[i]);
end.

— hdrz
स्रोत

अच्छा लगा। इसे छोटा करने के कुछ तरीके: integer→ byte; की घोषणा हटाने gऔर सीधे अपने मूल्य का उपयोग करें, ParamCount→ 5(के रूप में मैं काम को समझते हैं, वहाँ कोई दोहराया या अमान्य इनपुट आइटम वैसे भी हो जाएगा)। कम से कम FreePascal संख्यात्मक शाब्दिक, i:=1to 5doया जैसे कीवर्ड को छू सकता है 5in s। देखें कि क्या आपका समर्थन भी करता है।

— मैनटवर्क

मुझे लगता है कि इसके बजाय बिट्स का उपयोग setकरना फायदेमंद होगा: pastebin.com/r2nB5wY3

— मैनटवर्क

@manatwork वाह, हर बार मैं कुछ नया सीखता हूं .. मैं आपके सुझावों को छोड़कर उपयोग कर रहा हूं ParamCount, क्योंकि संख्याओं के लिए व्यवहार अपरिभाषित है, फिर वास्तविक इनपुट परम (कम से कम डॉक्स में इसके बारे में कुछ भी नहीं है), भले ही यह काम करता हो।

— hdrz

1

PHP प्रोग्राम, 84 बाइट्स

<?print_r(array_diff([Blinky,Inky,Pinky,Clyde],in_array('Pac-Man',$argv)?[]:$argv));

कमांड लाइन से तर्क लेता है, प्रिंट एक सरणी के रूप में परिणाम देता है।
फ़ाइलनाम किसी भी भूत या 'पैक-मैन' का नहीं होना चाहिए!
अल्प विराम: हटाएं (यदि 'पीएसी-मैन' तर्कों में है: कुछ नहीं, बाकी सभी तर्क) सभी भूतों से; प्रिंट परिणाम पुनरावर्ती

उदाहरण:

>php -d error_reporting=0 ghosts.php Clyde
Array
(
    [0] => Blinky
    [1] => Inky
    [2] => Pinky
)
>php -d error_reporting=0 ghosts.php Clyde Blinky
Array
(
    [0] => Inky
    [1] => Pinky
)
>php -d error_reporting=0 ghosts.php Pac-Man Clyde
Array
(
    [0] => Blinky
    [1] => Inky
    [2] => Pinky
    [3] => Clyde
)

PHP फ़ंक्शन, 90 बाइट्स

function p($a){return array_diff([Blinky,Inky,Pinky,Clyde],in_array('Pac-Man',$a)?[]:$a);}

एक सरणी लेता है और वापस करता है, खाली इनपुट के लिए खाली सरणी का उपयोग करता है, कोई अन्य गलत मूल्य नहीं है!

आगे के विचार

(-2) के बजाय पता लगाने के in_array(...)साथ बदलेंstrstr(join($argv),'-')-Pac-Man
ereg('-',join($argv))इसके बजाय उपयोग करें (दूसरा -2)
कार्यक्रम PHP <5.4 register_globalsपर साथ एक और 6 बाइट्स खो सकता है
बदल देते हैं: कार्यक्रम अल्पविराम से अलग की सूची प्रिंट बनाने के लिए <?print_r(साथ <?=join(',',(+2)। आप ;echo""पंक्ति विराम के लिए कॉल जोड़ना चाह सकते हैं

— टाइटस
स्रोत

1

jq, 69 वर्ण

("Blinky Inky Pinky Clyde"/" ")as $a|if inside($a)then$a-. else$a end

इनपुट JSON है, आउटपुट JSON है, सशर्त सिंटैक्स दर्द है।

नमूना रन:

bash-4.3$ jq '("Blinky Inky Pinky Clyde"/" ")as $a|if inside($a)then$a-. else$a end' <<< '["Clyde"]'
[
  "Blinky",
  "Inky",
  "Pinky"
]

bash-4.3$ jq '("Blinky Inky Pinky Clyde"/" ")as $a|if inside($a)then$a-. else$a end' <<< '["Pac-Man","Clyde"]'
[
  "Blinky",
  "Inky",
  "Pinky",
  "Clyde"
]

ऑन-लाइन परीक्षण:

— आदमी काम पर है
स्रोत

1

TSQL (sqlserver 2016), 114 बाइट्स

golfed:

DECLARE @ VARCHAR(99) = 'Blinky,Inky,Pinky,Clyde'

SELECT*FROM STRING_SPLIT('Blinky,Inky,Pinky,Clyde',',')EXCEPT SELECT*FROM STRING_SPLIT(@,','WHERE @ NOT LIKE'%-%'

Ungolfed:

DECLARE @ VARCHAR(99) = 'Blinky,Inky,Pinky,Clyde'

SELECT * FROM STRING_SPLIT('Blinky,Inky,Pinky,Clyde',',')
EXCEPT
SELECT * FROM STRING_SPLIT(@,',')
WHERE @ NOT LIKE'%-%'

बेला

— t-clausen.dk
स्रोत

1

लोटस नोट्स @Formula भाषा, 85 84 75 74 वर्ण

@ चरित्र असाइनमेंट उल्टा करके -1 चरित्र

-9 परिवर्तित @Contains (i; "-") से @ लाइक (i; "% -%") और हटा दिया गया @ (यदि सेपरेटर के रूप में स्थान का उपयोग करके प्रदर्शित नहीं किया गया तो आवश्यक नहीं)

-1 न्यूलाइन को हटाकर

दो फ़ील्ड के साथ एक फॉर्म बनाएं: i (टेक्स्ट, एडिटेबल, मल्टी-वैल्यू) और ओ (टेक्स्ट, कंप्यूटेड, मल्टी-वैल्यू)। निम्नलिखित सूत्र को ओ में दर्ज करें:

l:="Inky":"Pinky":"Blinky":"Clyde";@If(@Like(i;"%-%");l;@Replace(l;i;""))

नोट्स क्लाइंट से, फ़ॉर्म का उपयोग करके एक नया दस्तावेज़ बनाएं, i फ़ील्ड में नाम दर्ज करें और दस्तावेज़ को ताज़ा करने के लिए F9 दबाएं। फ़ील्ड ओ में प्रदर्शित उत्तर।

यह इस तथ्य का लाभ उठाता है कि @ लाइक और @ रीप्ले दोनों का उपयोग स्ट्रिंग पर या स्ट्रिंग्स की सूची में किया जा सकता है।

— ElPedro
स्रोत

1

C # ~~135 बाइट्स~~ 126 बाइट्स

string[] g{"Blinky","Inky","Pinky","Clyde"};Console.WriteLine(String.Join(",",i.Contains("Pac-Man")?g:g.Except(i).ToArray()));

(जहां मैं इनपुट युक्त एक स्ट्रिंग सरणी है)

अन्य उदाहरणों को देखने के बाद, मैं देखता हूं कि C # एक क्रियात्मक भाषा है :)

— supermeerkat
स्रोत

1

आप रिक्त स्थान और न्यूलाइन को हटाकर 126 बाइट्स प्राप्त कर सकते हैं।

— एक्रोलिथ जुएल 21'16

1

पायके, 45 39 38 37 32 बाइट्स

.d𖭺𐎪膎㧫l4dc].^D`\-R{!*

यहाँ यह कोशिश करो!

.d𖭺𐎪膎㧫l4dc - dictionary_lookup('blinky inky pinky clyde').title().split()
].^ - xor(^, input)
D`\-R{!* - ^*("-" not in input)

— नीला
स्रोत

1

बैच, 141 बाइट्स

@set g= Blinky Inky Pinky Clyde
@for %%a in (%*)do @if %%a==Pac-Man goto l
@for %%a in (%*)do call set g=%%g: %%a=%%
@l
@echo(%g:~1,-1%

( :~1,-1यदि व्हाट्सएप अग्रणी और अनुगामी है , तो 6 बाइट घटाना स्वीकार्य है।) शीर्षक मामले में पीएसी-मैन की आवश्यकता होती है, लेकिन भूत असंवेदनशील होते हैं।

— नील
स्रोत

0

Japt , 38 बाइट्स (गैर-प्रतिस्पर्धात्मक)

इनपुट को स्ट्रिंग्स की एक सरणी के रूप में लेता है, स्ट्रिंग्स की एक सरणी को आउटपुट करता है

`B¦nky Inky Pky CÒè`¸kUø`Pac-M` ?N:U

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

— झबरा
स्रोत

कौन से भूत गायब हैं?

इनपुट

उत्पादन

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

जेली , 25 22 बाइट्स

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

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

व्याख्या

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

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

रूबी, 55 49 बाइट्स

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

प्रयोग

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

प्रयोग

पायथ - 45 38 35 बाइट्स

सी, 171 बाइट्स

PowerShell v4 +, 107 बाइट्स

उदाहरण

पायथन 2, 66 61 96 बाइट्स

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

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

05AB1E, 47 44 बाइट्स

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

ऑब्जेक्ट पास्कल, 204 200 बाइट्स

एक सेट का उपयोग करके पुराना संस्करण, 227 209 बाइट्स

PHP प्रोग्राम, 84 बाइट्स

jq, 69 वर्ण

TSQL (sqlserver 2016), 114 बाइट्स

लोटस नोट्स @Formula भाषा, 85 84 75 74 वर्ण

पायके, 45 39 38 37 32 बाइट्स

बैच, 141 बाइट्स

Japt , 38 बाइट्स (गैर-प्रतिस्पर्धात्मक)