ढेर अतिप्रवाह

47

( इस सवाल से प्रेरित )

उद्देश्य

आपका कार्य STDOUT को स्टैक ओवरफ्लो लोगो के ASCII संस्करण को प्रिंट करने के लिए एक प्रोग्राम या फ़ंक्शन लिखना है

 \|/
(-)
(-)
(-)
(-)

आपके प्रोग्राम को दो इनपुट्स लेने चाहिए, जिन्हें H और N के रूप में संदर्भित किया जाता है। स्टैक "कंटेनर" (कोष्ठक) की ऊंचाई H द्वारा निर्धारित की जाती है। स्टैक में आइटमों की संख्या N. If N> H द्वारा निर्धारित की जाती है। स्टैक "अतिप्रवाह" होगा।

इनपुट आउटपुट

एच कंटेनरों की ऊंचाई निर्धारित करेगा

उदाहरण के लिए:

एच = 1:

( )

एच = 2:

( )
( )

एच = 3:

( )
( )
( )

एच हमेशा कम से कम 1 होगा

N यह निर्धारित करेगा कि स्टैक में कितने आइटम हैं। निम्नलिखित उदाहरण सभी H = 2 हैं:

एन = 0

( )
( )

एन = 1

( )
(-)

एन = 2

(-)
(-)

एन = 3

 \
(-)
(-)

एन = 4

 \|
(-)
(-)

एन = 5

 \|/
(-)
(-)

एन = 6

 \|/
(-)-
(-)

एन = 7

 \|/
(-)-
(-)-

एन कभी भी अधिक नहीं होगा 2H+3(दूसरे शब्दों में, स्टैक कभी जमीन के माध्यम से नहीं जाएगा)।

नियम

  • कोई मानक ढीला नहीं।
  • आपके प्रोग्राम में कोई त्रुटि नहीं होनी चाहिए।
  • सभी परीक्षण मामले पास होने चाहिए।
  • आप किसी भी तरह से एच और एन इनपुट कर सकते हैं।
  • मुझे गंभीरता से संदेह है कि आपकी भाषा में इसके लिए अंतर्निहित है।
  • प्रत्येक पंक्ति में वैकल्पिक रूप से अंत में एक अतिरिक्त स्थान हो सकता है। एक स्टैक के ऊपर एक रिक्त रेखा जहां N <= H वैकल्पिक है, जैसा कि एक अनुगामी न्यूलाइन है।
  • यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा कोड है!

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

इनपुट / आउटपुट सेक्शन के सभी H = 2 टेस्ट मामलों के अलावा, निम्नलिखित सभी टेस्ट केस पास होने चाहिए:

एच = 1, एन = 1

(-)

एच = 1, एन = 5

 \|/
(-)-

एच = 4, एन = 7

 \|/
(-)
(-)
(-)
(-)

एच = ५, एन = ०

( )
( )
( )
( )
( )

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई देता है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

# Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

कोड स्निपेट दिखाएं

code-golf  ascii-art 
— डैनियल एम।
स्रोत
4
क्या मैं एक गैर-प्रतिस्पर्धी कार्यक्रम पोस्ट कर सकता हूं जो वास्तव में लोगो को प्रिंट करने के बजाय स्टैक को ओवरफ्लो करता है?
— डोरुकायहन
@dorukayhan अगर केवल n> h :) से ओवरफ्लो होता है तो
— डैनियल एम।
मेरा मतलब है, क्या मैं एक प्रोग्राम बना सकता हूं जो स्टैक ओवरफ्लो से क्रैश हो?
— डोरुकायहन
@dorukayhan तभी होता है जब स्टैक की तुलना में अधिक आइटम होने पर यह दुर्घटनाग्रस्त हो सकता है
— डैनियल एम।

जवाबों:

14

पायथ, 43 41 40 बाइट्स

<" \|/"g#0hK-QJEVJs[\(?<N_Kd\-\)*<N-K3\-

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

पहले पास, जल्दी और गंदे। STDIN के रूप में इनपुट N\nH।

