ठीक है, मेरा पहला गोल्फ सवाल। कृपया सौम्य रहें :) मुझे पता है कि बहुत से एससीआई पहेलियाँ हैं: पी लेकिन यहाँ हम चलते हैं।

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

प्रत्येक त्रिकोण समान रूप से फैला हुआ है। मूल रूप से, आप तब तक त्रिकोण जोड़ते रहते हैं जब तक कि सबसे छोटे त्रिभुज के लिए पर्याप्त स्थान न हो।

आपको कहीं भी सफेद रिक्त स्थान की अनुमति दी जाती है जब तक आप चाहते हैं कि तरंग सही आकार के साथ उदाहरण के समान हो।

उदाहरण

q)g 1
__
\/
q)g 2
____
\  /
 \/
q)g 3
______
\    /
 \  /
  \/
q)g 4
________
\  __  /
 \ \/ /
  \  /
   \/
q)g 5
__________
\  ____  /
 \ \  / /
  \ \/ /
   \  /
    \/
q)g 6
____________
\  ______  /
 \ \    / /
  \ \  / /
   \ \/ /
    \  /
     \/
q)g 7
______________
\  ________  /
 \ \  __  / /
  \ \ \/ / /
   \ \  / /
    \ \/ /
     \  /
      \/
q)g 8
________________
\  __________  /
 \ \  ____  / /
  \ \ \  / / /
   \ \ \/ / /
    \ \  / /
     \ \/ /
      \  /
       \/

हमेशा की तरह, सबसे छोटा कोड जीतता है :)

code-golf ascii-art

— वूइकेंट ली
स्रोत

2

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

— Geobits

4

@Geobits अपने अलग पर्याप्त - इनपुट कल्पना काफी अलग है, पता लगाने की विधि कितने आकार अलग है, और त्रिकोण है! = Hexagons ;-)

— डिजिटल ट्रामा

अगर मैं सवाल को सही तरीके से समझ पाती हूं तो मुझे @ooiKent पर अब संदेह हो रहा है। एक लहर क्या है? यह त्रिकोणों का एक गाढ़ा सेट है, या कुछ और?

— डिजिटल ट्रामा

2

अच्छा सवाल है, लेकिन यह अधोमानक है। (1) पाठ को शाब्दिक रूप से पढ़ना, जब इनपुट 1,2 या 3 है, तो हमें हमेशा तीन त्रिकोणों का उत्पादन करना चाहिए । (२) मैं इसे एक दिया के रूप में लेता हूँ कि त्रिकोण के प्रत्येक सेट को गाढ़ा होना चाहिए, और (३) ऐसा प्रतीत होता है कि उन्हें एक ही पंक्ति में अपने निचले कोने भी होने चाहिए। (४) क्या क्षैतिज पृथक्करण को दिखाए गए अनुसार ठीक एक स्थान होना चाहिए, या अन्य विभाजनों की अनुमति है? (५) क्या अनावश्यक (व्हाट्सएप) व्हॉट्सएप को (ए, बी, सी, डी) बाएं, दाएं, ऊपर, नीचे की अनुमति है?

— स्तर नदी सेंट

मुझे लगता है कि यह स्पष्ट नहीं है, हालांकि स्पष्ट नहीं है। आप हमेशा दिए गए आकार के एक त्रिभुज को खींचते हैं, जिसका आकार n-3, n-6, n-9, आदि के नीडिंत त्रिकोण के साथ है

— Spear

5

पायथ, 31 बाइट्स

VhQ+J<t+++*Nd*N"\ "d*Q\_Q_XJ"\/

प्रदर्शन।

स्पष्टीकरण:

VhQ+J<t+++*Nd*N"\ "d*Q\_Q_XJ"\/
                                   Implicit: Q = eval(input()), d = ' '
VhQ                                for N in range(Q + 1):
                                   Concatenate:
          *Nd                      N spaces
         +   *N"\ "                N of the string "\ "
        +          d               another space
       +            *Q\_           Q of the string "_"
                                   If N = 2 and Q = 7, the string so far is:
                                   "  \ \  _______" and we want
                                   " \ \  _" as the left half.
      t                            Remove the first character.
     <                  Q          Take the first Q characters remaining.
                                   This is the left half of the triangle ripple.
    J                              Store it in J.
                          XJ"\/    Translate \ to / in J.
                         _         Reverse it.
   +                               Concatenate the left and right halves and print.

— isaacg
स्रोत

7

GNU sed -nr, 210

शुरुआत:

s/1/__/g
p
s#_(.*)_#\\\1/#
s#\\__#\\  #
s#__/#  /#
ta
:a
p
s#(.*) _{6}(_*) # \1\\  \2  /#;ta
s#(.*)  (  )# \1\2#;
s#(.*) _(_*)_ # \1\\\2/#
y/_/ /
Tc
:b
p
:c
s#(.*)((\\)  ( *)(/)|()()()\\/)# \1\3\4\5#;tb

इनपुट इस मेटा-प्रश्न के अनुसार, STDIN के माध्यम से एक सकारात्मक अनियारी पूर्णांक है ।

आउटपुट:

$ for i in 1 11 111 1111 11111 111111 1111111; do sed -rnf triripple.sed <<< $i; done
__
\/

____
\  /
 \/

______
\    /
 \  /
  \/

________
\  __  /
 \ \/ /
  \  /
   \/

__________
\  ____  /
 \ \  / /
  \ \/ /
   \  /
    \/

____________
\  ______  /
 \ \    / /
  \ \  / /
   \ \/ /
    \  /
     \/

______________
\  ________  /
 \ \  __  / /
  \ \ \/ / /
   \ \  / /
    \ \/ /
     \  /
      \/

$

— डिजिटल आघात
स्रोत

5

सी, 165 बाइट्स

n,x,y,b,c;main(c,v)char**v;{for(n=atoi(v[1]);y<=n;++y){for(x=-n;x<n;++x){b=2*n-abs(2*x+1);c=b-2*y+2;b-=6*y;putchar(b>0?95:b<-4&c>0&c%4==1?"/\\"[x<0]:32);}puts("");}}

पठनीयता को नष्ट करने वाले गोल्फिंग चरणों से पहले:

#include <stdio.h>
#include <stdlib.h>

int main(int c, char** v) {
    int n = atoi(v[1]);
    for (int y = 0; y <= n; ++y) {
        for (int x = -n; x < n; ++x) {
            int b = 2 * n - abs(2 * x + 1);
            int c = b - 2 * y + 2;
            b -= 6 * y;
            putchar(b > 0 ? 95 : 
                    b < -4 && c > 0 && c % 4 == 1 ? "/\\"[x<0] : 32);
        }
        puts("");
    }
}

यह आयत में सभी वर्णों पर लूप करता है, और रेखा समीकरणों का मूल्यांकन करता है जो त्रिकोण के अंदर को बाहर से अलग करते हैं, साथ ही साथ त्रिकोण के अलग-अलग हिस्सों को अलग करते हैं।

— रेटो कोराडी
स्रोत

गणित के साथ अच्छी नौकरी। आपको यह प्रयास करना चाहिए: codegolf.stackexchange.com/q/51396/21348

— edc65

156:

n,x,y,b,c;main(c,v)char**v;{for(n=atoi(v[1]);y<=n;++y)for(x=-n;x<=n;putchar(x++-n?b>6*y?95:b<6*y-4&c>0&c%4==1?"/\\"[x<1]:32:10))c=(b=2*n-abs(2*x+1))-2*y+2;}

— edc65

4

रेटिना , 182 बाइट्स

