शब्द -> सिटी स्काईलाइन

40

चुनौती

आपका प्रोग्राम या फ़ंक्शन STDIN या फ़ंक्शन पैरामीटर से एकल स्ट्रिंग इनपुट स्वीकार करेगा। आप मान सकते हैं कि इनपुट में केवल वर्णमाला अक्षर (ए-जेडए-जेड), रिक्त स्थान और पूर्ण स्टॉप होंगे। इनपुट केस असंवेदनशील है, इसलिए आपको 'ए' के ​​साथ वैसा ही व्यवहार करना चाहिए जैसा आप 'ए' के ​​साथ करते हैं।

स्ट्रिंग में प्रत्येक वर्ण के लिए, आप निम्नलिखित विनिर्देश के अनुसार एक इमारत के एक प्रतिनिधित्व का उत्पादन करेंगे।

प्रत्येक इमारत में एक छत होनी चाहिए, जो शीर्ष रेखा पर एक अंडरस्कोर द्वारा निर्दिष्ट की जाती है, फिर दूसरी लाइन पर एक स्लैश, स्थान, बैकस्लैश।

 _
/ \

तब आपके पास कई मंजिलें होंगी, जो अक्षर संख्या (a = 1, b = 2, c = 3 आदि) से मेल खाती हैं, जो कि प्रत्येक तरफ एक दीवार (!) द्वारा दर्शाई जाती हैं और बीच में एक स्थान होता है। नीचे की मंजिल (और केवल नीचे की मंजिल) में एक नींव होना चाहिए, जो दीवारों के बीच एक अंडरस्कोर है। ऐशे ही...

|_|

इसलिए उदाहरण के लिए, 'बी' इस तरह दिखेगा

 _
/ \
| |
|_|

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

इमारतों को ओवरलैप नहीं होना चाहिए, लेकिन उनके बीच कोई अनावश्यक स्थान नहीं होना चाहिए, और जमीन हमेशा सपाट होती है, इसलिए सभी भवनों का आधार एक ही स्तर पर होना चाहिए।

उदाहरण के लिए, 'एब्डेफेगा' ऐसा दिखेगा।

                           _
                          / \
                     _    | |
                _   / \   | |
           _   / \  | |   | |
          / \  | |  | |  /   \
       _  | |  | |  | |  |   |
    _ / \ | |  | | /   \ |   |
 _ / \| | | | /   \|   | |   |  _
/ \| || |/   \|   ||   |/     \/ \
|_||_||_||___||___||___||_____||_|

स्ट्रिंग इनपुट में रिक्त स्थान को दोहरे स्थान द्वारा दर्शाया जाना चाहिए।

स्ट्रिंग इनपुट में पूर्ण विराम को इस तरह मलबे द्वारा दर्शाया जाना चाहिए।

/\/\

आगे के उदाहरण

इनपुट = Hello world.

आउटपुट =

                                                   _                                                  
                                                  / \                                                 
                                                  | |                                                 
                                                  | |                                                 
                                                  | |                                                 
                                                 /   \                                                
                                                 |   |                                                
                                                 |   |                       _                        
                                                 |   |                      / \                       
                                                /     \                     | |                       
                                                |     |                     | |                       
                                   _            |     |          _          | |                       
                                  / \           |     |         / \        /   \                      
                                  | |          /       \        | |        |   |                      
                                  | |          |       |        | |        |   |                      
                _        _        | |          |       |        | |        |   |        _             
               / \      / \      /   \         |       |       /   \      /     \      / \            
               | |      | |      |   |        /         \      |   |      |     |      | |            
               | |      | |      |   |        |         |      |   |      |     |      | |            
               | |      | |      |   |        |         |      |   |      |     |      | |            
   _          /   \    /   \    /     \       |         |     /     \    /       \    /   \           
  / \         |   |    |   |    |     |      /           \    |     |    |       |    |   |           
  | |         |   |    |   |    |     |      |           |    |     |    |       |    |   |           
  | |         |   |    |   |    |     |      |           |    |     |    |       |    |   |           
  | |    _   /     \  /     \  /       \     |           |   /       \  /         \  /     \          
 /   \  / \  |     |  |     |  |       |    /             \  |       |  |         |  |     |   _      
 |   |  | |  |     |  |     |  |       |    |             |  |       |  |         |  |     |  / \     
 |   |  | |  |     |  |     |  |       |    |             |  |       |  |         |  |     |  | |     
 |   |  | | /       \/       \/         \   |             | /         \/           \/       \ | |     