व्याख्या

  1. दूसरा इनपुट (ऊंचाई) से J( ) तक सहेजें JE, और पहले इनपुट (आइटम की संख्या) से घटाएं। ( -QJE)
  2. अंतर (अतिप्रवाह वस्तुओं की संख्या) को सहेजें K। ( K-QJE)
  3. संख्या में 1 जोड़ें। ( hK-QJE)
  4. ले लो max(0, previous)। यह आवश्यक है क्योंकि नकारात्मक संख्या अगले चरण को तोड़ देगी। ( g#0hK-QJE)
  5. " \|/"पहली पंक्ति और प्रिंट प्राप्त करने के लिए स्ट्रिंग से बहुत से अक्षर लें । ( <" \|/"g#0hK-QJE)
  6. लूप Nओवर range(0, J)। ( VJ) प्रत्येक Nप्रिंट के लिए निम्नलिखित का संयोजन: ( s[)
    • "("( \()
    • " "यदि N+1स्टैक में कम से कम खाली स्थान हैं ( <N_K), "-"अन्यथा। ( ?<N_Kd\-)
    • ")"( \))
    • "-"यदि N+4स्टैक में कम से कम अतिप्रवाह टुकड़े हैं ( <N-K3), ""अन्यथा। ( *<N-K3\-)
— PurkkaKoodari
स्रोत
13

जावास्क्रिप्ट (ईएस 6), 105 102 बाइट्स

@ ईडिट: सहेजे गए 3 बाइट्स @PatrickRoberts की बदौलत।

f=
(n,h)=>` \\|/`.substr(0,n+1-h)+[...Array(h)].map((_,i)=>`
(${i+n<h?` `:`-`})${i+h+3<n?`-`:``}`).join``
;
<div oninput=o.textContent=f(+n.value,+h.value)>n<input id=n type=number min=0 value=0>h<input id=h type=number min=0 value=0><pre id=o>
स्निपेट का विस्तार करें

— नील
स्रोत
आप बदल सकते हैं substringके साथ substr3 बाइट्स बचाने के लिए, और बदलने के लिए i+n<h?' ':'-'के साथ '- '[i+n<h]करने के लिए सेव 2 बाइट्स और की जगह i+h+3<n?'-':''के साथ ' -'[i+h+3<n]1 बाइट को बचाने के लिए। यह आपको 100 से कम में मिलेगा
— पैट्रिक रॉबर्ट्स
@PatrickRoberts मुझे याद नहीं है कि substrनकारात्मक सदस्यता को अनदेखा किया गया था या नहीं, लेकिन मैं आपके अन्य सुझावों का उपयोग नहीं कर सकता क्योंकि स्ट्रिंग सदस्यता तार हैं, इसलिए बूलियंस पर्याप्त अच्छे नहीं हैं।
— नील
बकवास मैं उस बारे में भूल गया, अच्छी बात
— पैट्रिक रॉबर्ट्स
उन दो पात्रों को बचाने के लिए टैग किए गए टेम्पलेट का वास्तव में चतुर उपयोग!
— बेंजामिन ग्रुएनबाम
@BenjaminGruenbaum "टैग टेम्पलेट" क्या है?
— पैट्रिक रॉबर्ट्स
12

जावास्क्रिप्ट (ईएस 6), 126 122 112 बाइट्स

h=>n=>' \\|/'.substr(0,(o=n-h)+1)+`
( )`[r='repeat'](0>-o?0:-o)+`
(-)-`[r](o=0>o-3?0:o-3)+`
(-)`[r](n<h-o?n:h-o)

परीक्षा

f=h=>n=>' \\|/'.substr(0,(o=n-h)+1)+`
( )`[r='repeat'](0>-o?0:-o)+`
(-)-`[r](o=0>o-3?0:o-3)+`
(-)`[r](n<h-o?n:h-o)
document.write(`<pre>${[[2,0],[2,1],[2,2],[2,3],[2,4],[2,5],[2,6],[2,7],[1,1],[1,5],[4,7],[5,0]].map(a=>f(a.shift())(a.shift())).join`

`}</pre>`)
स्निपेट का विस्तार करें

वैकल्पिक परीक्षण (यदि आपका ब्राउज़र ES6 का समर्थन नहीं करता है)

Babeljs.io पर परीक्षण देखें और "मूल्यांकन" जांचें।

136 बाइट्स पर दिलचस्प वैकल्पिक दृष्टिकोण

h=>n=>' \\|/'.substr(0,(o=n-h)+1)+`
( )${0>-o?0:-o}
(-)-${o=0>o-3?0:o-3}
(-)${n<h-o?n:h-o}`.replace(/(\n.*)(\d+)/g,(_,s,r)=>s.repeat(r))

यह रिपीट अमाउंट को टेम्प्लेट स्ट्रिंग में ले जाता है और रीजैक्स का उपयोग करता है और रिपीटिंग समूहों को इंजेक्ट करने के लिए प्रतिस्थापित करता है। दुर्भाग्य से हस्ताक्षर .replace()अभी बहुत लंबे हैं।

— पैट्रिक रॉबर्ट्स
स्रोत
मुझे एक त्रुटि मिलती है ...?
— एडिसन क्रम्प
1
@VTCAKAVSMoACE आपके ब्राउज़र को ES6 सिंटैक्स का समर्थन करना चाहिए। यह मेरे लिए ठीक काम करता है। बेबल में परीक्षण पेस्ट करने के लिए स्वतंत्र महसूस करें ।
— पैट्रिक रॉबर्ट्स
@VTCAKAVSMoACE Chrome 52 (जून 2016 के अनुसार बीटा) में टेल कॉल ऑप्टिमाइज़ेशन और मॉड्यूल लोडिंग को छोड़कर सभी ES6 और ES7 का समर्थन करता है।
— gcampbell
10

सी ++ 14 (लैम्ब्डा फ़ंक्शन), 196

क्वेंटिन के लिए 1 बाइट धन्यवाद।

एडम मार्टिन के लिए धन्यवाद 2 बाइट्स बचाए।

#include<iostream>
using namespace std;[](int h,int n){auto s=" \\|/( ) (-) (-)-"s;int t=max(min(n-h,3),0);n-=t;cout<<s.substr(0,t+1)+'\n';for(;h;h--)n-=t=n>h?2:h<=n,cout<<s.substr(4+4*t,4)+'\n';}

फ़ंक्शन स्वयं 157 बाइट्स लेता है।

इसे यहां कार्रवाई में देखें ।

Ungolfed संस्करण:

[](int h, int n) {
    auto s = " \\|/( ) (-) (-)-"s;
    int t = max(min(n - h, 3), 0);
    n -= t;
    cout << s.substr(0, t + 1) + '\n';
    for(; h; h--) {
        if (n > h) t = 2;
        else if (h > n) t = 0;
        else t = 1;
        n -= t;
        cout << s.substr(4 + 4 * t, 4) + '\n';
    }
};
— vaultah
स्रोत
2
मैं भी शामिल करने का कोई मतलब देखना includeऔर using namespace std;बाइट गिनती में, जब तक कि आपका जवाब एक पूरा कार्यक्रम है (जो यह नहीं है)।
— अलेक्जेंडर रेवो
9

सीजेएम, 57 बाइट्स

Sri:X'(*+X),W%X)X')*+X),X))f+]zN*X5*,X'-*_"\|/"\++ri<S+er

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

