Вдохновленный Гольфом мне алфавит ASCII , этот вызов (почти) является прямым обратным.

Задача:

Возьмите строку текста ASCII-art и выведите содержимое текста в виде обычного текста ASCII.

Входные данные:

Строка ASCII-арт текста.

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

Входные данные будут содержать буквы A-ZASCII-art и пробелы ASCII-art (блок пробелов 5x5). Без знаков препинания. Есть только одна строка текста ASCII-art (5 фактических строк). Здесь не будет ни конечных, ни ведущих ASCII-арт-пространств, ни смежных ASCII-арт-пространств.

Размер письма 5х5 символов. Между буквами 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^

Python 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 байтов благодаря Neil
Сохранено 2 байта благодаря ETHproductions
Сохранено 2 байта благодаря YairRand

Сломать:

• 42-байтовая таблица поиска
• 162 144 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 (для распознавания текста). Вот мой код, который работает для теста 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 art в командную строку после запуска команды. Завершите ввод, нажав ^ d.

Токовый выход для тестовых случаев:

• Привет мир: привет мир
• ASCII: H5511
• PPCG: PPOG

Scala, 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

Попробуйте онлайн (Скалафиддл)

Более читабельно:

(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 art) разделена на 5 строк (высота символа ASCII)
• Каждая строка разбита на 6-символьные элементы (ширина символа ASCII + 1 пробел)
• Сохраняются только первые 5 символов (пробел в конце бесполезен)
• Строки транспонируются (каждый символ ASCII представлен в виде последовательности из 25 символов (5x5), содержащей либо '#'или ' ')
• Каждое символьное представление (последовательность) ASCII преобразуется в строку, и для этой строки вычисляется абсолютный хэш-код (абсолютный необходим из-за следующего модуля)
• 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-части, если они затем включены в ForeignObject. Поэтому я положил предварительный элемент в 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);}}

Попробуйте онлайн!