/     \/   \|       ||       ||         |  /               \|         ||           ||       | | |     
|     ||   ||       ||       ||         |  |               ||         ||           ||       |/   \    
|_____||___||_______||_______||_________|  |_______________||_________||___________||_______||___|/\/\

इनपुट = lorem ipsum

                                                                                             _                  
                                                                                            / \                 
                                                                              _             | |                 
                                                                             / \            | |                 
                          _                                                  | |            | |                 
                         / \                                                 | |           /   \                
                         | |                                    _            | |           |   |                
                         | |                                   / \          /   \          |   |                
              _          | |                                   | |          |   |          |   |                
             / \        /   \                                  | |          |   |         /     \               
             | |        |   |              _                   | |          |   |         |     |         _     
             | |        |   |             / \                 /   \        /     \        |     |        / \    
    _        | |        |   |             | |                 |   |        |     |        |     |        | |    
   / \      /   \      /     \            | |                 |   |        |     |       /       \       | |    
   | |      |   |      |     |            | |                 |   |        |     |       |       |       | |    
   | |      |   |      |     |           /   \               /     \      /       \      |       |      /   \   
   | |      |   |      |     |           |   |        _      |     |      |       |      |       |      |   |   
  /   \    /     \    /       \          |   |       / \     |     |      |       |     /         \     |   |   
  |   |    |     |    |       |          |   |       | |     |     |      |       |     |         |     |   |   
  |   |    |     |    |       |         /     \      | |    /       \    /         \    |         |    /     \  
  |   |    |     |    |       |         |     |      | |    |       |    |         |    |         |    |     |  
 /     \  /       \  /         \   _    |     |     /   \   |       |    |         |   /           \   |     |  
 |     |  |       |  |         |  / \   |     |     |   |   |       |    |         |   |           |   |     |  
 |     |  |       |  |         |  | |  /       \    |   |  /         \  /           \  |           |  /       \ 
 |     |  |       |  |         |  | |  |       |    |   |  |         |  |           |  |           |  |       | 
/       \/         \/           \ | |  |       |   /     \ |         |  |           | /             \ |       | 
|       ||         ||           |/   \ |       |   |     | |         |  |           | |             | |       | 
|       ||         ||           ||   |/         \  |     |/           \/             \|             |/         \
|_______||_________||___________||___||_________|  |_____||___________||_____________||_____________||_________|

इनपुट = a.a.a.x.x.x.a.a.a

                             _                    _                    _                             
                            / \                  / \                  / \                            
                            | |                  | |                  | |                            
                            | |                  | |                  | |                            
                            | |                  | |                  | |                            
                           /   \                /   \                /   \                           
                           |   |                |   |                |   |                           
                           |   |                |   |                |   |                           
                           |   |                |   |                |   |                           
                          /     \              /     \              /     \                          
                          |     |              |     |              |     |                          
                          |     |              |     |              |     |                          
                          |     |              |     |              |     |                          
                         /       \            /       \            /       \                         
                         |       |            |       |            |       |                         
                         |       |            |       |            |       |                         
                         |       |            |       |            |       |                         
                        /         \          /         \          /         \                        
                        |         |          |         |          |         |                        
                        |         |          |         |          |         |                        
                        |         |          |         |          |         |                        
                       /           \        /           \        /           \                       
                       |           |        |           |        |           |                       
                       |           |        |           |        |           |                       
                       |           |        |           |        |           |                       
                      /             \      /             \      /             \                      
                      |             |      |             |      |             |                      
                      |             |      |             |      |             |                      
                      |             |      |             |      |             |                      
                     /               \    /               \    /               \                     
 _      _      _     |               |    |               |    |               |     _      _      _ 
/ \    / \    / \    |               |    |               |    |               |    / \    / \    / \
|_|/\/\|_|/\/\|_|/\/\|_______________|/\/\|_______________|/\/\|_______________|/\/\|_|/\/\|_|/\/\|_|

