एबीसी के रूप में आसान के रूप में

28

इनपुट

एक स्ट्रिंग है कि पत्र में से प्रत्येक की अधिकतम एक बार होता है A, Bऔर C। वे किसी भी क्रम में हो सकते हैं। खाली स्ट्रिंग मान्य इनपुट है।

नोट: इस चुनौती के पिछले संस्करण में अक्षरों का उपयोग किया गया LEJथा ABCऔर यदि वांछित हो तो भी उनका उपयोग किया जा सकता है।

उत्पादन

की एक स्ट्रिंग A, B,C पत्र है कि इनपुट में मौजूद नहीं थे। वे किसी भी क्रम में हो सकते हैं।

यदि आउटपुट खाली स्ट्रिंग होगा, तो बस कोई आउटपुट देना मान्य नहीं है, अगर यह आपके कार्यान्वयन के लिए समझ में आता है। (जैसे आपको वास्तव में कॉल करने की आवश्यकता नहीं हैprint खाली स्ट्रिंग पर ।)

उदाहरण

  • इनपुट है Bतो उत्पादन या तो होना चाहिए CAया ACके बाद से AऔरC इनपुट में मौजूद नहीं हैं।
  • यदि इनपुट खाली स्ट्रिंग है तो आउटपुट होना चाहिए ABC या कोई भी क्रमपरिवर्तन क्योंकि इनपुट में तीन अक्षरों में से कोई भी मौजूद नहीं है।
  • यदि इनपुट है CABतो आउटपुट खाली स्ट्रिंग होना चाहिए क्योंकि सभी तीन अक्षर इनपुट में मौजूद हैं।

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

ऐसे बहुत कम इनपुट मामले हैं, जिनमें से हम सभी की गणना कर सकते हैं:

in -> out1 | out2 | out3 | ...
ABC -> ""
ACB -> ""
BCA -> ""
BAC -> ""
CAB -> ""
CBA -> ""
AB -> C
AC -> B
BC -> A
BA -> C
CA -> B
CB -> A
A -> BC | CB
B -> CA | AC
C -> AB | BA
"" -> ABC | ACB | BCA | BAC | CAB | CBA

प्रत्येक इनपुट के लिए सभी वैध आउटपुट दिए गए हैं, जो अलग हैं |। ""खाली स्ट्रिंग का प्रतिनिधित्व करता है

स्कोरिंग

बाइट्स में सबसे छोटा कोड जीतता है। लेकिन ध्यान रखें कि आप चुनौती को हल करने के लिए एक छोटे तरीके के बजाय एक अद्वितीय तरीके से अधिक मान्यता प्राप्त कर सकते हैं ;)

code-golf  string  set-theory 
— केल्विन के शौक
स्रोत
1
— मेगो
1
कार्य एक स्थिर और एक इनपुट के बीच अंतर निर्धारित करता है। यह अनुरोध करना कि वास्तविक कार्य की कठिनाई के संबंध में तार में सब कुछ किया जाना बोझिल है।
— Mego
2
मुझे अस्पष्ट रूप से एक अधिक सटीक डुप मैच याद है जहां आपको एक निरंतर सेट से इनपुट को घटाना था।
— xnor
1
क्या इनपुट में "एबीसी" के बाहर पत्र हो सकते हैं? विनिर्देशन: "एक स्ट्रिंग जिसमें A, B और C में से प्रत्येक अक्षर में से अधिकांश में शामिल है," इस तरह के इनपुट को बाहर नहीं करता है।
— Theonlygusti
1
@theonlygusti इनपुट में केवल एबीसी
— केल्विन के शौक

जवाबों:

20

पायथन 3, 29 27 22 बाइट्स

lambda x:{*"ABC"}-{*x}

जोनाथन एलन को -2 बाइट्स धन्यवाद

-5 बाइट्स रॉड के लिए धन्यवाद

