रेटिना , ४५ 43 बाइट्स
बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।
O$#`.(?<=(.+))|¶
$.1
!`(?<=(¶)+.*)(?<-1>.)+
अग्रणी लाइनफीड महत्वपूर्ण है। इनपुट और आउटपुट मुद्रण योग्य एएससीआईआई स्ट्रिंग की लाइन-टर्मिनेटेड सूची हैं (ध्यान दें कि दोनों में एक एकल अनुगामी लाइनफीड है)।
इसे ऑनलाइन आज़माएं!
मैं थोड़ी देर के लिए जानता था कि आयताकार ब्लॉकों को स्थानांतरित करना रेटिना में दर्द होगा (जबकि ट्रांसपोज़िंग स्क्वायर बहुत बुरा नहीं है), लेकिन वास्तव में कभी कोशिश नहीं की गई। पहला समाधान वास्तव में 110 बाइट्स लंबा था, लेकिन दृष्टिकोण में कई महत्वपूर्ण बदलावों के बाद, परिणामस्वरूप 45 बाइट्स अब तक खराब नहीं हुए हैं जितना कि मुझे संदेह है (लेकिन अभी भी ...)। स्पष्टीकरण कल का पालन करेंगे।
व्याख्या
चरण 1: सॉर्ट करें
O$#`.(?<=(.+))|¶
$.1
यह इनपुट में वर्णों को फिर से व्यवस्थित करने का मुख्य काम करता है, लेकिन यह पृथक्करण को लाइनों में गड़बड़ाने का काम करता है। दिलचस्प है, अगर हम हटा दें|¶ एक वर्ग इनपुट पारगमन के लिए आवश्यक कोड मिल जाता है।
सॉर्ट चरणों (द्वारा चिह्नित O) इस तरह से काम करते हैं: वे दिए गए रेगेक्स के सभी मैचों (बाद की चीज `) को ढूंढते हैं, और फिर उन मैचों को सॉर्ट करते हैं और उन जगहों पर फिर से स्थापित करते हैं जहां मैच पाए गए थे। जैसा कि होता है, यह रेगेक्स हर एक वर्ण से मेल खाता है: .(?<=(.*))विकल्प के माध्यम से गैर-लाइनफीड और के माध्यम से लाइनफीड ¶। इसलिए, यह इनपुट में सभी वर्णों को क्रमबद्ध करता है। अधिक दिलचस्प हिस्सा यह है कि वे किसके द्वारा हल किए जाते हैं ।
$विकल्प को सक्रिय करता है एक "प्रकार द्वारा" मोड है, जहां प्रत्येक मैच दूसरी पंक्ति है, जो तब मैचों की तुलना के लिए प्रयोग किया जाता है पर प्रतिस्थापन पैटर्न के साथ बदल दिया है। इसके अलावा,# रेटिना को एक पूर्णांक के प्रतिस्थापन के परिणाम को बदलने के लिए कहता है, और उन पूर्णांकों की तुलना करता है (उन्हें स्ट्रिंग के रूप में मानने के बजाय)।
इसलिए अंत में, हमें रेगेक्स और प्रतिस्थापन की ओर देखने की जरूरत है। यदि पहला वैकल्पिक मिलान (अर्थात हमने किसी एक वर्ण के भीतर किसी वर्ण का मिलान किया है), तो (?<=(.*))समूह में उस रेखा पर उस वर्ण तक सब कुछ पकड़ लेता है 1। $.1प्रतिस्थापन पैटर्न में से प्रतिस्थापित कर देता लंबाई समूह के 1। इसलिए, प्रत्येक स्ट्रिंग में पहला चरित्र बन जाता है 1, दूसरा बन जाता है 2, तीसरा बन जाता है 3और इसी तरह। यह अब स्पष्ट होना चाहिए कि यह एक वर्ग इनपुट को कैसे स्थानांतरित करता है: लाइनों के सभी पहले वर्ण पहले आते हैं और सभी शीर्ष-सबसे पंक्ति में समाप्त होते हैं, फिर सभी दूसरे वर्ण दूसरी पंक्ति में समाप्त होते हैं और इसी तरह। लेकिन इन आयताकार इनपुटों के लिए, हम लाइनफीड्स का मिलान भी कर रहे हैं। समूह के बाद से1इस मामले में अप्रयुक्त है, प्रतिस्थापन खाली है, लेकिन #विकल्प के प्रयोजनों के लिए , इस पर विचार किया जाता है 0। इसका मतलब है कि सभी लाइनफीड सामने की ओर छांटे गए हैं।
तो अब हमारे पास पहले क्रम में वर्ण हैं (प्रत्येक स्ट्रिंग का पहला चरित्र, प्रत्येक स्ट्रिंग का दूसरा चरित्र, आदि) और शुरुआत में सभी लाइनफीड।
स्टेज 2: मैच
!`(?<=(¶)+.*)(?<-1>.)+
अब हमें पात्रों को सही लंबाई की रेखाओं में विभाजित करने की आवश्यकता है। यह लंबाई मूल इनपुट में लाइनों की संख्या से मेल खाती है, जो स्ट्रिंग की शुरुआत में हमारे द्वारा की गई लाइनफीड की संख्या से मेल खाती है।
बंटवारे को यहां एक मैच चरण की मदद से किया जाता है, जो बस दिए गए रेगेक्स के सभी मैचों को ढूंढता है और उपयोग करता है ! उन मैचों को प्रिंट करने विकल्प (डिफ़ॉल्ट इसके बजाय उन्हें गिनना होगा)। तो रेगेक्स का लक्ष्य एक समय में एक पंक्ति से मेल खाना है।
हम लुकअप के साथ संख्या "गिनती" से शुरू करते हैं (?<=(¶)*.*)। यह समूह में एक कैप्चर उत्पन्न करता है1 फ्रंट में हर लाइनफीड के लिए ।
फिर, उन प्रत्येक कैप्चर के लिए, हम एक एकल चरित्र के साथ मेल खाते हैं (?<-1>.)+।