नियम

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

ध्यान दें

पीपीसीजी के लिए यह मेरी पहली पोस्ट है, इसलिए कृपया मुझ पर आसान काम करें। यह सैंडबॉक्स के माध्यम से किया गया है। किसी भी नकारात्मक बिंदु या संभावित सुधार कृपया टिप्पणी के रूप में पोस्ट करें और मैं वही करूंगा जो मैं कर सकता हूं

code-golf  ascii-art 
— डैरेन एच
स्रोत
7
परिवर्तित [a,z]और [A,Z]करने के लिए [1,26]एक व्यर्थ आवश्यकता की तरह लगता है। इनपुट के रूप में केवल सूची पूर्णांक का उपयोग करना बेहतर होगा ( 0मलबे के लिए इनपुट होना)। इसके अलावा, सैंडबॉक्स में केवल 21 घंटों तक रहने के बाद अपनी चुनौती पोस्ट करना, एक से अधिक उपयोगकर्ताओं से कोई वोट या प्रतिक्रिया प्राप्त करने के लिए इंतजार किए बिना, यह गिनती नहीं करता है कि यह "सैंडबॉक्स के माध्यम से" हो रहा है। लोगों को उनकी समीक्षा करने के लिए भरपूर समय देने के लिए, सैंडबॉक्स में 48-72 घंटों के लिए चुनौतियों को छोड़ने की सिफारिश की जाती है।
— मेगो
2
मुझे की याद दिलाता है यह । नाइस पहली चुनौती है, लेकिन मैं सुझाव है कि आप को बदलने पर विचार [a,z], [1.26]भागों Mego उल्लेख किया है। यह वैकल्पिक होना अक्सर सबसे अच्छा होता है (जब तक कि यह चुनौती का एक महत्वपूर्ण हिस्सा नहीं है (यह यहाँ नहीं है)।
— स्टीवी ग्रिफिन
2
मैं कहूंगा, यह एक बहुत अच्छी पहली चुनौती है। साइट पर आपका स्वागत है!
— डीजेमैकेम
1
मैं पूर्णांक के लिए एज मैपिंग के बारे में बात समझ सकता हूं। यह चुनौती के पहले पुनरावृत्ति में समझ में आता है लेकिन स्पष्टता और संक्षिप्तता के लिए संपादन के बाद से (एक बैकस्टोरी थी जिसे मैंने हटा दिया है) पत्र अब प्रासंगिक नहीं हैं। मैं जल्द से जल्द उचित रूप से संपादित करूंगा
— डेरेन एच।
1
मैं व्यक्तिगत रूप से az, space, period को पसंद करता हूं।
— isaacg

जवाबों:

10

जावास्क्रिप्ट (ईएस 6), 330 326 ... 315 309 बाइट्स

ASCII कला को पुनरावर्ती रूप से बनाता है, नीचे के तल से शुरू होता है और प्रत्येक चरण के बीच कई नियमित भावों को लागू करता है:

(a,l,R=(E,b)=>E.split`:`.map((e,i)=>l=(l||a).replace(RegExp(e,'g'),b?b.split`:`[i]:n=>(x=(n.charCodeAt()-65)%32)<0?x+1?'/y/y':n+n:x%3+'_'.repeat((x/3<<1)+1)+0)))=>(L=l)?(R('/y:_:/xy:1:2:/xx(x+)y:0(x+)0:3','  :x: _ :3:1: 2$10 :/$1y:0'),L==l?(l=a.join`
`,R('\\d:x:y','|: :\\'),l):f([l].concat(a),l)):f(R('.'),l)

यह काम किस प्रकार करता है

1) नीचे की मंजिल

हम इनपुट स्ट्रिंग को नीचे की मंजिल में अनुवाद करके शुरू करते हैं जैसे:

"ab cd.df.hcab"  -->  "0_01_0  2_00___0/y/y0___02___0/y/y1_____02_00_01_0"

