पीछे की तरफ निष्पादित करें

102

आपका कार्य उस क्रम को उलट देना है जिसमें कुछ printsनिष्पादित हो जाते हैं।

चश्मा:
आपका कोड इस रूप में होगा: 

//some lines of code
/*code*/ print "Line1" /*code*/
/*code*/ print "Line2" /*code*/
/*code*/ print "Line3" /*code*/
/*code*/ print "Line4" /*code*/
//some lines of code

आपको उन print(या echo, writeया समतुल्य) उन तार को चौथे से पहले तक करना होगा।

  • आप तय करते हैं कि आपके कार्यक्रम की कौन सी रेखाएं printतार हैं, लेकिन वे आसन्न होने चाहिए ;

  • हर पंक्ति में केवल एक ही हो सकता है print, और लंबाई में 60 बाइट्स से अधिक नहीं हो सकते ;

  • चूंकि यह लोकप्रियता-प्रतियोगिता है , रचनात्मक हो और सिर्फ एक gotoया एक साधारण लिखने से बचेंfor(i){if(i=4)print"Line1";if(i=3)...}

  • 2 सप्ताह में सबसे अधिक उत्कीर्ण जवाब यह जीतता है।

  • आपका आउटपुट चाहिए हो Line4 Line3 Line2 Line1 या Line4Line3Line2Line1 या Line4\nLine3\nLine2\nLine1 (जहां \nएक नई पंक्ति है), और यह केवल उन्हीं को क्रियान्वित करने के द्वारा उत्पन्न किया जाना चाहिए printsपीछे की ओर।

हैप्पी कोडिंग!

अद्यतन: प्रतियोगिता खत्म हो गया है! आप सभी को धन्यवाद :)

popularity-contest  programming-puzzle 
— Vereos
स्रोत
15
अरबी की गिनती है? :)
यदि आप चश्मे को पूरा करने में सक्षम हैं, तो निश्चित रूप से: पी
— वेरोस
एक नियम को जल्दी से स्पष्ट करना चाहते हैं ... जब आप कहते हैं कि "हर लाइक में केवल एक प्रिंट हो सकता है", तो क्या आपका मतलब कोड फाइल या एक एलओसी / स्टेटमेंट में एक टेक्स्ट लाइन है?
— रुस्लान
कोड की हर पंक्ति में केवल एक प्रिंट हो सकता है
— Vereos
क्या इसे कोड समीक्षा पास करनी है - उत्पादन कोड के लिए उपयुक्त है?
— लांस

जवाबों:

183

कमोडोर 64 बुनियादी

40 print "Line 1"
30 print "Line 2"
20 print "Line 3"
10 print "Line 4"
— डैंको डर्बीक
स्रोत
83
मैं कभी यह पता नहीं लगा सका कि अब तक लाइन नंबरों की आवश्यकता क्यों है।
— बदसूरत
3
मैं प्रॉमिस करने जा रहा था, कैरेक्टर रोम ($ D000) को RAM ($ 3000) में कॉपी करके, "1" <-> "4" और "2" <-> "3" के लिए कैरेक्टर बिटमैप स्वैप करना, फिर आगे के क्रम में प्रोग्राम चलाना। । यह cuter है।
— मार्क लकाटा
मुझे पूरा यकीन है कि आप वास्तव में / लोड को सहेज नहीं सकते हैं या अन्यथा मानक टूल का उपयोग करके दिखाए गए क्रम में कोड को सूचीबद्ध कर सकते हैं (निश्चित रूप से वैसे भी Apple II पर नहीं कर सकते हैं), आप जो कुछ कर सकते हैं, वह उन सभी प्रकारों को सांत्वना देने के लिए होगा। उस क्रम में। और अगर आपको अनुमति नहीं है तो आप सी # SendKeys लाइब्रेरी का उपयोग नहीं कर सकते हैं ताकि किसी भी उत्तर की गई भाषाओं में कोड टाइप करने के लिए तीर कुंजियों के साथ एक अलग क्रम में घूम सकें।
— लांस
108

पीएचपी

गाली देने से पहले ... :-)