— Trelzevir
स्रोत
print(*{*"LEJ"}-{*input()})बचाता है 2. (3.5 और 3.6 पर परीक्षण)।
— जोनाथन एलन
— रॉड
14
मैं अजगर ❤️ प्यार करता हूँ
— Theonlygusti
@Theonlygusti जो कुछ भी हुआ <3 और ♥?
— wizzwizz4
@ वेटलिगस्टी: मैं अजगर को पसंद करूंगा अगर मैं लैम्डा को 𝛌
— फहीम पारकर
10

जेली , 4 बाइट्स

जेली के शब्दकोश में परिवर्तन और "एबीसी" की उपस्थिति के बारे में जानकारी के लिए @DuctrTape का धन्यवाद।

“ḃ»ḟ

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

“ḃ»जेली के शब्दकोश में "एबीसी" प्रविष्टि को देखता है, ḟफिल्माया गया डायर है जो पात्रों की उस सूची से इनपुट में पाए गए वर्णों को त्यागता है। परिणाम स्पष्ट रूप से मुद्रित है।

निम्न स्थिति वाले संस्करण के लिए उपयोग करने के लिए शब्दकोष प्रविष्टि "अबैक" ( “c») या " अबका " ( “i») हो सकती है।

जब चुनौती "एलईजे" थी तो ऊपरी मामले में केवल 6 बाइट्स प्राप्त किए जा सकते थे, क्योंकि वर्णों के उस सेट के साथ कोई भी डिक्शनरी मौजूद नहीं है, जिससे हम पात्रों की सूची “LEJ”(या क्रमपरिवर्तन) बना सकें ।

शब्द "जेल" ( ) की उपस्थिति के कारण लोअरकेस वेरिएंट 5 बाइट्स में बेहतर हो गया “ẎṄ»।

— जोनाथन एलन
स्रोत
1
मुझे पसंद है कि अधिकांश कोड केवल "एबीसी" स्ट्रिंग उत्पन्न करता है, और वास्तविक कार्यक्रम स्वयं एक चरित्र है। क्लासिक जेली।
— sagiksp
6

बैश + कोरुटिल्स, 15 बाइट्स

tr -d x$1<<<LEJ

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

मैं छोड़ना चाहूंगा x, लेकिन tr -dइनपुट स्ट्रिंग खाली होने पर एक तर्क याद आ जाएगा। ( xकोई नुकसान नहीं करता है, क्योंकि यहाँ किसी भी x-string LEJ में नहीं हैं।) मैं आम तौर पर लिखूंगा tr -d "$1", लेकिन यह जिस तरह से मैंने किया वह एक बाइट से कम है।

— मिशेल स्पेक्टर
स्रोत
मेरा भी यही विचार था - उद्धरणों के साथ - तुरंत भी।
— rexkogitans
6

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

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

$
¶ABC
D`.
A1`

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

व्याख्या

$
¶ABC

युक्त एक दूसरी पंक्ति में जोड़ें ABC।

D`.

पात्रों को डेडुप्लिकेट करें। यह हर वर्ण को दूसरी पंक्ति से हटा देता है जो पहले से ही पहली पंक्ति में दिखाई देता है।

A1`

पहली पंक्ति को त्यागें।

