एक इंटरफ़ेस बनाएँ जो XKCD प्रकारों पर फिट बैठता है


34

color.rgb ("नीला") "# 0000FF" पैदावार देता है। color.rgb ("पीला नीला") पैदावार NaN। color.sort () पैदावार "इंद्रधनुष"

छवि में निर्धारित नियमों और इसके शीर्षक पाठ (यहां उद्धृत) का उपयोग करके, एक प्रोग्राम बनाएं जो सभी दिए गए इनपुट को स्वीकार करता है और उचित आउटपुट प्रदर्शित करता है।

  • इनपुट स्टड या निकटतम समकक्ष के साथ लिया जा सकता है। एक पंक्ति ऐसी होनी चाहिए [n]>जिस पर इसे टाइप किया जा सके, और n1 प्रत्येक कमांड बढ़े। यह 1 से शुरू होना चाहिए।

  • परिणाम को स्टडआउट या निकटतम समकक्ष का उपयोग करके प्रदर्शित किया जाना चाहिए। =>आउटपुट के प्रत्येक लाइन पर होना चाहिए ।

सभी 13 शर्तों, प्लस शीर्षक में 3 (उद्धृत) काम करना चाहिए।

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


16
इंटरफ़ेस कितना सामान्य होना चाहिए? उदाहरण के लिए, क्या फ़्लोर फ़ंक्शन को किसी भी फ़्लोटिंग के लिए काम करना पड़ता है या क्या हम मान सकते हैं कि यह केवल कभी पारित किया जाएगा 10.5?
अंख-मोर्फर्क

1
क्या इनपुट के लिए आउटपुट के साथ> n के रूप में बढ़ता है और इनपुट> दाईं ओर आगे बढ़ता है?
शुक्राणु

1
इस कॉमिक की संभावित रूप से कई तरह से व्याख्या की जा सकती है। क्या आप इस बात की सूची प्रदान कर सकते हैं कि हमें किन विशिष्ट प्रकार और कार्यों को लागू करने की आवश्यकता है?
ब्रेनसैट

5
n1 से क्यों बढ़नी चाहिए ? यही वह बात नहीं है जो कॉमिक करता है ... ;-)
मोनिका

3
@WolframH यह है - लेकिन उसने कमांड 11 में 2 = 4 बनाया है इसलिए यह 14 नहीं 12 प्रदर्शित करता है
टिम

जवाबों:


21

अजगर 3, 700 698 697 689 683 639 611

इंडेंटेशन के रूप में टैब।

from ast import*
E=literal_eval
O='=>%s\n'
P=print
I=int
def Q(a):P(O%a)
def W(a):Q('"%s"'%str(a))
def gb(a):W(_ if'y'in a else'#0000FF')
def t():W('rainbow')
def FLOOR(n):P(O%'|'*3+(O%'|{:_^10}').format(n))
def RANGE(*a):Q([('"','!',' ','!','"'),(1,4,3,4,5)][len(a)])
c=0
while 1:
    try:
        c+=1;A,*B=input('[%d]>'%c).split('+')
        if not A:W(c+I(B[0]))
        elif A=='""':Q("'\"+\"'")
        elif B:
            A=E(A);B=E(B[0])
            if A==B:Q('DONE')
            elif type(A)==list:Q(A[-1]==B-1)
            elif type(B)==list:W([I(A)])
            else:W(A+I(B))
        else:eval(A.lstrip('colrs.'))
    except:Q('Na'+['N','P','N.%s13'%('0'*13)][('-'in A)+len(B)])

चूंकि यह एक नंगे का उपयोग करता है सिवाय इसके कि आप इसे Ctrl-C नहीं कर सकते। Ctrl-Z और मार%% हालांकि काम करते हैं

