शब्दों के भीतर शब्दों के भीतर शब्द। । ।

वर्णमाला के अपरकेस अक्षरों के इस पिक्सेलयुक्त फ़ॉन्ट में, सभी वर्ण 5 इकाइयाँ चौड़ी और 5 ऊँची हैं।

 ███  ████   ███  ████  █████ █████  ████ █   █ █████     █ █   █ █     █   █
█   █ █   █ █   █ █   █ █     █     █     █   █   █       █ █  █  █     ██ ██
█████ ████  █     █   █ ████  ████  █  ██ █████   █       █ ███   █     █ █ █
█   █ █   █ █   █ █   █ █     █     █   █ █   █   █   █   █ █  █  █     █   █
█   █ ████   ███  ████  █████ █      ████ █   █ █████  ███  █   █ █████ █   █

█   █  ███  ████   ███  ████   ████ █████ █   █ █   █ █   █ █   █ █   █ █████
██  █ █   █ █   █ █   █ █   █ █       █   █   █ █   █ █   █  █ █   █ █     █ 
█ █ █ █   █ ████  █   █ ████   ███    █   █   █  █ █  █ █ █   █     █     █  
█  ██ █   █ █     █  ██ █  █      █   █   █   █  █ █  █ █ █  █ █    █    █   
█   █  ███  █      ████ █   █ ████    █    ███    █    █ █  █   █   █   █████

अक्षरों के बीच और लाइनों के बीच अंतरिक्ष की 1 इकाई भी है, जैसा कि देखा जा सकता है। इसलिए प्रत्येक अक्षर 6 × 6 यूनिट तक की जगह ले सकता है।

मान लीजिए कि अक्षरों के आकार को सीधे बनाने के लिए पूर्ण ब्लॉक चरित्र ( █) का उपयोग करने के बजाय , हम उसी फ़ॉन्ट में अन्य अक्षरों का उपयोग करना चाहते थे । इसमें पाठ 6-गुना के आयामों को बढ़ाना शामिल है ताकि पूर्ण-खंडों से बने अक्षरों का उपयोग बड़े पाठ में पूर्ण-ब्लॉक प्रतिस्थापन के रूप में किया जा सके।

अगर यह समझ में नहीं आया तो उम्मीद है कि यह उदाहरण होगा। यहाँ A का बना हुआ B, पिक्सेलयुक्त फ़ॉन्ट का उपयोग कर रहा है:

      ████  ████  ████       
      █   █ █   █ █   █      
      ████  ████  ████       
      █   █ █   █ █   █      
      ████  ████  ████       
                             
████                    ████ 
█   █                   █   █
████                    ████ 
█   █                   █   █
████                    ████ 
                             
████  ████  ████  ████  ████ 
█   █ █   █ █   █ █   █ █   █
████  ████  ████  ████  ████ 
█   █ █   █ █   █ █   █ █   █
████  ████  ████  ████  ████ 
                             
████                    ████ 
█   █                   █   █
████                    ████ 
█   █                   █   █
████                    ████ 
                             
████                    ████ 
█   █                   █   █
████                    ████ 
█   █                   █   █
████                    ████

B, पूर्ण ब्लॉक से बना है और A, B से बना है। ध्यान दें कि B की अभी भी उनके बीच एक इकाई क्षैतिज और लंबवत है।

हम इस विचार को केवल अक्षरों के बजाय शब्दों का उपयोग करके बढ़ा सकते हैं। यहाँ "जल" "आग" से बना है:

█████                   █████             ████  █████ █████             █████ ████  █████ █████ █████       ████  █████ █████ █████ ████        █████ █████ █████ ████       
█                         █               █   █ █     █                   █   █   █ █     █       █         █   █ █     █       █   █   █       █     █       █   █   █      
████                      █               ████  ████  ████                █   ████  ████  ████    █         ████  ████  ████    █   ████        ████  ████    █   ████       
█                         █               █  █  █     █                   █   █  █  █     █       █         █  █  █     █       █   █  █        █     █       █   █  █       
█                       █████             █   █ █████ █                 █████ █   █ █████ █     █████       █   █ █████ █     █████ █   █       █████ █     █████ █   █      
                                                                                                                                                                             
█████                   █████       ████                    █████                   █████                   █████                               ████                    █████
█                         █         █   █                   █                       █                         █                                 █   █                   █    
████                      █         ████                    ████                    ████                      █                                 ████                    ████ 
█                         █         █  █                    █                       █                         █                                 █  █                    █    
█                       █████       █   █                   █████                   █                       █████                               █   █                   █████
                                                                                                                                                                             
