इनपुट Code सोर्स कोड

70

पहचान

चुनौती एक प्रोग्राम / फ़ंक्शन बनाने की है जो अपने स्वयं के स्रोत कोड और एक दिए गए स्ट्रिंग इनपुट के चौराहे को प्रिंट करता है। यह कोड गोल्फ है और अधिक सटीक होना है:

  • Iइनपुट सेट होने दें
    • {"a","b","c"}
  • Sसोर्स कोड सेट होने दें
    • {"b","f"}
  • फिर चौराहा वे क्या साझा करते हैं
    • I ∩ S = {"b"}

इनपुट

इनपुट लचीला है। यह स्रोत कोड के लिए उपयोग किए जाने वाले वर्ण एन्कोडिंग को संभालने में सक्षम होना चाहिए।

उत्पादन

आउटपुट लचीला है। यह उन वर्णों का समूह होना चाहिए जो इनपुट और स्रोत कोड साझा करते हैं। इसके अलावा, सेट अलग-अलग वस्तुओं के अनियोजित संग्रह हैं। संक्षेप में:

  • आउटपुट लचीला है:
    • किसी भी डेटा संरचना (स्ट्रिंग या अन्यथा) हो सकता है
    • अनियंत्रित हो सकता है
    • एक अनुगामी हो सकता है \n
    • अलग होना चाहिए

बंधन

क्वीन चुनौतियों के समान , प्रोग्राम / फ़ंक्शन अपने स्वयं के सोर्स कोड को नहीं पढ़ सकते हैं और 0-बाइट समाधान की अनुमति नहीं है।

उदाहरण

  • # 1
functor x(I){ return I ∩ self; }

Inputs                                Outputs
------                                -------
enter preformatted text here      ->  {"e","n","t","r","f","o","x"}

["Albrt"," Einstin"]              ->  {"l","r","t","n","s"}
  • # 2
(_)->_&"(_)->&\"\\"

Inputs                                Outputs
------                                -------
"Security at the expense of       ->  "
usability comes at the expense 
of security."

(0____0)                          ->  (_)
  • # 3
ಠa益длф


Inputs                                Outputs
------                                -------
Far out in the uncharted backwaters ->"a"    
of the unfashionable end of the 
Western Spiral arm of the Galaxy lies 
a small unregarded yellow sun. 
Orbiting this at a distance of roughly 
ninety-eight million miles is an 
utterly insignificant little blue-green 
planet whose ape-descended life forms 
are so amazingly primitive that they 
still think digital watches are a pretty 
neat idea.

(ノಠ益ಠ)ノ彡┻━┻                      ->"ಠ益"

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

Albert Einstein

\__( O__O)_/

!@#$%^&*()_+{}|:"<>?

1234567890-=[]\;',./

(ノಠ益ಠ)ノ彡┻━┻

“¤>%,oỊȤʠ“ØụĊ5D³ṃṠɼQ»j;Ç;“;}¶”

┬──┬ ノ( ゜-゜ノ)

Far out in the uncharted backwaters of the unfashionable end of the Western Spiral arm of the Galaxy lies a small unregarded yellow sun. Orbiting this at a distance of roughly ninety-eight million miles is an utterly insignificant little blue-green planet whose ape-descended life forms are so amazingly primitive that they still think digital watches are a pretty neat idea.

अपडेट करें

  • [१६-० of-१०]: सेट अलग-अलग वस्तुओं के अनियोजित संग्रह हैं
  • [१६-० .-१०]: अनुगामी न्यूलाइन स्वीकार्य है
code-golf  quine 
— NonlinearFruit
स्रोत
2
क्या आउटपुट में डुप्लिकेट वर्ण हैं?
— डिजिटल ट्रॉमा
1
@DigitalTrauma उदाहरण # 1, # 2 और # 3 से ऐसा प्रतीत नहीं होता है
— लुइस मेंडो
@DigitalTrauma अस्पष्टता के लिए क्षमा करें, सेट (गणितीय अर्थ में) आदेश की उपेक्षा करते हैं और कोई पुनरावृत्ति नहीं होती है।
— नॉनलाइनयरफ्रूट
22
एक सामान्यीकृत क्वीन के साथ आने के लिए बधाई, जहां सबसे अच्छा समाधान भाषा के मानक क्वीन पर आधारित नहीं हैं। :)
— मार्टिन एंडर
1
यदि एक सेट में पुनरावृत्ति नहीं होनी चाहिए, तो क्या इनपुट सेट में भी पुनरावृत्ति नहीं होनी चाहिए? या इनपुट वास्तव में एक सेट नहीं है?
— 15:81 बजे user81655

