एक ASCII कला बनाएं!

Question

इस तरह की ASCII कला की एक स्ट्रिंग को देखते हुए (यह ASCII कला नहीं है, लेकिन यह उदाहरण के लिए क्या करेगा):

abc
d e
fgh

इसे जम्बल करें जैसे कि यह स्क्रीन पर प्रति पंक्ति एक वर्ण के साथ प्रदर्शित किया जा रहा है, जैसे:

a
b
c
d

e
f
g
h

परिणाम प्रिंट करें, टर्मिनल को साफ़ करने से पहले एक सेकंड, result 0.5 सेकंड प्रतीक्षा करें और एक ही चीज़ प्रिंट करें, लेकिन 1 के बजाय प्रति पंक्ति में प्रदर्शित 2 वर्णों के साथ। डिस्प्ले की चौड़ाई 1 से 2 हो जाती है।

ab
c
d 
e
fg
h

के बाद अंतरिक्ष पर ध्यान दें d। प्रतीक्षा को दोहराएं, फिर प्रति पंक्ति एक अतिरिक्त चरित्र के साथ तब तक प्रिंट करें जब तक कि इनपुट किए गए पाठ का आउटपुट न हो जाए।

यदि आप वर्णों को प्रिंट करने का प्रयास करते समय एक पंक्ति के अंत में आते हैं, तो आप एक नई पंक्ति सम्मिलित करते हैं और इस नियम का पालन करते हुए उनमें से शेष को प्रिंट करते हैं। उदाहरण के लिए इनपुट:

abcdefg
ab

प्रदर्शन की लंबाई 4 होने पर निम्नलिखित प्रिंट करेगा।

abcd
efg
ab

आप टर्मिनल आकार का प्रभाव यहां पा सकते हैं: https://repl.it/GoeU/1 । प्रोग्राम को चलाएं, फिर टेक्स्ट एडिटर से टर्मिनल को अलग करने वाली चीज़ को आगे और पीछे खींचें।

स्पष्टीकरण:

एक बार एक लाइन दिखाई देती है कि यह कैसे इनपुट किया गया था, आप उस लाइन को भविष्य में बड़े वर्ण प्रति पंक्ति के लिए अकेला छोड़ सकते हैं।

abc
ab

छपना चाहिए

ab
c
ab

जब वाक्य की लंबाई = २।

---

यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीतता है!

नियम:

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

यह विचार मुझे तब मिला जब मैं उस पर ASCII कला के साथ एक टर्मिनल का आकार बदल रहा था। यह दिलचस्प लग रहा था, इसलिए मैंने इससे बाहर एक चुनौती बनाने का फैसला किया।

---

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

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

 ______   ______     __     __   __     ______      __    __     ______    
/\  == \ /\  == \   /\ \   /\ "-.\ \   /\__  _\    /\ "-./  \   /\  ___\   
\ \  _-/ \ \  __<   \ \ \  \ \ \-.  \  \/_/\ \/    \ \ \-./\ \  \ \  __\   
 \ \_\    \ \_\ \_\  \ \_\  \ \_\\"\_\    \ \_\     \ \_\ \ \_\  \ \_____\ 
  \/_/     \/_/ /_/   \/_/   \/_/ \/_/     \/_/      \/_/  \/_/   \/_____/ 

यह पास्टबिन ।

                        __/\__
                        \    /
                  __/\__/    \__/\__
                  \                /
                  /_              _\
                    \            /
      __/\__      __/            \__      __/\__
      \    /      \                /      \    /
__/\__/    \__/\__/                \__/\__/    \__/\__

Answer 1

बैश (जीएनयू कोरुटिल्स के साथ), 69 बाइट्स

n=`tee x|wc -L`;for i in `seq 1 $n`;do fold -w$i x;sleep 1;clear;done

अस्थायी फ़ाइल में इनपुट को सहेजता है x, फिर सबसे लंबी लाइन (GNU कोरुटिल्स में wcइसके लिए -Lझंडा होता है) को गिनता है और प्रत्येक कंसोल की चौड़ाई 1 से सबसे लंबी लाइन की लंबाई के लिए पुनरावृत्त करता है। fold, sleepऔर clearबाकी जादू करता है।

Answer 2

पायथन 3.6, 124 बाइट्स