█████       █████       ████        █████ █████ █████ ████  █████                   █████                   █████ ████  █████ █████             █████ ████  █████ █████      
█             █         █   █       █     █       █   █   █ █                       █                         █   █   █ █     █                   █   █   █ █     █          
████          █         ████        ████  ████    █   ████  ████                    ████                      █   ████  ████  ████                █   ████  ████  ████       
█             █         █  █        █     █       █   █  █  █                       █                         █   █  █  █     █                   █   █  █  █     █          
█           █████       █   █       █████ █     █████ █   █ █████                   █                       █████ █   █ █████ █                 █████ █   █ █████ █          
                                                                                                                                                                             
█████       █████       ████        █████                   █████                   █████                   ████                                █████             █████      
█             █         █   █       █                       █                         █                     █   █                               █                 █          
████          █         ████        ████                    ████                      █                     ████                                ████              ████       
█             █         █  █        █                       █                         █                     █  █                                █                 █          
█           █████       █   █       █████                   █                       █████                   █   █                               █████             █          
                                                                                                                                                                             
      █████       █████             ████                    █████                   █████                   █████ ████  █████ █████ █████       ████                    █████
      █             █               █   █                   █                       █                         █   █   █ █     █       █         █   █                   █    
      ████          █               ████                    ████                    ████                      █   ████  ████  ████    █         ████                    ████ 
      █             █               █  █                    █                       █                         █   █  █  █     █       █         █  █                    █    
      █           █████             █   █                   █████                   █                       █████ █   █ █████ █     █████       █   █                   █████

ध्यान दें कि "FIRE" प्रत्येक पंक्ति पर बार-बार कैसे प्रकट होता है, और हमेशा क्रम में, कोई फर्क नहीं पड़ता कि अक्षरों के बीच कितनी जगह है। "FIRE" के सबसे सही उदाहरणों में से तीन को जल्द ही काट दिया गया था क्योंकि "WATER" के अक्षर आकार के हैं।

यह विचार इन का उपयोग करके आगे भी विस्तार किया जा सकता, शब्द से बना शब्द बनाने के लिए शब्दों से बना शब्द से बना शब्द , या यहाँ तक कि शब्द से बना शब्द से बना शब्द से बना शब्द । सैद्धांतिक रूप से कोई सीमा नहीं है।

एक और उदाहरण इस पोस्ट को 30k कैरेक्टर लिमिट से अधिक लगाएगा, लेकिन आप देख सकते हैं कि इस निफ्टी स्टैक स्निपेट को चलाकर "शब्दों से बने शब्द" का क्या अर्थ है। बस अपने चूक पर मापदंडों को छोड़ दें और "गो!" दबाएं। आपको "CAT" शब्द से बने शब्द "DOG" को "MOUSE" शब्द से देखना चाहिए।

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

