Lấy cảm hứng từ Golf cho tôi một Bảng chữ cái ASCII , trong đó thách thức này (gần như) là nghịch đảo trực tiếp.

Bài tập:

Lấy một chuỗi văn bản nghệ thuật ASCII và xuất nội dung của văn bản dưới dạng văn bản ASCII thông thường.

Đầu vào:

Chuỗi văn bản nghệ thuật ASCII.

Đầu vào sẽ chỉ chứa các phiên bản của ký tự ASCII #, dấu cách và 4 hoặc 5 dòng mới (một dòng mới là tùy chọn). Tất cả các dòng có cùng chiều dài. (Nghĩa là, chữ cái nghệ thuật ASCII cuối cùng được đệm bằng dấu cách.) Bạn có thể sử dụng một số ký tự ASCII có thể in khác thay vì #trong đầu vào nếu bạn muốn.

Đầu vào sẽ chứa các chữ cái nghệ thuật A-ZASCII và không gian nghệ thuật ASCII (một khối khoảng trắng 5x5). Không có dấu câu. Chỉ có một dòng văn bản nghệ thuật ASCII (5 dòng thực tế). Sẽ không có không gian nghệ thuật ASCII kéo dài hoặc hàng đầu, cũng sẽ không có không gian nghệ thuật ASCII liền kề.

Kích thước chữ là 5x5 ký tự. Có một khoảng trống 1x5 giữa mỗi chữ cái. Khoảng cách giữa các từ là một khối khoảng trắng 5x5 (+ khoảng trống 1x5 ở mỗi bên, vì nó chỉ là một chữ cái khác). Sẽ không có khoảng trống 1x5 ở cuối hoặc ở đầu, chỉ giữa các chữ cái nghệ thuật ASCII.

Đầu ra:

Chuỗi chứa văn bản dưới dạng ký tự ASCII A-Z+ dấu cách. Đầu ra cũng có thể được viết thường, nếu điều đó dễ dàng hơn cho giải pháp của bạn. Trường hợp hỗn hợp cũng được cho phép.

Các chữ cái nghệ thuật ASCII:

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

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

Vũ trụ:

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

Ví dụ:

Đầu vào:

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

Đầu ra: HELLO WORLD

Đầu vào:

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

Đầu ra: ASCII

Đầu vào:

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

Đầu ra: PPCG

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng.

Thạch ,  50 44  42 byte

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

Hãy thử trực tuyến! (lưu ý rằng đối số không yêu cầu dòng mới hàng đầu, nhưng vì dòng mới hàng đầu và theo dõi không có tác dụng nên tôi đã đưa vào một để làm cho chuỗi đa dòng dễ đọc hơn)

Kết quả là trường hợp hỗn hợp (như được OP cho phép trong một bình luận ).

Làm sao?

Tách trên các dòng mới, hoán vị và kết hợp các lát con của (tối đa) sáu với nhau để có được các biểu diễn ký tự và đảo ngược từng ký tự (đánh giá chuyển đổi cơ sở sau này cho ký tự cuối cùng có độ dài 25 cho tất cả các phần khác có độ dài 30). Sau đó, ánh xạ '#'và ' 'đến một và không tương ứng bằng cách sử dụng thực tế '#'có một số lẻ trong khi ' 'có một số chẵn. Đọc từng cái như thể nó là một số bảy cơ sở. Hiệu quả lấy modulo 81 của mỗi (để mang lại 27 giá trị duy nhất cho 27 trường hợp có thể) và cuối cùng lập chỉ mục thành một "chuỗi ma thuật" với các ký tự chính xác ở các chỉ mục chính xác (lập chỉ mục modulo được sử dụng với chuỗi ma thuật có độ dài 81 để lưu 2 byte).