कहा पे:

  • y बैकस्लैश के लिए एक छोटा उपनाम है (जिसमें भागने की आवश्यकता होती है)
  • अंकों ( 0, 1या 2) बस का एक क्रम से पहले _इमारत के बाईं दीवार है। यह उन दीवारों की संख्या को दर्शाता है जिन्हें अगली 'चौड़ीकरण परत' से पहले उसके ऊपर रखा जाना चाहिए।
  • अनुक्रम के बाद का अंक _भवन की दाहिनी दीवार है और हमेशा सेट किया जाता है 0।

2) प्रत्येक चरण के बीच नियमित अभिव्यक्ति लागू होती है

पुनरावर्ती प्रक्रिया में निम्न नियमित अभिव्यक्तियों का उपयोग करके पिछली मंजिल पर 9 प्रतिस्थापन लागू करने होते हैं:

  1. /\/y/g=> " "(मलबे को हटा दें)
  2. /_/g=> "x"(एक ठोस ब्लॉक के साथ नींव या इमारत के शीर्ष को बदलें)
  3. /\/xy/g=> " _ "(इमारत के शीर्ष के साथ अंतिम चौड़ी परत को बदलें)
  4. /1/g=> "3"(अस्थायी रूप से बदलने के 1साथ 3- अंतिम चरण देखें)
  5. /2/g=> "1"( 2साथ बदलें 1)
  6. /\/xx(x+)y/g=> " 2$10 "(एक नई, संकरी दीवार के साथ एक चौड़ीकरण परत को बदलें)
  7. /0(x+)0/g=> "/$1y"(दीवार के शीर्ष को एक चौड़ी परत के साथ बदलें)
  8. /3/g=> "0"( 3साथ बदलें 0)

उदाहरण के लिए, यहां 2___0(नीचे तल से उत्पन्न 'f') के क्रमिक परिवर्तन हैं :

"2___0" > "1xxx0" > "0xxx0" > "/xxxy" > " 2x0 " > " 1x0 " > " 0x0 " > " /xy " > "  _  "

                                                                                   _   
                                                                        /xy       /xy  
                                                              0x0       0x0       0x0  
                                                    1x0       1x0       1x0       1x0  
                                          2x0       2x0       2x0       2x0       2x0  
                               /xxxy     /xxxy     /xxxy     /xxxy     /xxxy     /xxxy 
                     0xxx0     0xxx0     0xxx0     0xxx0     0xxx0     0xxx0     0xxx0 
           1xxx0     1xxx0     1xxx0     1xxx0     1xxx0     1xxx0     1xxx0     1xxx0 
 2___0     2___0     2___0     2___0     2___0     2___0     2___0     2___0     2___0

नायब : इमारत के शीर्ष को तब बदल दिया जाता है x। यह उपरोक्त आरेख में नहीं दिखाया गया है।

3) नियमित परिणाम अंतिम परिणाम पर लागू होते हैं

जब कुछ बदलने के लिए अधिक कुछ नहीं होता है, तो पुनरावृत्ति रुक ​​जाती है, जिसका अर्थ है कि हम सर्वोच्च इमारत के शीर्ष से परे हैं।

अब हमें एक और नियमित अभिव्यक्ति के साथ सब कुछ साफ करने की आवश्यकता है:

  1. /\d/g=> "|"(अंकों को पाइप से बदलें)
  2. /x/g=> " "(रिक्त स्थान के साथ ठोस ब्लॉक बदलें)
  3. /y/g=> "\"( yबैकस्लैश के साथ बदलें )

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

  _            _  
 /xy          / \ 
 0x0          | | 
 1x0          | | 
 2x0   -->    | | 
/xxxy        /   \
0xxx0        |   |
1xxx0        |   |
2___0        |___|

डेमो

let f =

(a,l,R=(E,b)=>E.split`:`.map((e,i)=>l=(l||a).replace(RegExp(e,'g'),b?b.split`:`[i]:n=>(x=(n.charCodeAt()-65)%32)<0?x+1?'/y/y':n+n:x%3+'_'.repeat((x/3<<1)+1)+0)))=>(L=l)?(R('/y:_:/xy:1:2:/xx(x+)y:0(x+)0:3','  :x: _ :3:1: 2$10 :/$1y:0'),L==l?(l=a.join`
`,R('\\d:x:y','|: :\\'),l):f([l].concat(a),l)):f(R('.'),l)