alphabet = {A:[[0,1,1,1,0,0],[1,0,0,0,1,0],[1,1,1,1,1,0],[1,0,0,0,1,0],[1,0,0,0,1,0],[0,0,0,0,0,0]],C:[[0,1,1,1,0,0],[1,0,0,0,1,0],[1,0,0,0,0,0],[1,0,0,0,1,0],[0,1,1,1,0,0],[0,0,0,0,0,0]],B:[[1,1,1,1,0,0],[1,0,0,0,1,0],[1,1,1,1,0,0],[1,0,0,0,1,0],[1,1,1,1,0,0],[0,0,0,0,0,0]],E:[[1,1,1,1,1,0],[1,0,0,0,0,0],[1,1,1,1,0,0],[1,0,0,0,0,0],[1,1,1,1,1,0],[0,0,0,0,0,0]],D:[[1,1,1,1,0,0],[1,0,0,0,1,0],[1,0,0,0,1,0],[1,0,0,0,1,0],[1,1,1,1,0,0],[0,0,0,0,0,0]],G:[[0,1,1,1,1,0],[1,0,0,0,0,0],[1,0,0,1,1,0],[1,0,0,0,1,0],[0,1,1,1,1,0],[0,0,0,0,0,0]],F:[[1,1,1,1,1,0],[1,0,0,0,0,0],[1,1,1,1,0,0],[1,0,0,0,0,0],[1,0,0,0,0,0],[0,0,0,0,0,0]],I:[[1,1,1,1,1,0],[0,0,1,0,0,0],[0,0,1,0,0,0],[0,0,1,0,0,0],[1,1,1,1,1,0],[0,0,0,0,0,0]],H:[[1,0,0,0,1,0],[1,0,0,0,1,0],[1,1,1,1,1,0],[1,0,0,0,1,0],[1,0,0,0,1,0],[0,0,0,0,0,0]],K:[[1,0,0,0,1,0],[1,0,0,1,0,0],[1,1,1,0,0,0],[1,0,0,1,0,0],[1,0,0,0,1,0],[0,0,0,0,0,0]],J:[[0,0,0,0,1,0],[0,0,0,0,1,0],[0,0,0,0,1,0],[1,0,0,0,1,0],[0,1,1,1,0,0],[0,0,0,0,0,0]],M:[[1,0,0,0,1,0],[1,1,0,1,1,0],[1,0,1,0,1,0],[1,0,0,0,1,0],[1,0,0,0,1,0],[0,0,0,0,0,0]],L:[[1,0,0,0,0,0],[1,0,0,0,0,0],[1,0,0,0,0,0],[1,0,0,0,0,0],[1,1,1,1,1,0],[0,0,0,0,0,0]],O:[[0,1,1,1,0,0],[1,0,0,0,1,0],[1,0,0,0,1,0],[1,0,0,0,1,0],[0,1,1,1,0,0],[0,0,0,0,0,0]],N:[[1,0,0,0,1,0],[1,1,0,0,1,0],[1,0,1,0,1,0],[1,0,0,1,1,0],[1,0,0,0,1,0],[0,0,0,0,0,0]],Q:[[0,1,1,1,0,0],[1,0,0,0,1,0],[1,0,0,0,1,0],[1,0,0,1,1,0],[0,1,1,1,1,0],[0,0,0,0,0,0]],P:[[1,1,1,1,0,0],[1,0,0,0,1,0],[1,1,1,1,0,0],[1,0,0,0,0,0],[1,0,0,0,0,0],[0,0,0,0,0,0]],S:[[0,1,1,1,1,0],[1,0,0,0,0,0],[0,1,1,1,0,0],[0,0,0,0,1,0],[1,1,1,1,0,0],[0,0,0,0,0,0]],R:[[1,1,1,1,0,0],[1,0,0,0,1,0],[1,1,1,1,0,0],[1,0,0,1,0,0],[1,0,0,0,1,0],[0,0,0,0,0,0]],U:[[1,0,0,0,1,0],[1,0,0,0,1,0],[1,0,0,0,1,0],[1,0,0,0,1,0],[0,1,1,1,0,0],[0,0,0,0,0,0]],T:[[1,1,1,1,1,0],[0,0,1,0,0,0],[0,0,1,0,0,0],[0,0,1,0,0,0],[0,0,1,0,0,0],[0,0,0,0,0,0]],W:[[1,0,0,0,1,0],[1,0,0,0,1,0],[1,0,1,0,1,0],[1,0,1,0,1,0],[0,1,0,1,0,0],[0,0,0,0,0,0]],V:[[1,0,0,0,1,0],[1,0,0,0,1,0],[0,1,0,1,0,0],[0,1,0,1,0,0],[0,0,1,0,0,0],[0,0,0,0,0,0]],Y:[[1,0,0,0,1,0],[0,1,0,1,0,0],[0,0,1,0,0,0],[0,0,1,0,0,0],[0,0,1,0,0,0],[0,0,0,0,0,0]],X:[[1,0,0,0,1,0],[0,1,0,1,0,0],[0,0,1,0,0,0],[0,1,0,1,0,0],[1,0,0,0,1,0],[0,0,0,0,0,0]],Z:[[1,1,1,1,1,0],[0,0,0,1,0,0],[0,0,1,0,0,0],[0,1,0,0,0,0],[1,1,1,1,1,0],[0,0,0,0,0,0]]}

empty = ['\xA0', '.']
full = ['\u2588', 'X']
w = 6
h = 6

function makeGrid(height, width) {
    var grid = new Array(height)
    for(var y = 0; y < height; y++) {
        grid[y] = new Array(width)
    }
    return grid
}

function unfoldGrid(grid) {
    var newGrid = makeGrid(h * grid.length, w * grid[0].length)
    for (var y = 0; y < newGrid.length; y++) {
        for (var x = 0; x < newGrid[0].length; x++) {
            var yf = Math.floor(y / h), xf = Math.floor(x / w)
            if (grid[yf][xf] != 0) {
                newGrid[y][x] = grid[yf][xf][y % h][x % w]
            } else {
                newGrid[y][x] = 0
            }
        }
    }    
    return newGrid
}