जवाबों:

15

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

मुझे एक बाइट बचाने के लिए धन्यवाद कार्ल :-) मुझे दो बाइट बचाने के लिए धन्यवाद दादा!

मुझे लगता है कि यह काम करता है, लेकिन यह मेरी पहली क्वीन चुनौती है इसलिए मैं 100% निश्चित नहीं हूं। : \

print(set("printseu()&'"+'+"')&set(input()))

43 बाइट्स के साथ लैम्ब्डा संस्करण: lambda a:set(" lambdaset()&'"+':+"')&set(a)

— जेरेमी
स्रोत
8
'eroticpuns\()&\''तार जोड़ने से कम है। ( 'लेकिन बच गए लेकिन फिर आपको अतिरिक्त `\` की आवश्यकता है) वहाँ डॉट क्यों है?
— कार्लकास्टर
woops, .कम गोल्फ वाले कोड से एक अवशेष था। बैकस्लैश का उपयोग करने से काम नहीं चलता क्योंकि तब \` is \\ ` से आउटपुट , और इनपुट चरित्र को डुप्लिकेट करने की अनुमति नहीं है, मुझे लगता है।
— जेरेमी
1
आपका लंबोदर गायब है :।
— डेनिस
धन्यवाद @ डेनिस। कार्यक्रम में सभी पात्रों को खोजने की कोशिश करने के बाद मेरी आँखें ऊपर उठने लगती हैं;)
— जेरेमी
1
@Dada: यदि आप चाहते हैं, तो यह हो सकता है inspectour, nicestupor, poeticurns, nopictures, recountspi, या inputscore। या नए के लिए आप prunesit(कोड गोल्फर क्या करते हैं, इसका सटीक विवरण) ipunster, या nursepitदूसरों के बीच उपयोग कर सकते हैं।
— Deusovi
11

दिल्लोग एपीएल , 8 बाइट्स

'∩''⊢'∩⊢

