Натхненний Гольфом мене алфавітом ASCII , від якого ця проблема (майже) пряма обернена.

Завдання:

Візьміть рядок тексту тексту ASCII та виведіть вміст тексту як звичайний текст ASCII.

Вхід:

Рядок тексту мистецтва ASCII.

Вхід буде містити лише екземпляри символів ASCII #, пробіли та 4 або 5 нових рядків (останній новий рядок необов’язковий). Всі лінії мають однакову довжину. (Тобто, останній лист ASCII-аркуша прокладений пробілами.) #Якщо ви хочете, ви можете використати інший друкований символ ASCII замість введення.

Вхід буде містити букви A-ZASCII-мистецтва та пробіли ASCII (пробіл 5x5). Без розділових знаків. Є лише один рядок тексту тексту ASCII (5 фактичних рядків). Не буде ніяких кінцевих або провідних просторів мистецтва ASCII, а також не буде сусідніх просторів мистецтва ASCII.

Розмір букви - 5x5 символів. Між кожною буквою є пробіл 1x5. Пробіл між словами - це 5x5 пробілів (+ 1x5 пробіл з кожної сторони, тому що це просто інша літера). У кінці або на початку не буде пробілу 1x5, лише між літерами ASCII.

Вихід:

Рядок, що містить текст у вигляді символів ASCII A-Z+ пробіли. Вихід може бути і малим, якщо це якось простіше для вашого рішення. Також дозволено змішаний корпус.

Літери ASCII:

 ###  ####   ###  ####  ##### #####  ###  #   # ##### ##### #   # #     #   #
#   # #   # #   # #   # #     #     #     #   #   #     #   #  #  #     ## ##
##### ####  #     #   # ####  ####  #  ## #####   #     #   ###   #     # # #
#   # #   # #   # #   # #     #     #   # #   #   #   # #   #  #  #     #   #
#   # ####   ###  ####  ##### #      ###  #   # ##### ###   #   # ##### #   #

#   #  ###  ####   ###  ####   ###  ##### #   # #   # #   # #   # #   # #####
##  # #   # #   # #   # #   # #       #   #   # #   # #   #  # #   # #     # 
# # # #   # ####  #   # ####   ###    #   #   #  # #  # # #   #     #     #  
#  ## #   # #     #  #  #   #     #   #   #   #  # #  ## ##  # #    #    #   
#   #  ###  #      ## # #   #  ###    #    ###    #   #   # #   #   #   #####

Простір:

     |
     | A 5x5 square of spaces.
     | (Padded with |s to make it appear in this post.)
     |
     |

Приклади:

Вхід:

#   # ##### #     #      ###        #   #  ###  ####  #     #### 
#   # #     #     #     #   #       #   # #   # #   # #     #   #
##### ####  #     #     #   #       # # # #   # ####  #     #   #
#   # #     #     #     #   #       ## ## #   # #   # #     #   #
#   # ##### ##### #####  ###        #   #  ###  #   # ##### #### 

Вихід: HELLO WORLD

Вхід:

 ###   ###   ###  ##### #####
#   # #     #   #   #     #  
#####  ###  #       #     #  
#   #     # #   #   #     #  
#   #  ###   ###  ##### #####

Вихід: ASCII

Вхід:

####  ####   ###   ### 
#   # #   # #   # #    
####  ####  #     #  ##
#     #     #   # #   #
#     #      ###   ### 

Вихід: PPCG

Це код-гольф , тому найкоротша відповідь у байтах виграє.

Желе ,  50 44  42 байт

ỴZ;6/UOḂḅ7‘ị“¥ŒƲVĊ⁾|W£⁼³ƭÇuʋụzḢĖ0ḢẆẠØsĠỌỊ»

Спробуйте в Інтернеті! (зверніть увагу на те, що аргумент не вимагає провідного нового рядка, але оскільки провідні та зворотні нові рядки не впливають, я включив один, щоб зробити рядок багаторядкових більш зрозумілим для людини)

