जब तक ट्राई ब्लॉक में सब कुछ पहले ही पकड़ लिया जाता है तब तक पहुंचना

Question

यह जावा और सी # तक सीमित है जो मुझे लगता है कि सिंटैक्स द्वारा है।

इस प्रोग्रामिंग पहेली में, आपको ऐसे Exceptionएस प्रोड्यूस करने हैं जो पकड़े जा सकते हैं लेकिन कैच ब्लॉक के अंत में फिर से फेंक दिए जाते हैं।

try
{
    while(true)
        try
        {
            // you are only allowed to modify code between this try { } brackets
        }
        catch(Exception ex2) {  }
}
catch(Exception ex1)
{
    // your goal is to reach this catch block by modifying the code ...
    // in the inner try block above
    // You win if you reach this part and execute on of the following code lines
    Console.WriteLine("You won!"); // for C#
    // Or
    System.out.println("You won!"); // for Java
}

आप इस स्निपेट के पहले और बाद में स्वतंत्र रूप से कोड डाल सकते हैं।

बाहरी catchब्लॉक जीतने के लिए सबसे छोटा कोड जीतता है।

Comments

मुझे लगता है कि अजगर भी प्रतिस्पर्धा करने में सक्षम हो सकता है।

— user12205

आप मेरे स्निपेट के पहले और बाद में स्वतंत्र रूप से कोड डाल सकते हैं।

— user21634

बहुत बुरा यह बंद है। मुझे एक उपाय सूझा । @ अल्गोरिदमशार्क, माइकल और जान ड्वोरक के लिए: यह एक सामान्य प्रोग्रामिंग प्रश्न नहीं है। यह एक प्रोग्रामिंग पहेली है, जब एक जिराफ एक जिराफ नहीं है के समान है ? । मैं इसे फिर से खोलने के लिए नामांकित कर रहा हूं।

— user12205

ऊह्ह्ह्ह, वाहत ???

— TheDoctor

@ अल्गोरिद्मशर्क मुझे आवेषणों की लंबाई के योग के साथ जाना होगा

— user12205

Answer 1

सी #, 46 (बॉयलरप्लेट सहित 88)

using System;class P{static void Main(){
        try
        {
            while(true)
                try
                {
                    System.Threading.Thread.CurrentThread.Abort();
                }
                catch(Exception ex2) {  }
        }
        catch(Exception ex1)
        {
            // your goal is to reach this catch block by modifying the code ...
            // in the inner try block above
            // You win if you reach this part and execute on of the following code lines
            Console.WriteLine("You won!"); // for C#
        }
}}

Abort()विधि एक को जन्म देती है ThreadAbortException है, जो एक विशेष अपवाद है कि स्वचालित रूप से प्रत्येक कैच ब्लॉक के अंत में rethrown है (जब तक है Thread.ResetAbort()कहा जाता है)।

Answer 2

C # 24 वर्ण