!print "Line1\n".
!print "Line2\n".
!print "Line3\n".
!print "Line4\n";
— bwoebi
स्रोत
3
PHP में, printएक अभिव्यक्ति के रूप में इस्तेमाल किया जा सकता है, क्योंकि यह पर्ल में हो सकता है, जिसका वापसी मूल्य हमेशा होता है 1। !1रिटर्न bool(false), जो जब एक स्ट्रिंग के रूप में टाइप किया जाता है, तो खाली स्ट्रिंग देता है। PHP के लिए एक अधिक उचित प्रतिबंध के echoबजाय आवश्यकता हो सकती है print; ऊपर वास्तव में केवल एक बयान है।
— प्रिमो
1
@ kuldeep.kamboj यह सिर्फ इस तरह से समूहीकृत है: print ("Line 1". !print ("Line2". !print ("Line 3". !print "Line4")));- एक प्रिंट स्टेटमेंट के दाईं ओर सब कुछ इसका हिस्सा है।
— बोवबी
4
यह हर संस्करण में काम करने लगता है 3v4l.org/dpSpK बहुत प्रभावशाली!
— ईस्बर्ग
3
समझने के लिए मुझे कुछ समय लगा (लिंक के लिए धन्यवाद @eisberg!) लेकिन मुझे अब यह मिल गया है। जबकि पहले printको पहले कहा जाता है, यह तब तक समाप्त नहीं होता है जब तक कि इसे प्रिंट करने की आवश्यकता नहीं होती है जब तक कि आंतरिक (निचले) printको पहले से ही बुलाया नहीं गया हो और पूरी तरह से मूल्यांकन किया गया हो। और !एस सिर्फ 1 को छिपाने के लिए है जो अन्यथा प्रिंट होगा। शानदार, @bwoebi!
— sfarbota
1
@sfarbota पढ़ना नियम कठिन है। फिक्स्ड। धन्यवाद :-)
— bwoebi
76

सी

अपरिभाषित व्यवहार सबसे रोमांचक प्रकार का व्यवहार है!

f(){}
main()
{
   f(printf("Line 1\n"), 
     printf("Line 2\n"), 
     printf("Line 3\n"), 
     printf("Line 4\n"));
}

वास्तविक उत्पादन आपके संकलक, लिंकर, ऑपरेटिंग सिस्टम और प्रोसेसर के आधार पर भिन्न हो सकता है :)

— छेद
स्रोत
22
मुझे बिल्कुल पता नहीं है कि यह वास्तव में कैसे काम करता है, +1।
— svick
7
@vvick: varargs को सपोर्ट करने के लिए, अधिकांश C कंपाइलर्स स्टैक पर फ़ंक्शन आर्गुमेंट्स को रिवर्स ऑर्डर में लगाते हैं (इसलिए स्टैक पर शीर्ष आइटम हमेशा 1 तर्क होता है), जिसका अर्थ है कि वे उसी तरह तर्कों का मूल्यांकन करने की संभावना रखते हैं। बेशक, यह मानता है कि ढेर पर तर्क पारित किए जाते हैं जो नए संकलक के साथ कम और कम हो जाता है।
— गुंट्रम ब्लोह
जैसा कि @GuntramBlohm ने कहा, मूल विचार यह है कि सी फ़ंक्शन पैरामीटर अक्सर (लेकिन हमेशा नहीं) दाएं से बाएं क्रम में स्टैक पर धकेल दिए जाते हैं। चूंकि ये फ़ंक्शन कॉल हैं, इसलिए फ़ंक्शन संभवतः (लेकिन जरूरी नहीं) राइट-टू-लेफ्ट से भी कॉल किए जाते हैं। हालांकि यह सब C मानक द्वारा परिभाषित नहीं है, इसलिए जब यह GCC 4 में सही परिणाम देता है तो यह पूरी तरह से कंपाइलर और कॉलिंग कन्वेंशन तक होता है जो वास्तव में होता है।
— निक
1
@fluffy: काश, यह दूसरा तरीका है: C , अन्य बिंदुओं के विपरीत , arglist अल्पविराम को अनुक्रम बिंदु के रूप में नहीं मानता है ।
— विलीह टोटलैंड
6
@WillihamTotland अच्छी तरह से तो मुझे पता है कि मैं वास्तव में ठीक करने की जरूरत है कुछ कोड का पता है ... धन्यवाद
— शराबी
74

जावा

प्रतिबिंब का उपयोग करना

public class ReversePrint {
    public static void main(String[]a) {
        System.out.println("Line1");
        System.out.println("Line2");
        System.out.println("Line3");
        System.out.println("Line4");
    }
    static {
        try{
            Field f=String.class.getDeclaredField("value");
            f.setAccessible(true);
            f.set("Line1","Line4".toCharArray());
            f.set("Line2","Line3".toCharArray());
            f.set("Line3","Line2 ".trim().toCharArray());
            f.set("Line4","Line1 ".trim().toCharArray());
        }catch(Exception e){}
    }
}