Результати - це змішаний випадок (як дозволено ОП у коментарі ).

Як?

Розділяє на нові рядки, переміщує і з'єднує разом підрізки (до) шести разом, щоб отримати представлення символів і перевернути їх (прирівнюючи пізніше базове перетворення для кінцевого символу довжиною 25 до всіх інших довжиною 30). Тоді відображаємо '#'і ' 'до одного, і до нуля відповідно, використовуючи те, що'#' має непарний порядковий час, а ' 'має парний. Читає кожен так, ніби це було базове сім число. Ефективно приймає модуль 81 кожного (щоб отримати 27 унікальних значень для 27 можливих випадків) і, нарешті, індексує у "магічну рядок" з правильними символами у правильних індексах (модульне індексування використовується з чарівним рядком довжиною 81 для збереження 2 байти).

Ось "магічний рядок", який я створив разом із (нечутливим до регістру) схемою регулярних виразів, яким він повинен був відповідати (я додав "ed", щоб зробити його довжиною 81):

 ' affectedly Azerbaijan rewaxed naganas jiujitsudankly pase UVB freqHaarlemcoacted'
'^ ..f...e.....z......a..r.w.x...n.g......iuj....d..kly.p.s...vb....qh.....m.o.ct.*'

Як такий, він може бути стиснутий, шукаючи одинадцять підрозрізів як слова в словнику Jelly (більшість з яких використовують провідний пробіл за замовчуванням):

' affectedly Azerbaijan rewaxed naganas jiujitsudankly pase UVB freqHaarlemcoacted'
 ^          ^          ^       ^       ^        ^     ^    ^   ^    ^      ^

в результаті чого стискається рядок з желе, “¥ŒƲVĊ⁾|W£⁼³ƭÇuʋụzḢĖ0ḢẆẠØsĠỌỊ»

Решта коду працює наступним чином:

ỴZ;6/UOḂḅ7‘ị“...» - Main link: multi-line string, s   e.g. HI as the #s and spaces
Ỵ                 - split on new lines                     ["#   # #####","#   #   #  ","#####   #  ","#   #   #  ","#   # #####"] (each is actually a list)
 Z                - transpose                              ["#####","  #  ","  #  ","  #  ","#####","     ","#   #","#   #","#####","#   #","#   #"] (each is actually a list)
   6/             - six-wise reduce by
  ;               -     concatenation                      ["#####  #    #    #  #####     ","#   ##   #######   ##   #"] (each is actually a list)
     U            - upend (reverse each)                   ["     #####  #    #    #  #####","#   ##   #######   ##   #"] (each is actually a list)
                  -     note: all except the last will be length 30 and like "     ...", which will become [0,0,0,0,0,...], while the last will be length 25 without those five leading zeros.
      O           - cast to ordinals ('#' -> 35, ' '-> 32) [[32,32,...],[35,32,...]]
       Ḃ          - modulo 2 ('#' -> 1, ' ' -> 0)          [000001111100100001000010011111, 1000110001111111000110001] (each is actually a list)
        ḅ7        - convert from base 7 (vectorises)       [223498370543967315553, 191672428080864454753] (these are now integers)
          ‘       - increment                              [223498370543967315554, 191672428080864454754]
                  -  (modulo 81 these would be [68, 41])
           ị      - index into (modulo & 1-indexed):                        
            “...» -     the "magic string" described above ' affectedly Azerbaijan rewaxed naganas jiujitsudankly pase UVB freqHaarlemcoacted'
                                                           "Hi"                                   41^                        68^

Пітон 2 , 405 335 234 182 171 байт

lambda s,j=''.join:j(' QPVXU_O__FBLK_JMD_CSYZWIENH_AG___TR'[int(j(`ord(y)%2`for y in j(s.split('\n')[x][i:i+5]for x in range(5))),2)%13836%37]for i in range(0,len(s)/5,6))