इरादा से पहले इनर ट्राई ब्लॉक को समाप्त कर देता है, जिससे मैं ट्राई ब्लॉक के बाहर अपवाद पैदा कर सकता हूं।

}finally{int a=1/0;}try{

Comments

यार ये जीनियस है! मैंने ऐसा क्यों नहीं सोचा? (Btw आप वास्तव में एक अपवाद को फेंकने के बजाय एक अपवाद के कारण इसे छोटा कर सकते हैं? उदाहरण के लिए int a=1/0;?)

— user12205

क्या आपको int a=वहां जरूरत है? कुछ भाषाएं आपको सिर्फ अभिव्यक्ति लिखने देती हैं1/0

— gnibbler

यह पूरी तरह से काम करने का उदाहरण नहीं है, क्या यह है? तो 24 वर्णों की गिनती नहीं है ...

— मैट

Answer 3

जावा, 76 या 31

नई लाइनों को अनदेखा करते हुए, कोड में किए गए केवल सम्मिलन को गिना। 76 यदि आप मेरे द्वारा जोड़ी गई हर चीज को गिनते हैं , तो 31 यदि आप पहली पंक्ति और अंतिम पंक्ति को छोड़ते हैं, अर्थात केवल गिनती int a=1/0;try{}catch(Error e){}।

class P{public static void main(String[]A){
try
{
    while(true)
        try
        {
            int a=1/0;try{
        }
        catch(Exception ex2) {  }
}
catch(Exception ex1)
{
    // your goal is to reach this catch block by modifying the code ...
    // in the inner try block above
    // You win if you reach this part and execute on of the following code lines
    //Console.WriteLine("You won!"); // for C#
    // Or
    System.out.println("You won!"); // for Java
}
}catch(Error e){}
}}

Comments

ओह, क्षमा करें, मैंने ध्यान नहीं दिया कि आपने कैसे गिना। मैं अन्य उत्तर पद्धति को जोड़ने के लिए अपने उत्तर को अपडेट करूंगा। मुझे लगता है कि सिर्फ कोशिश ब्लॉक में पात्रों की गिनती करना बेहतर है, क्योंकि अन्यथा हम मूल रूप से सी # बनाम जावा बॉयलरप्लेट की तुलना करेंगे। लेकिन यह जटिल हो सकता है यदि कोई व्यक्ति कोशिश ब्लॉक के बाहर महत्वपूर्ण कोड के साथ जवाब प्रस्तुत करता है (जैसा कि नियमों द्वारा अनुमति है)।

— बेनएम

@BenM कोई चिंता नहीं है, और मैं समझता हूँ कि आपने इसे इस तरह क्यों गिना। यह सिर्फ इतना है कि ओपी ने निर्दिष्ट नहीं किया कि किस रास्ते को गिनना है, इसलिए मुझे लगा कि मैं दोनों को शामिल करूंगा।

— user12205

बहुत चालाक समाधान।

— निकोलस बारबुलेसको

@ नाइकोलाबार्बुल्सको सच कहूं तो मुझे लगता है कि रेयान का जवाब मेरे मुकाबले ज्यादा चालाक है। आखिरकार, मैंने स्निपेट के बाद एक catchब्लॉक जोड़ा , वह नहीं था।

— user12205

Answer 4

चेतावनी : ये कार्यक्रम क्लोन बम हैं (कांटा बम का एक प्रकार का कम-खतरनाक लेकिन फिर भी खतरनाक रूप); जैसे, सैंडबॉक्सिंग या संसाधन सीमा के बिना उन्हें उत्पादन प्रणाली पर न चलाएं । क्लोन बम एक लूप में थ्रेड बनाते हैं (कांटा बम के विपरीत, जो एक लूप में प्रक्रियाएं बनाते हैं), इस प्रकार आप प्रश्न में प्रक्रिया को मारकर उन्हें रोक सकते हैं (कांटा बम की तुलना में बहुत कम खतरनाक बनाते हैं, जो बहुत मुश्किल हो सकता है) साफ़ करो); जब तक आप ऐसा करने का प्रबंधन करते हैं (या जब तक कि कार्यक्रम जीत नहीं जाता है और स्वाभाविक रूप से अपने आप बाहर निकल जाता है) तक वे आपके अधिकांश सीपीयू को टाई करेंगे। अपने ओएस को मेमोरी और सीपीयू समय की सीमा पर रखने के लिए कहने से इन कार्यक्रमों को उपयोग करने की अनुमति मिलती है, जिससे उन्हें परीक्षण करने के लिए एक सुरक्षित वातावरण तैयार करना चाहिए।

जावा (ओपनजेडके 8) , 65 60 बाइट्स (आवरण के लिए थोड़ा संशोधन के साथ)

Thread x=Thread.currentThread();new Thread(x::stop).start();

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

catch (Exception …)को बदलने के लिए प्रश्न के दोनों उदाहरणों की आवश्यकता होती है catch (Throwable …)। यह सिद्धांत में अधिक सुरक्षित होना चाहिए , कम नहीं, लेकिन यह इस समाधान को संभव बनाने में सक्षम बनाता है।

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

जावा 4, 104 बाइट्स (अप्रकाशित, मूल आवरण के साथ काम करना चाहिए)

final Thread x=Thread.currentThread();new Thread(){public void run(){x.stop(new Exception());}}.start();