console.log(f('ab cd.df.hcab'));
स्निपेट का विस्तार करें

योगदानकर्ताओं:
4 बाइट्स ने हेडी को धन्यवाद दिया
8 बाइट्स ने धन्यवाद को बचाया नहीं चार्ल्स

— Arnauld
स्रोत
कोई भी एक पूर्णांक के रूप में एक इनपुट लेना चाहता है, लेकिन आपका स्वागत है कि मैं इस तरह की प्रविष्टि को गैर-प्रतिस्पर्धी होना चाहिए
— mbomb007
@ mbomb007 - यह तय है। मेरी वर्तमान अनुकूलन कुख्यात की लागत की भरपाई नहीं करते हैं .charCodeAt(), हालांकि।
— अरनुलद
आपको जरूरत नहीं new हैnew RegExp(e,'g')
— Hedi
मुझे यह दृष्टिकोण बहुत पसंद है। कुछ विचार जो मदद कर सकते हैं: 1. एक चार का उपयोग करें जैसे yकि आपके आगे के स्लैश के लिए भागने की आवश्यकता नहीं है। 2. यदि आप _भूतल के लिए उपयोग करते हैं, तो आप अभी भी regex के साथ शीर्ष को अलग कर सकते हैं /_ /:।
— नहीं कि चार्ल्स
1
@ नॉचचार्ल्स - मैंने वास्तव में "डबल स्पेस" नियम पर कभी गौर नहीं किया। ;) यह तय है।
— अरनौलद
7

PHP, 386 376 367 364 362 358 356 बाइट्स

पहले दृष्टिकोण; अभी भी गोल्फ हो सकता है।

foreach(str_split($argv[1])as$c)for($n=28,$w='.'!=$c?1+2*ceil(1/3*$n=31&ord($c)):4,$p=$y=0;$y<36;){$s=str_pad("",$w,$y||!$n?" ":_);if($n>26&&!$y){$s="/\\/\\";$n=-1;}elseif($n-->0){$s[$p]=$s[$w-$p-1]="|";if($n%3<1){$o[$y++].=$s;$s=str_pad("",$w);$s[$p]="/";$s[$w-++$p]="\\";}}$o[$y++].=$s;if(!$n)$o[$y++].=str_pad(_,$w," ",2);}for($y=36;$y--;)echo"$o[$y]
";

PHP, 366 362 361 360 357 बाइट्स

एक उपखंड के साथ समान दृष्टिकोण:

function a($p,$r){global$o,$w,$y;$o[$y++].=str_pad(str_pad($r[0],2*$p,$r[1]).$r[2],$w," ",2);}foreach(str_split($argv[1])as$i=>$c)for($n=28,$w='.'!=$c?1+2*$p=ceil(1/3*$n=31&ord($c)):$p=4,$y=0;$y<36;)if($n>26&&!$y)$o[$n=$y++].="/\\/\\";elseif($n-->0){a($p,$y?"| |":"|_|");if($n%3<1)a($p--,"/ \\");if(!$n)a(1," _");}else a(0,"");for($y=36;$y--;)echo"$o[$y]
";

दूसरे दृष्टिकोण के लिए ब्रेकडाउन

function a($p,$r)
{
    global$o,$w,$y;
    $o[$y++].=                  // 3. add result to current line, increase line counter
        str_pad(                // 2. pad ...
        str_pad($r[0],2*$p,$r[1]).$r[2]     // 1. A + inner width(=2*$p-1) times B + C
        ,$w," ",2);             // ... to $w with blanks on both sides # 2==STR_PAD_BOTH
}

foreach(str_split($argv[1])as$i=>$c)
    for(
    $n=28,
    $w='.'!=$c                          // $w=total width
        ?1+2*$p=ceil(1/3*$n=31&ord($c)) // $n=storey count, $p=(inner width+1)/2
        :$p=4                           // $n=28, $p <= $w=4 for rubble
    ,
    $y=0;$y<36;)                        // $y=line counter
        if($n>26&&!$y)
            $o[$n=$y++].="/\\/\\";      // bottom line=rubble, $n=0
        elseif($n-->0)
        {
            a($p,$y?"| |":"|_|");       // add storey
            if($n%3<1)a($p--,"/ \\");   // add widening layer/roof
            if(!$n)a(1," _");           // add roof top
        }
        else
            a(0,"");                    // idk why str_pad doesn´t yield a warning here

