बाहर निकलें कोड गोल्फिंग


55

IO के लिए इस डिफ़ॉल्ट से प्रेरित ।

काम

एक प्रोग्राम लिखें, xजिसमें 0 और 255 के बीच इनपुट पूर्णांक दिया गया है, जो एक्जिट कोड के साथ क्रैश करता है x

प्रतिबंध

  • आप कुछ भी नहीं कह सकते हैं जो सीधे बाहर निकलने के कोड उत्पादन के लिए अभिप्रेत है ( System.exit(x), से लौटकर main, आदि)। इसके बजाय, आपके प्रोग्राम को एक त्रुटि या दुर्घटना का कारण बनना चाहिए, जो 1 की संभावना के साथ, इनपुट पूर्णांक के साथ बाहर निकलने का कार्यक्रम होगा।
    • इस मामले में, शब्द "त्रुटि" और "क्रैश" का अर्थ है कि कार्यक्रम में कुछ घातक अनपेक्षित अपवाद थे, जिसमें एक विधि, संचालन या अन्यथा गलत तरीके से उपयोग किया गया था जो एक अपरिवर्तनीय विफलता का कारण बना।
    • आप सीधे सीधे इसे फेंककर त्रुटि का कारण नहीं हो सकते हैं। आपको एक विधि, फ़ंक्शन या अन्यथा का उपयोग करके इसका कारण होना चाहिए, जिसका उद्देश्य एक अलग कार्य करता है (यानी एक फाइल-रीड-ओनली डायरेक्टरी को लिखने के लिए निष्पादित करने का प्रयास)।
  • आपके कार्यक्रम में कम से कम दो निकास कोड होने चाहिए।
  • संकेतों के उपयोग के साथ प्रक्रिया को समाप्त करना प्रतिबंधित है। ( इस चर्चा में तर्क मिल सकता है )

स्कोरिंग

आपके प्रोग्राम का स्कोर समर्थित एक्ज़िट कोड की संख्या से निर्धारित होता है, जहाँ कोड कॉन्सेप्ट टाईब्रेकर है। समर्थित निकास कोड की सबसे बड़ी संख्या जीतती है!


बस स्पष्ट करने के लिए, अगर मैं एक त्रुटि बढ़ाता हूं, तो वह अवैध है?
एंथोनी फाम

@AnthonyPham यदि आप सीधे इसे ( throw new Exception()शैली) बढ़ाते हैं , तो यह अवैध है। यदि यह किसी मौजूदा फ़ंक्शन के दुरुपयोग का उपोत्पाद है, तो यह ठीक है।
Addison Crump

@VoteToClose मुझे लगता है कि मैं पर्याप्त स्पष्ट नहीं था। मैं आपसे सहमत हूं, लेकिन गुटबाजी के बजाय, वर्ग का सुझाव दे रहा था। लेकिन जो भी हो, यह वास्तव में मायने नहीं रखता है, सिर्फ एक सुझाव था
माल्टीसेन

8
क्या इनपुट को वर्तनी से बाहर के अंग्रेजी अंकों (जैसे one zero zero100 के लिए) स्वीकार्य है? इस चुनौती के लिए मेरे पास एक विचार है, लेकिन भाषा में I / O के बारे में कुछ असामान्य विचार हैं, और यह सबसे प्राकृतिक इनपुट प्रारूप है।

5
मैं एक्ज़िट कोड पर क्लिकबिट शीर्षक पर विचार करूंगा, हालांकि यह सही है। <(° _ ° <)
RaisingAgent

जवाबों:


48

यूनिक्स शैल (+ ncurses + BSD उपयोगिताओं), 36, 26 बाइट्स, 256 निकास कोड

golfed

jot -bu0 $[252+$1]|tput -S

यदि -S विकल्प का उपयोग किया जाता है, तो प्रत्येक लाइन से त्रुटियों के लिए tput जाँच होती है, और यदि कोई त्रुटि पाई जाती है, तो एक्ज़िट कोड को 4 पंक्तियों की संख्या के साथ सेट कर देगा। यदि कोई त्रुटि नहीं पाई जाती है, तो बाहर निकलने का कोड है। 0. कोई संकेत नहीं है कि कौन सी रेखा विफल हुई है, इसलिए बाहर निकलें कोड 1 कभी नहीं दिखाई देगा। कोड 2, 3 और 4 से बाहर निकलें और अपनी सामान्य व्याख्या बनाए रखें।

एक बार जब tput एग्जिट कोड 255 से अधिक हो जाता है, तो यह ओवरफ्लो हो जाता है, इसलिए 253 (इनपुट पर त्रुटियां) 1 के एग्जिट कोड के परिणामस्वरूप होंगी, इस प्रकार इनपुट की पूरी रेंज के लिए वांछित एक्जिट स्टेटस प्राप्त होता है।

नोट : किसी विशेष क्षमता को स्थापित / प्राप्त करते समय tput विफल होगा, टर्मिनल प्रकार पर निर्भर करता है, मैंने उपयोग किया है:xterm with 256 colors

jot एक BSD उपयोगिता है, जो अनुक्रमिक या यादृच्छिक डेटा प्रिंट करता है, और (AFAIK) OSX सिस्टम पर बॉक्स से बाहर भी उपलब्ध है।

यदि आपका सिस्टम jotउपलब्ध नहीं है , तो आप थोड़े लंबे (29 बाइट्स) संस्करण का उपयोग कर सकते हैं:

yes u0|sed $[252+$1]q|tput -S

यह ऑनलाइन की कोशिश करो! (29 बाइट्स संस्करण)


वाह, यह बहुत अच्छा है। +1
Addison Crump

45

बैश 4.2 + एक्सट्रा, 24 एग्जिट कोड

grep \#$1$ $0|sed 's:#.*::;s:T:tcc -run -<<<main=:;s:C:curl -L x.org/! :'|sh;exit
man#1
C-#2
C/#3
sed#4
C-x/#5
C_#6
C0#7
man /#16
C-f#22
C-o/#23
C-L3#35
C--capath /#60
C--max-filesize 1#63
C--cacert /#77
timeout 1e-9 w#124
/#126
-#127
T6\;#132
T204\;#133
$[2**63%-1]#136
{0..1000000000}#137
T0\;#139
exit _#255