आउटपुट:

Line4
Line3
Line2
Line1

यह कार्य यहाँ क्यों पाया जा सकता है, इसका स्पष्टीकरण दिया गया है ।

— डैनी
स्रोत
61
भयानक। मुझें यह पसंद है।
— रोजर लिंडजो
4
+1 लोग हमेशा कह रहे हैं कि जावा स्ट्रिंग्स अपरिवर्तनीय हैं। आप साबित करते हैं कि वे नहीं हैं।
— विक्टर स्टैफुसा
16
यह खुशी से बुरा है, लेकिन रिवर्स निष्पादन की आवश्यकता पूरी नहीं हुई है।
— थोरबजर्न रेव एंडरसन
4
@ ThorbjørnRavnAndersen shhhh ... आपका यह कहना उन्हें नहीं चाहिए। : पी
— डैनी
5
@Victor जावा में, स्ट्रिंग्स हैं अपरिवर्तनीय। स्टैकओवरफ़्लो पर सभी सवाल हैं, "मुझे लगा कि स्ट्रिंग्स अपरिवर्तनीय थे"। वे प्रतिबिंब का उपयोग करते हैं और यह उन्हें अपरिवर्तनीय लगता है। जावा के वादे इस तरह से काम करते हैं: "यदि आप हमारे उद्देश्य के अनुसार हमारी चीजों / वर्गों का उपयोग करते हैं, तो हम वादा करते हैं कि हमारे दावे सही हैं।" परावर्तन वह तरीका नहीं है जिसका उपयोग करने के लिए वर्गों का इरादा है।
— जस्टिन
70

सी (और अजगर की तरह)

प्रश्न प्रारूप को पूरी तरह से फिट करने के लिए मैक्रो का उपयोग करते हुए नया संस्करण। Quincunx की टिप्पणी के बाद, मैंने returnइसे अच्छा बनाने के लिए जोड़ा ।

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

#define print"\n",printf(
#define return"\n"))));}
#define def main(){0?

def main():
    print "Line 1"
    print "Line 2"
    print "Line 3"
    print "Line 4"
    return

main();

मूल संस्करण - मैक्रो प्रतिस्थापन के बाद दोनों व्यावहारिक रूप से समान हैं:

main(){
    printf("Line 1\n",
    printf("Line 2\n",
    printf("Line 3\n",
    printf("Line 4\n",
    0))));
}
— ugoren
स्रोत
1
मैक्रो के लिए +1। शायद एक और शामिल हो; कुछ ऐसा है #define } 0))));(मुझे ठीक से पता नहीं है कि मैक्रोज़ C में कैसे काम करते हैं)। इस तरह आप मुख्य विधि में सिर्फ प्रिंट स्टेटमेंट रख सकते हैं, और कुछ नहीं।
— जस्टिन
@Quincunx, आप परिभाषित नहीं कर सकते }, लेकिन आप परिभाषित कर सकते हैं return, जो मैंने अब किया। यह अब लगभग एक बहुभाषाविद है - printकई स्क्रिप्ट भाषाओं में वाक्य रचना काम करती है, #defineअक्सर एक टिप्पणी होती है, लेकिन main(){..}मुझे किसी भी भाषा में काम नहीं मिलता है जो मुझे मिल सकता है।
— ugoren
1
@Quincunx, और अब यह वास्तव में एक बहुभुज है।
— बदसूरत
रिक्त स्थान के बिना पहले दो परिभाषित कार्य कैसे होते हैं? क्या इसे printप्रतिस्थापित किया जाएगा "\n",printf(?
— फुलेव
@ LưuV LnhPhúc - स्थान वैकल्पिक है। यह आपके कहे अनुसार बदलता है।
— ugoren
61

ईएस 6 (बैकवर्ड मोड का उपयोग करते हुए;)

वाह, ऐसा लग रहा है कि ECMAScript के डिजाइनरों की कुछ अविश्वसनीय दूरदर्शिता थी जब उन्होंने पीछे की ओर मोड का हिस्सा बनाया :

// activate backwards mode:
'use backwardsˈ; \* mode backwards in now *\
code of lines some ⧵\
\*code*\ "Line1" print \*code*\
\*code*\ "Line2" print \*code*\
\*code*\ "Line3" print \*code*\
\*code*\ "Line4" print \*code*\
code of lines some ⧵\
⁏ˈforwards useˈ // back to ˈnormal'.

// So simple! No need to do anything this complicated:
split('"').reduce((L,o,l)=>(l%2?o:'')+L,'')

आउटपुट (मूल्यांकन, वास्तव में):

"Line4Line3Line2Line1"

ध्यान दें कि यह वास्तव में , प्रपत्र का अनुरोध का केवल मामूली backwardification साथ फिट करने के लिए मोड की वाक्य रचना । यह भी ध्यान दें कि यह मोड फिलहाल फ़ायरफ़ॉक्स के हाल के संस्करणों में समर्थित है ।

अंतिम नोट: वास्तव में, कोई पीछे की ओर मोड नहीं है। लेकिन यह अभी भी एक मान्य स्क्रिप्ट है जो फ़ायरफ़ॉक्स में चलती है (पूरी चीज़ की प्रतिलिपि बनाएँ)। : डी

ईएस 6 "लैक्स मोड"

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

// activate "lax" mode:
`use laxˋ; // also works: ˋuse relaxˋ, ˋuse guessingˋ, ˋuse whatevsˋ, etc.
//some lines of code
/*code*/ print "Line1" /*code*/
/*code*/ print "Line2" /*code*/
/*code*/ print "Line3" /*code*/
/*code*/ print "Line4" /*code*/
//some lines of code
ˋuse normalˋ; // same as ˋuse default`.

// Again, compare to inferior, illegible "traditional" ES6:
split('"').reduce((L,o,l)=>(l%2?o:'')+L,'')

कृपया ध्यान दें कि " लक्ष्मण विधा " वर्तमान में केवल फ़ायरफ़ॉक्स> = 34 में उपलब्ध है; पी

— NOYO
स्रोत
7
आपके द्वारा पोस्ट किए गए सभी 3 लिंक 404 पर चल रहे हैं। क्या इस तरह का मजाक है?
— मैनेटवर्क
8
आह। मुझे अब दिख गया। सिंटैक्स हाइलाइटर यहाँ आपका साथी था।
— मैनावर्क
12
यह एक कॉम्बो लोकप्रियता-प्रतियोगिता और कोड-ट्रोलिंग है , नहीं? :) मुझे यह पसंद है।
— नहीं कि चार्ल्स
8
यह जावास्क्रिप्ट का एक अभूतपूर्व दुरुपयोग है। मुझें यह पसंद है।
— सियारिया
2
ख़ुशामदी। सूइको डरपोक ....
— डेविड कॉनरेड
59