— मार्टिन एंडर
स्रोत
1`एंटीग्रेप स्टेज का हिस्सा वास्तव में कैसे काम करता है?
— क्रिति लिथोस
कॉन्फ़िगरेशन स्ट्रिंग में @KritiiLithos नंबर सीमाएँ हैं। 1आम तौर पर इसका मतलब है "केवल एक बार एक्स करें"। वास्तव में सीमाएं कैसे काम करती हैं (यानी एक्स क्या है) उस चरण प्रकार पर निर्भर करता है जिसका आप उपयोग कर रहे हैं। एंटीग्रेप चरणों के लिए, रेटिना पहले जाँचता है कि कौन सी रेखाएँ रेग्ज से मेल खाती हैं (यहाँ, हर पंक्ति, चूंकि रेग्ज खाली है), लेकिन फिर सीमा का अर्थ है "केवल पहली मिलान रेखा को त्यागें"। इसी तरह, अगर यह एक grep स्टेज था, तो इसका मतलब होगा "केवल पहली मैचिंग लाइन रखें"। सभी सीमाओं के शब्दार्थ विकि पर सूचीबद्ध हैं ।
— मार्टिन एंडर
6

05AB1E , 6 4 बाइट्स

केविन क्रूज़सेनžR द्वारा सुझाए गए नए आदेश का उपयोग करके 2 बाइट्स सहेजे गए

žRsм

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

   м  # remove the character of
  s   # the input
žR    # from the string "ABC"
— Emigna
स्रोत
क्या केवल Jरिटर्न का इनपुट नहीं होना चाहिए EL, LE?
— मैजिक ऑक्टोपस Urn
2
अच्छा! FYI के रूप में, इनपुट्स को भी दर्शाया जा सकता है """{input}""", जो खाली तारों के लिए भी काम करता है :)।
— अदनान
@ क्रूसोकोमपूतिंग: यह या तो वापस आ सकता है (इस मामले में यह वापस लौटता है LE)।
— एमिगा
1
— केविन क्रूज़सेन
1
@Emigna Tbh सं। मुझे लगता है कि शायद इस चुनौती के कारण इसे जोड़ा गया था, लेकिन मैंने व्यक्तिगत रूप से पहले इसका इस्तेमाल नहीं किया है।
— केविन क्रूज़सेन
5

जावा 7, 73 58 बाइट्स

String c(String s){return"EJL".replaceAll("[ "+s+"]","");}

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

टेस्ट कोड:

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

class M{
  static String c(String s){return"EJL".replaceAll("[ "+s+"]","");}

  public static void main(final String[] a) {
    System.out.print("LEJ=" + c("LEJ") + "; ");
    System.out.print("LJE=" + c("LJE") + "; ");
    System.out.print("EJL=" + c("EJL") + "; ");
    System.out.print("ELJ=" + c("ELJ") + "; ");
    System.out.print("JLE=" + c("JLE") + "; ");
    System.out.print("JEL=" + c("JEL") + "; ");
    System.out.print("LE=" + c("LE") + "; ");
    System.out.print("LJ=" + c("LJ") + "; ");
    System.out.print("EJ=" + c("EJ") + "; ");
    System.out.print("EL=" + c("EL") + "; ");
    System.out.print("JL=" + c("JL") + "; ");
    System.out.print("JE=" + c("JE") + "; ");
    System.out.print("L=" + c("L") + "; ");
    System.out.print("E=" + c("E") + "; ");
    System.out.print("J=" + c("J") + "; ");
    System.out.print("\"\"=" + c(""));
  }
}

आउटपुट:

LEJ=; LJE=; EJL=; ELJ=; JLE=; JEL=; LE=J; LJ=E; EJ=L; EL=J; JL=E; JE=L; L=EJ; E=JL; J=EL; ""=EJL
— केविन क्रूज़सेन
स्रोत
1
क्या आप इसके "["+s+"]"बजाय कर सकते हैं s.replaceAll("(.)","$1|")?
— कृति लिथोस
@ कृतिलिथोस स्मार्ट। यह रिक्त स्ट्रिंग के लिए विफल रहता है, लेकिन एक स्थान (या कोई अन्य वर्ण जो नहीं है EJL) को जोड़कर यह फिर से काम करता है, जो अभी भी बहुत छोटा है। :)
— केविन क्रूज़सेन
5

अजगर, 5 बाइट्स

-"ABC

इसका परीक्षण यहां करें

तक फैलता है

-"ABC"Q
-       # Filter on absence
 "ABC"  # Literal string 
      Q # Input
— छड़ी
स्रोत
abc के रूप में लिखा जा सकता है<G3
— माल्टीसेन
@ माल्टीसेन हाँ मैडीफिश ने उसका इस्तेमाल किया, लेकिन यह वैसे भी कम है = \
— रॉड
4

MATL, 10 8 बाइट्स

स्वेवर के लिए धन्यवाद दो बाइट्स बचाए। setdiffसे छोटा है ismember।

'ABC'iX-

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

व्याख्या

'ABC'      % Create a string literal
     i     % User input
      X-   % Set difference, between two elements of the stack

हां, यह एक तुच्छ काम हो सकता है, लेकिन मैं काफी संतुष्ट हूं कि मैं इसे MATL के साथ खुद से हल करने में कामयाब रहा। मैंने कभी नहीं कहा कि यह सबसे छोटा उपाय था ... धन्यवाद स्वेअर!

— स्टीवी ग्रिफिन
स्रोत
4

जावास्क्रिप्ट ईएस 6, 41 39 38 बाइट्स

s=>eval(`'ABC'.replace(/[${s}]/g,'')`)

2 बाइट्स अर्नुल्ड के लिए धन्यवाद। 1 बाइट्स को LarsW को धन्यवाद दिया।

f=s=>eval(`'ABC'.replace(/[${s}]/g,'')`)

console.log(f("AB"));
स्निपेट का विस्तार करें

— टॉम
स्रोत
मैं मोबाइल पर हूं, इसलिए मैं अपने कोड का परीक्षण नहीं कर सकता, लेकिन मुझे लगता है कि यह काम करना चाहिए:s=>eval`'ABC'.replace(/[${s}]/g,'')`
— 22
अच्छा काम! कहने के लिए सक्षम होने के नाते .join``आप उस समाधान पर दो चरित्रों को सहेजते हैं जो मैं साथ आया था f=s=>"ABC".replace(RegExp(`[${s}]`,'g'),""):।
— nnnnnn
1
@LarsW यह सटीक कोड काम नहीं करता था, लेकिन टेम्प्लेट स्ट्रिंग के चारों ओर ब्रैकेट्स जोड़ने से एक बाइट बचती है। धन्यवाद!
— टॉम
3

वी , 10 बाइट्स

CLEJ<ESC>Ó[<C-r>"]

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

Hexdump:

00000000: 434c 454a 1bd3 5b12 225d                 CLEJ..[."]

व्याख्या

इनपुट बफर की पहली पंक्ति पर है। तो कुछ इस तरह:

EL

और कर्सर पहले वर्ण पर है। इसलिए हम इनपुट को डिलीट करते हैं (जो इसे रजिस्टर में स्टोर करता है ") और एक साथ प्रयोग करते हुए इन्सर्ट मोड डालें C।

एक बार इन्सर्ट मोड में, अक्षर LEJडाले जाते हैं, जिसके बाद मैं सामान्य मोड में वापस आता हूं <ESC>।

अब हमें उन सभी पात्रों को हटाना होगा जो इनपुट में मौजूद हैं।

Ó                       " remove every
 [<C-r>"]               "  character that appears in the input
                        " synonym of Vim's :s/[<C-r>"]//g

और एक बार ऐसा होने के बाद, हम बफ़र में शेष अक्षरों के साथ छोड़ दिए जाते हैं।

— क्रिक्टी लिथोस
स्रोत
3

रूबी, 27 19 18 बाइट्स

->s{"ABC".tr s,""}

मार्टिन एंडर को -1 बाइट

— जीबी
स्रोत
3

हास्केल , 27 26 बाइट्स

import Data.List
("ABC"\\)

इसे ऑनलाइन आज़माएं! उपयोग: ("ABC"\\) "CB"पैदावार "A"।

\\सेट डिफरेंस ऑपरेटर है, कोष्ठक एक तथाकथित खंड बनाता है जो लैम्डा के लिए एक संक्षिप्त रूप है (\x -> "ABC" \\ x)।

आयात के बिना: (@nimi के लिए एक ही बाइट गिनती धन्यवाद)

f x=[c|c<-"ABC",all(/=c)x]

इसे ऑनलाइन आज़माएं! उपयोग: f "CB"पैदावार "A"।

अन्य दृष्टिकोण:

f x=filter(`notElem`x)"ABC"
(`filter`"ABC").flip notElem
f x=[c|c<-"ABC",notElem c x]
— Laikoni
स्रोत
1
मुझे आशा है कि (\\)जल्द ही प्रस्तावना में ले जाया जाएगा।
— Theonlygusti
@ मुझे उम्मीद है कि यह नहीं होगा; यह वास्तव में सूचियों के लिए एक समझदार ऑपरेशन नहीं है (कम से कम तब तक जब तक आप स्पष्ट रूप से यह नहीं बताएं कि आप सूची-जैसा-सेट चाहते हैं)। उस कार्य के लिए डिफ़ॉल्ट ऑपरेशन होना चाहिए Data.Set.difference।
— चालू करना बंद कर दिया
@ceasedtoturncounterclockwis क्यों यह समझदार नहीं है? इसके अलावा, केवल एक ही कारण है कि मैं इसे ले जाना चाहता हूं क्योंकि यह उपयोगी है, अक्सर।
— Theonlygusti
1
@Theonlygusti यह इस अर्थ में समझदार नहीं है कि यदि आप इसका उपयोग करते हुए खुद को पाते हैं, तो यह एक संकेत है कि आप शायद गलत डेटा संरचना का उपयोग कर रहे हैं। सूचियों में डुप्लिकेट तत्व, एक आदेश हो सकता है, और वे आलसी निर्माण (यहां तक ​​कि अनंत) हो सकते हैं। (\\)इसका कोई सम्मान नहीं करता। डेटा प्रकार जो इस व्यवहार के लिए अभिप्रेत है , एक संरचना है जो उन्हें आम तौर पर थोड़ा अधिक कुशल बनाता है, सुरक्षित (क्योंकि कोई संभावित स्थिरता आदि मान्यताओं को तोड़ा नहीं जा सकता है) और अधिक आरामदायक इंटरफ़ेस को उजागर करना।
— को बंद कर दिया
@ceasedtoturncounterclockwis क्या, हाँ यह करता है। "पहली घटना ..." लेकिन nvm
— theonlygusti
3

GNU sed , 34 29 बाइट्स

के लिए +1 शामिल है -r

-5 डिजिटल ट्रॉमा के लिए धन्यवाद

s/^/ABC/
:
s/(.)(.*)\1/\2/
t

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

किसी कारण से TIO विस्तारित regex ( -r) के साथ काम नहीं करता है , इसलिए मुझे इसे BASH में लपेटना पड़ा।

s/^/ABC/        # put ABC at the beginning of the string
:               # nameless label
s/(.)(.*)\1/\2/ # remove a duplicate letter
t               # branch to the nameless label if something changed
— रिले
स्रोत
नई लाइन, -nऔर Pअनावश्यक हैं। इसके अलावा आप इसे टीआईओ में काम करने के लिए बैश में लपेट सकते हैं। पता नहीं क्यों -rकाम नहीं करता है tio.run/nexus/bash#DcmxDYAwDATA/qdIR4JELCjp7F8jooIFCPubb@/...
— डिजिटल ट्रामा
@DigitalTrauma धन्यवाद! मैं सोच रहा था कि जब मैंने यह लिखा है तो ए, बी और सी के अलावा भी कुछ किरदार होंगे।
— रिले
3

ब्रेन-फ्लैक , 120 + 3 = 123 बाइट्स

<>((((((((()()){}){}){}){}){}())())())<>{({}(<()>)){(([({})]<>({}))){(<({}<>{})<>([{}]{}<>)>)}{}}{}{}<>{}{({}<>)<>}{}}<>

इसे -c3 बाइट्स जोड़कर ध्वज के साथ चलाया जाता है

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

व्याख्या

कुल मिलाकर यह कार्यक्रम बहुत ज्यादा सही स्टैक सेट करता है जो कि लेफ्ट स्टैक के साथ माइनस लेफ्ट स्टैक होता है जिसे इनिशियलाइज़ किया जाता है CBA और लेफ्ट स्टैक इनपुट से इनिशियलाइज़ होता है।

एनोटेट कोड

<>((((((((()()){}){}){}){}){}())())())<> # Switch to right stack, push CBA, switch back
{({}(<()>)){(([({})]<>({}))){(<({}<>{})<>([{}]{}<>)>)}{}}{}{}<>{}{({}<>)<>}{}}<>

अधिक स्पष्टीकरण आने के लिए ...

— 0 '
स्रोत
2

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

Complement@@Characters@{"ABC",#}<>""&
— मार्टिन एंडर
स्रोत
क्या आप पात्रों की सूची के बजाय यहाँ तार का उपयोग करते हैं?
— ग्रेग मार्टिन
@GregMartin आदत, मुझे लगता है
— मार्टिन
बस मुझे लगता है कि अगर आप बच सकते हैं तो यह कम हो जाता हैCharacters
— ग्रेग मार्टिन
2

गाजर , 15 बाइट्स, गैर-प्रतिस्पर्धात्मक

एक बग के कारण गैर-प्रतिस्पर्धा, जो मुझे मैच और खाली तारों के साथ मिला। इसलिए मैंने इसे ठीक किया

ABC^//[^#]/gS""

इसे ऑनलाइन आज़माएं! (कॉपी पेस्ट)

व्याख्या

ABC^                   //sets stack (just a string, not an array) to "ABC"
    /                  //return match(es) of:
     /[^#]/g           // `#` is the placeholder for the input
                       // so effectively, this returns the matches of any character not present in the input
                       // applied on the stack
                       //this returns an array of all the matches of the regex
            S""        //join all the elements of the array using "", the empty string