for($y=36;$y--;)if($s=rtrim($o[$y]))echo"$s\n"; // output

+16 बाइट्स अगर प्रमुख नईलाइनों की अनुमति नहीं है: के साथ
बदलें ।echo"$o[$y]\n;if($s=rtrim($o[$y]))echo"$s\n";

-3 से किसी के लिए बाइट्स ;<=>?[\]^_{|}~की जगह 1): मलबे के रूप में ($n=31&ord($c))के साथ $n, 2) $n=28,$w='.'!=$cके साथ ($n=31&ord($c))<27और 3) 4के साथ ($n=28)/7।

एक और -8 >, ^या ~मलबे के रूप में: पूर्ववत करें 3)

— टाइटस
स्रोत
1
if(!$n){$o[$y++].=str_pad(_,$w," ",2);}कोष्ठक के लिए -2 बाइट्स
— जॉर्ग ह्यूल्सरमन
और आउटपुट 3 बाइट्स छोटे किए जा सकते हैं for($y=36;$y--;)echo"$o[$y]\n";:; लेकिन मेरे पास एक नया तरीका है जो अन्य 2 बाइट्स को बचाता है।
— टाइटस
1
दूसरे दृष्टिकोण के लिए php.net/manual/en/functions.anonymous.php ` वैश्विक के बजाय` a ($ p, $ r) उपयोग ($ o, $ w, $ y) का उपयोग करें
— Jörg Hülsermann
@ JörgHülsermann: useकेवल अनाम कार्यों के लिए काम करता है। यह 2 बाइट्स बचाएगा; लेकिन मुझे उस फ़ंक्शन को एक $a=नाम (+3 बाइट्स) देने के बजाय एक चर में संग्रहीत करना होगा और $प्रत्येक चार कॉल में एक जोड़ना होगा ।
— टाइटस
4

पायथ, 93 79 बाइट्स