कुछ शर्तें सामान्यीकृत हैं और अन्य केवल सटीक इनपुट के साथ काम करेंगे।

  1. A+"B" किसी भी ए और बी के साथ काम करेंगे जब नहीं A == B
  2. "A"+[] किसी भी ए के लिए काम करेगा जिसे इंट में परिवर्तित किया जा सकता है (जिसमें हेक्स और बाइनरी स्ट्रिंग्स जैसे 0xff और 0b01010 शामिल हैं)
  3. (A/0)किसी भी ए, एवल कॉज के लिए काम करेगा, DivideByZeroErrorजो इसके अलावा है
  4. (A/0)+Bकिसी भी ए या बी literal_eval(ई) के साथ काम करेगा एक त्रुटि उठाता है।
  5. ""+""केवल + चिह्न के लिए काम करता है। और कुछ भी NaN, NaP या NaN.00 प्रिंट करेगा ...
  6. [A, B, C]+Dजाँच करके काम करता है D == C+1ताकि सूची की किसी भी लंबाई और किसी भी संख्या के लिए काम हो।
  7. ^^
  8. 2/(2-(3/2+1/2)), कुछ भी जो पार्स करने में विफल रहता है उसके बाद कहीं न कहीं इसके -साथ +NaN.000 का उत्पादन होगा ... 13
  9. RANGE(" ") हार्ड कोडित
  10. +A किसी A. Ouputs के लिए काम करेगा "current_line_number+A"
  11. A+A किसी भी ए के लिए काम करता है जब तक वे एक ही हैं और bulitin अजगर प्रकार हैं
  12. RANGE(1,5) हार्ड कोडित।
  13. FLOOR(A) किसी भी ए के लिए काम करता है।
  14. colors.rgb("blue")Eval में lstrip यह gb("blue")एक हार्डकोड प्रतिक्रिया है जिसमें बदल जाता है ।
  15. colors.rgb("yellowish blue")Eval में lstrip यह बदल जाता है gb("yellowish blue")जिसमें गैर-मौजूद वैरिएबल का उपयोग करने का प्रयास किया yजाता है यदि तर्क में कोई त्रुटि होती है, जो अपवाद को छोड़कर NaN में बदल जाती है
  16. colors.sort()लेस्ट्रिप यह बदल जाता है t()जिसमें एक हार्डकोड प्रतिक्रिया होती है।

ब्रेनस्टील ने नियम 10 के लिए मेरी धारणा में एक त्रुटि बताई।


बहुत साफ़। मुझे लगता है, # 10 पर, ऐसा लगता है कि "+ ए" का उद्देश्य लाइन नंबर + ए का उत्पादन करना है , न कि केवल 1 से पहले से चल रहा है।
ब्रेनसैट

आह हाँ, अब स्पष्ट है कि इसकी ओर इशारा किया। खैर इसका मतलब है कि इंट एक ही अक्षर फ़ंक्शन के रूप में बेहतर होगा। एक बाइट या दो बचा सकता है।
डैनियल वेकफील्ड

re # 9: RANGE(" ")दोहरे वर्ण वाले वर्ण \ x22 से लेकर अंतरिक्ष वर्ण \ x20 और पीछे के वर्णों की एक श्रृंखला है।
जॉन ड्वोरक

3
फिर से कूदें: क्योंकि रान्डेल 11, 2 पंक्ति में 4 पर सेट 2है 4और अब 12 है। 14. यह पंक्ति संख्याओं पर भी लागू होता है।
जॉन ड्वोरक

2
आप अपने इंडेंटेशन के लिए स्पेस, टैब और टैब + स्पेस का उपयोग करके कुछ बाइट्स बचा सकते हैं।
टायरो

16

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

ऑपरेटर ओवरलोडिंग बुराई नहीं है, है ना ??

from re import*
class V(str):
 def __add__(s,r):return s[:-1]+chr(ord(s[-1])+r)
class S(str):
 def __str__(s):return "'"+s+"'"if '"'in s else'"'+s+'"'
 def __repr__(s):return str(s)
 def __add__(s,r):s=str(s)[1:-1];return S('['+s+']'if type(r)==L else '"+"' if(s,r)==('','')else s+r)
class I(int):
 def __add__(s,r):return type(r)(int(s)+int(r))if s!=r else V('DONE')
 def __div__(s,r):return N if r==0 else int(s)/int(r)
 def __pos__(s):return s+c*10
 def __mul__(s,r):return V('NaN.'+'0'*13+'13')if r==1 else int(s)*int(r)
class L(list):
 def __add__(s,r):return V(str(r==s[-1]+1).upper())
def RANGE(a,b=0):return 2*(a,S(chr(ord(a)+1)))if b==0 else tuple([a]+[b-1,a+2]*((b-a)/4)+[b-1,b])
def FLOOR(n):return V('|\n|\n|\n|___%s___'%n)
def colorsrgb(c):
 m={'blue':V('#0000FF')}
 return m.get(c,N)
def colorssort():return V('rainbow')
N=V('NaN')
c=1
while True:
 try:l=raw_input('[%d] >'%c)
 except:break
 l=sub(r'(?<!"|\.)(\d+)(?!\.|\d)',r'I(\1)',l)
 l=sub(r'"(.*?)"',r'S("\1")',l)
 l=sub(r'\[(.*?)\]',r'L([\1])',l)
 l=sub(r'/\(','*(',l)
 l=sub('s\.','s',l)
 for x in str(eval(l)).split('\n'):print ' =',x
 c+=1