निश्चित रूप से कुछ सुधार का उपयोग कर सकता है। विचार एक ग्रिड का निर्माण करना है जहां -\|/-कोशिकाओं को लगातार पूर्णांक के साथ बदल दिया जाता है, जैसे

 345
(2)6
(1)7
(0)8

और फिर अंत में उन्हें सही पात्रों (संभावित रिक्त स्थान) के साथ बदलने के लिए।

— मार्टिन एंडर
स्रोत
6

पायथन 2, 101 100 98 बाइट्स

def f(h,n):
 print" \|/"[:max(0,n-h+1)]
 for i in range(h):print("(-)","( )")[h-i>n]+"-"*(n>i+h+3)
— चक मॉरिस
स्रोत
के बाद रिक्त स्थान printअनावश्यक हैं
— Cyoce
@ कोको धन्यवाद, जो 2 वर्ण बचाता है।
— चक मॉरिस
4

जावास्क्रिप्ट (ईएस 6), 87 80 बाइट्स

F=(h,n)=>h?F(h-1,n-1)+`
(${n>0?'-':' '})${n>2*h+2?'-':''}`:' \\|/'.substr(0,n+1)

नीचे से ऊपर तक आउटपुट स्ट्रिंग बनाने के लिए पुनरावर्तन का उपयोग करता है।

