ASCII दिन की कला # 3 - चीनी झींगा

16

AAOD की आज की कड़ी में, हम अलग-अलग ऊंचाइयों के एक चीनी तीर्थ का निर्माण करने जा रहे हैं।

ऊंचाई के लिए निम्नलिखित उदाहरणों पर विचार करें ( N) 1से6

N = 1:

       .
       |
  .   ]#[   .
   \_______/
.    ]###[    .
 \__]#.-.#[__/
  |___| |___|
  |___|_|___|
  ####/_\####
     |___|
    /_____\

N = 2:

         .
         |
    .   ]#[   .
     \_______/
  .    ]###[    .
   \___________/
.     ]#####[     .
 \___]#.---.#[___/
  |__|_|   |_|__|
  |__|_|___|_|__|
  #####/___\#####
      |_____|
     /_______\

N = 3:

           .
           |
      .   ]#[   .
       \_______/
    .    ]###[    .
     \___________/
  .     ]#####[     .
   \_______________/
.      ]#######[      .
 \____]#.-----.#[____/
  |__|__|     |__|__|
  |__|__|_____|__|__|
  ######/_____\######
       |_______|
      /_________\

N = 4:

             .
             |
        .   ]#[   .
         \_______/
      .    ]###[    .
       \___________/
    .     ]#####[     .
     \_______________/
  .      ]#######[      .
   \___________________/
.       ]#########[       .
 \_____]##.-----.##[_____/
  |__|__|_|     |_|__|__|
  |__|__|_|_____|_|__|__|
  ########/_____\########
         |_______|
        /_________\

N = 5: 

               .
               |
          .   ]#[   .
           \_______/
        .    ]###[    .
         \___________/
      .     ]#####[     .
       \_______________/
    .      ]#######[      .
     \___________________/
  .       ]#########[       .
   \_______________________/ 
.        ]###########[        .
 \______]###.-----.###[______/
  |__|__|___|     |___|__|__|
  |__|__|___|_____|___|__|__|
  ##########/_____\##########
           |_______|
          /_________\

N = 6: 

                 .
                 |
            .   ]#[   .
             \_______/
          .    ]###[    .
           \___________/
        .     ]#####[     .
         \_______________/
      .      ]#######[      .
       \___________________/
    .       ]#########[       .
     \_______________________/ 
  .        ]###########[        .
   \___________________________/ 
.         ]#############[         .
 \_______]####.-----.####[_______/
  |__|__|__|__|     |__|__|__|__|
  |__|__|__|__|_____|__|__|__|__|
  ############/_____\############
             |_______|
            /_________\

और इसी तरह।

निर्माण विवरण