मेरा लक्ष्य उतना जीतना नहीं था (स्पष्ट रूप से) क्योंकि यह इसे यथासंभव सामान्य बना रहा है। बहुत कम हार्डकोड होता है। की तरह सामान की कोशिश करो RANGE(10), 9*1और RANGE("A"), (2/0)+14और "123"मज़ा परिणामों के लिए!

यहाँ एक नमूना सत्र है:

ryan@DevPC-LX:~/golf/xktp$ python xktp.py
[1] >ryan@DevPC-LX:~/golf/xktp$ python xktp.py
[1] >1+1
 = DONE
[2] >2+"2"
 = "4"
[3] >"2"+2
Traceback (most recent call last):
  File "xktp.py", line 31, in <module>
    for x in str(eval(l)).split('\n'):print ' =',x
  File "<string>", line 1, in <module>
  File "xktp.py", line 7, in __add__
    def __add__(s,r):s=str(s)[1:-1];return S('['+s+']'if type(r)==L else '"+"' if(s,r)==('','')else s+r)
TypeError: cannot concatenate 'str' and 'I' objects
ryan@DevPC-LX:~/golf/xktp$ python xktp.py
[1] >ryan@DevPC-LX:~/golf/xktp$
ryan@DevPC-LX:~/golf/xktp$
ryan@DevPC-LX:~/golf/xktp$
ryan@DevPC-LX:~/golf/xktp$ python xktp.py
[1] >2+"2"
 = "4"
[2] >"2"+[]
 = "[2]"
[3] >"2"+[1, 2, 3]
 = "[2]"
[4] >(2/0)
 = NaN
[5] >(2/0)+2
 = NaP
[6] >(2/0)+14
 = Na\
[7] >""+""
 = '"+"'
[8] >[1,2,3]+2
 = FALSE
[9] >[1,2,3]+4
 = TRUE
[10] >[1,2,3,4,5,6,7]+9
 = FALSE
[11] >[1,2,3,4,5,6,7]+8
 = TRUE
[12] >2/(2-(3/2+1/2))
 = NaN.000000000000013
[13] >9*1
 = NaN.000000000000013
[14] >RANGE(" ")
 = (" ", "!", " ", "!")
[15] >RANGE("2")
 = ("2", "3", "2", "3")
[16] >RANGE(2)
Traceback (most recent call last):
  File "xktp.py", line 31, in <module>
    for x in str(eval(l)).split('\n'):print ' =',x
  File "<string>", line 1, in <module>
  File "xktp.py", line 15, in RANGE
    def RANGE(a,b=0):return 2*(a,S(chr(ord(a)+1)))if b==0 else tuple([a]+[b-1,a+2]*((b-a)/4)+[b-1,b])
TypeError: ord() expected string of length 1, but I found
ryan@DevPC-LX:~/golf/xktp$ python xktp.py
[1] >ryan@DevPC-LX:~/golf/xktp$ # oops
ryan@DevPC-LX:~/golf/xktp$ python xktp.py
[1] >RANGE("2")
 = ("2", "3", "2", "3")
[2] >RANGE(2*1)
Traceback (most recent call last):
  File "xktp.py", line 31, in <module>
    for x in str(eval(l)).split('\n'):print ' =',x
  File "<string>", line 1, in <module>
  File "xktp.py", line 15, in RANGE
    def RANGE(a,b=0):return 2*(a,S(chr(ord(a)+1)))if b==0 else tuple([a]+[b-1,a+2]*((b-a)/4)+[b-1,b])
TypeError: ord() expected a character, but string of length 19 found
ryan@DevPC-LX:~/golf/xktp$ python xktp.py # oops again
[1] >RANGE(1,20)
 = (1, 19, 3, 19, 3, 19, 3, 19, 3, 19, 20)
[2] >RANGE(1,5)
 = (1, 4, 3, 4, 5)
[3] >RANGE(10,20)
 = (10, 19, 12, 19, 12, 19, 20)
[4] >RANGE(10,200)
 = (10, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 12, 199, 200)
[5] >+2
 = 52
[6] >+"99"
Traceback (most recent call last):
  File "xktp.py", line 31, in <module>
    for x in str(eval(l)).split('\n'):print ' =',x
  File "<string>", line 1, in <module>
TypeError: bad operand type for unary +: 'S'
ryan@DevPC-LX:~/golf/xktp$ python xktp.py # oops again and again!
[1] >FLOOR(200)
 = |
 = |
 = |
 = |___200___
[2] >2+2
 = DONE
[3] >3+#
Traceback (most recent call last):
  File "xktp.py", line 31, in <module>
    for x in str(eval(l)).split('\n'):print ' =',x
  File "<string>", line 1
    I(3)+#
         ^
SyntaxError: unexpected EOF while parsing
ryan@DevPC-LX:~/golf/xktp$ python xktp.py
[1] >3+3
 = DONE