Спробуйте в Інтернеті!

Нарешті коротший за JS

JavaScript (ES6), 204 186 184 182 байт

Збережено 18 байт завдяки Нілу
Збережено 2 байти завдяки ETHproductions
Збережено 2 байти завдяки YairRand

Зламатися:

• 42-байтова таблиця пошуку
• 162 144 142 142 140 байт коду

s=>(a=s.split`
`)[0].replace(/.{6}/g,(_,n)=>' H_JM__WDCSORLU___QKG_P_AFT_N_EI_XBV____YZ'[[0,1,2,4].reduce((p,r,i)=>p+='0b'+a[r].substr(n,5).replace(/./g,c=>1^1-c)<<i*6,0)%178%69%43])

Демо

let f =

s=>(a=s.split`
`)[0].replace(/.{6}/g,(_,n)=>' H_JM__WDCSORLU___QKG_P_AFT_N_EI_XBV____YZ'[[0,1,2,4].reduce((p,r,i)=>p+='0b'+a[r].substr(n,5).replace(/./g,c=>1^1-c)<<i*6,0)%178%69%43])

console.log(f(
  ' ###   ###   ###  ##### ##### \n'+
  '#   # #     #   #   #     #   \n'+
  '#####  ###  #       #     #   \n'+
  '#   #     # #   #   #     #   \n'+
  '#   #  ###   ###  ##### ##### \n'
));

Bash + ImageMagick + Tesseract , 161 байт

Я хотів спробувати підхід, запропонований @ stewie-griffin, і пішов на bash + ImageMagick (для перетворення рядка в зображення) та Tesseract (зробити OCR). Ось мій код, який працює для тесту "HELLO WORLD", але не дає інших. Можливо, допоможе налаштування параметрів (шрифту, розміру шрифту, кернінгу, інтервалу).

convert -font Courier-Bold -pointsize 8 -interline-spacing -3 -kerning -3 label:"$(</dev/stdin)" -bordercolor White -border 5%x20% png:- | tesseract stdin stdout

Просто скопіюйте та вставте мистецтво ascii в командний рядок після запуску команди. Закінчіть введення, натиснувши ^ d.

Поточний вихід для тестових випадків:

• Хелло Світ: Хелло Світ
• ASCII: H5511
• PPCG: PPOG

Скала, 184 181 байт

Чарівна струна + модульне рішення на основі hashCode:)

(a:String)=>a.split("\n").map(_.grouped(6)map(_.take(5))toArray).transpose.map(l=>"Q__WLUY_XOI_ZN_GEFR_P__JKBMV_S__ __C__D__H_T__A"(Math.abs(l.mkString.hashCode)%106%79%47))mkString

Спробуйте в Інтернеті (Scalafiddle)

Більш зрозумілі:

(a:String) => a.split("\n")
                .map(_.grouped(6)map(_.take(5))toArray)
                .transpose
                .map ( l => 
                    "Q__WLUY_XOI_ZN_GEFR_P__JKBMV_S__ __C__D__H_T__A"(
                        Math.abs(l.mkString.hashCode)%106%79%47
                    )
                )mkString

Пояснення