मुझे यकीन है कि पैटर्न के बारे में अधिकांश विवरण स्पष्ट हैं। यहाँ कुछ बारीक विवरण दिए गए हैं:

  • पूजास्थल के नीचे का दरवाजा न्यूनतम 1 _चौड़ाई का हो सकता है और अधिकतम 5 _चौड़ाई का हो सकता है ।
  • .दरवाजे के चारों ओर खंभे के ऊपर हमेशा दो सीधे होंगे (दो ऊर्ध्वाधर |)।
  • सीढ़ियां दरवाजे के समान चौड़ाई से शुरू होती हैं और पैटर्न में शो की तरह बढ़ती हैं
  • ]##..##[प्रत्येक छत के स्तर से ऊपर ब्लॉक के आकार में वृद्धि 2ऊपर से नीचे तक।
  • \__...__/छतों के स्तर के आकार में वृद्धि 4ऊपर से नीचे तक।
  • दरवाजे के चारों ओर की दीवारें कम से कम 1 _और अधिकतम, 3 _दोनों के बीच में होनी चाहिए |। प्राथमिकता बाहरी दीवार ब्लॉकों पर जाती है ताकि दरवाजे के सबसे करीब प्रत्येक स्तर के लिए अलग-अलग आकार मिल सके।
  • के बीच की जगह .और ](या [) द्वारा भरा जाता है #बस के दरवाजे के ऊपर छत में।

चुनौती का विवरण

  • एक समारोह या पूरा कार्यक्रम है कि तुलना में एक सकारात्मक पूर्णांक अधिक से अधिक पढ़ता लिखें 0के माध्यम से STDIN / ARGV / समारोह तर्क या निकटतम बराबर और आउटपुट (STDOUT करने के लिए या निकटतम समतुल्य) Nवें चीनी तीर्थ
  • अनुगामी न्यूलाइन वैकल्पिक है।
  • न्यूनतम बाउंडिंग आयत में आउटपुट पैड करने के लिए या तो कोई अनुगामी स्थान या पर्याप्त अनुगामी स्थान नहीं होना चाहिए।
  • कोई भी अग्रणी स्थान नहीं होना चाहिए जो पैटर्न का हिस्सा नहीं हैं।

लीडरबोर्ड

श्रृंखला की पहली पोस्ट एक लीडरबोर्ड उत्पन्न करती है।

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

# Language Name, N bytes

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

# Ruby, <s>104</s> <s>101</s> 96 bytes
code-golf  ascii-art 
— अनुकूलक
स्रोत
दरवाजा चौड़ाई मेरे लिए बल्कि मनमानी लगती है - यह N=1मामले में 1 क्यों है ? क्यों नहीं 3 और N=2मामले में छोटी साइड विंडो है ?
— मैटी
इसके अलावा, N=1मामले में, पहला छत बहुत लंबा (चौड़ा) नहीं है?
— मैटी
@ दरवाजे के संबंध में - यदि दरवाजा चौड़ाई 3 का था, तो इसके और उसके ऊपर समर्थन करने #के .लिए कोई बगल में नहीं होगा । शुरुआती छत के आकार के बारे में - यह प्रत्येक ऊंचाई की शीर्ष छत में छत का आकार है। ][
— ऑप्टिमाइज़र
मैं खिड़कियों के ठीक ऊपर सबसे नीचे की छत के बारे में पूछ रहा था। अन्य सभी मामलों में यह ऊपर छत का आकार +4 (दोनों तरफ +2) है। लेकिन यहाँ यह +8 है।
— मैटी
@ माटी ओह, आप सही कह रहे हैं। फिक्स्ड।
— ऑप्टिमाइज़र

जवाबों:

2

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

-4'.-4'|]2/ri:M),{2af.-~[W'.I3+~']'#I)*][-2'\'_I2*4+*]]}fI~[~M)<']
M2m1e>'#*'.'-M3e<:D*][-3"|__"M*M2+M2*(e>:L<"_|"D~][_~~'_*][-3'#L)*
'/'_D*][L2+~'|'_D)*][L)~'/'_D2+*]]{{_0<{~S*}&}%s_W%1>"\/]""/\["erN}%

स्क्रॉलिंग से बचने के लिए नए लिंक जोड़े गए। इसे ऑनलाइन आज़माएं

संक्षिप्त विवरण:

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

कार्यक्रम शीर्ष 2 लाइनों के साथ शुरू होता है, फिर प्रत्येक छत के स्तर के लिए, यह पिछली सभी लाइनों को 2 रिक्त स्थान के साथ प्रस्तुत करता है और नई छत (2 लाइनें) जोड़ता है। अंतिम छत को "ऊपर के दरवाजे" भाग को जोड़ने के लिए संशोधित किया गया है।

इसके बाद, ऊपरी दीवार "दोहराई" द्वारा बनाई गई है और सही लंबाई पर काट-छाँट करते हुए, उसके बाद एक निश्चित \ _ " और रिक्त स्थान। फिर दीवार को डुप्लिकेट किया जाता है और दरवाजे के स्थान को अंडरस्कोर से बदल दिया जाता है। अंत में, निचला भाग लाइन द्वारा लाइन का निर्माण किया जाता है।

— aditsu छोड़ दिया क्योंकि SE EVIL है
स्रोत
5

पर्ल, 332 316 294