Đây là "chuỗi ma thuật" mà tôi đã tạo cùng với mẫu biểu thức chính quy (không phân biệt chữ hoa chữ thường) mà nó cần để khớp (tôi đã thêm "ed" để làm cho nó dài 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.*'

Vì vậy, nó có thể được nén, tìm kiếm mười một lát con dưới dạng các từ trong từ điển của Jelly (hầu hết đều sử dụng mặc định không gian hàng đầu):

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

dẫn đến chuỗi nén Jelly, “¥ŒƲVĊ⁾|W£⁼³ƭÇuʋụzḢĖ0ḢẆẠØsĠỌỊ»

Phần còn lại của mã hoạt động như sau:

Ỵ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 byte

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))

Hãy thử trực tuyến!

Cuối cùng ngắn hơn JS

JavaScript (ES6), 204 186 184 182 byte

Đã lưu 18 byte nhờ Neil
Lưu 2 byte nhờ ETHproductions
Lưu 2 byte nhờ YairRand

Phá vỡ:

• Bảng tra cứu 42 byte
• 162 144 142 140 byte mã

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])

Bản giới thiệu

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 byte

Tôi muốn thử cách tiếp cận được đề xuất bởi @ stewie-griffin và đã đi bash + ImageMagick (để chuyển đổi một chuỗi thành một hình ảnh) và Tesseract (để thực hiện OCR). Đây là mã của tôi, hoạt động cho bản thử nghiệm 'HELLO WORLD', nhưng không thành công. Có thể một số điều chỉnh cho các tham số (phông chữ, kích thước phông chữ, k sâu, khoảng cách) giúp.

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

Chỉ cần sao chép-dán nghệ thuật ascii vào dòng lệnh sau khi chạy lệnh. Hoàn thành đầu vào của bạn bằng cách nhấn ^ d.

Đầu ra hiện tại cho các trường hợp thử nghiệm:

• THẾ GIỚI HELLO: THẾ GIỚI HELLO
• ASCII: H5511
• PPCG: PPOG

Scala, 184 181 byte

Một chuỗi ma thuật + giải pháp modulo dựa trên 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

Thử trực tuyến (Scalafiddle)

Dễ đọc hơn:

(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

Giải thích

• Chuỗi ban đầu (nghệ thuật ASCII) được chia thành 5 dòng (chiều cao của ký tự ASCII)
• Mỗi dòng được chia thành các phần tử 6 ký tự (chiều rộng của ký tự ASCII + 1 khoảng trắng)
• Chỉ có 5 ký tự đầu tiên được giữ (khoảng trống ở cuối là vô dụng)
• Các dòng được hoán vị (mỗi ký tự ASCII được biểu diễn dưới dạng một chuỗi gồm 25 ký tự (5x5), chứa một trong hai '#'hoặc ' ')
• Mỗi biểu diễn (chuỗi) ký tự ASCII được chuyển đổi thành Chuỗi và mã băm tuyệt đối được tính cho Chuỗi đó (cần tuyệt đối vì mô-đun tiếp theo)
• 3 mô đun liên tiếp ( % 106 % 79 % 47) được áp dụng để liên kết một số [0; 47[cho mỗi ký tự ASCII (xem giải thích bên dưới)
• Số này được sử dụng như một chỉ số của chuỗi ma thuật

Làm thế nào để có được chuỗi ma thuật?

Đầu tiên, tôi đại diện cho tất cả các chữ cái như thế này:

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

Sau đó, tôi đã tạo một bảng chữ cái chứa các biểu diễn ASCII của tất cả các ký tự:

Thí dụ :

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

trở thành

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

Đối với mỗi chữ cái, một mã băm tuyệt đối đã được tính toán (tất cả các mã băm đều khác biệt):

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))

Sau đó, tôi đã cố gắng giảm từng mã, nhưng luôn tôn trọng thực tế là mỗi mã phải là duy nhất (danh sách được nhóm theo mã phải có 27 phần tử, 1 cho mỗi chữ cái). Vì vậy, tôi đã thử 200 mô-đun đầu tiên:

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

Tôi tìm thấy 106như là modulo đầu tiên được áp dụng:

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))

Tôi lặp lại các bước trước cho đến khi modulo nhỏ nhất. Tôi đã tìm thấy :

• 79
• 47
• 44
• 42

Lưu ý: Modulo cuối cùng tôi chọn ( 47) không phải là nhỏ nhất ở đây:

• Tôi đã tìm thấy 44, nhưng nếu tôi đã chọn 44, chuỗi ma thuật sẽ có kích thước 44 (thay vì 47) nhưng tôi sẽ phải viết %106%79%47%44(13 ký tự thay vì%106%79%47 = 10 ký tự). Vì vậy, tính bằng byte, mã phải có cùng kích thước với mã tôi nhận được
• Ngoài ra còn có 42, nhưng sau đó mã phải có nhiều hơn 1 byte so với mã tôi nhận được

Tiếp theo, tôi đã áp dụng mô-đun liên tiếp ( % 79 % 47) cho lần cuối cùng codes, để lấy các mã xác định liên quan đến mỗi chữ cái:

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))

Cuối cùng, để xây dựng chuỗi ma thuật:

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"

Ví dụ: Chữ cái Aở trên được liên kết với 46 ( 380997542 % 106 % 79 % 47) và phần tử thứ 46 của chuỗi ma thuật là A :)

Các trường hợp thử nghiệm

// 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

CHÀO THẾ GIỚI :

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

f(asciiArt)    // HELLO WORLD

ASCII:

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

f(asciiArt)    // ASCII

PPCG:

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

f(asciiArt)    // PPCG

Chỉnh sửa

• Lưu 3 byte bằng cách loại bỏ .trước map, toArrayvàmkString

PHP, 294 byte

<?$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;

Hãy thử trực tuyến!

Mở rộng

$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

Chuyển đổi đầu vào thành định dạng hình ảnh

@Stevie Griffin tìm kiếm một giải pháp để có được điều này từ một hình ảnh. Tôi nghĩ rằng anh ấy không muốn thực sự định dạng hình ảnh tôi đã sử dụng.

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 có thể chứa các phần HTML nếu sau đó được bao gồm trong ForeignObject. Vì vậy, tôi đặt một phần tử trước trong một SVG.

Đầu ra hình ảnh

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

Giải quyết từ thay đổi hình ảnh

SVG có thể đọc được bằng máy, vì vậy sau khi lưu SVG thành "i.svg", bạn chỉ cần thay thế $_GET[0]bằng preg_replace("#(^.*e>)(.*)(</p.*$)#s","$2",join(file("i.svg")))cách nhập thông thường + 55 Byte

Powershell, 152 146 byte

-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]})

Kịch bản thử nghiệm:

$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 @"
       ###  ####   ###  ####  ##### #####  ###  #   # ##### ##### #   # #     #   # #   #  ###  ####   ###  ####   ###  ##### #   # #   # #   # #   # #   # #####
      #   # #   # #   # #   # #     #     #     #   #   #     #   #  #  #     ## ## ##  # #   # #   # #   # #   # #       #   #   # #   # #   #  # #   # #     # 
      ##### ####  #     #   # ####  ####  #  ## #####   #     #   ###   #     # # # # # # #   # ####  #   # ####   ###    #   #   #  # #  # # #   #     #     #  
      #   # #   # #   # #   # #     #     #   # #   #   #   # #   #  #  #     #   # #  ## #   # #     #  #  #   #     #   #   #   #  # #  ## ##  # #    #    #   
      #   # ####   ###  ####  ##### #      ###  #   # ##### ###   #   # ##### #   # #   #  ###  #      ## # #   #  ###    #    ###    #   #   # #   #   #   #####
"@

Đầu ra:

HELLO WORLD
ASCII
PPCG
 ABCDEFGHIJKLMNOPQRSTUVWXYZ

Chú thích:

1. $t|% s*g $c,5|% t*y|%{$s+=$s+$_} là lối tắt cho $t.substring($c,5).toCharArray()|%{$s+=$s+$_}
2. ("abcd","efgh").substring(1,2) trả về mảng ("bc","de")
3. ("bc","de").toCharArray() trả về mảng ('b','c','d','e')

C,  225  209 byte

Cảm ơn @ceilingcat vì đã lưu 16 byte!

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);}}

Hãy thử trực tuyến!