सी

main()
{
  int i = 0;
  for(; i == 0; printf("Line 1\n"))
    for(; i == 0; printf("Line 2\n"))
      for(; i == 0; printf("Line 3\n"))
        for(; i == 0; printf("Line 4\n"))
          i = 1;
}
— डेविड याव
स्रोत
56

माणिक

print 'Line1' unless
print 'Line2' unless
print 'Line3' unless
print 'Line4'

वैकल्पिक रूप से,

def method_missing(meth,*)
  puts meth.to_s.sub('print'){}
end

printLine1(
printLine2(
printLine3(
printLine4)))
— histocrat
स्रोत
38
मैं इसे पसंद करता हूँ क्योंकि यह
— रे
2
यदि आपके पास दो समाधान हैं तो क्या आप दो उत्तर सामान्य नहीं देंगे?
— TheConstructor
3
क्या यह rubyकोड ब्लॉक के साथ और अधिक नहीं लगेगा ? pastebin.com/LDWpxKx8
— मैनटवर्क
2
@PacMani वे पार्न्स व्हाइट स्पेस का उपयोग नहीं करते, वे व्हाइट स्पेस का उपयोग करते हैं।
— corsiKa
@manatwork अच्छा! मुझे लगता method_missingहै कि सुंदर रूबी-ईश ही है, हालांकि।
— हिस्टोक्रैट
49

पीएचपी

मुझे पता है, यह पागलपन है ...

goto d;
a: print "Line1\n"; goto end;
b: print "Line2\n"; goto a;
c: print "Line3\n"; goto b;
d: print "Line4\n"; goto c;
end: exit;
— फ्लोरेंट
स्रोत
66
वह शोर जो आप सुन रहे हैं, वह दीजकस्ट्रा अपनी कब्र में घूम रहा है। :-)
— गैरेथ
24
किसी ने कहा कि "रचनात्मक goto
— बनें
22
@ TheConstructor PHP में रचनात्मक भाग का उपयोग कर रहा है ;)
— NikiC
1
इसलिए जीत से भरपूर।
— निक टी
41

हास्केल

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

a << b = (const a =<< b)

main = putStrLn "Line1"
    << putStrLn "Line2"
    << putStrLn "Line3"
    << putStrLn "Line4"