$:=($w=<>)*2+6;$r=2x($m=$w>3?3:$w);$k=1x($w-3).b.4x$m;
y!a-f1-4!/.|\\[,#_ -!,/,/,s/(.*),(.*).{@{-}}/$2$1/,printf"%$:s%s
",y!/\\[!\\/]!r,(reverse=~s/.//r)for@x=(b,c,
(map{b33.3x$_.e.1x$_,"[#$k,"x/$w/.a__.22x$_}1..++$w),
_c.3x$m.f.($z=substr"|__"x$:,0,2*++$w),"_|$r,$z","d$r,".11x$w,c_.$r,d__.$r)

मुझे आजमाओ ।

सी, 371

d,i,w;char s[1<<24];m(){v(w,13);}p(){puts(s+1);}
v(i,j){s[w-i]=".|]\\#/"[j%7];s[w+i]=".|[/#\\"[j%7];
while(i--)s[w-i]=s[w+i]="# _-"[j/7];}
main(l){scanf("%d",&l);d=l>3?3:l;m(w=l*2+6);p(v(0,0));
for(v(0,1);i++<=l;v(i*2+2,17))p(),v(i*2+3,7),m(p(v(i,2)));v(l+2,2);p(v(d,21));
for(m(i=w-3);i>d+1;i-=3)v(i,15);p(v(d,8));p(v(d,15));
v(w-3,4);m(p(v(d,19)));p(v(d+1,15));p(v(d+2,19));}

मुझे आजमाओ ।

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

ऊपर जावास्क्रिप्ट में लगभग 1 से 1 अनुवाद किया जा सकता है:

s=[];r="";i=0;m=()=>v(w,13);p=()=>r+=s.join('')+"\n";
v=(i,j)=>{s[w-i]=".|]\\#/"[j%7];s[w+i]=".|[/#\\"[j%7];
while(i--)s[w-i]=s[w+i]="# _-"[j/7|0];};
f=l=>{d=l>3?3:l;m(w=l*2+6);p(v(0,0));
for(v(0,1);i++<=l;v(i*2+2,17))p(),v(i*2+3,7),m(p(v(i,2)));v(l+2,2);p(v(d,21));
for(m(i=w-3);i>d+1;i-=3)v(i,15);p(v(d,8));p(v(d,15));
v(w-3,4);m(p(v(d,19)));p(v(d+1,15));p(v(d+2,19));}

उपयोग:

f(2);console.log(r)
— nutki
स्रोत
C संस्करण 12 से ऊपर के आकार के लिए क्रैश हो जाता है। चूंकि यह दिखता है कि आप अस्थायी परिणाम धारण करने के लिए एक निश्चित आकार की स्ट्रिंग का उपयोग कर रहे हैं, मुझे लगता है कि आपके पास हमेशा एक ऊपरी सीमा होगी, कोई फर्क नहीं पड़ता कि आप किस प्रकार का आकार चुनते हैं s। जब तक आप इसे गतिशील रूप से आवंटित नहीं करते हैं, निश्चित रूप से।
— रेटो कोराडी
@RetoKoradi, हां आप सही हैं, मैंने गलती से एक छोटे बफर के साथ संस्करण पोस्ट किया। लेकिन अंत में, जब तक कि इसे गतिशील रूप से आवंटित नहीं किया जाता है, हमेशा एक सीमा होगी।
— नटकी
4

पायथन 2, 356 352 347 344 बाइट्स

n=input()
A,B,C,D,E,F,G,H,I='_ |\/#.]['
def p(*S):
 for s in S:print(5+2*n-len(s)/2)*B+s
p(G,C,'.   ]#[   .')
for i in range(n):b=B*(4+i);p(D+A*(7+4*i)+E,G+b+H+F*(3+2*i)+I+b+G)
d=2*min(3,n)-1
a=A*(2+i)
f=F*(1+i-d/2)
j=4+2*i-d/2
w=('|__'*n)[:j-1]+A+C
v=w[::-1]
p(D+a+H+f+G+'-'*d+G+f+I+a+E,w+B*d+v,w+A*d+v,F*j+E+A*d+D+F*j,C+A*(d+2)+C,E+A*(d+4)+D)

