Golf bana ilham verdi bu ASCII Alfabe , ki bu meydan okuma (neredeyse) doğrudan bir ters.

Görev:

Bir dizi ASCII-art metni alın ve metnin içeriğini normal ASCII metni olarak çıkarın.

Giriş:

ASCII-art metni

Girdi yalnızca ASCII karakter örnekleri #, boşluklar ve 4 veya 5 yeni satır içerecektir (takip eden bir yeni satır isteğe bağlıdır). Tüm çizgiler aynı uzunluktadır. (Yani, son ASCII-art harfi sondaki boşluklarla doludur.) İsterseniz #giriş yerine bazı yazdırılabilir ASCII karakterlerini kullanabilirsiniz .

Giriş, ASCII resim harflerini A-Zve ASCII resim alanlarını (5x5 beyaz boşluk bloğu) içerecektir . Noktalama işaretleri yok. Sadece bir satır ASCII-art metni vardır (5 gerçek satır). Hiçbir izleyen ya da öncü ASCII-sanat alanı olmayacak, bitişik ASCII-sanat alanı olmayacak.

Harf boyutu 5x5 karakterdir. Her harf arasında 1x5 boşluk vardır. Kelimeler arasındaki boşluk 5x5 boşluk bloğu (her iki tarafta da +1x5 boşluk, çünkü başka bir harf). Sonunda veya başında yalnızca ASCII-art harfleri arasında 1x5 boşluk kalmaz.

Çıktı:

ASCII karakterleri A-Z+ boşlukları içeren metni içeren dize . Çözüm, çözümünüz için bir şekilde daha kolaysa, çıktı küçük harflerle de olabilir. Karışık durumda da izin verilir.

ASCII-sanat mektupları:

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

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

Boşluk:

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

Örnekler:

Giriş:

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

Çıktı: HELLO WORLD

Giriş:

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

Çıktı: ASCII

Giriş:

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

Çıktı: PPCG

Bu kod golf , yani bayt cinsinden en kısa cevap kazanır.

Jöle ,  50 44  42 bayt

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

Çevrimiçi deneyin! (argümanın baştaki yeni satırı gerektirmediğine dikkat edin, ancak baştaki ve sondaki yeni satırların hiçbir etkisi olmadığından, çok satırlı dizeyi daha okunaklı hale getirmek için bir tanesini ekledim)

Sonuçlar karışık durumda ( bir yorumda OP tarafından izin verildiği şekilde ).

Nasıl?

Yeni çizgiler üzerine ayırır, karakter temsillerini elde etmek ve her birini tersine çevirmek için (altıya kadar) alt dilimlerini bir araya getirir, birleştirir ve birleştirir (uzunluk 25'in son karakteri için daha sonraki baz dönüşümünü, uzunluk 30'un tümü ile eşdeğer tutar). Sonra haritalar '#'ve ' 'bir ve sıfır olarak sırasıyla gerçeği kullanırken '#'ederken garip bir ordinal sahip ' 'bir hatta birine sahiptir. Her birini bir taban yedi numaraymış gibi okur. Etkili bir şekilde her birinin modulo 81'ini alır (27 olası durum için 27 benzersiz değer sağlar) ve son olarak doğru dizinlerde doğru karakterlerle doğru bir "sihirli dizge" indeksler (modulo indeksleme, kaydetmek için 81 uzunluklu bir sihirli dizeyle kullanılır 2 bayt).

İşte eşleştirmem gereken (harf duyarsız) bir regex deseniyle birlikte oluşturduğum "sihirli dize" (uzunluğu 81 yapmak için "ed" ekledim):

 ' 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.*'

Bu şekilde sıkıştırılmış olabilir, Jelly'in sözlüğündeki kelimelerden onbir alt dilimi aramak (çoğu önde gelen alanı varsayılan olarak kullanır):

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

Jöle sıkıştırılmış ipte sonuçlanan, “¥ŒƲVĊ⁾|W£⁼³ƭÇuʋụzḢĖ0ḢẆẠØsĠỌỊ»

Kodun geri kalanı şu şekilde çalışır:

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

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

Çevrimiçi deneyin!

Sonunda JS'den daha kısa

JavaScript (ES6), 204 186 184 182 bayt

Neil sayesinde 18 bayt
kaydedildi ETHproductions sayesinde 2 bayt kaydedildi YairRand sayesinde
kaydedilmiş 2 bayt

Yıkmak:

• 42 baytlık arama tablosu
• 162 144 142 140 bayt kodu

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

gösteri

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 bayt

@ Stewie-griffin tarafından önerilen yaklaşımı denemek istedim ve bash + ImageMagick (bir dizgeyi bir resme dönüştürmek için) ve Tesseract (OCR yapmak için) için gittim. İşte benim 'HELLO WORLD' test çantası için çalışan kodum, diğeri başarısız. Belki bazı parametrelere ince ayar (yazı tipi, yazı tipi boyutu, karakter aralığı, boşluk) yardımcı olur.

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