function makeWords(words, empty, full) {
    var grid = makeGrid(1, words[0].length)
    for (var i = 0; i < words[0].length; i++) {
        grid[0][i] = alphabet[words[0][i]]
    }
    console.log(grid.length)
        console.log(grid[0].length)
    grid = unfoldGrid(grid)
    
        console.log(grid.length)
        console.log(grid[0].length)
    for(var i = 1; i < words.length; i++) {
        for (var y = 0; y < grid.length; y++) {
            var offset = 0
            for (var x = 0; x < grid[0].length; x++) {
                if (grid[y][x]) {
                    grid[y][x] = alphabet[words[i][offset++ % words[i].length]]
                }
            }
        }
        grid = unfoldGrid(grid)
    }
    
    var output = ''
    
    var height = Math.pow(h, words.length) - (Math.pow(h, words.length) - 1) / (h - 1)
    var width = words[0].length * Math.pow(w, words.length) - (Math.pow(w, words.length) - 1) / (w - 1)
    
    for (var y = 0; y < height; y++) {
        for (var x = 0; x < width; x++) {
            output += grid[y][x] ? full : empty                                    
        }
        if (y + 1 != height) {
            output += '\r\n'
        }
    }
    
    return output
}

function go() {
    plain = document.getElementById('plain').checked ? 1 : 0
    document.getElementById('canvas').value = makeWords(document.getElementById('words').value.split(' '), empty[plain], full[plain])
    resize()
}

function resize() {
    document.getElementById('canvas').style.fontSize = document.getElementById('size').value
}

function zoom(magnify) {
    canvas = document.getElementById('canvas')
    match = canvas.style.fontSize.match(/^(\d+(?:\.\d+)?)(.*)$/)
    if (match !== null) {
        number = parseFloat(match[1])
        unit = match[2]
        canvas.style.fontSize = document.getElementById('size').value = (number + (magnify ? 0.1 : -0.1)) + unit
    }
}

#canvas {
    font-family: Consolas, "Courier New", sans-serif;
    white-space: nowrap; overflow: auto;
    width: 6in;
    height: 3in;
}

<p>Words: <input type='text' id='words' value='DOG CAT MOUSE'> <button type='button' onclick='go()'>Go!</button> Plain ASCII <input type='checkbox' id='plain'></p>
<p>Font Size: <input type='text' id='size' value='0.4mm'> <button type='button' onclick='resize()'>Resize</button> <button type='button' onclick='zoom(1)'>+</button> <button type='button' onclick='zoom(0)'>-</button> (use any unit: in, cm, mm, em, pt, px)</p>
<textarea id='canvas'></textarea>

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

टेक्स्टबॉक्स में केवल कैपिटल अक्षरों वाले शब्दों की किसी भी अलग-अलग जगह को टाइप करने से तीसरे शब्द से बने पहले शब्द का उत्पादन होगा, जो चौथे से बना है, जो ... आदि से बना है।

चेतावनी: 4 या 3 शब्दों से अधिक दर्ज करने से A LOT पाठ का उत्पादन होगा और एक लंबा समय लगेगा। यह आपके ब्राउज़र / कंप्यूटर / कार को क्रैश कर सकता है।

चुनौती

इस चुनौती का लक्ष्य यह साबित करना है कि स्टैक स्निपेट सबसे कम पात्रों में क्या करता है।

आपको एक प्रोग्राम लिखना होगा जो केवल कैपिटल अक्षरों से युक्त शब्दों के एक अंतरिक्ष में अलग-अलग स्ट्रिंग में लेता है, और ऊपर दिए गए पिक्सेलेटेड फ़ॉन्ट का उपयोग करके, तीसरे और इसी तरह "दूसरा" से बना पहला शब्द "आउटपुट" करता है।

"प्लेन ASCII" चेकबॉक्स और स्निपेट के फ़ॉन्ट आकार की विशेषताओं को आपके कार्यक्रम में समर्थित होने की आवश्यकता नहीं है। शब्दों की सूचियों से शब्दों से बने शब्दों में परिवर्तन को प्रतिबिंबित करना मुख्य बिंदु और केवल आवश्यकता है।

विवरण