संपादित करें : 87 बाइट्स से 7 बाइट्स दाढ़ी के लिए @Neil का धन्यवाद

मूल

(h,n)=>(E=s=>h--?E(`
(${n>0?'-':' '})${--n>2*h+3?'-':''}`+s):` \\|/`.substr(0,n+1)+s)``

टेस्ट स्निपेट:

F=(h,n)=>h?F(h-1,n-1)+`
(${n>0?'-':' '})${n>2*h+2?'-':''}`:' \\|/'.substr(0,n+1)


h.oninput = n.oninput = () => output.innerHTML = F(+h.value, +n.value);
<label>h <input type="number" min="0" value="0" id="h" /></label>
<label>n <input type="number" min="0" value="0" id="n" /></label>
<hr />
<pre id="output"></pre>
स्निपेट का विस्तार करें

— जॉर्ज रीथ
स्रोत
अच्छा स्निपेट के लिए धन्यवाद! एक अतिरिक्त बिंदु देना चाहिए: पी
— किममैक्स
1
@ किमैक्स धन्यवाद दोस्त, कोई भी व्यक्ति को सांत्वना के साथ खिलवाड़ नहीं करना चाहता
— जॉर्ज रीथ
कम से कम जब मैंने कोशिश की, तो स्टैक बहुत बड़ा था, और यह केवल 78 बाइट्स के साथ सामान्य पुनरावृत्ति होगा।
— नील
स्निपेट कंसोल SyntaxErrorमेरे लिए दिखा रहा है ।
— आर्टऑफकोड
1
@ArtOfCode को ES6 अनुरूप ब्राउज़र का उपयोग करने की आवश्यकता है
— जॉर्ज रीथ
3

जावास्क्रिप्ट (ईएस 6), 149 139 137 बाइट्स

h=>n=>` ${[(g=(j,m=1)=>` -\\|/`[(j<n)*m])(h,2),g(h+1,3),g(h+2,4)].join``}${[...Array(h)].map((_,i)=>`
(${g(h-i-1)})${g(h+i+3)}`).join``}`

मुझे -\|/पात्रों को अनुक्रमित करने के बारे में @ मार्टिनियर का विचार पसंद आया और मैं यह देखना चाहता था कि ईएस 6 में इसका किराया कैसे होगा। जाहिर तौर पर मैंने इतना अच्छा नहीं किया। यह पता लगाने की कोशिश की जा रही है कि क्या इसका उपयोग करके सुधार किया जा सकता है for...of।

संपादित करता

  • मैं बदले .replaceमें सीधे अनुक्रमण को आगे बढ़ाते हुए regexp और कॉल को हटाने में कामयाब रहा g()।
  • मैं गलती f=से दूसरी बाइट की गिनती में आ गया

परीक्षा

f=h=>n=>` ${[(g=(j,m=1)=>` -\\|/`[(j<n)*m])(h,2),g(h+1,3),g(h+2,4)].join``}${[...Array(h)].map((_,i)=>`
(${g(h-i-1)})${g(h+i+3)}`).join``}`
document.write(`<pre>${[[2,0],[2,1],[2,2],[2,3],[2,4],[2,5],[2,6],[2,7],[1,1],[1,5],[4,7],[5,0]].map(a=>f(a.shift())(a.shift())).join`

`}</pre>`)
स्निपेट का विस्तार करें

— पैट्रिक रॉबर्ट्स
स्रोत
3

जावा, 186 177 बाइट्स

void f(int h,int n){for(int i=0;i<h+1;i++)System.out.print((i>0?"(":" ")+(i>0?n>h-i-2?"-":" ":n>h+0?"\\":" ")+(i>0?")":n>h+1?"|":" ")+(i>0?n>h+2+i?"-":" ":n>h+2?"/":" ")+"\n");}

अघोषित ऑनलाइन प्रयास करें