3 निकास कोड के लिए @ KenY-N का धन्यवाद। 1 निकास कोड के लिए @ el.pescado का धन्यवाद।

सत्यापन

सभी परीक्षण खुलेआम 13.2 पर किए गए हैं।

$ for n in {0..255}; do bash exit.sh $n; (($? == $n)) && echo $n >&0; done &> /dev/null
0
1
2
3
4
6
7
16
22
23
35
60
63
77
124
126
127
132
133
136
137
139
255

1
बाहर निकलें कोड 5:http_proxy=fafa curl http://example.org
el.pescado

1
@ el.pescado यह मुझे एक वर्ष से अधिक समय लगा, लेकिन मैंने आखिरकार आपके सुझाव पर अमल किया। धन्यवाद!
डेनिस

30

INTERCAL (C-INTERCAL), 15 कोड, 313 + 2 = 315 बाइट्स

        PLEASE WRITE IN .1
(8)     PLEASE CREATE .1 A
        PLEASE A
        PLEASE COME FROM #2$!1/#1'

        DO X
(123)   DO (123) NEXT
        DO COME FROM (222)
(222)   DO STASH .2
(240)   DO ,1 <- #0
(241)   DO ,1 SUB #0 <- #1
(19)    DO .2 <- #256 $ #0
(21)    DO .1 <- #2
(148)   DO GO BACK
(180)   DO RETRIEVE .2
        DO COME FROM (50)
(50)    DO WRITE IN .2
(109)   DO RESUME #0
(120)   DO RESUME #9
        MAYBE COME FROM (223)
(223)   DO COME FROM (223)
(121)   PLEASE NOT X

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

यहाँ सभी व्हाट्सएप अप्रासंगिक है। (मूल कार्यक्रम में टैब शामिल थे, लेकिन मैंने उन्हें रिक्त स्थान में बदल दिया ताकि वह एसई पर सही ढंग से काम कर सके; यह इंटरकैल के लिए 8 की टैब चौड़ाई का उपयोग करने के लिए पारंपरिक है। मैंने सभी टैब, रिक्त स्थान के साथ कार्यक्रम के एक संस्करण का परीक्षण किया है। , और newlines नष्ट कर दिया, हालांकि, और यह ठीक काम करता है।)

संकलन -abm(2 बाइट पेनल्टी के साथ, क्योंकि -bकंपाइलर को नियतात्मक होना आवश्यक है)।

INTERCAL के लिए हमेशा की तरह, यह प्रारूप में, जैसे, के ONE TWO THREEलिए संख्यात्मक इनपुट लेता है 123

व्याख्या

जब C-INTERCAL प्रोग्राम में त्रुटियां होती हैं, तो बाहर निकलने की स्थिति में त्रुटि कोड मोडुलो 256 होता है। परिणामस्वरूप, हम एक ऐसे प्रोग्राम को लिखने का लक्ष्य बना सकते हैं, जो अधिक से अधिक रनटाइम त्रुटियों के उत्पादन में सक्षम हो। यह प्रोग्राम केवल दो रनटाइम त्रुटियों को छोड़ देता है जो आंतरिक संकलक मुद्दों को इंगित नहीं करते हैं: ICL200I, क्योंकि इसे पुन: प्रस्तुत करने के लिए बाहरी पुस्तकालयों के उपयोग की आवश्यकता होती है जो केवल एकल-थ्रेडेड प्रोग्राम के साथ संगत होते हैं (और मल्टीथ्रेडेड प्रोग्राम में अधिक त्रुटियां उपलब्ध हैं); और ICL533I, क्योंकि 533 में 277 के रूप में एक ही मूल्य modulo 256 है, और कार्यक्रम ICL277I के उत्पादन में सक्षम है।

कार्यक्रम हमेशा उसी तरह से शुरू होता है। सबसे पहले, हम WRITE INचर के लिए एक इनपुट ( ) मान देते हैं .1। फिर, हम CREATEनए वाक्यविन्यास (यहाँ, A) बनाने के लिए एक गणना कथन का उपयोग करते हैं ; लेकिन क्योंकि यह गणना है, वाक्यविन्यास की परिभाषा मूल्य के आधार पर भिन्न होती है .1। अंत में, ज्यादातर मामलों में हम अपना नया Aबयान चलाते हैं , जिसे एक त्रुटि उत्पन्न करने के लिए परिभाषित किया गया है; संभावित परिभाषाओं की तालिका में हमारे पास प्रत्येक संभावित रनटाइम त्रुटि (ऊपर सूचीबद्ध अपवादों के अलावा) की परिभाषा है।

सबसे पहले, इस सामान्य योजना के दो अपवाद हैं। (0)मान्य लाइन नंबर नहीं है, इसलिए यदि उपयोगकर्ता इनपुट करता है ZERO, तो हम (8)गणना किए गए COME FROMविवरण के माध्यम से दूसरी पंक्ति (क्रमांकित ) से चौथी पंक्ति तक कूदते हैं । यह तब एक सिंटैक्स त्रुटि में आता है DO X, जो त्रुटि पैदा करता है ICL000I। (INTERCAL में, वाक्यविन्यास त्रुटियां रनटाइम के दौरान होती हैं, क्योंकि आदेशों को निष्क्रिय करने की प्रवृत्ति के कारण, आपके तहत सिंटैक्स को फिर से परिभाषित किया जाना है, आदि)। COME FROMबयान में यह भी एक पक्ष प्रभाव भले ही कोई वास्तविक है, COME FROMहोता है से एक संकार्य अधिभार बनाने .1के लिए #1जब भी एक लाइन नंबर के साथ एक लाइन निष्पादित किया जाता है; इसका उपयोग बाद में आउटपुट 21 के उत्पादन में किया जाता है। (रैंडम वैश्विक साइड इफेक्ट INTERCAL में काफी मुहावरेदार हैं।)

अन्य अपवाद इनपुट के साथ है ONE TWO NINE(129)प्रोग्राम में कोई लाइन नंबर नहीं है , इसलिए हमें एक लापता लाइन नंबर के लिए एक त्रुटि मिलती है, जो कि है ICL129I। इसलिए मुझे उस केस को कवर करने के लिए कोई कोड लिखने की ज़रूरत नहीं थी।