— shiona
स्रोत
5
टिप:(<<) = flip (>>)
— बरगी
@ बर्गी यह लिखने का एक और तरीका है, मुझे लगता है कि थोड़ा और भी सुरुचिपूर्ण। मैं वास्तव में यह देखकर थोड़ा आश्चर्यचकित था कि बात को प्रस्तावना (या नियंत्रण.मोनड) में परिभाषित नहीं किया गया था
— shiona
@ सियोना: हाँ, यह याद करने के लिए एक आश्चर्यजनक बात है। खुशी से, हम दोनों ऑपरेटरों के लिए है: <*और *>।
— तिखन जेल्विस
@ TikhonJelvis वास्तव में, ऐप्लिकेटर <*ऑपरेटर इससे अलग है <<: a <* bके बराबर है do x<-a;b;return x, अर्थात यह aपहले प्रभाव चलाता है
— गर्व हैसेलकर
40

पर्ल

use threads;

$a=threads->create(sub {sleep(5); print("Line1\n");});
$b=threads->create(sub {sleep(4); print("Line2\n");});
$c=threads->create(sub {sleep(3); print("Line3\n");});
$d=threads->create(sub {sleep(2); print("Line4\n");});

$a->join();
$b->join();
$c->join();
$d->join();
— गैरेथ
स्रोत
22
यह सैद्धांतिक रूप से सटीक रिवर्स ऑर्डर में प्रिंट करने की गारंटी नहीं है।
— क्रंचर
4
@ क्रंचर मुझे पता है, लेकिन 1 सेकंड के अंतराल के साथ रिवर्स ऑर्डर के अलावा किसी अन्य चीज में छपाई की संभावना बहुत पतली है।
— गारेथ
3
@ यही कारण है कि मैं सैद्धांतिक रूप से italicized :)
— Cruncher
3
@ क्रंचर नहीं है कि यह इतना मजेदार क्या है?
— पियरे अरलाउड
@ क्रंचर उसी तरह से जो सैद्धांतिक रूप से मेरे परमाणु एक दीवार से गुजर सकते हैं?
— cdeange
37

HTML + सीएसएस

<p>Line 1</p>
<p>Line 2</p>
<p>Line 3</p>
<p>Line 4</p>

सीएसएस:

body {margin-top:7em}
p + p {margin-top:-4em}

JsFiddle देखें ।

संपादित करें:
नियमों को बेहतर तरीके से पालन करने के लिए, XML में एक संस्करण है, जो वास्तव में उपयोग करता है print।

<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet href="style.css"?>
<root>
  <print>Line 1</print>
  <print>Line 2</print>
  <print>Line 3</print>
  <print>Line 4</print>
</root>

जहां style.css होना चाहिए

* {display:block; margin-top:3em}
print + print {margin-top:-3em}

बिना CSS के HTML

और इसके लिए, यहाँ सीएसएस के बिना एक है।

<table>
<tfoot><tr><td><table><tfoot><tr><td>Line 1</tr></tfoot>
<tbody><tr><td>                      Line 2</table></tfoot>
<tbody><tr><td><table><tfoot><tr><td>Line 3</tr></tfoot>
<tbody><tr><td>                      Line 4</table></tbody>
</table>

फील करना ।

— मिस्टर लिस्टर
स्रोत
2
क्या कोई नीच को समझा सकता है? यह काम करता है जब मुद्रण, तुम्हें पता है।
— मिस्टर लिस्टर
तुम भी बस कर सकते हैंp {float:right;}
— Noyo
लेकिन तब परिणाम सभी एक लाइन पर होंगे!
— मिस्टर लिस्टर
... और इसकी अनुमति है। :]
— नॉयो
1
... और वह अस्वीकृत नहीं है। : D आप इसे div में भी लपेट सकते हैं और CSS नियम जोड़ सकते हैं div {float:left}।
— नोयो
23

सी ++

#include <iostream>
#define Q(x,y) x ## y
#define P(x,y) Q(x, y)
#define print S P(s, __LINE__) =
struct S { const char *s; S(const char *s): s(s) {} ~S() { std::cout << s << std::endl; } };
int main() {
    print "Line1";
    print "Line2";
    print "Line3";
    print "Line4";
}

(स्थानीय चर घोषणा के रिवर्स ऑर्डर में नष्ट हो जाते हैं।)

सी ++ 11

#include <iostream>
int main() {
    struct S { void (*f)(); S(void (*f)()): f(f) {} ~S() { f(); } } s[] = {
        {[](){ std::cout << "Line1" << std::endl; }},
        {[](){ std::cout << "Line2" << std::endl; }},
        {[](){ std::cout << "Line3" << std::endl; }},
        {[](){ std::cout << "Line4" << std::endl; }},
    };
}

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

