শব্দের মধ্যে শব্দের মধ্যে শব্দের মধ্যে শব্দ। । ।

বর্ণমালার বড় হাতের অক্ষরের এই পিক্সिलेটেড ফন্টে, সমস্ত অক্ষর 5 ইউনিট প্রস্থ এবং 5 লম্বা।

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

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

বর্ণগুলির মধ্যে এবং লাইনের মধ্যে স্থানটিরও 1 ইউনিট রয়েছে, যেমনটি দেখা যায়। সুতরাং প্রতিটি অক্ষর স্থান 6 × 6 ইউনিট নিতে পারে।

মনে করুন যে অক্ষরগুলির█ আকারটি সরাসরি গঠনের জন্য পূর্ণ ব্লক অক্ষর ( ) ব্যবহার করার পরিবর্তে আমরা একই ফন্টে অন্য বর্ণগুলি ব্যবহার করতে চেয়েছিলাম । এর মধ্যে পাঠ্যের 6-ভাড়ার মাত্রা বৃদ্ধি করা জড়িত যাতে পূর্ণ-ব্লকের তৈরি বর্ণগুলি বৃহত্তর পাঠ্যে পূর্ণ-ব্লক প্রতিস্থাপন হিসাবে ব্যবহার করতে পারে।

যদি তা বোঝা যায় না তবে আশা করি এই উদাহরণটি আসবে। পিক্সেলিটেড ফন্ট ব্যবহার করে এখানে বি এর তৈরি একটি রয়েছে:

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

বি সম্পূর্ণ ব্লক এবং এ বি দ্বারা তৈরি করা হয়। লক্ষ্য করুন যে বি এর এখনও অনুভূমিকভাবে এবং উল্লম্বভাবে তাদের মধ্যে একটি ইউনিট রয়েছে।

আমরা কেবল অক্ষরের পরিবর্তে শব্দ ব্যবহার করে এই ধারণাটি প্রসারিত করতে পারি। এখানে "জল" "" আগুন "দিয়ে তৈরি করা হয়েছে:

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

প্রতিটি লাইনে "আগুন" কীভাবে বারবার প্রদর্শিত হয় তা লক্ষ্য করুন এবং সর্বদা ক্রমে অক্ষরের মাঝে কতটা জায়গা থাকে তা বিবেচনা করে না। "জল" এর অক্ষরগুলি কীভাবে আকারিত হয় তার কারণে "আগুন" এর তিনটি ডান দৃষ্টান্ত তাড়াতাড়ি কেটে যায়।

এই ধারণা এই ব্যবহার করে এমনকি আরও সম্প্রসারিত করা যেতে পারে, শব্দ দিয়ে তৈরি শব্দের করতে শব্দ দিয়ে তৈরি শব্দের তৈরি শব্দ , অথবা এমনকি শব্দ দিয়ে তৈরি শব্দের তৈরি শব্দ দিয়ে তৈরি শব্দের । তাত্ত্বিকভাবে কোনও সীমা নেই।

আর একটি উদাহরণ এই পোস্টটিকে 30 কে অক্ষরের সীমা ছাড়িয়ে যাবে, তবে আপনি এই নিফটি স্ট্যাক স্নিপেট চালিয়ে "শব্দ দিয়ে তৈরি শব্দ" বলতে কী বোঝায় তা আপনি দেখতে পাচ্ছেন। পরামিতিগুলি কেবল তাদের ডিফল্টে রেখে "যান!" টিপুন। "মাউস" শব্দটি দিয়ে তৈরি "ক্যাট" শব্দের দ্বারা তৈরি "ডিওজি" শব্দটি দেখতে পাওয়া উচিত।

কোড স্নিপেট দেখান

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>

স্নিপেট প্রসারিত করুন

কেবলমাত্র মূল অক্ষরযুক্ত শব্দের কোনও স্থান পৃথকীকরণের তালিকা টাইপ করুন বাক্সে বর্ণযুক্ত করলে তৃতীয় শব্দটির তৈরি দ্বিতীয় শব্দটি তৈরি করা হবে, চতুর্থটি দিয়ে তৈরি, ... ইত্যাদি দিয়ে তৈরি করা হবে word

সতর্কতা: 4 বা 3 টিরও বেশি শব্দের প্রবেশ করিয়ে প্রচুর পাঠ্য উত্পন্ন হবে এবং দীর্ঘ সময় নিবে। এটি আপনার ব্রাউজার / কম্পিউটার / গাড়ি ক্র্যাশ করতে পারে।

চ্যালেঞ্জ

এই চ্যালেঞ্জটির লক্ষ্য হ'ল স্ট্যাক স্নিপেট অল্প সংখ্যক চরিত্রের মধ্যে কী করে mirror

আপনাকে অবশ্যই এমন একটি প্রোগ্রাম লিখতে হবে যা কেবলমাত্র মূল অক্ষরযুক্ত শব্দের একটি স্পেস বিভাজনযুক্ত স্ট্রিংয়ের মধ্যে নেবে এবং উপরের পিক্সिलेটেড ফন্ট ব্যবহার করে প্রথম শব্দটি "দ্বিতীয়" দিয়ে তৈরি "দ্বিতীয়" তৈরি করবে on