इसे ऑनलाइन आज़माएं! (लिंक एक जावा 8 कार्यान्वयन के लिए जाता है, इस प्रकार काम नहीं करेगा)

जावा के आधुनिक संस्करणों से हटाए गए सुविधाओं का उपयोग करना, पहेली के उस संस्करण को भी हल करना संभव है जिसके लिए एक की आवश्यकता है Exception। शायद, कम से कम। (जावा 4 अब तक बहुत पुराना है और मुझे यह याद नहीं है कि इसमें कौन-कौन सी सुविधाएँ थीं और इसमें शामिल नहीं हैं। जैसा कि देखा जा सकता है, तब जावा में बहुत कम सुविधाएँ थीं और इसलिए यह अधिक क्रिया थी; हमारे पास नहीं थी; लंबोदर, इसलिए मुझे एक आंतरिक वर्ग बनाना पड़ा।)

स्पष्टीकरण

इस प्रश्न के अधिकांश समाधान C # में हैं (एक जावा समाधान के साथ जो कोड इंजेक्शन के रूप में असंतुलित कोष्ठक का उपयोग करके धोखा देता है, और एक पर्ल समाधान जो जावा में भी नहीं है)। इसलिए मैंने सोचा कि यह दिखाने की कोशिश की जाएगी कि यह पहेली कैसे जावा में भी "ठीक से" हल की जा सकती है।