— ecatmur
स्रोत
मैंने एक समाधान का उपयोग करके पोस्ट किया std::function, और मैं इससे छुटकारा पाने की कोशिश कर रहा था। अब मुझे इसकी आवश्यकता नहीं है क्योंकि आपको यह मिल गया है!
— सर्गियोल
21

हास्केल

main = sequence_ $ reverse [
    putStr "Line1",
    putStr "Line2",
    putStr "Line3",
    putStr "Line4"]
— mniip
स्रोत
21

जावास्क्रिप्ट

setTimeout(function(){console.log("Line 1");},900);
setTimeout(function(){console.log("Line 2");},800);
setTimeout(function(){console.log("Line 3");},700);
setTimeout(function(){console.log("Line 4");},600);
— JoshWillik
स्रोत
1,2,3,4टाइमआउट के रूप में उपयोग करना मेरे लिए भी काम करता है। (हालांकि, मुझे नहीं पता कि यह व्यवहार
— ईसीएमएस्क्रिप्ट
1
@ComFreek: setTimeoutHTML5 / टाइमर में मानकीकृत है, ES में नहीं। इसके अलावा, यह 4ms :-) का न्यूनतम समय
— निर्धारण
1
@Bergi हां, आप सही हैं, बिल्कुल! HTML मानक - टाइमर - अगर किसी को दिलचस्पी है।
— कॉमफ्रीक
1
इसे धीमी गति से पर्याप्त मशीन पर चलाएं (कहते हैं, 8086 में कई अन्य एप्लिकेशन चल रहे हैं?) और यह विफल हो जाएगा। (विफल होने से, मेरा मतलब है कि आदेश उलट नहीं जाएगा, क्योंकि यह प्रत्येक कथन को निष्पादित करने के लिए> = 100ms लेगा।
— जेफ डेविस
1
@ lastr2d2 छोरों के साथ एक धीमी गति से कंप्यूटर का अनुकरण करना काफी व्यक्तिपरक है, लेकिन मुझे लगता है कि यह अधिक पसंद आएगा: jsfiddle.net/7zbKw/1 । Whatwg.org/specs/web-apps/current-work/multipage/… से ध्यान दें "यह एपीआई इस बात की गारंटी नहीं देता है कि टाइमर बिल्कुल समय पर चलेगा। सीपीयू लोड, अन्य कार्यों, आदि के कारण देरी होने की उम्मीद है।"
— जेफ डेविस
20

सी

यथासंभव प्रश्न में सुझावों की अवहेलना करने की कोशिश करना:

#include <stdio.h>
#define print if (i == __LINE__) puts
static unsigned i;
int main(void) {
  while (--i) {
    print("Line 1");
    print("Line 2");
    print("Line 3");
    print("Line 4");
  }
  return 0;
}
— HVD
स्रोत
3
#define का अच्छा दुरुपयोग: पी +1
— मास्टरएक्स 244
15

बीएफ

सेल-रैपिंग मान लेता है।

++++[->+
----[> (line 1) .[-]<]++++
---[> (line 2) .[-]<]+++
--[> (line 3) .[-]<]++
-[> (line 4) .[-]<]+
<]

यह काम क्यों करता है

पहली और आखिरी लाइनें एक लूप की रचना करती हैं जो चार बार दोहराता है (काउंटर = cell0)।

लूप के अंदर, एक काउंटर चर ( cell1) है जो हर रन को बढ़ाया जाता है।

प्रत्येक रेखा चार, तीन, दो या एक शून्य से कम होने पर जांच करती है। इसलिए, पहले रन पर, काउंटर एक है और अंतिम लाइन निष्पादित की जाती है, दूसरे रन पर, तीसरी लाइन निष्पादित होती है, आदि।

वह (line 1)शो जहाँ आपको मुद्रित होने वाले पाठ को बनाना चाहिए। छोरों में तीर cell2इस उद्देश्य के लिए आवंटित होते हैं । [-]की सफाई cell2आप इसका इस्तेमाल के बाद।

— Timtech
स्रोत
14

दे घुमा के

आदरणीय SleepSort और SleepAdd की स्मृति में , मैं आपके समक्ष प्रस्तुत ... SleepReverse :

#!/bin/bash

function print(){(sleep $((4-$1));echo "Line $1";)&}

print 1
print 2
print 3
print 4
— दंगा
स्रोत
इसके लिए चश्मे की तरह अधिक देखने के लिए, का उपयोग करें $1और $2: function print(){(sleep $((4-$2));echo "$1 $2";)&}; print Line 1
— ThinkChaos
13

जावा

import java.io.PrintStream;
import java.util.concurrent.FutureTask;

public class Print {
  public static void main(String[] args) {
    new FutureTask<PrintStream>(new Runnable() {
      public void run() {
        new FutureTask<PrintStream>(new Runnable() {
          public void run() {
            new FutureTask<PrintStream>(new Runnable() {
              public void run() {
                System.out.append("Line1"); }
            }, System.out.append("Line2")).run(); }
        }, System.out.append("Line3")).run(); }
    }, System.out.append("Line4")).run();
  }
}

यह सब सही समय में है ... ;-)