"প্লেন এএসসিআইআই" চেকবক্স এবং স্নিপেটের ফন্ট আকারের বৈশিষ্ট্যগুলি আপনার প্রোগ্রামটিতে সমর্থন করার প্রয়োজন নেই। শব্দের তালিকা থেকে শব্দের দ্বারা তৈরি শব্দগুলিতে রূপান্তরকে মিরর করা মূল বিষয় এবং একমাত্র প্রয়োজন।

বিস্তারিত

ইনপুটটি স্ট্যান্ডিন, কমান্ড লাইন থেকে আসা উচিত, অথবা আপনি কেবল একটি ফাংশন লিখতে পারেন যা স্ট্রিং নেয়।
আপনি ধরে নিতে পারেন ইনপুটটি সর্বদা বৈধ, অর্থাত্ বড় বড় অক্ষর দিয়ে তৈরি শব্দের একটি স্ট্রিং, ঠিক কোনও স্থান দ্বারা আলাদা, কোনও শীর্ষস্থানীয় বা অনুসরণযোগ্য স্থান নেই।
আউটপুট স্টাডাউট (বা অনুরূপ বিকল্প) বা আপনার পছন্দের নাম সহ কোনও ফাইলে যেতে হবে।
আউটপুটে পুরোপুরি খালি স্থানের অক্ষর , পূর্ণ স্থানের অক্ষর এবং নিউলাইনগুলি থাকা উচিত।
- খালি / সম্পূর্ণ-স্পেস অক্ষরের পারেন স্থান এবং সম্পূর্ণ ব্লক (হওয়া উচিত , █) যথাক্রমে বা সময়সীমা এবং এক্স ( ., 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..
```
কেবল শূন্য-স্থানের অক্ষর বিশিষ্ট কোনও শীর্ষস্থানীয় বা চলমান সারি থাকা উচিত না । একটি একক পেছনের নতুন লাইন optionচ্ছিকভাবে অনুমোদিত।

এখানে হরফের আরও একটি স্ট্রিং-বান্ধব সংস্করণ রয়েছে:

.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

— Doorknob

অথবা উত্তরগুলি অন্তর্ভুক্ত করার জন্য$('#question pre, .answer pre').css('line-height',1)

— মার্টিন এেন্ডার

আমি জানি এই রসিকতাটি করতে একটু দেরি হয়েছে, তবে আমি প্রতিরোধ করতে পারিনি: i.imgur.com/vAZi1Zt.png ।

— অ্যালগরিদমশার্ক

আমি কীভাবে এই চ্যালেঞ্জটি মিস করেছি ?!

— ম্যাজিক অক্টোপাস উর্ন

উত্তর:

সিজেম, 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 টি কলামের প্রতিনিধিত্ব করে Xএবং .27 টি অক্ষরের প্রত্যেকটির জন্য 2 ডি অ্যারের অ্যারে দেয় । আসুন এই অ্যারে হিসাবে কল করুন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 বাইট এক অক্ষরের এক সারিতে অনুরূপ, বিটগুলি ইউনিট ব্লকগুলি উপস্থাপন করে। এটি খুব দক্ষ স্কিম নয়, তবে প্রতিটি চরিত্রের জন্য নম্পপি বিটমাস্কে আনপ্যাক করা সহজ।

আমরা 1 এস এর 2 ডি অ্যারে দিয়ে শুরু করি। এটিতে প্রথম শব্দের প্রতিটি অক্ষরের জন্য একটি কলাম এবং একক সারিতে রয়েছে। তারপরে, প্রতিটি শব্দের জন্য আমরা 0 এর একটি নতুন অ্যারে তৈরি করব যা পূর্ববর্তী অ্যারের চেয়ে ছয়গুণ বেশি এবং ছয়গুণ প্রশস্ত। পূর্ববর্তী অ্যারেটিতে যেখানে 1 ছিল সেখানে নতুন অ্যারের সাথে সম্পর্কিত 6x6 বিভাগটি যথাযথ অক্ষরের বিটমাস্কে পূর্ণ।

এখানে একটি উদাহরণ (অত্যন্ত ছোট ফন্ট সহ):

এখানে চিত্র বর্ণনা লিখুন

— GRC
সূত্র

সিজেম, 181 174 170 বাইট

All সমস্ত ASCII নয় এমন অক্ষরগুলি এখনও বর্ধিত ASCII সীমার মধ্যে রয়েছে, সুতরাং সেগুলি সমস্ত একক বাইটে এনকোড করা যায়। (বাদে █, তবে সেটিকে চ্যালেঞ্জের অনুমান অনুসারে বিশেষভাবে বিবেচনা করা হয়)) সুতরাং, আমি প্রতিটি চরিত্রকে বাইট হিসাবে গণনা করছি counting

"Á  :½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;

প্রথম স্ট্রিংটি কেবল একটি সংকুচিত সংখ্যা। আমরা কোড পয়েন্টগুলিকে বেস -২7 digit সংখ্যা হিসাবে বিবেচনা করি, তারপরে আমরা ফলাফলের সংখ্যাটি বাইনারিতে রূপান্তর করি। 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.";

ফলাফলটি প্রোগ্রামের শেষে স্বয়ংক্রিয়ভাবে মুদ্রিত হয়।

— মার্টিন ইন্ডার
সূত্র