— क्रिक्टी लिथोस
स्रोत
2

अष्टक, २ ९ 27 बाइट्स

कॉल के 'ABC'अंदर, स्ट्रिंग बनाकर, स्वेअर के लिए दो बाइट्स को सहेजा गया ismember।

@(s)x(~ismember(x='ABC',s))

हम ~ismember()चर के लिए तार्किक सूचक के रूप में उपयोग करते हैं x। अजीबोगरीब चीज है, हम x='ABC' अंदर पैदा करते हैंismember , उसके सामने नहीं। ऑर्डर ऑक्टेव इसे देखता है:

@(s)                        % Anonymous function that takes a string s as input
                x='ABC'     % Create a variable x with the characters 'ABC'
       ismember(x='ABC',s)  % True for elements that are in both x and s. False otherwise.
      ~ismember(x='ABC',s)  % Negate this, so that we keep the characters that aren't in s
@(s)x(~ismember(x='ABC',s)) % Use the logical vector as indices to x and return the result
— स्टीवी ग्रिफिन
स्रोत
2

सी #, 50 बाइट्स 32 बाइट्स 47 बाइट्स 35 बाइट्स

iइनपुट कहाँ है:

i=>string.Join("","ABC".Except(i));

LINQPad में परीक्षण किया गया पूर्ण ऐप