इनपुट को स्टडिन, कमांड लाइन से आना चाहिए, या आप केवल एक फ़ंक्शन लिख सकते हैं जो एक स्ट्रिंग लेता है।
आप मान सकते हैं कि इनपुट हमेशा वैध होता है, यानी बड़े अक्षरों से बने शब्दों की एक स्ट्रिंग, जो बिना किसी अग्रणी या अनुगामी रिक्त स्थान के, बिल्कुल एक स्थान से अलग होती है।
आउटपुट को अपनी पसंद के नाम के साथ stdout (या समान विकल्प) या फ़ाइल में जाना चाहिए।
आउटपुट में पूरी तरह से रिक्त-स्थान वर्ण , पूर्ण-स्थान वर्ण , और newlines शामिल होना चाहिए ।
- खाली / पूर्ण अंतरिक्ष वर्ण या तो अंतरिक्ष और पूर्ण ब्लॉक (होना चाहिए , █) क्रमशः, या अवधि और एक्स ( ., X) क्रमशः।
आउटपुट में केवल खाली-खाली वर्ण वाले किसी भी अग्रणी स्तंभ को शामिल नहीं किया जाना चाहिए , हालाँकि किसी भी रेखा पर रिक्त-स्थान वर्णों के अनुगमन के किसी भी संयोजन की अनुमति है।
- तो यह अनुमति है:
```
X...X.XXXXX..
X...X.X
X.X.X.XXXX....
X.X.X.X..
.X.X..XXXXX..
```
- लेकिन यह नहीं है:
```
.X...X.XXXXX..
.X...X.X
.X.X.X.XXXX....
.X.X.X.X..
..X.X..XXXXX..
```
केवल खाली स्थान वाले वर्णों में कोई अग्रणी या अनुगामी पंक्तियाँ नहीं होनी चाहिए । एक एकल अनुगामी न्यूलाइन को वैकल्पिक रूप से अनुमति दी जाती है।

यहाँ फ़ॉन्ट का एक अधिक स्ट्रिंग-फ्रेंडली संस्करण है:

.XXX.
X...X
XXXXX
X...X
X...X

XXXX.
X...X
XXXX.
X...X
XXXX.

.XXX.
X...X
X....
X...X
.XXX.

XXXX.
X...X
X...X
X...X
XXXX.

XXXXX
X....
XXXX.
X....
XXXXX

XXXXX
X....
XXXX.
X....
X....

.XXXX
X....
X..XX
X...X
.XXXX

X...X
X...X
XXXXX
X...X
X...X

XXXXX
..X..
..X..
..X..
XXXXX

....X
....X
....X
X...X
.XXX.

X...X
X..X.
XXX..
X..X.
X...X

X....
X....
X....
X....
XXXXX

X...X
XX.XX
X.X.X
X...X
X...X

X...X
XX..X
X.X.X
X..XX
X...X

.XXX.
X...X
X...X
X...X
.XXX.

XXXX.
X...X
XXXX.
X....
X....

.XXX.
X...X
X...X
X..XX
.XXXX

XXXX.
X...X
XXXX.
X..X.
X...X

.XXXX
X....
.XXX.
....X
XXXX.

XXXXX
..X..
..X..
..X..
..X..

X...X
X...X
X...X
X...X
.XXX.

X...X
X...X
.X.X.
.X.X.
..X..

X...X
X...X
X.X.X
X.X.X
.X.X.

X...X
.X.X.
..X..
.X.X.
X...X

X...X
.X.X.
..X..
..X..
..X..

XXXXX
...X.
..X..
.X...
XXXXX

स्कोरिंग

यह कोड-गोल्फ है इसलिए बाइट्स जीत में सबसे कम सबमिशन है । एक पूर्ण ब्लॉक ( █) के किसी भी उदाहरण को 3 के बजाए 1 बाइट के रूप में गिना जा सकता है ताकि उपयोग Xकरने वाले को फायदा न हो।

code-golf ascii-art kolmogorov-complexity

— केल्विन के शौक
स्रोत

आप javascript:ASCII कला को यहां पढ़ने के लिए बहुत आसान बनाने के लिए निम्नलिखित जावास्क्रिप्ट स्निपेट ( URL बार में टाइप करके और इसे चिपकाकर) चला सकते हैं $('#question pre').css('line-height',1)। परिणाम: i.stack.imgur.com/XmB8C.png

— दरवाज़े

या उत्तरों को शामिल करने के लिए$('#question pre, .answer pre').css('line-height',1)

— मार्टिन एंडर

मुझे पता है कि इस मजाक को बनाने में थोड़ी देर हो गई है, लेकिन मैं विरोध नहीं कर सका: i.imgur.com/vAZi1Zt.png ।

— एल्गोरिथमशाक

कैसे मैं इस चुनौती को याद किया ?!

— मैजिक ऑक्टोपस Urn

जवाबों:

सीजेएम, 171 165 162 161 बाइट्स