1
_
^
#$_
((`#([^#]*?)( ?)_(_*)_( ?)([^#]*?)$
$0# $1\$3/$5
+)`\\( ?)_(_*)_( ?)/(?=[^#]*$)
\ $1$2$3 /
#( *(\\ )*\\ *)  ( *(/ )*/)$
$0# $1$3
)`#( *(\\ )*)\\/(( /)*)$
$0# $1$3
# 
#
^#
<empty line>

इनपुट को एकरी के रूप में लेता है।

प्रत्येक पंक्ति को अपनी स्वयं की फ़ाइल पर #जाना चाहिए और फ़ाइलों में newline को बदलना चाहिए। यह अव्यवहारिक है लेकिन आप कोड को -sध्वज के साथ एक फ़ाइल के रूप में चला सकते हैं , #मार्करों को रखते हुए । #यदि आप चाहें तो उत्पादन में पठनीयता के नए बिंदुओं को बदल सकते हैं । उदाहरण के लिए:

> echo -n 1111|retina -s triangle|tr # '\n'
________
\  __  /
 \ \/ /
  \  /
   \/

कोड बहुत अच्छी तरह से गोल्फ (अभी तक) नहीं है।

— randomra
स्रोत

2

सी - 206 बाइट्स

i,j,m,k,a,b;main(i,v)char**v;{m=atoi(v[1])*2;while(k<m*(m/2+1)){i=k/m;j=k%m;a=i*3,b=(i+j)%2;putchar("_\\/ "[j>=a&&j<m-a?0:j>i-2&&b&&j<i*3-1&&j<m/2?1:j<=m-i&&!b&&j>m-a&&j>=m/2?2:3]);if(j==m-1)puts("");k++;};}

 x,m,i,j,a,b;
int main(x,v)char**v;{
    m=atoi(v[1])*2;
    for(i=0;i<m/2+1;i++){
        for(j=0;j<m;j++){
            a=i*3,b=(i+j)%2;
            j>=a&&j<m-a?a=0:j>=i-1&&b&&j<i*3-1&&j<m/2?a=1:j<=m-i&&!b&&j>m-a&&j>=m/2?a=2:(a=3);putchar("_\\/ \n"[a]);
        }
        puts("");
    }
}

उदाहरण आउटपुट

Pauls-iMac:ppcg pvons$ for i in $(seq 1 7); do ./a.out $i; done
__
\/
____
\  /
 \/ 
______
\    /
 \  / 
  \/  
________
\  __  /
 \ \/ / 
  \  /  
   \/   
__________
\  ____  /
 \ \  / / 
  \ \/ /  
   \  /   
    \/    
____________
\  ______  /
 \ \    / / 
  \ \  / /  
   \ \/ /   
    \  /    
     \/     
______________
\  ________  /
 \ \  __  / / 
  \ \ \/ / /  
   \ \  / /   
    \ \/ /    
     \  /     
      \/

— paulvs
स्रोत

1

आप इसे काफी कम ट्रिम कर सकते हैं। पुरानी शैली सी का लाभ उठाते हुए, आप वैरिएबल को बिना किसी प्रकार के घोषित कर सकते हैं int। इसके अलावा, यदि आप उन्हें वैश्विक दायरे में घोषित करते हैं, तो वे स्वचालित रूप से 0. के लिए प्रारंभ हो जाते हैं। putchar()विभिन्न शाखाओं में कॉल का एक गुच्छा होने के बजाय , आप एकल कॉल का उपयोग कर सकते हैं और ifबयानों को टर्नरी ऑपरेटरों के साथ बदल सकते हैं । बेशक उस तरह से पढ़ना मुश्किल हो जाता है, लेकिन अगर यह छोटा है तो बदसूरत कोड लिखने के लिए इस साइट की भावना में पूरी तरह से है। :)

— रेटो कोराडी

धन्यवाद @RetoKoradi, मैंने इसे आपके सुझावों को लागू करके 279 से घटाकर 214 कर दिया :) मुझे लगता है कि मुझे और सुधार लाने के लिए अपने एल्गोरिथ्म में सुधार करना होगा।

— पौलव्स

हां, एक बार जब आप यांत्रिकी से परे हो जाते हैं, तो कुंजी उन नियमों को ढूंढना है जो तर्क को यथासंभव सरल बनाते हैं। यदि आप मेरे समाधान को देखते हैं, जो मौलिक रूप से बहुत समान है, तो मैंने पाया कि तर्क त्रिभुज के केंद्र में क्षैतिज समन्वय की उत्पत्ति को रखकर थोड़ा सरल किया गया है। इस तरह, मैं समरूपता का लाभ उठा सकता था। और दूसरों को शायद बेहतर दृष्टिकोण भी मिला। यह वास्तव में दिलचस्प है कि एक समस्या पर कितना किया जा सकता है जो कि भ्रामक रूप से सरल दिखता है।

— रेटो कोराडी

1

जावास्क्रिप्ट ( ईएस 6 ) 165 180 204

परीक्षण करने के लिए फ़ायरफ़ॉक्स में स्निपेट चलाएँ। यदि स्ट्रिंग वापस करना पर्याप्त नहीं है, तो आउटपुट के लिए अलर्ट का उपयोग करना 2 चार्ट अधिक है।

// 165 - return the string
F=n=>
  (i=>{
    for(r='__'[R='repeat'](m=n);i<n;)
      r+=`\n`+' '[R](i)
       +('\\ '[R](t=-~(m>3?i:~-n/3))+' ').slice(0,n-i)
       +'__'[R](m>3?m-=3:0)
       +(' '+' /'[R](t)).slice(i++-n)
  })(0)||r


// 167 - output the string
A=n=>{
  for(i=0,r='__'[R='repeat'](m=n);i<n;)
    r+=`\n`+' '[R](i)
     +('\\ '[R](t=-~(m>3?i:~-n/3))+' ').slice(0,n-i)
     +'__'[R](m>3?m-=3:0)
     +(' '+' /'[R](t)).slice(i++-n);
  alert(r)
}

// TEST
out=x=>O.innerHTML += x+'\n' 

for(k=1;k<13;k++)out(k+'\n'+F(k))

<pre id=O></pre>

स्निपेट का विस्तार करें

— edc65
स्रोत

ASCII त्रिकोण तरंग