String f(int h, int n)
{
    String s=" ";
    s+=n>h+0?"\\":" ";
    s+=n>h+1? "|":" ";
    s+=n>h+2? "/":" ";
    s+="\n";

    for(int i=0; i<h; i++)
    {
        s+="(";
        s+=n>h-i-1?"-":" ";
        s+=")";
        s+=n>h+3+i?"-":" ";
        s+="\n";
    }

    return s;
}
— Khaled.K
स्रोत
आप एक मेमने का उपयोग करके बाइट्स बचा सकते हैं- आप शायद मेमने का शरीर भी छोड़ सकते हैं
— डैनियल एम।
2
क्या मुझे Ungoled Java कोड को संकलित करने के लिए कुछ कस्टम IDE की आवश्यकता है ? : डी
— किम्मैक्स
@ किमैक्स .. डी’ओह!
— खालिद .K
3

एक्सेल, 131 बाइट्स

इनपुट एक टपल, ऊंचाई के रूप में लिया Hमें A1, Nमें B1। फार्मूला वाले सेल में टेक्स्ट रैपिंग चालू होना आवश्यक है। मोनो-रिक्ति फ़ॉन्ट का उपयोग करके सुझाव दें।

=LEFT(" \|/",MAX(0,B1-A1+1))&"
"&REPT("(-)-
",MAX(0,B1-A1-3))&REPT("( )
",MAX(0,A1-B1))&REPT("(-)
",A1-MAX(0,B1-A1-3)-MAX(0,A1-B1))
— Wernisch
स्रोत
अद्भुत समाधान! आपको यह जोड़ना चाहिए कि इस इनपुट को 2-टपल से इनपुट के रूप में लें A1और B1सरल नोट को जोड़ें जिससे कि कॉलिंग सेल को रैप टेक्स्ट विकल्प के सही होने की आवश्यकता हो। यह भी हो सकता है कि उचित संरेखण पाने के लिए इसमें कोरियर न्यू या ल्यूसिडिया कंसोल जैसे एक मोनो-स्पॉन्टेड फ़ॉन्ट होना चाहिए
— टेलर स्कॉट
1
धन्यवाद @TaylorScott आपके सुझावों के साथ अद्यतन उत्तर।
— विर्निस्क नोव
2

सी ++ 11, 155 148 145 बाइट्स

void f(int h,int n){cout<<string{" \\|/",max(min(3,n-h),0)+1}<<'\n';for(int i=0;i<h;++i)cout<<(h-i<=n?"(-)":"( )")<<(i<max(n-h-3,0)?"-\n":"\n");}

अधूरा :

void f(int h,int n)
{
  cout << string{" \\|/", max(min(3, n-h), 0) + 1} << '\n';
  for(int i=0; i<h; ++i)
    cout << (h-i <= n ? "(-)" : "( )") << (i < max(n-h-3,0) ? "-\n" : "\n");
}

उपयोग :

#include <iostream>
#include <string>
using namespace std;

void f(int h,int n){cout<<string{" \\|/",max(min(3,n-h),0)+1}<<'\n';for(int i=0;i<h;++i)cout<<(h-i<=n?"(-)":"( )")<<(i<max(n-h-3,0)?"-\n":"\n");}

int main()
{
  int h,n;
  cin >> h >> n;
  f(h, n);
}
— अलेक्जेंडर रेवो
स्रोत
— सीलिंगकैट
1

पायथन 3, 134 121 118 111 बाइट्स

def f(h,n):print('\|/'[:max(0,n-h)]+'\n'+'\n'.join('(-)-'if h<n-x-3else('(-)','( )')[x+n<h] for x in range(h)))

इसे यहां देखें: https://repl.it/CYL1/0

संयुक्त राष्ट्र के golfed:

def f(h,n):
  top=['\|/'[:max(0,n-h)]]
  stack=['( )'if x+n<h else'(-)'for x in range(h)]
  overflow=top+stack
  v=n-3
  while v>h:
      overflow[h-v]+='-' #add side overflow
      v-=1

  print('\n'.join(overflow))