∩बाएं तर्क से उन वर्णों को लौटाता है जो सही तर्क में मौजूद हैं (यदि बाएं तर्क में कोई डुप्लिकेट नहीं है - जैसा कि इस मामले में है - तो परिणाम में भी कोई डुप्लिकेट नहीं है

⊢ तर्क है

फिर स्ट्रिंग में सिर्फ वे दो प्लस होते हैं जो कोट वर्ण (दोगुना होता है, जैसा कि एक स्ट्रिंग में होता है)।

TryAPL ऑनलाइन!

— एडम
स्रोत
9

पायथन 2, 56 46 39 बाइट्स

-1 बाइट @ जेरेमी को धन्यवाद

lambda a:set(':&()smelt\ bad\'')&set(a)

अनाम लंबू फ़ंक्शन, एक स्ट्रिंग लेता है, एक सेट लौटाता है

पुराना संस्करण:

lambda x,w=set('newmatrixbuspdl_:-)(=,\ \''):w-(w-set(x))
— KarlKastor
स्रोत
मुझे यह पसंद है, लेकिन यह सिर्फ एक के बजाय `\\ 'पर दो बैकस्लैश देता है।
— जेरेमी
इसके अलावा, मुझे लगता है कि आप मेमने का नाम बदलकर एक बाइट बचा सकते हैंa
— जेरेमी
1
टिप के लिए @ जेरेमी धन्यवाद, '\\'स्ट्रिंग रूप में एक बैकस्लैश का प्रतिनिधित्व करने का सिर्फ पायथन का तरीका है, क्योंकि एक एकल अंत उद्धरण से बच जाएगा, इसलिए आपको इसे काम करने के लिए बैकस्लैश के साथ बैकस्लैश से बचना होगा। टाइप करें print '\\'और आप देखेंगे कि यह केवल एक बैकस्लैश के लिए प्रतिनिधित्व है।
— KarlKastor
आप 36 के साथ मिल सकते हैं lambda a:{*''' lambda&':{}*'''}&{*a}।
— मॉर्गन थ्रैप 16
1
@ मॉर्गनट्रैप 35lambda a:{*' lambda&\\\':{}*'}&{*a}
— देखिए
9

पर्ल 6 , 56, 55 बाइट्स

" फ्रेंच " / यूनिकोड संस्करण (55 बाइट्स)

say perl q.say perlq∩$*IN\\\.comb:..comb∩$*IN.comb:

" टेक्सास " / ASCII संस्करण (56 बाइट्स)

say (q.sayq(&) $*IN\\\.combperl..comb (&)$*IN.comb).perl
say perl q.sayq(&) $*IN\\\.comb:perl..comb (&)$*IN.comb:

गैर golfed:

my \Source = 'my \\Source = \'say ( $*IN.comb.Set ∩ Source.comb.Set ).perl\'';
say ( $*IN.comb.Set ∩ Source.comb.Set ).perl

उदाहरण:

$ echo -n 'say perl q.say perlq∩$*IN\\\.comb:..comb∩$*IN.comb:' > test-unicode.p6

$ echo -n 'say (q.sayq(&) $*IN\\\.combperl..comb (&)$*IN.comb).perl' > test-ascii.p6

$ perl6 test-ascii.p6 <<< 'abcdefghijklmnopqrstuvwxyz'
set("p","a","l","r","c","q","b","s","e","m","y","o")

$ perl6 test-unicode.p6 < test-unicode.p6
set("\\","I","p"," ","a","c","l","r","q","b","∩","*","s","m","e",".","y",":","o","N","\$")

$ perl6 test-ascii.p6 < test-ascii.p6
set("p","\\","I"," ","a","l","r","c","q","b",")","*","s","e","m","\&",".","(","y","o","N","\$")

$ perl6 test-ascii.p6 < test-unicode.p6
set("p","\\","I"," ","a","l","r","c","q","b","*","s","e","m",".","y","o","N","\$")

$ perl6 test-unicode.p6 <<< 'Albert Einstein'
set(" ","l","r","b","s","e")

$ perl6 test-unicode.p6 <<< '\__( O__O)_/'
set("\\"," ")

$ perl6 test-ascii.p6 <<< '!@#$%^&*()_+{}|:"<>?'
set(")","*","\&","(","\$")

$ perl6 test-unicode.p6 <<< "1234567890-=[]\\;',./"
set("\\",".")

$ perl6 test-unicode.p6 <<< '(ノಠ益ಠ)ノ彡┻━┻'
set()

“¤>%,oỊȤʠ“ØụĊ5D³ṃṠɼQ»j;Ç;“;}¶”
set("o")

$ perl6 test-unicode.p6 <<< '┬──┬ ノ( ゜-゜ノ)'
set(" ")


$ perl6 test-ascii.p6 <<< 'Far out in the uncharted backwaters of the unfashionable end of the Western Spiral arm of the Galaxy lies a small unregarded yellow sun. Orbiting this at a distance of roughly ninety-eight million miles is an utterly insignificant little blue-green planet whose ape-descended life forms are so amazingly primitive that they still think digital watches are a pretty neat idea.'
set("p"," ","a","l","r","c","b","s","e","m",".","y","o")
— ब्रैड गिल्बर्ट b2gills
स्रोत
2
क्या $*PROGRAMप्रोग्राम के स्रोत कोड तक पहुँच नहीं है , और इस प्रकार नियमों का उल्लंघन है?
— celtschk
@celtschk मुझे पोस्ट करने से पहले प्रश्न को फिर से पढ़ना चाहिए, तय किया गया। (तकनीकी रूप से संकलक यह देख सकता है कि $*PROGRAMसंकलित कार्यक्रम में पूरे स्रोत को एक स्ट्रिंग के रूप में संग्रहीत किया गया है, जिसने इसे एक ग्रे क्षेत्र में डाल दिया होगा)
— ब्रैड गिल्बर्ट b2gills
8

MATL , 8 बाइट्स

'X&'''X&

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

इनपुट एकल उद्धरण में संलग्न एक स्ट्रिंग है। यदि स्ट्रिंग में एकल-उद्धरण चिह्न है, तो इसे बचने के लिए डुप्लिकेट होना चाहिए।

व्याख्या

'X&'''   % Push string with the three characters used by the program. The single-quote 
         % symbol needs to be escaped by duplicating it
X&       % Take input implicitly. Set intersection. Display implicitly
— लुइस मेंडो
स्रोत
6

दरअसल, 6 बाइट्स

`∩è`è∩

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

स्पष्टीकरण:

`∩è`è∩
`∩è`    push the function `∩è` (which contains every character in the source code except '`')
    è   repr (same as Python repr - leaves "`∩è`", which contains every character in the source code)
      ∩ set intersection with input
— मेगो
स्रोत
5

हास्केल (30 बाइट्स)

यह एक ऐसा उबाऊ समाधान है ... लेकिन मैं बेहतर नहीं कर सका। :(

filter(`elem`"f(term)\"i`l\\")
— MarLinn
स्रोत
5

ब्रेकीलॉग , 23 बाइट्स

:{e.~e":{}e~\"fd\."}fd.

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

व्याख्या

:{                 }f      Find all chars that verify the predicate below
                     d.    Remove duplicates and output

  e.                       Take a char from the input ; this is our output…
    ~e":{}e~\"fd\."        … if that char is in the string :{}e~"fd. (the first \ is here
                               to escape the ")
— Fatalize
स्रोत
1
क्या आप हमारे चैटरूम को देख सकते हैं?
— लीकेज नन
1
मूंछ आदमी :{और आश्चर्यचकित मूंछ आदमी के लिए +1:{}
— विनाशकारी नींबू
4

सी, 142 बाइट्स

main(i){char*p,a[]="remain([*]){fought?>:01;,\\\"=capsv+-l}";for(;(i=getchar())>=0;p?putchar(i),memmove(p,p+1,a+strlen(a)-p):0)p=strchr(a,i);}

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

— owacoder
स्रोत
2
एक ungolfed संस्करण और / या स्पष्टीकरण बहुत अच्छा होगा!
— YSC
आप सहेजे गए बाइट के sizeof aबजाय उपयोग कर सकते थे strlen(a), लेकिन इससे भी बेहतर है कि एरे को एक ज्ञात आकार दिया जाए: a[99]="..."और 5 बाइट्स को शेव करने के लिए बदल strlen(a)दिया 99जाए।
— जी। स्लीपेन 11
एक और 3 या 4 बाइट के (i=getchar())>=0साथ बदलकर बचाया जा सकता है read(0,&i,1)। यह छोटे-एंडियन मशीनों पर काम करता है। iयदि आप किसी भी तर्क के साथ कार्यक्रम नहीं चलाते हैं, तो इसे 1 से प्रारंभ किया जाता है। यदि आप चाहते हैं कि यह बड़े-एंडियन मशीनों पर भी काम करे, तो मुझे तर्क सूची से हटा दें main()और इसे शरीर के अंदर एक चार के रूप में घोषित करें (लेकिन तब आप केवल 3 बाइट बचाते हैं)। read()ईओएफ पर आसानी से 0 रिटर्न।
— जी। स्लीपेन 12
4

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

"`q&"`q&

इसे यहाँ आज़माएँ।

स्पष्टीकरण:

"`q&"    e# Push that string to the stack
     `   e# Stringify, pops the string and pushes "\"`r&\"" to the stack
      q  e# Pushes the input to the stack
       & e# Union, pops two elements and pushes a list of every element that is contained in both.
— Loovjo
स्रोत
4

अजगर , ९ 9 बाइट्स

1 बाइट Sp3000 के लिए धन्यवाद

@Q"\Q@\"

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

@Q"\Q@\"
@Q"\Q@\""   implicit string ending

@Q           intersect the input with
  "\Q@\""   the string containing '\', 'Q', '@', '"'.
— लीक नन
स्रोत
@z"z\"@1 बाइट छोटी है।
— drobilc
@drobilc यह याद होगा \।
— लीक
ओह, हाँ, इस बारे में पूरी तरह से भूल गया।
— drobilc
4

रेटिना, 21 20 बाइट्स

स्रोत कोड में नहीं वर्णों को निकालता है, फिर डुप्लिकेट वर्णों को निकालता है।

[^Ds.n\n[-a_-]

Ds`.

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

— mbomb007
स्रोत
आपके स्रोत कोड में लाइनफ़ीड (आपका आउटपुट नहीं है) शामिल है।
— मार्टिन एंडर
मेरे पास मूल रूप से एक ही समाधान पहले था, लेकिन इसे पोस्ट करना भूल गया। आप रेंज के साथ कुछ बाइट्स बचा सकते हैं [-a(और फिर एक अंडरस्कोर और एक हाइफ़न शामिल करें और दूसरी पंक्ति पर बैकटिक को छोड़ दें)। लेकिन भविष्य के संदर्भ के लिए, ]यदि आपको इसे पहले चरित्र के रूप में रखा जाए तो भागने की आवश्यकता नहीं होगी। ओह और अच्छाई के लिए, आप दो चरणों की अदला-बदली से बचने के लिए स्वैप कर सकते हैं।
— मार्टिन एंडर
@MartinEnder यह अभी भी लाइन फीड को कम नहीं करता है, क्या यह एक समस्या है?
— mbomb007
ओह, तुम सही हो, मैंने यह नोटिस नहीं किया। आपको तब और वर्ण वर्ग sके विकल्पों में जोड़ना होगा D।
— मार्टिन एंडर
4

मैथेमेटिका, 35 बाइट्स

Characters@"\"#&@C\acehrst⋂"⋂#&

अनाम फ़ंक्शन। किसी भी उत्पन्न संदेशों को अनदेखा करें। इनपुट के रूप में वर्णों की एक सूची लेता है और आउटपुट के रूप में वर्णों की एक सूची देता है। यूनिकोड वर्ण U + 22C2 है \[Intersection]।

— LegionMammal978
स्रोत
4

सी #, 36 बाइट्स

s=>s.Intersect("s=>.Interc(\"\\);");

इरादा कास्ट Func<string, IEnumerable<char>>( stringइनपुट, IEnumerable<char>आउटपुट) है।

— दूध
स्रोत
— दूध
4

विम, 78 68 78 79 61 कीस्ट्रोक्स

पूरी तरह से मेरे दृष्टिकोण को बदल दिया:

oo/\$kjxd<esc>/o<cr>xj$/\/<cr>xj$/\\<cr>xj$/$<cr>xj$/k<cr>xj$/x<cr>xj$/j<cr>xj$/d<cr>xkdd

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

सबसे पहले, यह सभी प्रोग्राम वर्णों के साथ एक पंक्ति बनाता है, फिर, यह प्रोग्राम के प्रत्येक अक्षर का पहला उदाहरण पाता है, जो या तो इनपुट में होता है, यदि इनपुट और आउटपुट इंटरसेक्ट होता है, या आउटपुट यदि वे नहीं करते हैं, तो हटाता है यह फ़ाइल के अंतिम वर्ण में जाता है (इसलिए यह चारों ओर घूमता है) और ऐसा करता है कि स्रोत के प्रत्येक अद्वितीय वर्ण के लिए, d को छोड़कर, जहाँ फ़ाइल के अंत में जाने के बजाय, यह इनपुट को हटाकर समाप्त होता है

— विनाशकारी नींबू
स्रोत
बैकस्लैश आपके कोड में है, लेकिन आपके स्ट्रिंग में नहीं लगता है।
— टाइटस
क्या यह तीसरा नहीं है?
— विध्वंसक नींबू
4

बैश , 45 50 41 39 37 34 29 बाइट्स

-9 बाइट्स का धन्यवाद ज्यॉफ के लिए धन्यवाद
-4 बाइट्स डेनिस
-5 बाइट्स की बदौलत नाहुएल फौइलुल को धन्यवाद

grep -o '[] [|\'\'grepouniq-]

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

— रिले
स्रोत
क्या आपको केवल एक grep कमांड की आवश्यकता नहीं है?
— ज्योफ रेडी
@GeoffReedy पहला grep कमांड इनपुट को प्रति पंक्ति एक वर्ण में विभाजित करता है।
— डेनिस
ठीक है, लेकिन -o को दूसरे grep पर नहीं लगाया जा सकता है
— ज्यॉफ कॉमेडी
आप सही हैं, और यह 'के लिए जाँच करने के लिए होने से बचाता है।' धन्यवाद!
— रिले
1
@ बिट्स के बाद BASH यह बात करता है, grep हो जाता है -oऔर [] [|\'grepouniq-]। तो यह इनमें से कुछ के लिए देख रहा है [ ] {space} [ | {slash} ' g r e p o u n i q - ]:।
— रिले
3

PowerShell v4 +, 122 104 बाइट्स

([char[]]($args[0]+'acegfhmnoprstu012|][()"?+_,.$-{0}{1}{2}'-f("'","}","{"))|group|?{$_.count-gt1}).name

ओह। PowerShell बेकार में Quines या quine-like कोड, क्योंकि स्ट्रिंग प्रतिस्थापन फ़ॉर्मेटिंग बहुत क्लूनी है।

ace...{2}बीच में स्ट्रिंग प्रत्येक वर्ण है जो बाकी कोड में मौजूद है। {0}{1}{2}साथ संयोजन के रूप में प्रयोग किया जाता है -fखींचने के लिए ormat ऑपरेटर '{}स्ट्रिंग में वर्ण।

यह इनपुट के साथ चार-सरणी के रूप में संयुक्त है $args, फिर पाइप लाइन में खिलाया जाता है। पहला पड़ाव वह है Group-Object(जो अनिवार्य रूप से) इनपुट ऑब्जेक्ट का हैशटेबल बनाता है और इनपुट में कितनी बार होता है। यह केवल उन वस्तुओं का चयन करने |?{...}के Where-Objectलिए पाइप किया गया है जो .countइससे अधिक है 1। हम इसे पैरेन्स में एनकैप्सुलेट करते हैं, और हैशटेबल के .Nameहिस्से को प्लक करते हैं (जो कि v4 + आवश्यकता खेल में आता है, अन्यथा हमें एक अतिरिक्त की आवश्यकता होगी|Select Name पाइपलाइन के लिए चरण की )।

उन तत्वों को पाइप लाइन पर छोड़ दिया जाता है (एक सरणी के रूप में), और मुद्रण अंतर्निहित है।

— AdmBorkBork
स्रोत
3

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

x='c=set;print c(`x`)&c(raw_input())';exec x

सिर्फ मनोरंजन के लिए, यहां एक क्वीन जैसा पूर्ण कार्यक्रम प्रस्तुत किया गया है। एक पायथन 2 सेट के स्ट्रिंग प्रतिनिधित्व को आउटपुट करता है।

— Sp3000
स्रोत
3

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

f=
t=>[..."\"().=>O[\\]defilnrtx~"].filter(e=>~t.indexOf(e))
;
<input placeholder=Input oninput=o.value=f(this.value).join``><input placeholder=Output id=o>
स्निपेट का विस्तार करें

मूल स्ट्रिंग / वर्ण सरणी और स्रोत कोड दोनों में मौजूद वर्णों की एक सरणी देता है। संपादित करें: @ user81655 के लिए 2 बाइट्स धन्यवाद सहेजा गया।

— नील
स्रोत
f=s=>[...new Set(f+'')]...बाइट्स बचा सकता है।
— 15:81 बजे user81655
या उससे भी कम:f=s=>[...s].filter(c=>(new Set(f+'')).has(c))
— user81655
@ user81655 कम से कम फ़ायरफ़ॉक्स, स्रोत कोड को f+''पढ़ने के द्वारा काम करता है f। (कुछ मामलों में आप स्रोत फ़ाइल को बदलकर फ़ायरफ़ॉक्स को दुर्घटनाग्रस्त कर सकते हैं और फिर उससे लोड किए गए फ़ंक्शन को कठोर बनाने का प्रयास कर सकते हैं।)
— नील
@ user81655 आपका दूसरा उदाहरण विफल हो जाता है जब sबार-बार तत्व होते हैं, और वैसे भी indexOfकम होते हैं new Set।
— नील
उस स्थिति में, आप सहेजने की कोशिश कर सकते हैं चार्ट (जैसे cकि पहले से ही सूची में एक चरित्र के पैरामीटर को बदलना )।
— 1581 पर user81655
3

मतलाब, 37 बाइट्स

काफी सरल:

intersectचौराहे को खोजने के लिए बिलिन का उपयोग करता है । स्रोत कोड हार्ड कोडित है। उद्धरण चिह्नों के अंदर इनपुट दिया जाना चाहिए''

intersect(input(''),'''intersc(pu),')
— स्टीवी ग्रिफिन
स्रोत
आपको एक अनाम फ़ंक्शन का उपयोग करना चाहिए ... 5 बाइट्स से हराया
— Sanchises
हेहे, मुझे लगता है कि मेरा सबसे अच्छा गोल्फ नहीं था ...
— स्टिव ग्रिफिन
3

जावास्क्रिप्ट (ओएस एक्स 10 पर क्रोम 58), 12654 12,426 11992 बाइट्स

https://paste.ubuntu.com/25593218/

https://paste.ubuntu.com/25595798/

https://paste.ubuntu.com/25595831/

मूल कोड:

var t=prompt();"!+()[]".split("").forEach(function(f){if(t.includes(f))alert(f)})

इसे तब एक प्रोग्रामिंग स्टाइल में परिवर्तित किया गया जिसे jsfk कहा जाता है जो केवल इन छह अक्षरों का उपयोग करता है: 

(+)[!]

एक ऑनलाइन संकलक का उपयोग करना।

— Tornado547
स्रोत
यदि jsfk भाषा है, तो आपको जावास्क्रिप्ट के बजाय हेडर में उपयोग करना चाहिए।
— नॉनलाइनरफोर्स
1
@NonlinearFruit jsfk एक प्रोग्रामिंग शैली है । यह मान्य जावास्क्रिप्ट है
— टॉर्नेडो 547
2

आर, 129 बाइट्स

f=function(s){b=strsplit("f=unctio(s){arpl;,[1]b\\\"qemh0T}",c())[[1]];cat(b[unique(pmatch(strsplit(s,c())[[1]],b,0,T))],sep="")}

अगर मैं इसे ungolf करता हूं, तो इसके लिए स्ट्रिंग में न्यूलाइन की तरह अजीब चीजों को बदलना होगा b। किसी भी तरह, इसका सुपर सिंपल - फ़ंक्शन में सभी वर्णों के साथ एक वेक्टर बनाता है। फिर यह एक वेक्टर में इनपुट को खींचता है, और सदस्यता की जांच करता है।

— user5957401
स्रोत
आपने लगभग एक वर्ष में साइट का दौरा नहीं किया है, लेकिन f=function(s)cat(instersect(strsplit(s,"")[[1]],strsplit("f=unctio(s)aerpl,\\\"[1]","")[[1]]),sep="")101 बाइट्स हैं, और मुझे लगता है कि I / O प्रारूप सरल हो सकता है, बिना cat...
— Giuseppe
2

रूबी, 34 + nध्वज = 35 बाइट्स

मल्टी-लाइन इनपुट के साथ बिल्कुल काम नहीं करता है, क्योंकि -nप्रोग्राम एसटीडीआईएन लाइन-बाय-लाइन को प्रोसेस करने का कारण बनता है। इस कोड में कोई नई बात नहीं है, लेकिन इस तरह से इनपुट करने की कोशिश की जा रही है कि एक के बजाय कई सरणियों का उत्पादन होगा। यदि यह युक्ति के अनुसार ठीक नहीं है, तो कृपया मुझे सूचित करें और मैं ठीक कर दूंगा।

p $_.chars&"\\\"p $_.chars&".chars
— मूल्य स्याही
स्रोत
2

ListSharp , 222 बाइट्स

STRG S=READ[<here>+"\\S.txt"]
ROWS T=ROWSPLIT S BY [""]
ROWS R=ROWSPLIT "STRG =EAD[<her>+\".tx]OWPLIBYCFMHVNc#isn()oay\r\n" BY [""]
ROWS R=SELECT FROM T WHERE[EVERY STRG IS ANY STRG IN R]
SHOW=<c#R.Distinct().ToArray()c#>

हास्यास्पद लेकिन im मनोरंजन

— downrep_nation
स्रोत
2

sed, 47 वर्ण

:s;st[^])(*\1.s2t:[;^]tt;st\(.\)\(.*\1\)t\2t;ts

मैं थोड़ा निराश हूं कि यह कब तक निकला, विशेष रूप से दोहराया पात्रों को हटाने के लिए।

— ज्योफ की कॉमेडी
स्रोत
यह सेड का कौन सा संस्करण है? GNU sed कहता है sed: -e expression #1, char 47: unterminated `s' command।
— डेनिस
43 बाइट्स जिनमें 1 for -r: sed -r ':;ss[^][str().*\12;:^]ss;ss(.)(.*\1)s\2s;t' मैंने इसे आपकी सूचना देने से पहले लिखा था और यह बहुत समान निकला
— izabera
@ डेनिस तय; एक होने के बाद: एक के बाद [यह प्रयास करने के लिए और एक चरित्र वर्ग पार्स करने के लिए कारण
— ज्योफ कॉमेडी
@ हिजाब अच्छा, मुझे काफी आश्चर्य है कि: कमांड को वास्तव में एक लेबल की आवश्यकता नहीं है और यह एक लेबल के बिना टी के अर्थ को बदल देता है
— ज्यॉफ कॉमेडी
हाँ, यह एक विष्णुवाद है
— izabera
2

जावा 8 लैम्ब्डा, 152 142 140 अक्षर

काफी छोटा:

s->s.chars().mapToObj(i->(char)i).filter(c->"COSTab\"\\cefh(i)j+l-mn.oprstuv>".contains(""+c)).collect(java.util.stream.Collectors.toSet())

या यहाँ पर अपराजित:

public class Q89400 {

    static Set<Character> inAndQuine(String in) {
        return in.chars()
                .mapToObj(i->(char)i)
                .filter(c->"COSTab\"\\cefh(i)j+l-mn.oprstuv>".contains(""+c))
                .collect(java.util.stream.Collectors.toSet());

    }
}

बेशक यह अनौपचारिक समाधान गलत है, क्योंकि यह घुंघराले कोष्ठक और कुछ और पात्रों से मेल नहीं खाता है, यह पूर्णता के लिए सिर्फ उनका है।

फ़ंक्शन इनपुट को एक के रूप में लेता है Stringऔर एक java.util.Set<Character>वर्ण देता है जो इनपुट और स्रोत दोनों में मौजूद होता है।

अपडेट

यह पता चला कि समाधान काम नहीं कर रहा था। मैंने String#containsएक रेगेक्स मैच के लिए परीक्षण सोचा था लेकिन यह सिर्फ एक शाब्दिक मिलान है। मैंने पात्रों को उद्धृत करने के लिए कुछ भागने को जोड़ा, .लेकिन यह आवश्यक नहीं था , बल्कि इसके बजाय सब कुछ बर्बाद कर दिया। अब इस से बचने के बिना हम कुछ पात्रों को बचाते हैं और अब यह वास्तव में काम करता है :)

एक चरित्र चर का उपयोग करने की याद दिलाने के लिए @ नोनलियरफ्रूट पर धन्यवाद।

— Frozn
स्रोत
inएक ही अक्षर का नाम बदलें जैसेa
— NonlinearFruit
3
@NonlinearFruit आप सही हैं: हे मैं कैसे भूल सकता है कि के बारे में ?!
— Frozn
2

एसक्यूएफ , 71 69 64 बाइट्स

फ़ाइल-ए-फ़ंक्शन फ़ंक्शन का उपयोग करना:

i="-_h ;""=()sSplitrng"splitString"";i-(i-(_this splitString""))

के रूप में बुलाओ "STRING" call NAME_OF_COMPILED_FUNCTION

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