K"/\\"j_.tsm?hJxGdC_m.[hyNk\ +\_mj*hy/k4?nkJ\ \_?%k4"||"Kh=+J=Nh/J3[F*2|@d;Krz0

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

व्याख्या

मैं डिफ़ॉल्ट रूप से इसे छुपाता हूं क्योंकि यह बहुत लंबा है।

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

— PurkkaKoodari
स्रोत
4

पर्ल, 147 146 बाइट्स

के लिए +1 शामिल है -p

STDIN पर इनपुट के साथ चलाएं, जैसे

citysky.pl <<< " abcdefgxyz."

citysky.pl:

#!/usr/bin/perl -p
s%.%@{[map chr~-ord(lc$&)*4/3-4*(abs||-9),-9..9]}%g;y/M\xa248
A|-\xc6\0-\xff/MA||
A}-\xc6A/d,$a=(lc$a).$_ for($_)x36;*_=a;s/\x9f.*?\K\x9f/\xa3/g;y%A\xc6\x9f-\xa3\x0b-\xff%__/|||\\ %

दिखाए गए अनुसार काम करता है, लेकिन \xhhदावा किए गए स्कोर को प्राप्त करने के लिए उनके शाब्दिक मूल्य से पलायन को प्रतिस्थापित करता है। आप इस कमांडलाइन का उपयोग कर सकते हैं:

perl -0pi -e 's/\\x(..)/chr hex $1/eg;s/\n$//' citysky.pl

मैंने वास्तव में किसी भी अन्य दृष्टिकोण का पता नहीं लगाया है, इसलिए यह बहुत ही महत्वपूर्ण हो सकता है ...

— टन हास्पेल
स्रोत
2

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

c?l=c++l++c
c%s=("|"?(drop 2(r s)>>c)):s
g 46=["/\\"?""]
g 32=["  "]
g x="_"%h(mod x 32)
h 1=["/ \\"," _ "]
h x=(" "%h(x-1))!x
v!x|mod x 3/=1=v|z<-'/':r v++"\\"=z:map(" "?)v
r v=v!!0>>" "
f t|l<-map(g.fromEnum)t,m<-maximum(map length l)-1=unlines[l>>= \x->(x++cycle[r x])!!i|i<-[m,m-1..0]]
— डेमियन
स्रोत
2

रूबी, २४५

->s{a=['']*36
w=' '
s.chars{|c|a[u=0]+=c<?!?w*2:c<?/?"/\\"*2:(h=c.upcase.ord-64
1.upto(1+h+=(h-1)/3){|t|u=[u,l=1+2*((f=h-t)/4)].max
a[t]+=w*(a[0].size-a[t].size)+(f<-1?w:f<0??_:(f%4<1?[?/,?\\]:[?|]*2)*(w*l)).center(u+2)}
"|#{?_*u}|")}
a.reverse}

आप जितनी चाहें उतनी अतिरिक्त नई अनुमति देते हैं, इसलिए मैं इसके साथ स्वतंत्रता ले रहा हूं। इसके अलावा, प्रक्रिया इस प्रकार है:

  1. एक आउटपुट ऐरे को आरम्भ करें a।
  2. प्रत्येक चार के लिए:
    1. अगर यह 'है', को जोड़ने  के लिएa[0]
    2. अगर यह '।', जोड़ने /\/\के लिएa[0]
    3. अन्यथा:
      1. ऊंचाई की गणना करें ( c.upcase.ord + (c.upcase.ord-1)/3)
      2. प्रत्येक पंक्ति के लिए a:
        1. व्हॉट्सएप के साथ पंक्ति पैड। a[t]+=w*(a[0].size-a[t].size)
        2. यदि हम एक से ऊपर हैं h, तो केंद्र_
        3. और अगर हम ऊंचाई से ऊपर हैं, तो केंद्र ए 
        4. यदि हम ऊंचाई, केंद्र | |या / \उचित चौड़ाई ( 1+2*((h-t)/4) से नीचे हैं, तो इस पर निर्भर करता हैh-t%4==0
        5. "|___|"के लिए सही चौड़ाई का जोड़a[0]
  3. वापसी a.reverse

मुझे यकीन है कि अगर मैं गणित से बचने के लिए काम करता हूं तो मैं इसे छोटा कर सकता हूं reverse

— चार्ल्स नहीं
स्रोत
2

PHP, 297 बाइट्स

foreach(str_split($argv[1])as$c)for($j=0,$h=ord($c)-64,$g=$h+$f=ceil($h/3),$w=$v=$h<0?$h<-18?2:4:2*$f+1;$j<36;$j++,$g--,$v-=$h>0&&$v>1?($g%4||!$j)?0*$n="|$s|":2+0*$n="/$s\\":$v+0*$n=['','_','',0,'/\/\\'][$v],$o[$j].=str_pad($n,$w,' ',2))$s=str_repeat($j?' ':'_',$v-2);krsort($o);echo join($o,'
');

अधिक पठनीय संस्करण:

foreach (str_split($argv[1]) as $character) {
    for (
        $line = 0,
        $buildingHeight = ord($character) - 64,
        $floorsLeft = $buildingHeight + $supportFloors = ceil($buildingHeight / 3),
        $buildingWidth = $widthOnThisFloor = $buildingHeight < 0
            ? $buildingHeight < -18
                ? 2
                : 4
            : 2 * $supportFloors + 1;

        $line < 36;

        // The body of the for-loop is executed between these statements

        $line++,
        $floorsLeft--,
        $widthOnThisFloor -= $buildingHeight > 0 && $widthOnThisFloor > 1
            ? ($floorsLeft % 4 || !$line)
                ? 0 * $floorString = "|$middleSpacing|"
                : 2 + 0 * $floorString = "/$middleSpacing\\"
            : $widthOnThisFloor + 0 * $floorString = ['', '_', '', 0, '/\/\\'][$widthOnThisFloor],
        $outputArray[$line] .= str_pad($floorString, $buildingWidth, ' ', 2)
    ) {
        $middleSpacing = str_repeat($line ? ' ' : '_', $widthOnThisFloor - 2);
    }
}
krsort($outputArray);
echo join($outputArray, '
');
— chocochaos
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.