void Main()
{
    var testcases = new Dictionary<string,string[]>
    {
        ["ABC"] = new[]{""},
        ["ACB"] = new[]{""},
        ["BCA"]  = new[]{""},
        ["BAC"]  = new[]{""},
        ["CAB"]  = new[]{""},
        ["CBA"]  = new[]{""},
        ["AB"] = new[]{"C"},
        ["AC"] = new[]{"B"},
        ["BC"] = new[]{"A"},
        ["BA"] = new[]{"C"},
        ["CA"] = new[]{"B"},
        ["CB"] = new[]{"A"},
        ["A"] = new[]{"BC","CB"},
        ["B"] = new[]{"CA","AC"},
        ["C"] = new[]{"AB","BA"},
        [""] = new[]{"ABC","ACB","BCA","BAC","CAB","CBA"},
    };

    var output = "";

    foreach(var input in testcases.Keys)
    {
        var expect = testcases[input];
        var actual = GetResult(input);
        if(!expect.Contains(actual)) throw new ApplicationException($"{input}:{string.Join(",",expect)}:{actual}");
        output+=$"{input} -> {actual}\n";
    }
    output.Dump();
}

// Define other methods and classes here
private string GetResult(string input){
    return string.Join("","ABC".Except(i));
}

परीक्षण के परिणाम