दोनों कार्यक्रम प्रभावी रूप से समान हैं (इस प्रकार यह तथ्य कि पहला कार्यक्रम काम करता है मुझे उच्च आत्मविश्वास देता है कि दूसरा कार्यक्रम भी काम करेगा, जब तक कि मैंने गलती से गैर-जावा -4 सुविधा का उपयोग नहीं किया Thread#stopथा ; जावा 5 में पदावनत किया गया था)।

जावा की Thread#stopविधि, पर्दे के पीछे काम करती है, जिसके माध्यम से एक फेंकने योग्य को प्रश्न में धागे में फेंक दिया जाता है। उद्देश्य के लिए फेंकने योग्य उद्देश्य है ThreadDeath( Error, विशेष रूप से क्योंकि लोग अक्सर कंबल-कैच अपवादों की कोशिश करते हैं और जावा के डिजाइनर ऐसा नहीं चाहते थे), हालांकि यह आपको कुछ भी फेंकने की अनुमति देता है (या एपीआई के बाद कुछ बिंदु पर इस्तेमाल किया गया था) डिज़ाइन किया गया, जावा के डिजाइनरों ने महसूस किया कि यह एक अविश्वसनीय रूप से बुरा विचार था और इस पद्धति के संस्करण को हटा दिया जो तर्क को एक समान रूप से लेता है)। बेशक, यहां तक ​​कि संस्करण जो फेंकता है ThreadDeathवह एक काफी जोखिम भरा ऑपरेशन है, जिसके बारे में आप कुछ गारंटी दे सकते हैं (उदाहरण के लिए, यह आपको इस पहेली को हल करने की अनुमति देता है, कुछ ऐसा जो "संभव नहीं होना चाहिए", इसलिए आप इसे स्वीकार नहीं करेंगे इसका उपयोग करें, लेकिन जावा 8 के रूप में, यह अभी भी काम करता है।

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

(टीआईओ नोट: टीआईओ का वर्तमान संस्करण इस कार्यक्रम को अपने निष्पादन में जल्दी से मारने के लिए इच्छुक है, संभवतः सभी थ्रेड्स बनाए जाने के कारण। यह टीआईओ पर काम कर सकता है, लेकिन मज़बूती से काम नहीं करता है, इसलिए अक्सर कुछ प्रयासों की आवश्यकता होती है। "आप जीते!" आउटपुट प्राप्त करें।

Answer 5

सी#

    try
    {
        int i = 0, j = 1, k;

        int flag = 0;
        lbl:
        if (flag == 1)
        {
            k = j / i;
        }

        while (true)
            try
            {
                k = j / i;

            }
            catch (Exception e)
            {
                flag = 1;
                goto lbl;
                //Console.WriteLine("loose");

            }
    }
    catch (Exception e)
    {
        Console.WriteLine("Won");

    }

Comments

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

— प्रोग्रामफॉक्स

Answer 6

पर्ल 5 , 37 या 36 बाइट्स

eval {
    while (1) {
        eval {

 

use overload'""',sub{die};die bless[]

 

        };
        $@ eq "" or 0;
    }
};
$@ eq "" or print "You won!\n";

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

पता चलता है कि यह सवाल पर्ल में अच्छी तरह से अनुवाद करता है ताकि वहां एक दिलचस्प पहेली भी बन सके। पर्ल के tryसमतुल्य को (थोड़ा भ्रमित करने वाला) कहा जाता है eval, और @_यदि ऐसा हुआ है, और शून्य स्ट्रिंग को अन्यथा अपवाद के रूप में सेट करके एक अपवाद निर्दिष्ट करता है । जैसे, नल स्ट्रिंग की catchतुलना के माध्यम से एक ब्लॉक लागू किया जाता है @_।

यह समाधान एक ऑब्जेक्ट बनाकर काम करता है (जिसका वर्ग एक पूरे के रूप में प्रोग्राम है; आप कक्षाओं की तरह मनमानी पर्ल फ़ाइलों का उपयोग कर सकते हैं, जावा के रिवर्स की तरह तरह (जहाँ आप फ़ाइलों की तरह मनमाना कक्षाओं का उपयोग कर सकते हैं)। यह वह bless[]हिस्सा है ( blessआमतौर पर केवल निर्माणकर्ताओं के अंदर गहराई से प्रकट होता है, जैसे कि आदिम जो वस्तुओं को पहले स्थान पर बनाता है, लेकिन आप इसे सीधे उपयोग कर सकते हैं यदि आप वास्तव में चाहते हैं; []ऑब्जेक्ट के लिए मेमोरी एलोकेटर है - एक सूची निर्माता, इसमें; मामला - और वर्ग नहीं दिया गया है इसलिए यह माना जाता है कि वर्तमान में एक निष्पादित हो रहा है)। इस बीच, हम अपनी "क्लास" (यानी मुख्य फ़ाइल) एक कस्टम तुलना-से-स्ट्रिंग विधि के माध्यम से देते हैं use overload, और उस विधि को एक अपवाद फेंक देते हैं (इस प्रकार लूप से बाहर निकलकर पहेली को हल करते हैं); हम वास्तव में डाल सकते हैंuse overloadकहीं भी, और हालांकि यह परंपरागत रूप से अन्य विधि परिभाषाओं के साथ जाएगा और फ़ाइल के शीर्ष को पास करेगा, हम इसे उस खाई में डाल सकते हैं जो हमें इसके बजाय दिया गया है और यह अभी भी काम करता है। (यदि हम इसे फ़ाइल के अंत में रखते हैं, तो हम इसके बाद सेमीकोलन को छोड़ सकते हैं, जिससे 36-बाइट समाधान हो सकता है, लेकिन यह यकीनन धोखा है क्योंकि यह प्रोग्राम में पहले स्थान पर पीछे चल रहे अर्धविराम पर निर्भर करता है, जो है गारंटीकृत नहीं है।) यह वास्तव में स्ट्रिंग ऑपरेशन को ओवरलोड करने के लिए कम है और पर्ल को एक स्ट्रिंग से तुलना करने की अनुमति देता है, क्योंकि यह सीधे स्ट्रिंग तुलना की तुलना में अधिक लोड करने के लिए होगा (क्योंकि कुछ ऑपरेटरों को ओवरलोड करने से आप अन्य ऑपरेटरों को भी अधिभार करने के लिए मजबूर करते हैं)।

अब, हमें बस इतना करना है कि अपनी वस्तु का उपयोग करना है die। evalसमाप्त, तो जब हम तुलना करने के लिए प्रयास $@अशक्त स्ट्रिंग के लिए (यदि वहाँ एक अपवाद था देखने के लिए), तुलना एक और अपवाद फेंकता है और हम बाहर भागने eval।