qS/_0=,0a*a\{{W:I;{'[{RI):I=}?i65-"c¿»ÐòO*4Õ]%ÐÎ<Ã IX]{-ïèq=ô}s×o)½2~û³'é¨1ÃlØeúN!Ö3~4ÜË|ÕÇäaepý®"255b2b5/5/=}%z1af*}%R,1a*a*}fR2a*"█ 
"f=

मैं █1 बाइट मान रहा हूं । बाकी सभी वर्ण ASCII सीमा में अच्छी तरह से हैं, इसलिए उन्हें 1 बाइट भी माना जाता है।

आप सटीक कोड के लिए इस पास्टबिन का उपयोग कर सकते हैं

इनपुट के लिए उदाहरण आउटपुट:

FIRST HELLO WORLD

यहाँ छवि विवरण दर्ज करें

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

सबसे पहले

"c¿»ÐòO*4Õ]%ÐÎ<Ã IX]{-ïèq=ô}s×o)½2~û³'é¨1ÃlØeúN!Ö3~4ÜË|ÕÇäaepý®"255b2b5/5/

बस 27 वर्णों ( A-Zऔर स्थान) में से प्रत्येक के लिए पैटर्न है जो 0( Xपदों पर) और 1( .पदों पर) से बना है। डिकोड करने के बाद, यह 5 पंक्तियों के 5 वें और 5 कॉलमों के 2 डी सरणियों का 27 तत्व सरणी देता है Xऔर .प्रत्येक 27 वर्णों के लिए। इस सरणी को हम कहते हैं L।

अब शेष कोड:

qS/                      "Read the input and split it on space to get array Q";
   _0=                   "Get a copy of the first element of the above array";
      ,0a*               "Create an array filled with 0 with length of the first element";
          a\             "Wrap that array in another array and swap to get Q on top";
{  ...  }fR              "This is a for each loop on the array Q with R having the";
                         "current element value in each loop";
 {...}%                  "In the first iteration, the 0 array we created will be the";
                         "only thing on stack, in subsequent iterations, the result";
                         "of previous iteration will be on stack";
  W:I;                   "Initialize variable I with -1";
      {...}%             "Run this block on each element of the current array";
{'[{RI):I=}?i65-L=}%     "This is the above code block. In each iteration, we figure";
                         "out what character needs to be be put at the current index";
                         "Then we get the pattern of 0 and 1 for that character";
 '[{      }?             "Stack contains either 0 or 1. If it is 1, we want to leave";
                         "that index blank, so we put pattern of '[ which is 5X5 spaces";
    RI_:I=               "When we do not want a blank character, we get the next"
                         "character from R to fill the non empty space";
            i65-         "Convert A-Z  to 0-27 notation";
                L=       "Get the corresponding pattern from the pattern array L";
z1af*                    "After the above iterations, for each line of the previous";
                         "iteration's output, we get a vertical 2D array for next";
                         "iteration. We transpose it and join each character in";
                         "this line using a space";
      R,1a*a*            "After getting all lines from current iteration, we join them";
                         "with one full line of space characters";

 2a*                     "After all iterations, we have the 0 1 based 2D array for the";
                         "final output ASCII with each row representing a line. We join";
                         "these lines with 2, to get a 0 1 2 based array";
     "█                  "A brick, a space and a newline. Mapping 1 to 1 with 0 1 2";
"                        "based array";
 f=                      "For each of the 0 1 2 based array element, convert them to";
                         "one of the brick, space and new line character";

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

पायथन 3, 437 बाइट्स

from numpy import*
s=input().split()
d=fromstring('NONO__^Q_PQAQQNONO^_QQQQQ_QQQQAAAQDPIA[SQQQQADQQQJJH_OAQOOY_DPGAUUQOQONDQJUDDDQQQQAAQQDQIAQYQAYIPDQJUJDBQONO_A^Q_NQ_QQNA^QODNDJQD_',byte)[:,None]>>arange(5)&1
b=0
x=1
y=len(s[0])
n=[[1]*y]
for w in s:
 g=n;b+=x;x*=6;n=zeros((x,x*y),int);i=-6
 for q in g:
  o=j=0;i+=6
  for p in q:n[i:i+5,j:j+5]|=d[ord(w[o%len(w)])-65::26]*p;o+=p;j+=6
for r in n[:-b]:print(''.join(' █'[x] for x in r))

चरित्र आकार ASCII में एन्कोड किए गए हैं। प्रत्येक ASCII बाइट एक वर्ण की एक पंक्ति से मेल खाती है, जिसमें बिट्स यूनिट ब्लॉक का प्रतिनिधित्व करते हैं। यह एक बहुत ही कुशल योजना नहीं है, लेकिन प्रत्येक वर्ण के लिए NumPy बिटमास्क में अनपैक करना आसान है।

हम 1s के 2d सरणी के साथ शुरू करते हैं। इसमें प्रत्येक अक्षर के लिए पहला शब्द और एक पंक्ति में एक कॉलम होता है। फिर, प्रत्येक शब्द के लिए, हम पिछले सरणी की तुलना में 0s का एक नया सरणी, छह गुना अधिक और छह गुना चौड़ा बनाते हैं। जहां पिछले सरणी में 1 था, नए सरणी का संबंधित 6x6 खंड उपयुक्त वर्ण के बिटमास्क से भरा हुआ है।

यहाँ एक उदाहरण है (एक बहुत छोटे फ़ॉन्ट के साथ):

यहाँ छवि विवरण दर्ज करें

— gRC
स्रोत

सीजेम, 181 174 170 बाइट्स

उन सभी गैर-एएससीआईआई अक्षर अभी भी विस्तारित एएससीआईआई सीमा के भीतर हैं, इसलिए वे सभी एक ही बाइट में एन्कोड किए जा सकते हैं। (को छोड़कर █, लेकिन उस चुनौती के अनुसार विशेष रूप से व्यवहार किया जाता है।) इसलिए, मैं प्रत्येक चरित्र को एक बाइट के रूप में गिन रहा हूं।

"Á  :½A%õÍú£àËªë8!Õ*j4¶fVËa¡ùÔ¯{+ÛyéâõKn#@?
9Ôia)(Ñç;~LÒª"257b2bYYb" █"er5/5/:L;lS/_0=,'█*a\{f{W:T;\{' ={S5*a5*}{T):T1$='A-L=}?\}%W<zSf*}Sa*}/N*

स्टैक एक्सचेंज ने शायद कुछ अनपेक्षित वर्णों का प्रबंधन किया है, इसलिए आपको कोड कॉपी करना पड़ सकता है इस पास्टबिन से ।

इसका परीक्षण यहां करें।

शब्दों के एक अंतरिक्ष से अलग सूची के रूप में STDIN के माध्यम से इनपुट लेता है। पहला शब्द सबसे बड़ा पैमाना है। उदाहरण के लिए:

HOLISM REDUCTIONISM

पैदावार

████                    █████             ████  █   █  ███              █████                               █████  ███  █   █ █████  ████             █   █ ████  █████ ████        █   █                    ███ 
█   █                   █                 █   █ █   █ █   █               █                                   █   █   █ ██  █   █   █                 ██ ██ █   █ █     █   █       █   █                   █   █
████                    ████              █   █ █   █ █                   █                                   █   █   █ █ █ █   █    ███              █ █ █ ████  ████  █   █       █   █                   █    
█  █                    █                 █   █ █   █ █   █               █                                   █   █   █ █  ██   █       █             █   █ █  █  █     █   █       █   █                   █   █
█   █                   █████             ████   ███   ███                █                                 █████  ███  █   █ █████ ████              █   █ █   █ █████ ████         ███                     ███ 

████                    █████       ████                    █   █        ███                                            █████                   █████                                ███  █   █       █████  ████
█   █                   █           █   █                   █   █       █   █                                             █                       █                                 █   █ ██  █         █   █    
████                    ████        █   █                   █   █       █                                                 █                       █                                 █   █ █ █ █         █    ███ 
█  █                    █           █   █                   █   █       █   █                                             █                       █                                 █   █ █  ██         █       █
█   █                   █████       ████                     ███         ███                                              █                     █████                                ███  █   █       █████ ████ 

████  █████ ████  █   █  ███        █████                   █████        ███                                            █   █                         █████  ████ █   █             ████        █████       ████ 
█   █ █     █   █ █   █ █   █         █                       █         █   █                                           ██  █                           █   █     ██ ██             █   █       █           █   █
████  ████  █   █ █   █ █             █                       █         █   █                                           █ █ █                           █    ███  █ █ █             ████        ████        █   █
█  █  █     █   █ █   █ █   █         █                       █         █   █                                           █  ██                           █       █ █   █             █  █        █           █   █
█   █ █████ ████   ███   ███          █                     █████        ███                                            █   █                         █████ ████  █   █             █   █       █████       ████ 

████                    █████       ████                    █   █        ███                                            █████                                           █████        ███                    █   █
█   █                   █           █   █                   █   █       █   █                                             █                                               █         █   █                   ██  █
████                    ████        █   █                   █   █       █                                                 █                                               █         █   █                   █ █ █
█  █                    █           █   █                   █   █       █   █                                             █                                               █         █   █                   █  ██
█   █                   █████       ████                     ███         ███                                              █                                             █████        ███                    █   █

████                    █████             ████  █   █  ███              █████ █████  ███  █   █ █████        ████ █   █ ████  █████ ████        █   █  ███  █████ █████              ███                    █   █
█   █                   █                 █   █ █   █ █   █               █     █   █   █ ██  █   █         █     ██ ██ █   █ █     █   █       █   █ █   █   █     █               █   █                   ██  █
████                    ████              █   █ █   █ █                   █     █   █   █ █ █ █   █          ███  █ █ █ ████  ████  █   █       █   █ █       █     █               █   █                   █ █ █
█  █                    █                 █   █ █   █ █   █               █     █   █   █ █  ██   █             █ █   █ █  █  █     █   █       █   █ █   █   █     █               █   █                   █  ██
█   █                   █████             ████   ███   ███                █   █████  ███  █   █ █████       ████  █   █ █   █ █████ ████         ███   ███    █   █████              ███                    █   █

व्याख्या

सबसे पहले, हम पत्र आकृतियों के लिए एक लुकअप तालिका संग्रहीत करते हैं L:

"Á  :½A%õÍú£àËªë8!Õ*j4¶fVËa¡ùÔ¯{+ÛyéâõKn#@?
9Ôia)(Ñç;~LÒª"257b2bYYb" █"er5/5/:L;

पहली स्ट्रिंग सिर्फ एक संपीड़ित संख्या है। हम कोड बिंदुओं को आधार -257 अंकों के रूप में मानते हैं, फिर हम परिणामी संख्या को द्विआधारी में बदलते हैं। YYb2 बेस 2 में है, इसलिए यह देता है [1 0]। हम तत्व प्रतिस्थापन का उपयोग करते हैं" █" अंकों को स्थान और ब्लॉक वर्णों में बदलने के लिए करते हैं। अंत में, हम स्ट्रिंग को 5 वर्णों की पंक्तियों में विभाजित करते हैं, और फिर से 5 पंक्तियों के ब्लॉक में। परिणाम Lस्टैक से संग्रहीत और खारिज किया जाता है।

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

lS/_0=,'█*a\
lS/          "Read input, split on spaces.";
   _0=       "Duplicate and get first word.";
      ,'█*   "Get length repeat █ that many times.";
          a  "Wrap in array, to make the grid two-dimensional.";
           \ "Swap with word list.";

आइए पहले शेष कार्यक्रम की सबसे बाहरी संरचना को देखें। अगला ब्लॉक {...}/हर शब्द के लिए चलाया जाता है, और ब्लॉक के प्रत्येक अक्षर को विस्तारित करता है।

{f{...}Sa*}/N*
{         }/   "Process each word in the input.";
 f{...}        "Map this block onto each line of the grid, passing in the current word as well.";
       Sa*     "Since each original line will be turned into 5 lines, the grid is still grouped
                into blocks of 5 lines. We join them together with empty lines as required.";
            N* "Join all lines together with newlines.";

अंत में, आइए देखें कि एक पंक्ति का विस्तार कैसे किया जाता है:

W:T;\{' ={S5*a5*}{T):T1$='A-L=}?\}%
W:T;                                "Store -1 in T.";
    \                               "Swap word with line.";
     {                           }% "Map this block onto each character.";
      ' =                           "Check if the character is a space.";
         {      }{            }?    "If it is, run the first block, otherwise the second.";
          S5*                       "Create a string of five spaces.";
             a5*                    "Create an array of five such strings.";
                  T):T              "Push T, increment, store in T.";
                      1$=           "Copy the word and access the T'th character, cyclically.";
                         'A-        "Subtract A from the letter.";
                            L=      "Use the result to get the character shape from L.";
                                \   "Swap resulting block with word.";

"At this point each character is replaced with a 5x5 array of new characters.
 So we actually have a 3D array right now. Since we used a map operation, the
 current word will also be at the end of the array, which we need to get rid off.";

W<zSf*
W<     "Discard last array element - the current word.";
  z    "Zip or transpose the top two levels of the array.";
   Sf* "Join each line together with spaces.";

परिणाम कार्यक्रम के अंत में स्वचालित रूप से मुद्रित होता है।

— मार्टिन एंडर
स्रोत