एबीसी ->
एसीबी ->
बीसीए ->
बीएसी ->
टैक्सी ->
CBA ->
एबी -> सी
एसी -> बी
बी सी -> एक
बीए -> सी
सीए -> बी
सीबी -> एक
एक -> ई.पू.
बी -> एसी
सी -> एबी
-> एबीसी

— माइकल कॉक्सन
स्रोत
1
यह एक मान्य उत्तर नहीं है, यह एक फ़ंक्शन या प्रोग्राम होना चाहिए, न कि एक कोड स्निपेट।
— Theonlygusti
आह। मेरी गलती। यहां पहले टाइमर। तो क्या मुझे इसमें प्रिंट पार्ट चाहिए?
— माइकल कॉक्सन
@ मिचेलकोक्सन: आपको या तो पूरे कार्यक्रम में प्रवेश करने की आवश्यकता है, जो संकलित करता है (सी # में अनुशंसित नहीं है, इसमें बहुत सारे बॉयलरप्लेट हैं), या एक फ़ंक्शन में जिसे कई बार कहा जा सकता है; फिलहाल यह सिर्फ एक बयान है। C # में, लंबोदा बनाकर इसे फंक्शन में बनाना लगभग हमेशा सबसे आसान है, जो इसके तर्कों के माध्यम से इनपुट लेता है, और इसके रिटर्न वैल्यू के माध्यम से रिटर्न करता है।
string.Join("",...)-> string.Concat(...)1 बाइट बचाता है
— अज्ञानता
1

एपीएल, 7 बाइट्स

'ABC'∘~

~घटाव सेट किया गया है, ∘रचना है, इसलिए यह एक ऐसा कार्य है जो ABCइसके इनपुट में वर्णों को देता है ।

— मारीनस
स्रोत
1

पर्ल 5.9.9 79 38 37 35 बाइट्स

perl -le '$_="ABC";eval"y/$ARGV[0]//d";print'

(यहाँ गिनती के नियमों के बारे में सुनिश्चित नहीं है - इसमें स्विच शामिल हैं लेकिन पर्ल कमांड नहीं)।

> perl -le '$_="ABC";eval"y/$ARGV[0]//d";print' AB
C
> perl -le '$_="ABC";eval"y/$ARGV[0]//d";print'
ABC

(नीचे टिप्पणी के बाद समायोजित की गई गणना)

— टॉम टान्नर
स्रोत
क्या वह खाली इनपुट के लिए काम करेगा?
— टाइटस
अब मैंने प्रतिलेखन त्रुटि ("" .. ", टाइप किया {,} यहाँ ...) तय किया
— टॉम
आपका कोड 35 बाइट्स लंबा है। ( -lझंडे के लिए 34 +1 )। :)
— पॉल पिकार्ड
धन्यवाद। -L प्रेटिफिकेशन के लिए है (जैसा कि आउटपुट के अंत में एक नई पंक्ति में है।)। यकीन नहीं था कि अगर प्रतियोगिता नियमों से आवश्यक था।
— टॉम टैनर
5.14+ के साथ , आप perl -pe'$_=eval"ABC=~y/$_//dr"'केवल 23 बाइट्स (22 + 1 के लिए -p) कर सकते हैं।
— ThisSuitIsBlackNot
1

आम लिस्प, 71 बाइट्स

इस समय सबसे बड़ी प्रविष्टि, लेकिन कम से कम यह पठनीय है ;-)

(lambda(s)(coerce(set-difference'(#\A #\B #\C)(coerce s'list))'string))
— कोर निपात
स्रोत
1

सी, 53 बाइट्स

b=64;c(char*a){while(b<67)putchar(++b*!strchr(a,b));}

यदि स्ट्रिंग के निहित घोषणाओं को जोड़ने की अनुमति नहीं है, तो 72 बाइट्स जोड़ने के लिए#include<string.h>

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

या 75 बाइट्स में कुछ अधिक मजेदार है

a[128]={};b=64;c(char*d){while(*d)++a[*d++];while(b<67)putchar(b*!a[++b]);}

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

— Ahemone
स्रोत
— छत
1

बैच, 101 बाइट्स

@set/ps=
@for %%c in (L E J)do @call set d=%%s:%%c=%%&call:c %%c
:c
@if "%d%"=="%s%" set/pd=%1<nul

एसटीडीआईएन पर इनपुट लेता है, जिसका मतलब है कि %1कोड खाली होने पर उप-सहायक के माध्यम से कोड खाली हो जाता है और कुछ भी प्रिंट नहीं होता है।

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