आधिकारिक स्ट्रिंग जैसे इनपुट स्ट्रिंग की लंबाई पर लूप्स

import re,time
def d(s):
 for i in range(len(s)):print(*'\n'*75,*re.split(f'(.{{1,{i+1}}})',s)[1::2],sep='\n');time.sleep(1)

143 बाइट्स केवल सबसे लंबी लाइन की चौड़ाई पर जाने के लिए एक अल फ्रेक्सट्रेम के बैश उत्तर

import re,time
def d(s):
 for i in range(max(map(len,s.split()))):print(*'\n'*75,*re.split(f'(.{{1,{i+1}}})', s)[1::2],sep='\n');time.sleep(.5)

स्ट्रिंग को वर्णों में तोड़ने के लिए "re.split ((। {1, i + 1}))" का उपयोग करता है। चूंकि '।' '\ n' से मेल नहीं खाता, समूह एक पंक्ति से दूसरी पंक्ति के आसपास नहीं लिपटे। यदि रेगेक्स कैप्चरिंग समूह का उपयोग करता है, तो re.split () विषम सूचियों में मिलान किए गए समूहों के साथ एक सूची देता है। इन्हें [1 :: 2] के साथ पुनः प्राप्त किया जाता है।

Python का उपयोग करता है 3.6 पैटर्न फिर से बनाने के लिए समूह की चौड़ाई पर निर्भर करता है i।

पुन: ssplit के सामने * () प्रिंट स्टेटमेंट के लिए तर्कों में सूची को चालू करने के लिए अजगर 3.6 अनपैकिंग का उपयोग करता है। इसी तरह, * '\ n' * 75, 75 '\ n' में बदलकर प्रिंट स्टेटमेंट देता है। प्रिंट कीवर्ड तर्क sep = '\ n' के साथ, परिणाम स्क्रीन को खाली करने के लिए लगभग 150 रिक्त लाइनों को प्रिंट कर रहा है, इसके बाद प्रत्येक समूह के अक्षर एक अलग लाइन पर हैं।

Comments

यह लोग मेरे मुकाबले बेहतर और छोटे हैं। अच्छा काम! (y)

— आधिकारिक ५

Answer 3

पायथन 3.5 ( 238 233 229 225 223 222 बाइट्स)

- विंडोज टर्मिनल में ठीक काम करता है; सिस्टम-विशिष्ट os.system ("cls") कमांड के कारण अन्य प्लेटफार्मों के बारे में निश्चित नहीं है।

- पास की गई स्ट्रिंग को newlines के लिए \ n द्वारा चिह्नित किया जाना चाहिए जैसे: 'abc \ nd efgh \ n'

import os,time 
def b(s):
 p=len(s);z=print;r=range
 for i in r(1,p):
  os.system("cls");l=0
  for j in r(p):
   z(s[j],end="");l+=1
   if(s[j]=='\n'):l=0
   if(j+1<p and l==i and s[j+1]!='\n'):z();l=0
  z();time.sleep(.5)

• सहेजे गए 5 बाइट्स: अवांछित व्हाट्सएप को हटा दिया गया
• सहेजे गए 4 बाइट्स: लेन के लिए आशुलिपि
• सहेजे गए 4 बाइट्स: स्पार्कलेपोनी (प्रिंट के लिए शॉर्टहैंड) के लिए धन्यवाद
• सहेजे गए 2 बाइट्स: स्पार्कलेपोनी (आर और आर के रूप में रेंज के लिए शॉर्टहैंड (0, आई) रेंज के रूप में (आई) के लिए धन्यवाद
• बचाया 1 बाइट: स्टीव के लिए धन्यवाद (0.5 बस के रूप में .5)

Comments

ठंडा! मुझे लगता है कि आप कोड का उपयोग करके कुछ बाइट्स बंद दाढ़ी सकता है z=printशीर्ष पर, और उसके बाद के अन्य सभी इंस्टेंस को बदलने print()के लिए z()।

— कॉमरेड स्पार्कलपनी

मुझे लगता है कि आपको कुछ भी पुराना ही बात आप के साथ किया था printके साथ range, और के बजाय range(0,3)उपयोग range(3)।

— कॉमरेड स्पार्कलपनी

sleep(0.5)केवल के रूप में लिखा जा सकता हैsleep(.5)

— स्टीव