— TheConstructor
स्रोत
रेखाओं को आसन्न होना है।
— 15
वे उदाहरण के लिए codegolf.stackexchange.com/a/20660/16293 के साथ किसी भी तरह से कम सटे हुए नहीं हैं, किसी ने कहा कि उन्हें समान दिखना चाहिए। कुछ न्यूलाइन-वर्णों को हटा देगा ;-)
— TheConstructor
ठीक है, महान :-)
— टिमटेक
12

दे घुमा के

यहाँ दो-मुखी स्क्रिप्ट आती है:

#!/bin/bash
s=1
if [ $s -ne 0 ]; then tac $0 | bash; exit; fi
s=0
echo "Line1"
echo "Line2"
echo "Line3"
echo "Line4"
— माटेओ इटालिया
स्रोत
2
मुझे कभी पता भी नहीं चला tac! हा हा धन्यवाद।
— नॉयो
11

आम लिस्प № 1

ngorpमैक्रो लिखना आसान है जो रिवर्स ऑर्डर में अपने रूपों को निष्पादित करता है:

(macrolet ((ngorp (&body ydob) `(progn ,@(reverse ydob))))
  (ngorp
   (write-line "Line 1")
   (write-line "Line 2")
   (write-line "Line 3")
   (write-line "Line 4")))

Line 4
Line 3
Line 2
Line 1

आम लिस्प № 2

यहाँ एक है जो समस्या को बहुत शाब्दिक रूप से लेता है; प्रश्न से कोड संशोधन के बिना कार्यक्रम में दिखाई देता है:

(macrolet ((execute-prints-backwards (&body body)
             `(progn 
                ,@(nreverse (mapcar (lambda (string)
                                      (list 'write-line string))
                                    (remove-if-not 'stringp body))))))
  (execute-prints-backwards

//some lines of code
/*code*/ print "Line1" /*code*/
/*code*/ print "Line2" /*code*/
/*code*/ print "Line3" /*code*/
/*code*/ print "Line4" /*code*/
//some lines of code

  ))

Line4
Line3
Line2
Line1
— जोशुआ टेलर
स्रोत
10

पीएचपी

एक और evalप्रकार:

$lines=array_slice(file(__FILE__),-4); // get last 4 lines of current file
eval(implode('',array_reverse($lines)));exit; // eval lines reversed and exit
print "Line1\n";
print "Line2\n";
print "Line3\n";
print "Line4\n";
— निर्णायक डब्बलर
स्रोत
1
स्लिक! बहरहाल, मुझे लगता है कि यह एक बहुत बुरा विचार है।
— डेविड क्रिजानिक
9

एफ #

let inline (?) f g x = g x; f x

(printfn "Line1%s") ?
 (printfn "Line2%s") ?
  (printfn "Line3%s") ?
   (printfn "Line4%s") ""

बस एक कस्टम ऑपरेटर बनाया जो रिवर्स ऑर्डर में फ़ंक्शन निष्पादित करता है।

— pswg
स्रोत
3
मुझे पूरा यकीन है (;) f (g (x)) = g (x); f (x) कैलकुलस है न कि प्रोग्रामिंग।
— जेफ डेविस
2
@ जेफडेविस: बहुत यकीन (?) f g xहै कि मोटे तौर पर के रूप में पढ़ता है (?)(f, g, x), नहींf(g(x))
— एरिक
9

गो (गोलंग)

package main

import "fmt"

func main() {
    defer fmt.Println("Line 1")
    defer fmt.Println("Line 2")
    defer fmt.Println("Line 3")
    defer fmt.Println("Line 4")
}

इसे आज़माएं: http://play.golang.org/p/fjsJLwOFn2

— cory.todd
स्रोत
मैं ठीक उसी कोड को पोस्ट करना चाहता था। वास्तव में, बाइट के लिए बाइट बिल्कुल वैसा ही।
— आर्ट
@ भयानक, कमाल! मुझे और अधिक देखने की उम्मीद है कि कोड गोल्फ में उपयोग किया जाता है।
— cory.todd
शायद नहीं होगा। गो वास्तव में एक संपीड़ित होने के कारण अच्छा नहीं है, वे जानबूझकर अजीब निर्माणों को सीमित करते हैं ताकि आप एक अपठनीय गंदगी पैदा न कर सकें। लेकिन इस मामले में (और शायद अन्य लोकप्रियता प्रतियोगिता) इसका एक मौका है।
— कला
8

python3

print("Line1",
print("Line2",
print("Line3",
print("Line4") or '') or '') or '')

अंतिम पंक्ति में सभी रिक्त स्थान हटाकर 6 बाइट्स छोटी हो सकती हैं।

— aragaer
स्रोत
7

जावास्क्रिप्ट

[
  "console.log('Line1')",
  "console.log('Line2')",
  "console.log('Line3')",
  "console.log('Line4')"
].reverse().forEach(function(e){eval(e)})

सी ++ 11

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<std::function<void()>> functors;
    functors.push_back([] { std::cout << "Line1"; });
    functors.push_back([] { std::cout << "Line2"; });
    functors.push_back([] { std::cout << "Line3"; });
    functors.push_back([] { std::cout << "Line4"; });
    std::reverse(functors.begin(),functors.end());
    std::for_each (functors.begin(), functors.end(), [](std::function<void()> f) {f();});
    return 0;
}
— माइकल एम।
स्रोत
इसके बजाय std::reverseऔर std::for_each, बस का उपयोगwhile (! functors.empty()) { functors.back()(); functors.pop_back(); }
— डेविड Hammen
7

जत्था

echo off

call :revers ^
echo.line1 ^
echo.line2 ^
echo.line3 ^
echo.line4

:revers
if not "%2"=="" call :revers %2 %3 %4 %5 %6 %7 %8 %9
%1
— hmilch
स्रोत
Codegolf में आपका स्वागत है! अच्छा लेख।
— क्रंचर
7

सी#

रन विधि को सीधे कॉल करने के बजाय, मैं एक डायनामिक विधि बना रहा हूं जिसमें रन आईएल बायोटेक की एक प्रति शामिल है, सिवाय इसके कि लोड-स्ट्रिंग ओपोड ऑपरेंड स्वैप किए जाते हैं। जो नई पद्धति को उल्टे क्रम में तारों को प्रदर्शित करने का कारण बनता है।

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Reflection.Emit;

namespace TestApp
{
    class Program
    {
        public static void Run()
        {
            Console.WriteLine("Line 1");
            Console.WriteLine("Line 2");
            Console.WriteLine("Line 3");
            Console.WriteLine("Line 4");
        }


        static void Main(string[] args)
        {
            var method = typeof(Program).GetMethod("Run");
            var il = method.GetMethodBody().GetILAsByteArray();
            var loadStringOperands = new Stack<int>();
            for (int i = 0; i < il.Length; i++)
            {
                if (il[i] == OpCodes.Ldstr.Value)
                {
                    loadStringOperands.Push(BitConverter.ToInt32(il, i + 1));
                    i += 4;
                }
            }

            var run = new DynamicMethod("Run", typeof(void), null);
            var gen = run.GetILGenerator(il.Length);
            for (int i = 0; i < il.Length; i++)
            {
                if (il[i] == OpCodes.Ldstr.Value)
                {
                    var str = method.Module.ResolveString(loadStringOperands.Pop());
                    gen.Emit(OpCodes.Ldstr, str);
                    i += 4;
                }
                else if (il[i] == OpCodes.Call.Value)
                {
                    var mInfo = method.Module.ResolveMethod(BitConverter.ToInt32(il, i + 1)) as MethodInfo;
                    gen.Emit(OpCodes.Call, mInfo);
                    i += 4;
                }
                else if (il[i] == OpCodes.Ret.Value)
                {
                    gen.Emit(OpCodes.Ret);
                }
            }

            run.Invoke(null, null);
        }
    }
}
— पीटर विटोवेट
स्रोत
6

अजगर

अभी तक एक और समाधान का उपयोग कर eval()

a = [
"print('Line1')",
"print('Line2')",
"print('Line3')",
"print('Line4')"]

for line in reversed(a):
    eval(line)

यह बहुत जटिल नहीं है, लेकिन समझने में आसान है।

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