मुझे सूची समझ में साइड ओवरफ्लो जोड़ा गया है, लेकिन मैं इसे निचोड़ नहीं सकता था, इसलिए मुझे लूप के साथ जाना पड़ा। 13 बाइट्स बचाए!

— atlasologist
स्रोत
आउटपुट बंद है, आपको संभवतः '\|/'[:max(0,n-h)]पायथन 2 समाधान की तरह बदलने की आवश्यकता है ।
— बसफॉल्ट
1

पिप , 50 बाइट्स

Ps.(0Xa."\|/")@<bDC0Fi,aP"()"WV"- "@[b<a-ib<a+4+i]

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

उह, यह बहुत लंबा है ... यह किसी भी अधिक छोटा करने के लिए कैसे पता नहीं है, हालांकि। चक्रीय अनुक्रमण, जो आमतौर पर सहायक होता है, इस समय अतिरिक्त बाइट्स खर्च करता है।

— DLosc
स्रोत
1

पॉवरशेल , 109 108 104 बाइट्स

param($n,$h)-join" \|/"[0..(($d=$n-$h),0)[$d-lt0]]
1..$h|%{("( )","(-)")[$h-$_-lt$n]+"-"*($h+$_+2-lt$n)}

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

महंगी अनुक्रमण पर बहुत कुछ खो दिया है, लेकिन अभी भी सभ्य-ईश। मुझे यकीन नहीं है कि मेरा सूचकांक गणित हालांकि इष्टतम है। एक बाइट को बचाने के लिए अन्य उत्तरों से कुछ तर्क चुराया। -4 बाइट्स के लिए कुछ पार्न्स को पॉप करने की पूर्वता को भी याद किया।

— Veskah
स्रोत
0

05AB1E , 45 बाइट्स

-U…( )¸¹иε²N›ið'-:]RεX4-N@i'-«]" \|/"XdX*>£š»

निश्चित रूप से गोल्फ हो सकता है .. अपने वर्तमान स्वरूप में इसके बारे में बहुत खुश नहीं हैं।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

-                # Subtract the 2nd (implicit) input `n` from the 1st (implicit) input `h`
                 #  i.e. `h`=3, `n`=8 → 5
 U               # Pop and store it in variable `X`
…( )             # Push string "( )"
    ¸            # Wrap it into a list: ["( )"]
     ¹и          # Repeat it the first input (`h`) amount of times
                 #  i.e. 3 → ["( )","( )","( )"]
ε                # Map each to:
 ²N›i            #  If the second input `n` is larger than the map-index N:
                 #    i.e. `n`=8 >= N=0 → 1 (truthy)
     ð'-:       '#   Replace the space with a "-"
                 #    i.e. "( )" → "(-)"
]                # Close both the if and map
 R               # Reverse the list
ε                # Map each to:
 X4-N@i          #  If `X` minus 4 is larger than or equal to the map-index N:
                 #     i.e. `X`=5 and N=0 → 5-4 >= 0 → 1 (truthy)
                 #     i.e. `X`=5 and N=2 → 5-4 >= 2 → 0 (falsey)
       '-«      '#   Append a "-"
]                # Close both the if and map
 " \|/"          # Push String " \|/"
       Xd        # Check if `X` is 0 or positive (0 if negative, 1 if 0 or positive)
                 #  i.e. `X`=5 → 1 (truthy)
         X*      # Multiply it by `X`
                 #  i.e. 1 * 5 → 5
           >     # Increase it by 1
                 #  i.e. 5 → 6
            £    # Take that many character of the string " \|/"
                 #  i.e. 6 → " \|/"
             š   # Prepend it to the list
                 #  i.e. ["(-)-","(-)-","(-)"] and " \|/" → [" \|/","(-)-","(-)-","(-)"]
              »  # Join the list by newlines (and output implicitly)
                 #  i.e. [" \|/","(-)-","(-)-","(-)"] → " \|/\n(-)-\n(-)-\n(-)"
— केविन क्रूज़सेन
स्रोत
यदि यह आपको यहाँ बेहतर महसूस कराता है जो मेरे पास था: LR'(ì')«¹x‚3+¬UŸ¦ζJ¹XŸJ¦1úr)˜»और यह केवल आधा है।
— मैजिक ऑक्टोपस Urn
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.