Komutu çalıştırdıktan sonra sadece ascii resmini komut satırına yapıştırın. Girişinizi ^ d tuşuna basarak bitirin.

Test durumları için akım çıkışı:

• MERHABA DÜNYASI: MERHABA DÜNYASI
• ASCII: H5511
• PPCG: PPOG

Scala, 184 181 bayt

Dayalı bir sihirli dize + modulo çözümü 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

Çevrimiçi dene (Scalafiddle)

Daha okunabilir:

(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çıklamalar

• İlk String (ASCII art) 5 satıra bölünür (ASCII karakterinin yüksekliği)
• Her satır 6 karakterli öğelere ayrılmıştır (ASCII karakter genişliği + 1 boşluk)
• Sadece ilk 5 karakter tutulur (sonunda boşluk işe yaramaz)
• Satırlar (her ASCII karakteri, ya '#'da ' ') içeren 25 karakterden oluşan bir dizi olarak gösterilir (5x5 ).
• Her ASCII karakter gösterimi (dizi) String'e dönüştürülür ve bu String için mutlak bir karma kod hesaplanır (bir sonraki modülden dolayı mutlak gereklidir)
• Her ASCII karakteri için % 106 % 79 % 47bir sayıyı ate ilişkilendirmek için ardışık 3 modül ( ) uygulanır [0; 47[(aşağıdaki açıklamalara bakınız)
• Bu sayı sihirli dizgenin bir dizini olarak kullanılır

Sihirli ip nasıl elde edilir?

İlk önce bunun gibi bütün harfleri temsil ettim:

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

Sonra, tüm karakterlerin ASCII temsillerini içeren bir alfabe oluşturdum:

Örnek :

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

olur

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

Her harf için mutlak bir hashcode hesaplandı (tüm hashcode'lar ayrıdır):

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

Sonra her kodu azaltmaya çalıştım, ancak her zaman her kodun benzersiz olması gerektiğine saygı duydum (kod tarafından gruplandırılmış listede her harf için 1 adet olmalı). Bu yüzden ilk 200 modülü denedim:

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

106Uygulanacak ilk modulo olarak bulundu :

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

Önceki adımları en küçük modülo olana kadar tekrarladım. Buldum :

• 79
• 47
• 44
• 42

Not: Seçtiğim son modül ( 47) buradaki en küçük değil:

• 44'ü buldum, ancak 44'ü seçseydim, sihirli dizginin büyüklüğü 44 (47 yerine) olur, ancak yazmak zorunda kalırdım %106%79%47%44( %106%79%47= 10 karakter yerine 13 karakter). Yani, bayt cinsinden, kodun aldığım ile aynı boyutta olması gerekirdi.
• Ayrıca 42 tane var, fakat kodun elimdekinden 1 byte daha olması gerekirdi.

Daha sonra, her harfe ilişkin kesin kodları almak için ardışık modülü ( % 79 % 47) sonuncu olarak uyguladım 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))

Son olarak, sihirli dize oluşturmak için:

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"

Örnek: Yukarıdaki harf A46 ( 380997542 % 106 % 79 % 47) ile ilişkilendirilir ve sihirli dizenin 46. maddesi A :) 'dır.

Test durumları

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

SELAM DÜNYA :

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

f(asciiArt)    // HELLO WORLD

ASCII:

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

f(asciiArt)    // ASCII

PPCG:

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

f(asciiArt)    // PPCG

Düzenlemeler

• Çıkararak 3 bayt Kaydedilen .önce map, toArrayvemkString

PHP, 294 Bayt

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

Çevrimiçi deneyin!

Expanded

$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

Girişi bir görüntü formatına dönüştürme

@Stevie Griffin bunu bir görüntüden almak için bir çözüm arar. Onun istiyorum düşünüyorum gerçekten ben kullanımı var görüntü formatını.

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, eğer bir foreignObject’e eklenmişse HTML bölümleri içerebilir. Bu yüzden SVG'ye bir Öğe koydum.

Görüntü çıkışı

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

Görüntü Değişikliklerinden Çözme

SVG yalnızca değiştirmek gerek "i.svg" olarak SVG kaydettikten sonra makine tarafından okunabilir böyledir $_GET[0]ile preg_replace("#(^.*e>)(.*)(</p.*$)#s","$2",join(file("i.svg")))normal giriş + 55 Bayt ile yolla

Powershell, 152 146 bayt

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

Test komut dosyası:

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

Çıktı:

HELLO WORLD
ASCII
PPCG
 ABCDEFGHIJKLMNOPQRSTUVWXYZ

Not:

1. $t|% s*g $c,5|% t*y|%{$s+=$s+$_} kısayol $t.substring($c,5).toCharArray()|%{$s+=$s+$_}
2. ("abcd","efgh").substring(1,2) diziyi döndürür ("bc","de")
3. ("bc","de").toCharArray() diziyi döndürür ('b','c','d','e')

C,  225  209 bayt

16 bayt tasarrufu için @ceilingcat'e teşekkürler!

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

Çevrimiçi deneyin!