• Початковий рядок (арт. ASCII) розділений на 5 рядків (висота символу ASCII)
• Кожен рядок розділений на 6 символів (ширина символу ASCII + 1 пробіл)
• Зберігається лише перші 5 символів (пробіл в кінці марний)
• Рядки переносяться (кожен символ ASCII представлений у вигляді послідовності з 25 символів (5x5), що містить або '#'або ' ')
• Кожне представлення символів ASCII (послідовність) перетворюється на String і для цієї рядка обчислюється абсолютний хеш-код (абсолютний необхідний через наступний модуль)
• 3 послідовних модуля ( % 106 % 79 % 47) застосовуються для асоціації числа ∈ [0; 47[для кожного символу ASCII (див. Пояснення нижче)
• Це число використовується як індекс магічного рядка

Як дістати чарівну струну?

По-перше, я представляв усі такі букви:

case class Letter(letter: Char, ascii: Seq[Char])

Потім я створив алфавіт, що містить представлення ASCII усіх символів:

Приклад:

 ### 
#   #  
#####  
#   #  
#   #

стає

Letter('A', " ### #   #######   ##   #") // 25 characters from top-left to bottom-right

Для кожної літери було обчислено абсолютний хеш-код (усі хеш-коди виразні):

val codes = alphabet.map { case Letter(l, a) => (l, Math.abs(a.mkString.hashCode)) }
// codes: Seq[(Char, Int)] = List(( ,253243360), (A,380997542), (B,1221679148), (C,1573119535), (D,307929190), (E,858088672), (F,857996320), (G,750155628), (H,897290147), (I,1518088099), (J,928547488), (K,1184149391), (L,519601059), (M,741735953), (N,2139154001), (O,1625960980), (P,1307658950), (Q,92382816), (R,1221771494), (S,1689301359), (T,1515228067), (U,1390718627), (V,386730851), (W,733134481), (X,628338619), (Y,23919695), (Z,2081560145))

Потім я намагався зменшити кожен код, але завжди поважаючи той факт, що кожен код повинен бути унікальним (список, згрупований за кодом, повинен містити 27 елементів, по 1 на кожну букву). Тому я спробував перший модуль 200:

val mod = (1 to 200).find(modulo => codes.map { case (a,b) => (a, b % modulo) }.groupBy(_._2).size==27).get

Я визнав 106першим застосованим модуль:

val codes2 = codes.map { case (l, c) => (l, c%mod) }
val codes = codes2
// codes: Seq[(Char, Int)] = List(( ,32), (A,46), (B,104), (C,35), (D,38), (E,16), (F,96), (G,94), (H,41), (I,89), (J,102), (K,71), (L,83), (M,105), (N,13), (O,56), (P,20), (Q,0), (R,18), (S,29), (T,43), (U,5), (V,27), (W,3), (X,87), (Y,53), (Z,91))

Я повторював попередні кроки до найменшого модуля. Я знайшов :

• 79
• 47
• 44
• 42

Примітка: останній модуль, який я вибрав ( 47), тут не найменший:

• Я знайшов 44, але якби я вибрав 44, магічна рядок мала б розмір 44 (замість 47), але мені доведеться писати %106%79%47%44(13 символів замість%106%79%47 = 10 символів). Отже, в байтах код повинен був мати той самий розмір, як і той, який я отримав
• Також є 42, але тоді код повинен був на 1 байт більше, ніж я отримав

Далі я застосував послідовний модуль ( % 79 % 47) до останнього codes, щоб отримати остаточні коди, пов'язані з кожною буквою:

codes: Seq[(Char, Int)] = List(( ,32), (A,46), (B,25), (C,35), (D,38), (E,16), (F,17), (G,15), (H,41), (I,10), (J,23), (K,24), (L,4), (M,26), (N,13), (O,9), (P,20), (Q,0), (R,18), (S,29), (T,43), (U,5), (V,27), (W,3), (X,8), (Y,6), (Z,12))

Нарешті, щоб побудувати магічну струну:

val initialMap = (0 until 47).map(i => (i, '_')).toMap
val codesMap = codes.map(i => (i._2, i._1)).toMap

val magicString = (initialMap ++ codesMap).toSeq.sortBy(_._1).map(_._2).mkString
// magicString: String "Q__WLUY_XOI_ZN_GEFR_P__JKBMV_S__ __C__D__H_T__A"

Приклад: Літера Aвище пов'язана з 46 ( 380997542 % 106 % 79 % 47), а 46-й елемент магічної струни - A :)

Тестові справи

// assign function to f
val f = (a:String)=>a.split("\n").map(_.grouped(6)map(_.take(5))toArray).transpose.map(l=>"Q__WLUY_XOI_ZN_GEFR_P__JKBMV_S__ __C__D__H_T__A"(Math.abs(l.mkString.hashCode)%106%79%47))mkString

ПРИВІТ СВІТ :

val asciiArt = """|#   # ##### #     #      ###        #   #  ###  ####  #     #### 
                  |#   # #     #     #     #   #       #   # #   # #   # #     #   #
                  |##### ####  #     #     #   #       # # # #   # ####  #     #   #
                  |#   # #     #     #     #   #       ## ## #   # #   # #     #   #
                  |#   # ##### ##### #####  ###        #   #  ###  #   # ##### #### """.stripMargin

f(asciiArt)    // HELLO WORLD

ASCII:

val asciiArt = """| ###   ###   ###  ##### #####
                  |#   # #     #   #   #     #  
                  |#####  ###  #       #     #  
                  |#   #     # #   #   #     #  
                  |#   #  ###   ###  ##### #####""".stripMargin

f(asciiArt)    // ASCII

PPCG:

val asciiArt = """|####  ####   ###   ### 
                  |#   # #   # #   # #    
                  |####  ####  #     #  ##
                  |#     #     #   # #   #
                  |#     #      ###   ### """.stripMargin

f(asciiArt)    // PPCG

Правки

• Збережено 3 байти, видаливши .раніше map, toArrayіmkString

PHP, 294 байт

<?$l=" 00000YE00G0000R000A0Q0000C0BW000K00000000000LT00000J00000000MU0000Z0000DI000000V0000000P00H0000ONF000S00X";preg_match_all("#(.{5})\s#s","$_GET[0] ",$t);for($i=0;$i<$c=count($a=$t[1])/5;$i++)$s.=$l[bindec(strtr($a[$i].$a[$i+$c].$a[$i+2*$c].$a[$i+3*$c].$a[$i+4*$c]," #","01"))%106];echo$s;

Спробуйте в Інтернеті!

Розширено

$l=" 00000YE00G0000R000A0Q0000C0BW000K00000000000LT00000J00000000MU0000Z0000DI000000V0000000P00H0000ONF000S00X"; # search string mod 106
preg_match_all("#(.{5})\s#s","$_GET[0] ",$t); # Regex take each group of five chars followed by a whitespace
for($i=0;$i<$c=count($a=$t[1])/5;$i++)
  $s.=$l[bindec(strtr($a[$i].$a[$i+$c].$a[$i+2*$c].$a[$i+3*$c].$a[$i+4*$c]," #","01"))%106]; # join each groups make a binaray make a decimal mod 106  
echo$s; # Output

Перетворення вводу у формат зображення

@Stevie Griffin шукайте рішення, щоб отримати це з зображення. Я думаю, що він не дуже хоче використовувати формат зображення, яким я користуюся.

echo'<svg xmlns="http://www.w3.org/2000/svg" width="100%"><switch><foreignObject x="0" y="0" width="100%" height="300"><body xmlns="http://www.w3.org/1999/xhtml"><pre>'.$_GET[0].'</pre></body></foreignObject></switch></svg>';

SVG може містити частини HTML, якщо потім їх включити в закордонний об'єкт. Тому я помістив попередній елемент у SVG.

Вихід зображення

<svg xmlns="http://www.w3.org/2000/svg" width="100%"><switch><foreignObject x="0" y="0" width="100%" height="300"><body xmlns="http://www.w3.org/1999/xhtml"><pre>#   # ##### #     #      ###        #   #  ###  ####  #     #### 
#   # #     #     #     #   #       #   # #   # #   # #     #   #
##### ####  #     #     #   #       # # # #   # ####  #     #   #
#   # #     #     #     #   #       ## ## #   # #   # #     #   #
#   # ##### ##### #####  ###        #   #  ###  #   # ##### #### </pre></body></foreignObject></switch></svg>

Вирішення із змін зображення

SVG є машиночитаному так що після збереження SVG , як «i.svg» вам потрібно тільки замінити $_GET[0]з preg_replace("#(^.*e>)(.*)(</p.*$)#s","$2",join(file("i.svg")))на шляху з нормальними вхідними + 55 байт

Powershell, 152 146 байт

-join$(for($t=$args-split'
';$c-lt$t[0].Length;$c+=6){$s=0;$t|% s*g $c,5|% t*y|%{$s+=$s+$_}
'_ISRJ_BK_HFQPL_MYNCE _TXDAO_VWUZ__G'[$s%578%174%36]})

Тестовий сценарій:

$f = {

-join$(for($t=$args-split'
';$c-lt$t[0].Length;$c+=6){$s=0;$t|% s*g $c,5|% t*y|%{$s+=$s+$_}
'_ISRJ_BK_HFQPL_MYNCE _TXDAO_VWUZ__G'[$s%578%174%36]})

}

&$f @"
#   # ##### #     #      ###        #   #  ###  ####  #     #### 
#   # #     #     #     #   #       #   # #   # #   # #     #   #
##### ####  #     #     #   #       # # # #   # ####  #     #   #
#   # #     #     #     #   #       ## ## #   # #   # #     #   #
#   # ##### ##### #####  ###        #   #  ###  #   # ##### #### 
"@

&$f @"
 ###   ###   ###  ##### #####
#   # #     #   #   #     #  
#####  ###  #       #     #  
#   #     # #   #   #     #  
#   #  ###   ###  ##### #####
"@

&$f @"
####  ####   ###   ### 
#   # #   # #   # #    
####  ####  #     #  ##
#     #     #   # #   #
#     #      ###   ### 
"@

&$f @"
       ###  ####   ###  ####  ##### #####  ###  #   # ##### ##### #   # #     #   # #   #  ###  ####   ###  ####   ###  ##### #   # #   # #   # #   # #   # #####
      #   # #   # #   # #   # #     #     #     #   #   #     #   #  #  #     ## ## ##  # #   # #   # #   # #   # #       #   #   # #   # #   #  # #   # #     # 
      ##### ####  #     #   # ####  ####  #  ## #####   #     #   ###   #     # # # # # # #   # ####  #   # ####   ###    #   #   #  # #  # # #   #     #     #  
      #   # #   # #   # #   # #     #     #   # #   #   #   # #   #  #  #     #   # #  ## #   # #     #  #  #   #     #   #   #   #  # #  ## ##  # #    #    #   
      #   # ####   ###  ####  ##### #      ###  #   # ##### ###   #   # ##### #   # #   #  ###  #      ## # #   #  ###    #    ###    #   #   # #   #   #   #####
"@

Вихід:

HELLO WORLD
ASCII
PPCG
 ABCDEFGHIJKLMNOPQRSTUVWXYZ

Примітка:

1. $t|% s*g $c,5|% t*y|%{$s+=$s+$_} це ярлик для $t.substring($c,5).toCharArray()|%{$s+=$s+$_}
2. ("abcd","efgh").substring(1,2) повертає масив ("bc","de")
3. ("bc","de").toCharArray() повертає масив ('b','c','d','e')

C,  225  209 байт

Дякуємо @ceilingcat за економію 16 байт!

i,j,k,l,n,m;f(char*s){l=index(s,10)-s+1;for(i=0;i<l/6;++i){for(m=j=0;j<5;m+=n*(exp10(j++)+.1))for(n=k=0;k<5;)n+=(s[i*6+j+k*l]==35)<<k++;for(j=0;"Qi Y$>W);Xa%d^F4K-]7jcMAG="[j++]-32-m%77;);putchar(n?64+j:32);}}

Спробуйте в Інтернеті!