[2] >ryan@DevPC-LX:~/golf/xktp$

7

सी, 412 बाइट्स

यह मूल रूप से हार्डकोड है, लेकिन अब तक के सभी अन्य उत्तर कुछ याद कर रहे थे ...

i;char b[99];main(){for(;;){printf("[%d]>",abs(++i));gets(b);i-=b[2]==50?26:0;printf("=>");puts(*b==82?b[6]==34?"('\"',\"!\",\" \",\"!\",'\"')":"(1,4,3,4,5)":*b==70?"|\n=>|\n=>|\n=>|___10.5___":*b==43?"12":*b==91?b[8]==50?"FALSE":"TRUE":*b==34?b[1]==34?"'\"+\"'":"\"[2]\"":*b==40?b[5]==43?"NaP":"NaN":*b==99?b[7]=='s'?"rainbow":b[12]==98?"#0000FF":"NaN":b[1]==43?b[2]==34?"\"4\"":"DONE":"NaN.000000000000013");}}

आउटपुट:

[1]>2+"2"
=>"4"
[2]>"2"+[]
=>"[2]"
[3]>(2/0)
=>NaN
[4]>(2/0)+2
=>NaP
[5]>""+""
=>'"+"'
[6]>[1,2,3]+2
=>FALSE
[7]>[1,2,3]+4
=>TRUE
[8]>2/(2-(3/2+1/2))
=>NaN.000000000000013
[9]>RANGE(" ")
=>('"',"!"," ","!",'"')
[10]>+2
=>12
[11]>2+2
=>DONE
[14]>RANGE(1,5)
=>(1,4,3,4,5)
[13]>FLOOR(10.5)
=>|
=>|
=>|
=>|___10.5___

5

अजगर 3, 298

सब कुछ हार्डकोड किया गया है, लेकिन इनपुट को एक संख्या में बदल दिया जाता है, जिसे बाद में एक स्ट्रिंग में बदल दिया जाता है और एक बड़े स्ट्रिंग में देखा जाता है जिसमें ये सभी नंबर होते हैं जिनके बाद उनके उत्तर होते हैं।

B="""53"#0000FF"~62DONE~43NaN.000000000000013~25(1,4,3,4,5)~26"rainbow"~49"4"~21"[2]"~29FALSE~15|*|*|*|___10.5___~17'"+"'~1212~60('"',"!"," ","!",'"')~24NaN~31TRUE~64NaN~76NaP"""
i=0
while 1:i+=1;s=input("[%s]>"%i);print("=>"+B[B.find(str(sum(map(ord,s))%81))+2:].split("~")[0].replace("*","\n=>"))

1

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

चूँकि यहाँ मेरे समाधान का पूर्ण रूप से उल्लेख नहीं था।

a={'2+"2"':'"4"','"2"+[]':'"[2]"',"(2/0)":"NaN","(2/0)+2":"NaP",'""+""':"'\"+\"'","[1,2,3]+2":"FALSE","[1,2,3]+4":"TRUE","2/(2-(3/2+1/2))":"NaN.000000000000013",'RANGE(" ")':'(\'"\',"!"," ","!",\'"\')',"+2":"12","2+2":"DONE","RANGE(1,5)":"(1,4,3,4,5)","FLOOR(10.5)":"|\n|\n|\n|___10.5___",'colors.rgb("blue")':'"#0000FF"','colors.rgb("yellowish blue")':"NaN","colors.sort()":'"rainbow"'}
i=1
while 1:b=a[input("[%i]>"%i).replace("\t","")].split("\n");print("=> "+"\n=> ".join(b));i+=1

हार्डकोडिंग ठीक है, लेकिन मुझे लगता है कि डिफ़ॉल्ट रूप से मना की गई कमियां डिफ़ॉल्ट रूप से मना की जाती हैं। : पी
lirtosiast

@ThomasKwa मुझे यहां कुछ भी दिखाई नहीं दे रहा है जो निषिद्ध लूपहोल है। है?
एथन बीरेलिन

1
सब कुछ मेरे अनुरूप लगता है। मैंने पहले माना था कि आप एक खामियों का शोषण कर रहे थे क्योंकि आपने कहा था कि "[...] मानक खामियों का कोई उल्लेख नहीं है"।
lirtosiast

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

2
आप दोनों उद्धरणों का उपयोग करके एक अच्छी राशि बचा सकते हैं। "2+\"2\""बन जाता है '2+"2"'। यदि आप एक काउंटर वैरिएबल जोड़ते हैं तो इम्पोर्टिंग काउंट को भी हटाया जा सकता है।
डैनियल वेकफील्ड
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.