यहां अन्य त्रुटियां हैं, और उनके कारण क्या हैं:

  • 123 एक NEXTस्टैक ओवरफ्लो ( DO (123) NEXT) है। इस NEXTकथन को पूर्वव्यापी रूप से निर्धारित करने के लिए अन्य संशोधक ( FORGETया RESUME) की आवश्यकता है कि यह किस प्रकार का नियंत्रण कथन था। एक बार 80 अनसुलझे `अगले कथनों में ICL123I के कारण उन त्रुटियों का नहीं होना।
  • 222 एक गुप्त कोष में अतिप्रवाह (है DO STASH .2एक में COME FROMपाश)। स्टैम्स केवल उपलब्ध मेमोरी द्वारा सीमित हैं, लेकिन यह अंततः बाहर चलेगा, जिससे ICL222I त्रुटि होगी।
  • 240 आयाम है एक सरणी का आकार शून्य है। ठीक यही DO ,1 <- #0मतलब है, और यह ICL240I त्रुटि का कारण बनता है।
  • 241 एक सरणी की सीमा के बाहर असाइन करने के कारण होता है। इस स्थिति में, ,1उन्हें आवंटित नहीं किया गया है ( ,INTERCAL में सरणी-प्रकार चर के लिए उपयोग किया जाता है), इसलिए इसे अनुक्रमित करने से ICL1.1I त्रुटि होती है।
  • 19#256 $ #0 एक 16-बिट चर के लिए 65536 ( ) असाइन करता है .2। यह फिट नहीं है, जिससे ICL275I त्रुटि हुई है।
  • 21 को असाइन करता #2है .1। यह एक साधारण पर्याप्त असाइनमेंट की तरह लग सकता है, लेकिन हम पहले .1से मतलब करने के लिए अतिभारित #1थे, और -vकमांड लाइन पर कोई विकल्प नहीं के साथ 1 के मूल्य को बदलने का प्रयास ICL277I त्रुटि का कारण बनता है।
  • 148 चॉइस पॉइंट स्टैक ( GO BACK) के शीर्ष प्रविष्टि पर लौटने का प्रयास करता है, जो कार्यक्रम में इस बिंदु पर मौजूद नहीं है (च्वाइसपॉइंट स्टैक में हेरफेर करने के लिए हमने कोई कमांड नहीं चलाया है, इसलिए यह अभी भी खाली है)। जो ICL404I त्रुटि का कारण बनता है।
  • 180RETRIEVE .2 एक बिना किसी रोक-टोक के प्रयास (क्योंकि हमने कार्यक्रम की इस शाखा में वहाँ कुछ भी नहीं किया था), जिसके कारण ICL236I त्रुटि हुई।
  • 50 अनुरोध इनपुट ( WRITE IN) हमेशा के लिए एक COME FROMलूप में। आखिरकार हम EOF पिछले पढ़ने को समाप्त कर देंगे, जिससे ICL562I त्रुटि होगी।
  • 109 स्टेटमेंट चलाता है DO RESUME #0, जो अर्थहीन है और विशेष रूप से एक त्रुटि (ICL621I) के रूप में प्रलेखित है।
  • 120 का बयान दिया DO RESUME #9। हमने NEXTअभी तक कई कथन नहीं चलाए हैं , और इस प्रकार हमें त्रुटि ICL120I मिलती है। (गहनता से, यह विशेष त्रुटि INTERCAL दस्तावेज़ में प्रोग्राम को सामान्य रूप से बाहर निकालने और फिर त्रुटि के कारण प्रोग्राम से बाहर निकलने के बजाय परिभाषित किया गया है। मुझे विश्वास नहीं है कि ये दोनों मामले अवलोकन से भिन्न हैं, हालांकि।)
  • 223 मूल रूप से मल्टीथ्रेडिंग प्राइमेटिक्स की एक जटिल उलझन है जो सभी 223 लाइन पर वापस आती है, जिससे एक अनंत लूप बनता है जो स्मृति को उड़ा देता है। आखिरकार, मल्टीथ्रेडिंग सबसिस्टम में मेमोरी थकावट होती है, जिससे ICL991I त्रुटि होती है।
  • 121 वास्तव में एक वैध कथन है (यह एक टिप्पणी है), लेकिन यह कार्यक्रम के अंत में दिखाई देता है। जैसे कि, निष्पादन के तुरंत बाद कार्यक्रम समाप्त हो जाता है, जिससे ICL633I त्रुटि होती है।

सत्यापन

कुछ त्रुटियों में जानबूझकर प्रोग्राम को मेमोरी से बाहर चलाना शामिल है, इसलिए मैं सुझाव देता हूं कि काफी छोटी मेमोरी लिमिट सेट करें। यहाँ शेल कमांड है जिसे मैंने प्रोग्राम का परीक्षण करने के लिए इस्तेमाल किया था (पठनीयता के लिए नई सूचियों के साथ, यदि आप इसे स्वयं चलाते हैं तो उन्हें हटा दें):

for x in "ZERO" "ONE NINE" "TWO ONE" "FIVE ZERO" "ONE ZERO NINE"
         "ONE TWO ZERO" "ONE TWO ONE" "ONE TWO THREE" "ONE TWO NINE"
         "ONE FOUR EIGHT" "ONE EIGHT ZERO" "TWO TWO TWO"
         "TWO TWO THREE" "TWO FOUR ZERO" "TWO FOUR ONE";
do  echo;
    echo $x;
    echo $x | (ulimit -Sd 40000; ulimit -Sv 40000; ulimit -Ss 40000;
               ./errors; echo $?);
done

और यहां आउटपुट (लाइन नंबरों और "कृपया सहेजें स्रोत" संदेशों को स्थान बचाने के लिए हटा दिया गया है), जिसे मैंने आंशिक रूप से कार्यक्रम को प्रदर्शित करने के लिए जोड़ा, लेकिन ज्यादातर इंटरकैल के मूर्खतापूर्ण त्रुटि संदेशों को दिखाने के लिए:

ZERO
ICL000I PLEASEWRITEIN.1(8)PLEASECREATE.1APLEASEAPLEASECOMEFROM#2$!1/#1'DOX(123)DO(123)NEXTDOCOMEFROM(222)(222)DOSTASH.2(240)DO,1<-#0(241)DO,1SUB#0<-#1(19)DO.2<-#256$#0(21)DO.1<-#2(148)DOGOBACK(180)DORETRIEVE.2DOCOMEFROM(50)(50)DOWRITEIN.2(109)DORESUME#0(120)DORESUME#9MAYBECOMEFROM(223)(223)DOCOMEFROM(223)(121)PLEASENOTX
0

ONE NINE
ICL275I DON'T BYTE OFF MORE THAN YOU CAN CHEW
19

TWO ONE
ICL277I YOU CAN ONLY DISTORT THE LAWS OF MATHEMATICS SO FAR
21

FIVE ZERO
ICL562I I DO NOT COMPUTE
50

ONE ZERO NINE
ICL621I ERROR TYPE 621 ENCOUNTERED
109

ONE TWO ZERO
ICL632I THE NEXT STACK RUPTURES.  ALL DIE.  OH, THE EMBARRASSMENT!
120

ONE TWO ONE
ICL633I PROGRAM FELL OFF THE EDGE
121

ONE TWO THREE
ICL123I PROGRAM HAS DISAPPEARED INTO THE BLACK LAGOON
123

ONE TWO NINE
ICL129I PROGRAM HAS GOTTEN LOST
129

ONE FOUR EIGHT
ICL404I I'M ALL OUT OF CHOICES!
148

ONE EIGHT ZERO
ICL436I THROW STICK BEFORE RETRIEVING!
180

TWO TWO TWO
ICL222I BUMMER, DUDE!
222

TWO TWO THREE
ICL991I YOU HAVE TOO MUCH ROPE TO HANG YOURSELF
223

TWO FOUR ZERO
ICL240I ERROR HANDLER PRINTED SNIDE REMARK
240

TWO FOUR ONE
ICL241I VARIABLES MAY NOT BE STORED IN WEST HYPERSPACE
241

4
यह संभवतः सबसे बड़ा INTERCAL कार्यक्रम है जिसे मैंने कभी देखा है।
स्काईलर

27

पर्ल, 108 बाइट्स, 256 निकास कोड

यह प्रोग्राम (ab) टेस्ट :: अधिक मॉड्यूल का उपयोग करता है । यह "" n नाम की फ़ाइल को खोलने की कोशिश करता है जहाँ n को कमांड लाइन तर्क के रूप में दिया जाता है। यह हर बार विफल रहता है, और प्रत्येक आह्वान को एक परीक्षण के रूप में माना जाता है। परीक्षण :: बाहर निकलने के कोड के रूप में विफल परीक्षणों की अधिक वापसी संख्या। plan tests => $ARGV[0]%255निकास कोड 255 प्राप्त करने की आवश्यकता है।

#!/usr/bin/perl
use Test::More;
plan tests => $ARGV[0]%255 if($ARGV[0]>0);
ok(open(F,"")) for (1..$ARGV[0])

गोल्फ:, perl -MTest::More -e'plan tests,$%%255if$%=<>;ok 0for 1..$%'51 बाइट्स (38 बाइट्स + 13 बाइट्स के लिए -MTest::More<space>)। स्टड पर इनपुट लेता है।
ThisSuitIsBlackNot

27

C90 (gcc), 256 निकास कोड, 28 27 18 बाइट्स

main(){getchar();}

मुझे यकीन है कि अगर यह चतुर या cheaty है नहीं कर रहा हूँ, लेकिन मैं इसे नियम लिखा के रूप में उल्लंघन करता है नहीं लगता है: यह तकनीकी रूप से उपयोग नहीं करता है exit, returnया किसी भी त्रुटि तंत्र फेंक, लेकिन बस अपरिभाषित व्यवहार और तथ्य यह है कि जीसीसी पर निर्भर करता है जहाँ तक यह चुनौती जाती है वहां तक ​​कुछ सुविधाजनक है।

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

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

यह बस getcharस्टैटिन से एक बाइट पढ़ने के लिए उपयोग करता है। अपने आप से, यह कुछ भी नहीं करता है।

हालांकि, एक आज्ञाकारी C90 कार्यक्रम एक returnबयान या कुछ समकक्ष के साथ समाप्त होना चाहिए ; बाकी सब कुछ अपरिभाषित व्यवहार है। gcc किसी retभी तरह से उत्पन्न विधानसभा को समाप्त करता है, इसलिए जो भी मूल्य लापरवाही से रजिस्टर में था वह EAX प्रोग्राम द्वारा वापस मिल जाएगा। सौभाग्य से, glibc के getcharस्टोर बाइट को EAX में STDIN से पढ़ता है, इसलिए उस बाइट का मूल्य हमारे प्रोग्राम का एक्ज़िट कोड है।


यह देखना दिलचस्प होगा कि क्या यह 8 बिट बैरियर के माध्यम से टूटने के लिए संशोधित किया जा सकता है , जो कि जेएस जैसे शेल का उपयोग करता है, जो समर्थन करता है set -o fullexitcode
टसेपेल्लिन

1
यह चालाकी है। लेकिन कार्यक्रम वास्तव में दुर्घटना नहीं करता है, तब। यह सामान्य रूप से लौटता है, चाहे वह कल्पना "घातक अपवाद / अपरिवर्तनीय विफलता / दुर्घटना का कारण हो"
मंद

किसी भी तरह से, यह कमाल है।
क्वेंटिन

4
@ मुझे लगता है कि दुर्घटना की आपकी परिभाषा पर निर्भर करता है। जहां तक ​​C90 मानक जाता है, उसके साथ मुख्य अंत नहीं है returnया exitएक त्रुटि है, और इसका परिणाम एक निकास कोड है जो विफलता को इंगित करता है। यह सब एक दुर्घटना दिल में है।
डेनिस

क्रैश ठीक से काम करने के लिए एक कार्यक्रम है। आपका कार्यक्रम वह सब करता है जो आपने इसे ठीक से करने के लिए कहा था, यह इनपुट से एक चरित्र को पढ़ता है और फिर बंद हो जाता है। भले ही बाहर निकलें कोड एक त्रुटि को इंगित करता है कि यह दुर्घटना नहीं हुई।
findusl

19

सी (gcc) x86, 230 बाइट्स, 8 एग्जिट कोड पर बैश शेल के तहत

पठनीयता में सहायता के लिए नई कड़ियाँ जोड़ी गईं। टिप्पणियाँ स्कोर में नजरअंदाज कर दिया।

main(int c, char **v){
int p[2];
switch(atoi(v[1])-128){
case 2:__asm("UD2");        /* SIGILL: x86 undefined instruction */
case 5:__asm("int $3");     /* SIGTRAP: x86 breakpoint instruction */
case 6:abort();             /* SIGABRT: raise() is called under the covers */
case 8:c/=c-2;              /* SIGFPE: divide by 0 (c-2) */
case 11:c=*(int *)c;        /* SIGSEGV: dereference of invalid pointer */
                            /* SIGPIPE: write() to a pipe closed at the other end */
case 13:socketpair(1,1,0,p);close(p[1]);write(p[0],v,1);
case 14:alarm(1);sleep(2);  /* SIGALRM: kernel will send alarm signal after 1 sec */
}
}

बैश शेल की एक विशेषता:

जब कोई कमांड घातक सिग्नल एन पर समाप्त हो जाती है, तो बैश बाहर निकलने की स्थिति के रूप में 128 + एन के मूल्य का उपयोग करता है।

इसलिए हमें केवल एसी प्रोग्राम के भीतर से विभिन्न संकेतों को ट्रिगर करना होगा। इस बिंदु पर, मुझे लगता है कि बस करना kill(n-128);प्रतिबंधित है। इसलिए इसके बजाय हम विभिन्न संकेतों को ट्रिगर करने वाले कोड को निष्पादित करते हैं, जिसके कारण संबंधित त्रुटि कोड कॉलिंग शेल पर उपलब्ध कराया जाता है।

निकास कोड 0, 130, 133, 134, 136, 139, 141, 142 हैं।

इसे ऑनलाइन आज़माएं । रिटर्न कोड देखने के लिए "डीबग" अनुभाग का विस्तार करें।

यह निश्चित रूप से गहरा हो सकता है। लेकिन मुझे और अधिक संकेतों को जोड़ने में अधिक दिलचस्पी होगी।


क्या मैं यह मान लेना सही होगा कि सिग्नल आपके मौजूदा कार्यों या संचालन के कारण आपके कोड के बाहर हैं ?
Addison Crump

1
@VoteToClose हाँ, यह सही है। उदाहरण के लिए, __asm("UD2")x86 "अपरिभाषित निर्देश" चलाता है , जो एक CPU अपवाद का कारण होगा जो कि प्रोग्राम द्वारा SIGILL सिग्नल के रूप में कर्नेल द्वारा रिले जाएगा। उदाहरण के socketpairलिए, SIGPIPE कर्नेल या ग्लिबेक द्वारा भेजा जाएगा क्योंकि हम write()एक पाइप की कोशिश कर रहे हैं close()जो दूसरे छोर पर था।
डिजिटल ट्रामा

1
तब मेरे पास इसका कोई मुद्दा नहीं है। : पी
एडिसन क्रम्प

1
यदि आप उपयोग करते हैं तो आप 1) दो वर्णों को गोल्फ कर सकते int3हैं int $3और 2) एक वर्ण को यदि आप घोषित vकरते हैं int**, तो यह देखते हुए कि आप मूल रूप charसे अपने सूचक अंकगणितीय में डेटाटाइप की- निर्भरता पर भरोसा नहीं करते हैं , प्लस 3) दो वर्ण जो आप उपयोग करते हैं *pइसके बजाय p[0], या 4) छह अक्षर, यदि आप तैयार हैं fdकि सभी syscalls द्वारा उन्हें लौटाए गए पूर्वानुमानित संख्याओं पर भरोसा करें, और उनके पास p[0]और p[1]उनके निश्चित मानों को बदल दें। अंत में, pipe(fd)की तुलना में बहुत कम है socketpair(...)और बंद करने fd[0]और लिखने के दौरान एक ही त्रुटि उत्पन्न करता है। fd[1]
इविलनोटिक्सिस्ट इडोनोटेक्सिस्ट

2
कुछ अतिरिक्त गोल्फ सुझाव: 1) के &63बजाय का उपयोग करें -128। 2) के sleep(2)साथ बदलें for(;;)। 3) के c=*(int*)cसाथ बदलें atoi(0)। 4) के c/=c-2साथ बदलें c/=0
nwellnhof

10

पायथन 2, 13 बाइट्स, 2 निकास कोड

1/(input()-1)

यदि आप 0 दर्ज करते हैं, तो यह प्रिंट करने की कोशिश करता है, 1/-1जो -1 है जो इस प्रकार कोड से पूरी तरह से ठीक है। 0. यदि आप 1 दर्ज करते हैं, तो आपको वह मिलता है, 1/0जिसमें ZeroDivisionErrorएक निकास कोड होता है। 1. मेरी आईडीई के साथ, केवल 0 है। और बाहर निकलने के कोड के लिए 1 ...

आउटपुट:


यहाँ छवि विवरण दर्ज करें


यहाँ छवि विवरण दर्ज करें


10

PHP, 15 बाइट्स, 2 निकास कोड

बिना die/ exit, PHP कुछ भी 0या लेकिन 255(afaik; शायद ~1) वापस नहीं कर सकता , इसलिए ...

!$argv[1]?:p();

यदि कमांड लाइन तर्क गलत है, तो यह मूल्यांकन करता है 1और इसके साथ बाहर निकलता है 0। यदि नहीं, तो यह एक फ़ंक्शन को कॉल करने की कोशिश करता है और साथ बाहर निकलता है <b>Fatal error</b>: Uncaught Error: Call to undefined function p()

के साथ भागो -r


5
यह सच नहीं है। exit()एक निकास स्थिति सेट करता है ... जिसे आप इस चुनौती के लिए उपयोग नहीं कर सकते हैं, दी गई है। लेकिन आपका कोड भी अमान्य है। यह निकास की स्थिति को 255
बजे

@ सकल: हम्म मैंने हमेशा यह मान लिया कि त्रुटि के साथ बाहर निकल जाएगा 1। मैंने बाहर निकलने के कोड की एक सूची की खोज की, लेकिन एक नहीं मिला।
टाइटस

10

एक्सेल VBA, 414 514 533 + 3 बाइट्स, 14 निकास कोड

इनपुट को एक के रूप में लेता है Conditional Compilation Argument, n=[input value]और उस नंबर के संबंधित त्रुटि कोड का उत्पादन करता है।

Sub e()
Dim a As Application, b As Byte, s As String, v(), x
Set a=Application
#If n=3 Then
Return
#ElseIf n=5 Then
b=a.CommandBars("")
#ElseIf n=6 Then
b=2^8
#ElseIf n=7 Then
ReDim v(9^9)
#ElseIf n=9 Then
v=Sheets("")
#ElseIf n=10 Then
v=Array(1)
For Each x In v
ReDim v(9)
Next
#ElseIf n=11 Then
b=1/0
#ElseIf n=13 Then
Debug.?Int("X")
#ElseIf n=14 Then
Debug.?String(9E8,1)
#ElseIf n=20 Then
Resume
#ElseIf n=28 Then
f 256
#ElseIf n=35 Then
Call c
#ElseIf n=92 Then
For Each x In v
ReDim v(9)
Next
#ElseIf n=94 Then
b=Null
#End If
End Sub

Sub f(n):DoEvents:f n-1:End Sub

n=[Value]सशर्त संकलन कॉल के लिए +3

जहां इनपुट्स संभालता है n=

3
5
6
7
9
10
11
13
14
20
28
35
92
94    

नोट: VBA में निकास कोड 0या नहीं है 1। मैंने उन समाधानों को शामिल किया है 3और 5, जो कि उनकी जगह वीबीए में उपलब्ध दो सबसे कम संख्या वाले एक्जिट कोड हैं


1
मैं इस उत्तर को अस्वीकार नहीं करूंगा, क्योंकि यह मेरे लिए आउटपुट प्रकारों के लिए भाषा की क्षमता के कारण अस्वीकार करने का पर्याय है।
Addison Crump

1
यहाँ क्या करता #है?
ब्रूसवेने

#ifऔर #ElseIfजिसका अर्थ है कि बयान है कि यह केवल तभी फ़ॉलो हालत सच है संकलित किए जाते हैं सशर्त संकलन बयान कर रहे हैं
टेलर स्कॉट

1
इसलिए, यदि वे सच नहीं हैं, तो बयान संकलित नहीं किए जाते हैं ... यह उपयोग न करने से अलग है #, जहां वे संकलित किए जाएंगे कि क्या कथन सच हैं या नहीं? मुझे पता है कि Ifबयान कैसे काम करते हैं, लेकिन मैं वास्तव में संकलित करने के लिए नीचे आ रहा हूं , इसलिए इस तरह के एक सरल प्रश्न के लिए खेद है।
ब्रूसवेने

1
@ ब्रूसवेने, हाँ, यह बिल्कुल मामला है। क्योंकि इन पंक्तियों फेंकने के लिए तैयार कर रहे हैं विशिष्ट त्रुटियों, यह है के लिए आवश्यक है केवल लाइनों कि उत्पादन वांछित त्रुटि कोड एक दे समय में संकलित किया जा। ऐसा करने के लिए या केवल सशर्त विवरण संकलित #ifकिए जाने के स्थान पर उपयोग किया जाता है । इस मामले में विशेष रूप में, इस त्रुटि कोड के साथ बाहर निकलने से कार्यक्रम रहता है , हर निष्पादन पर, बल्कि केवल इस कोड के साथ बाहर निकलने जबIfSelect Casetruthy3Return without GoSubn=3
टेलर स्कॉट

7

Turtlèd, 4 बाइट्स, 2 निकास कोड

मुझे नहीं पता कि क्या अधिक निकास कोड प्राप्त करने के कोई तरीके हैं ... क्या दुभाषिया भाषा में और भी तरीके हैं

मुझे कुछ चार लंबाई के उत्तर मिले

' ?;

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

!.(0

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

?;(*

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

ये कैसे काम करते हैं:

' ?;

मेरे दुभाषिया में, एक बग सुविधा है जो त्रुटियों का कारण बनती है जब मेमोरी में ग्रिड एक से अधिक पंक्ति में होता है, और उस पर कोई गैर-स्थान वर्ण नहीं होता है। यह प्रोग्राम मूल कोशिका पर * मिटाता है '[space], गैर-नकारात्मक पूर्णांक इनपुट लेता है ?(0 या 1 वास्तव में), और नीचे ले जाता है कि कई ;, यदि यह शून्य है, तो ग्रिड में केवल एक पंक्ति होगी और त्रुटि नहीं होगी, अन्यथा यह नीचे चला जाएगा। और त्रुटि उत्पन्न होगी

!.(0

कोष्ठक और सामान को पार्स नहीं किया जाता है, वे सिर्फ रन टाइम पर निष्पादित होने का मतलब निकालते हैं: "सेल के प्रतीक सही नहीं है, तो मेल खाने वाले पैरेन पर जाएं"। इस प्रोग्राम में, इनपुटिंग ( !) एक प्रोग्राम को सेल में लिखने का कारण बनता है ( .), उस परन को निष्पादित करता है, जो यह जांचता है कि सेल सिंबल 0 है या नहीं, मैचिंग परन को स्किप करने की कोशिश करें, लेकिन एक एरर फेंक दें क्योंकि कोई नहीं है । यदि यह शून्य है, तो यह इसे लिखता है, कोष्ठकों की जांच करता है, खुद को 0 पर पाता है, और फिर इसे अनदेखा करता है, और प्रोग्राम को पूरा करता है

?;(*

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


7

जावास्क्रिप्ट (नोड), 19 बाइट्स, 2 निकास कोड

पूरा कार्यक्रम:

+process.argv[2]&&a

समारोह:

f=i=>i&&f(i)

process.argvएक ऐसा सरणी है जिसमें नोड एग्जीक्यूटिव के लिए पथ, जावास्क्रिप्ट फाइल के लिए पथ निष्पादित और कमांड लाइन तर्क हैं। इस मामले में, यह "1"या तो होगा "0"। स्ट्रिंग को गैर- +संचालक के साथ संख्या में परिवर्तित किया जाता है । यदि संख्या शून्य है तो आलसी &&ऑपरेटर दाहिने हाथ की तरफ का मूल्यांकन नहीं करेगा, यदि संख्या सत्य है (शून्य नहीं), तो दाहिने हाथ की तरफ का &&मूल्यांकन किया जाता है और एक त्रुटि को फेंक दिया जाता है क्योंकि यह अपरिभाषित चर का संदर्भ दे रहा है, और कार्यक्रम मौजूद है बाहर निकलने के कोड 1 के साथ।

फ़ंक्शन इनपुट की संख्या के रूप में अपेक्षा करता है। यदि इनपुट सत्य है, तो फ़ंक्शन स्वयं कॉल करता है, और नोड रनटाइम को स्टैक ओवरफ्लो के साथ क्रैश करता है। यदि इनपुट 0 है, तो आलसी &&ऑपरेटर दाएं हाथ की ओर का मूल्यांकन किए बिना 0 देता है।


@VoteToClose ने इसे अपरिभाषित चर में बदल दिया
corvus_192

यह काम करता है। : P
Addison Crump

पूरा कार्यक्रम छोटा किया जा सकता है +process.argv[2]&&a
user2428118

@ user2428118 आप सही हैं
corvus_192

जिज्ञासा से बाहर, ReferenceError.prototype.name=process.argv[2]?a:0वैध होगा ?
पैट्रिक रॉबर्ट्स

6

पर्ल 6 , 57 बाइट्स, 256 निकास कोड

use Test;plan $_=@*ARGS[0];ok try {open ""} for ^($_%255)

इसे आज़माएं यह
पर्ल 5 उदाहरण का अनुवाद है।

विस्तारित

use Test;  # bring in 「plan」 and 「ok」

plan $_ = @*ARGS[0]; # plan on having the input number of tests
                     # only actually needed for the 255 case
                     # if the plan is greater than the number of tests
                     # it fails with exitcode 255


  ok                 # increment the failure counter if the following is False
    try {            # don't let this kill the whole program
      open ""        # fails to open a file
    }

for                  # repeatedly do that

  ^(                 # upto Range
    $_ % 255         # either the input number of times, or 0 times for 255
  )

5

स्काला, 19 बाइट्स, 2 निकास कोड

if(args(0)=="1")1/0

1/(args(0).toInt-1)

जेवीएम केवल 1 और 0 को एक्ज़िट कोड के रूप में सपोर्ट करता है अगर आप कॉल नहीं करते हैं System.exit

पहला प्रोग्राम यह गणना करने की कोशिश करता है 1/0कि पहला तर्क क्या है 1, जो 1. के एक्जिट कोड के साथ JVM को क्रैश कर देगा। यदि तर्क 0 है, तो यह एक्सेप्ट एक्सेप्ट करता है।

दूसरा प्रोग्राम तर्क को पूर्णांक में परिवर्तित करता है, एक को घटाता है और 1 को उस संख्या से विभाजित करने का प्रयास करता है। यदि तर्क 1 है, तो यह गणना करता है 1/0, इसलिए जेवीएम दुर्घटनाग्रस्त हो जाएगा; यदि तर्क 0 है, तो यह गणना 1/-1और बाहर निकलता है।


5

पायथन 3 , 15 बाइट्स, 2 निकास कोड

जाहिर है, यह पायथन 2 समाधान से अधिक लंबा है , क्योंकि पायथन 3 में हम बिना कॉल किए शाब्दिक इनपुट नहीं ले सकते eval। हालांकि, हम स्ट्रिंग तुलना तकनीकों का रोचक तरीके से उपयोग कर सकते हैं ...

1/(input()<'1')

इनपुट या तो स्ट्रिंग होगा 0या 1- यदि यह 1 है, तो स्थिति 0 (गलत) का मूल्यांकन करती है, जिसके परिणामस्वरूप गणना करने का प्रयास होता है 1 / 0जो स्पष्ट रूप से क्रैश (निकास कोड 1) होता है। अन्यथा, कुछ भी नहीं होता है, और पायथन नियमित निकास कोड 0 से बाहर निकलता है।

जहां तक ​​मुझे जानकारी है, पायथन अन्य निकास कोड के साथ दुर्घटनाग्रस्त होने में असमर्थ है।


5

जावा, 71 66 बाइट्स, 2 निकास कोड

4 बाइट्स ने होल्गर को धन्यवाद दिया

पूरा कार्यक्रम:

interface I{static void main(String[]a){a[a[0].charAt(0)-48]="";}}

एक तर्क के रूप में एक इंट लेने का कार्य:

i->1/(i-1)

प्रोग्राम पूर्णांक (0 या 1) में से पहले argumant (या तो '0'या '1'घटाता है 48 (ascii मान '0') का पहला चार्ट लेता है । यह तब उस पूर्णांक की स्थिति में तर्क को रिक्त स्ट्रिंग पर सेट करने का प्रयास करता है।) इनपुट 1 है, प्रोग्राम ए के साथ क्रैश हो जाता है ArrayIndexOutOfBoundsException, तर्क सरणी को केवल स्थिति 0 (शून्य-अनुक्रमित) में एक तत्व है।


आप मान असाइन कर सकते हैं या किसी अन्य तरीके से उपयोग कर सकते हैं, जैसे कि सरणी सूचकांक a[a[0].equals("1")?1/0:1]="";, जो बराबर है int x=a[0].equals("1")?1/0:1;। लेकिन कुछ बाइट्स ArrayIndexOutOfBoundsExceptionको ArithmeticExceptionबचाने के बजाय कार्यक्रम को और अधिक भड़काने के लिए :interface I{static void main(String[]a){a[a[0].charAt(0)-'0']="";}}
होल्गर

4

पायथन 2, 11 बाइट्स, 2 निकास कोड

1>>-input()
1/~-input()
0<input()<x

तीन अलग-अलग त्रुटियों के लिए तीन अलग-अलग 11-बाइट समाधान! (सिर्फ मनोरंजन के लिए, यह अंक नहीं देता है।) डिफ़ॉल्ट रूप से, पायथन में सफल निकास के लिए केवल 0 और त्रुटि के लिए निकास कोड हैं। सफल रन कुछ भी उत्पादन नहीं करते हैं।

 1>>-input()

इनपुट 1 पर, "ValueError: negative shift count" देता है। इनपुट 0 पर, एक शून्य शिफ्ट काउंट सफल होता है और 1 देता है।

1/~-input()

इनपुट 1 पर, "ZeroDivisionError: पूर्णांक विभाजन या मोडुलो को शून्य से देता है" ~-input(), aka input()-10. होने के कारण , इनपुट 1 में, 1/-1-1 देता है। 0**-input()काम भी करेगा।

0<input()<x

इनपुट 1 पर, "NameError: नाम 'x' परिभाषित नहीं है"। इनपुट 0 पर, इन पहली असमानता 0<0का मूल्यांकन फाल्स के लिए किया जाता है, इसलिए बाकी का मूल्यांकन नहीं किया जाता है और परिणाम सिर्फ गलत होता है।


2

Node.js (ES6), 77 बाइट्स, 2 निकास कोड

require('readline').createInterface({input:process.stdin}).prompt("",i=>i&&x)

2

जेली , 4 निकास कोड, 18 बाइट्स

߀
2*
Ṁ¹Ŀ
RÇĿỌḊ?R

बाहर निकलने के कोड का समर्थन करता है 0 , 1 , 137 (मारे गए), और 139 (विभाजन दोष)।

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

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

RÇĿỌḊ?R  Main link. Argument: n (integer)

R        Range; yield [1, ..., n] if n > 1 or [] if n = 0.
    Ḋ?   If the dequeued range, i.e., [2, ..., n] is non-empty:
 Ç         Call the third helper link.
  Ŀ        Execute the k-th helper link, where k is the the integer returned by Ç.
         Else, i.e., if n is 0 or 1:
   Ọ       Unordinal; yield [] for n = 0 and "\x01" for n = 1.
      R  Range. This maps [] to [] and causes and error (exit code 1) for "\x01".


Ṁ¹Ŀ      Third helper link. Argument: r (range)

Ṁ        Maximum; retrieve n from r = [1, ..., n].
 ¹Ŀ      Call the n-th helper link (modular).
         When n = 139, since 139 % 3 = 1, this calls the first helper link.
         When n = 137, since 137 % 3 = 2, this calls the second helper link.


2*       Second helper link. Argument: k

2*       Return 2**k.
         Since 2**137 % 3 = 174224571863520493293247799005065324265472 % 3 = 2,
         ÇĿ in the main link will once again call the second helper link.
         Trying to compute 2**2**137, a 174224571863520493293247799005065324265472-
         bit number, will get the program killed for excessive memory usage.


߀       First helper link. Argument: k

߀       Recursively map the first helper link over [1, ..., k].
         This creates infinite recursion. Due to Jelly's high recursion limit,
         a segmentation fault will be triggered.

2

SmileBASIC, 640 बाइट्स, 39 निकास कोड (52 में से)

SPSET.,0INPUT C$GOTO"@"+C$@0
STOP@3
A
@4
CLS.@5@A
GOSUB@A@7?1/A@8
X$=3@9
A%=POW(2,31)@10
BEEP-1@11
DIM B[#ZL*#R]@13
READ A
@15
V"OPTION STRICT?X
@16
CALL@D@17
V@A*2
@18
V"VAR A,A
@19
V"DEF A:END:DEF A
@20
V"FOR I=0TO
@21
V"NEXT
@22
V"REPEAT
@23
V"UNTIL
@24
V"WHILE.
@25
V"WEND
@26
V"IF.THEN
@27
V"IF.THEN"+CHR$(10)+"ELSE
@28
V"ENDIF
@29
V"DEF X
@30
RETURN@31
DIM E[-1]@32
V"DEF A:DEF
@34
GOTO"|
@36
XOFF MIC
MICSTOP
@37
XOFF MOTION
GYROSYNC
@38
PRGDEL
@39
DIM F[66]SPANIM.,1,F
@40
DIM G[2]SPANIM.,1,G
@42
MPSTART 2,@A@L
MPSEND"A"GOTO@L@44
PROJECT
@46
USE"PRG1:A
@47
BGMPLAY"`
@48
X=
@51
DLCOPEN"
DEF V C
PRGEDIT 1PRGDEL-1PRGSET C
EXEC 1
END