यह मूल रूप से लाइन द्वारा तीर्थ रेखा बनाता है। कार्यक्रमp इसे केंद्र में रखने के लिए आवश्यक रिक्त स्थान के साथ एक स्ट्रिंग प्रिंट करता है।

मैंने बहुत सारे बाइट्स को बचाने के लिए अजगर 2 का इस्तेमाल किया , क्योंकि अजगर 3 मैप ऑब्जेक्ट को ट्रिगर नहीं करता है। मुझे लगता है कि मुझे अजगर 2 में हमेशा गोल्फ खेलना चाहिए , बस कुछ और बाइट्स बचाता है (भले ही यह इंट को इनपुट पार्स करने के लिए नहीं है)। Hehehe, यह पहली जगह में गोल्फ के लिए कोड की तरह सुंदर नहीं है।

संपादित करें: और निश्चित रूप से, मुझे अब मानचित्र की आवश्यकता नहीं है ...

यहाँ कोड असंबद्ध रूप में है:

n = int(input())

# A function to print strings centered
half_width = 5 + 2*n
def p(string):
    spaces = ' ' * (half_width - len(string) // 2)
    print(spaces + string)

# The rooftops
p('.')
p('|')
p('.   ]#[   .')
for i in range(n):
    p('\\' + '_'*(7 + 4*i) + '/')
    p('.{0}]{1}[{0}.'.format(' '*(i + 4), '#'*(3 + 2*i)))

# The bottom rooftop
door_width = 2 * min(3, n) - 1
# (11+4i - (3+2i) - 4) / 2 = (4 + 2i) / 2 = 2 + i
p('\{0}]{1}.{2}.{1}[{0}/'.format('_'*(2 + i), '#'*(1 + i - door_width // 2), '-'*door_width))

# The windows
w = '|__'*n
w = w[:4 + 2*i  - door_width // 2]
if w[-1] == '|':
    w = w[:-1] + '_'
w += '|'
p(w + ' '*door_width + w[::-1])
p(w + '_'*door_width + w[::-1])

# The foundation and the stairs
w = '#'*(4 + 2*i - door_width // 2)
p(w + '/' + '_'*(door_width) + '\\' + w)

# The remaining stairs
p('|' + '_'*(door_width + 2) + '|')
p('/' + '_'*(door_width + 4) + '\\')
— मैटी
स्रोत
1
आप अजगर 2 के बाद से उपयोग कर रहे हैं आप बदल सकते हैं print(B*(5+2*n-len(s)//2)+s)में print B*(5+2*n-len(s)/2)+s(निकालें कोष्ठकों और परिवर्तन //में /)।
— user12205
1
धन्यवाद @ace, python2 ने फ्लोट डिवीजन को अनदेखा नहीं किया।
— मैटी
1
@ मैटी यह फ्लोट डिवीजन को नजरअंदाज नहीं करता है। आप पूर्णांकों पर विभाजन कर रहे हैं , इसलिए परिणाम पूर्णांक है। यह केवल फ्लोट डिवीजन करता है यदि एक या अधिक ऑपरेंड फ्लोट है।
— mbomb007
2
आप के क्रम को पुनर्व्यवस्थित तो print B*(5+2*n-len(s)/2)+sकरने के लिए print(5+2*n-len(s)/2)*B+s, आप के बाद अंतरिक्ष को हटा सकते हैं print।
— इसहाक
4

जावास्क्रिप्ट ( ईएस 6 ), 440

फिक्स्ड लिंटेल बग संपादित करें

एक फ़ंक्शन व्हाइट ऊंचाई एक पैरामीटर, कंसोल के लिए आउटपुट के रूप में।

टेम्पलेट स्ट्रिंग का उपयोग करते हुए एक बहुत , सभी नई-पंक्तियों महत्वपूर्ण और गिना रहे हैं।

फ़ायरफ़ॉक्स में परीक्षण करने के लिए स्निपेट चलाएँ (कंसोल आउटपुट के साथ) 

f=x=>{R=(n,s=0)=>' #_-'[s][Z='repeat'](n),M=c=>R(2)+'|__'[Z](z+1).slice(0,z-1)+'_|'+R(y,c)+'|_'+'__|'[Z](z+1).slice(1-z)
for(z=x+x+(x<2)+(x<3),y=x>2?5:x>1?3:1,l=-1,o=`${t=R(x+x+5)}.
${t}|
`;l++<x;)o+=`${t=R(x+x-l-l)}.${u=R(l+3)}]${R(l*2+1,1)}[${u}.
 ${t}\\${l-x?R(7+l*4,2):`${t=R(x+1,2)}]${u=R(x<3||x-2,1)}.${R(y,3)}.${u}[${t}`}/
`;console.log(`${o+M(0)}
${M(2)}
${R(2)}${t=R(z,1)}/${u=R(y,2)}\\${t}
${R(1+z)}|__${u}|
${R(z)}/____${u}\\`)}

// TEST
f(1),f(2),f(3),f(4),f(5),f(6)
Output 1 to 6 in console
स्निपेट का विस्तार करें

इंटरैक्टिव परीक्षण के लिए अनगुल्ड संस्करण:

// Not so golfed

f=x=>{
  R=(n,s=0)=>' #_-'[s].repeat(n); // base building blocks
  M=c=>R(2)+'|__'.repeat(z+1).slice(0,z-1)+'_|'+R(y,c)+'|_'+'__|'.repeat(z+1).slice(1-z); // manage door level

  z=x+x+(x<2)+(x<3); // door and stairs surroundings
  y=x>2?5:x>1?3:1; // door and stairs width
  
  o = `${R(x+x+5)}.\n${R(x+x+5)}|\n`; // top 
  for(l=-1;l++<x;)
    o += `${ // even row
      t=R(x+x-l-l) // left padding
    }.${
      u=R(l+3)
    }]${
      R(l*2+1,1)
    }[${
      u
    }.\n ${ // end even row, start odd row
      t // left padding
    }\\${
      l-x?R(7+l*4,2)
      :`${t=R(x+1,2)}]${u=R(x<3||x-2,1)}.${R(y,3)}.${u}[${t}` // if last row before the door, insert lintel 
    }/\n`;
  
  o += `${
    M(0) // door level row 1
  }\n${
    M(2) // door level row 2
  }\n${
    R(2)}${t=R(z,1)}/${u=R(y,2)}\\${t  // stairs row 1
  }\n${ 
    R(1+z)}|__${u  // stairs row 2
  }|\n${ 
    R(z)}/____${u // stairs row 3
  }\\`;
  
  out(o)
}

out=x=>O.innerHTML=x

f(3)
<input id=I value=3><button onclick='f(+I.value)'>-></button><br>
<pre id=O></pre>
स्निपेट का विस्तार करें

— edc65
स्रोत
2

हास्केल, 473 बाइट्स

g '\\'='/'
g '/'='\\'
g '['=']'
g ']'='['
g x=x
z=reverse
d=min 3
m n s=putStrLn$(6+2*n+1-length s)#' '++map g(z s)++tail s
n#c=replicate n c
t 0=".";t n=n#'#'++"["++(2+n)#' '++"."
r 0="|";r n=(2+2*n)#'_'++"/"
q n=d n#'-'++"."++max(n-2)1#'#'++"["++(n+1)#'_'++"/"
e i n=d n#i++"|_"++z(take(max(n+2)(2*n-1))(cycle"|__"))
b n=d n#'_'++"\\"++max(2*n)(3+n)#'#'
w i n=(d n+1+i)#'_'++["|","\\"]!!i
f n=mapM_(m n)$[u k|k<-[0..n],u<-[t,r]]++(t(n+1):map($n)[q,e ' ',e '_',b,w 0,w 1])
— डेमियन
स्रोत
ठीक है धन्यवाद। अब ठीक लग रहा है
— डेमियन
मुझे लगता है कि यह अब ठीक है। btw, आपके N = 1 तीर्थस्थल में आधार एक और # है
— डेमियन
हाँ, अब काम करता है। तय है कि अतिरिक्त अनपेक्षित#
— ऑप्टिमाइज़र
0

सी, 660 बाइट्स

पैटर्न सिर्फ कुछ भी फैंसी के साथ आने के लिए बहुत अनियमित लग रहा था, खासकर स्ट्रिंग प्रसंस्करण के बिना एक भाषा में। तो यहाँ मेरा जानवर बल दृष्टिकोण है:

m,d,w,k,j;r(n,c){for(j=0;j++<n;)putchar(c);}c(char*s){for(;*s;)putchar(*s++);}f(n){m=n*2;d=n<3?m-1:5;w=m-d/2+2;r(m+5,32);c(".\n");r(m+5,32);c("|\n");for(;;){r(m-k*2,32);c(".");r(k+3,32);c("]");r(k*2+1,35);c("[");r(k+3,32);c(".\n");if(k==n)break;r(m-k*2+1,32);c("\\");r(k++*4+7,95);c("/\n");}c(" \\");r(n+1,95);c("]");r(n-d/2,35);c(".");r(d,45);c(".");r(n-d/2,35);c("[");r(n+1,95);c("/\n");for(k=0;k<2;){c("  ");for(j=0;j<w/3;++j)c("|__");c("|_|"-w%3+2);r(d,k++?95:32);c(!w%3?"|":w%3<2?"|_":"|_|");for(j=0;j<w/3;++j)c("__|");c("\n");}c("  ");r(w,35);c("/");r(d,95);c("\\");r(w,35);c("\n");r(w+1,32);c("|");r(d+2,95);c("|\n");r(w,32);c("/");r(d+4,95);c("\\\n");}

गोल्फ से पहले:

#include <stdio.h>

void r(int n, int c) {
    for (int i = 0; i++ < n; )
        putchar(c);
}

void c(char* s) {
    for (; *s; ++s) putchar(*s);
}

int f(int n) {
    int m = n * 2;
    int d = n < 3 ? m - 1 : 5;
    int w = m - d / 2 + 2;

    r(m + 5, 32);
    c(".\n");

    r(m + 5, 32);
    c("|\n");

    for (int k = 0; ; ++k) {
        r(m - k * 2, 32);
        c(".");
        r(k + 3, 32);
        c("]");
        r(k * 2 + 1, 35);
        c("[");
        r(k + 3, 32);
        c(".\n");

        if (k == n) break;

        r(m - k * 2 + 1, 32);
        c("\\");
        r(k * 4 + 7, 95);
        c("/\n");
    }

    c(" \\");
    r(n + 1, 95);
    c("]");
    r(n - d / 2 , 35);
    c(".");
    r(d, 45);
    c(".");
    r(n - d / 2 , 35);
    c("[");
    r(n + 1, 95);
    c("/\n");

    for (int k = 0; k < 2; ++k) {
        c("  ");
        for (int j = 0; j < w / 3; ++j)
            c("|__");
        c("|_|" - w % 3 + 2);
        r(d, k ? 95 : 32);
        c(!w % 3 ? "|" : w % 3 < 2 ? "|_" : "|_|");
        for (int j = 0; j < w / 3; ++j)
            c("__|");
        c("\n");
    }

    c("  ");
    r(w, 35);
    c("/");
    r(d, 95);
    c("\\");
    r(w, 35);
    c("\n");

    r(w + 1, 32);
    c("|");
    r(d + 2, 95);
    c("|\n");

    r(w, 32);
    c("/");
    r(d + 4, 95);
    c("\\\n");

    return 0;
}

यहाँ समझाने के लिए ज्यादा नहीं। यह बस लाइन से लाइन में जाता है, और प्रत्येक वर्ण की आवश्यक गणना उत्पन्न करता है। मैंने कोड को खुद को कॉम्पैक्ट रखने की कोशिश की, लेकिन यह अभी भी जोड़ता है। dदरवाजे wकी चौड़ाई, प्रत्येक ईंट की दीवार की चौड़ाई है।

— रेटो कोराडी
स्रोत
1
c(char*s){for(;*s;)putchar(*s++);}==> #define c printf; r(n,c){for(j=0;j++<n;)putchar(c);}==>r(n,C){while(n--)putchar(C);}
— उपयोगकर्ता 12205
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.