यह निश्चित रूप से कम किया जा सकता है। SB में केवल 0 से 51 तक त्रुटि कोड हैं, और कुछ को ट्रिगर करना असंभव है।


0

ZX81 बुनियादी> 255 निकास कोड - 52 बाइट्स (लिस्टिंग)

1 INPUT N
2 GOTO 1+(2*(N>0 AND N <=255))
3 PRINT "EXIT CODE ";N
4 RAND USR N

तकनीकी रूप से, Nसीमा के भीतर कोई भी 24 बिट फ्लोटिंग पॉइंट नंबर हो सकता है, लेकिन हम यहां पूर्णांक मान लेंगे। IF N>0 AND N <=255 THEN GOTO 3: ELSE GOTO 1यदि ZX81 बुनियादी IF/ELSEप्रतीकात्मक निर्देशों में था , तो पंक्ति 2 के बराबर है ।


3
यह कैसे संतुष्ट करता है the program caused some fatal unintended exception? यह सिर्फ कुछ पाठ को प्रिंट करता है और निष्पादन को पूरा करता है।
AdmBorkBork

आप सही हैं - मुझे सुबह जागने की जरूरत है।
शॉन बेयबर्स

RAND USR Nअनपेक्षित प्रभाव का कारण होगा क्योंकि एक अप्रत्याशित स्थान से रॉम का हिस्सा कॉलिंग एक अच्छा विचार नहीं है, इसलिए RAND USR 0इसे बहुत ही सुंदर के रूप में बाहर रखा गया है।
शॉन बेयबर्स

क्या आप इस बारे में थोड़ा और विस्तार कर सकते हैं कि वास्तव में यह कार्यक्रम दुर्घटना का कारण कैसे बनता है? मैं ZX81 बुनियादी के साथ परिचित नहीं हूँ।
AdmBorkBork

ROM 0x0000 से रहता है - 0x1fff; यदि आप सही जगह पर शुरू करते हैं तो ROM रूट कॉल करना काम करेगा। Z80 में किसी भी मशीन कोड रूटीन में एक या एक से अधिक बाइट्स शुरू करने से अप्रत्याशित प्रभाव पड़ेगा। यदि आपके पास LD BC, 0000 RST 10 RET0x1000 पर एक सरल है , लेकिन RAND USR 4097तब आपको एलडी ऑपरेंड याद आएगा और इसलिए मशीन कोड को तिरछा कर दिया जाएगा। मुझे सभी ROM कॉल याद नहीं हैं, लेकिन मैं सभी कानूनी / सुशोभित सिरों को काम करूंगा और बाद में उन्हें बाहर कर दूंगा।
शॉन बेयबर्स
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.