Ispirato da Golf me un alfabeto ASCII , di cui questa sfida è (quasi) un'inverso diretto.

Compito:

Prendi una stringa di testo ASCII-art e genera il contenuto del testo come normale testo ASCII.

Ingresso:

Stringa di testo in formato ASCII.

L'input conterrà solo istanze di caratteri ASCII #, spazi e 4 o 5 newline (una newline finale è facoltativa). Tutte le linee hanno la stessa lunghezza. (Cioè, l'ultima lettera di arte ASCII è riempita di spazi finali.) #Se lo si desidera, è possibile utilizzare qualche altro carattere ASCII stampabile anziché nell'input.

L'ingresso conterrà lettere di arte A-ZASCII e spazi di arte ASCII (un blocco 5x5 di spazi bianchi). Nessuna punteggiatura. C'è solo una riga di testo in formato ASCII (5 righe effettive). Non ci saranno spazi di arte ASCII finali o di coda, né spazi di arte ASCII adiacenti.

La dimensione della lettera è di 5x5 caratteri. C'è uno spazio 1x5 tra ogni lettera. Lo spazio tra le parole è un blocco 5x5 di spazio bianco (+ 1x5 spazio su ogni lato, perché è solo un'altra lettera). Non ci sarà spazio 1x5 alla fine o all'inizio, solo tra lettere di arte ASCII.

Produzione:

Stringa contenente il testo come caratteri ASCII A-Z+ spazi. L'output può anche essere in minuscolo, se in qualche modo è più semplice per la tua soluzione. È consentito anche il caso misto.

Le lettere di arte ASCII:

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

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

Lo spazio:

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

Esempi:

Ingresso:

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

Produzione: HELLO WORLD

Ingresso:

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

Produzione: ASCII

Ingresso:

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

Produzione: PPCG

Questo è code-golf , quindi vince la risposta più breve in byte.

Gelatina ,  50 44  42 byte

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

Provalo online! (nota che l'argomento non richiede la nuova riga iniziale, ma poiché le nuove righe iniziali e finali non hanno alcun effetto ne ho inclusa una per rendere la stringa multilinea più leggibile dall'uomo)

I risultati sono casi misti (come consentito dall'OP in un commento ).

Come?

Si divide su nuove linee, traspone e unisce sotto-sezioni di (fino a) sei insieme per ottenere le rappresentazioni dei personaggi e inverte ciascuna (equiparando la successiva conversione base per il carattere finale della lunghezza 25 a tutti gli altri della lunghezza 30). Quindi mappe '#'e ' 'a uno e zero rispettivamente usando il fatto che '#'ha un ordinario dispari mentre ne ' 'ha uno pari. Legge ciascuno come se fosse un numero di base sette. Prende efficacemente il modulo 81 di ciascuno (per produrre 27 valori univoci per i 27 casi possibili), e infine si indicizza in una "stringa magica" con i caratteri corretti agli indici corretti (l'indicizzazione del modulo viene utilizzata con una stringa magica di lunghezza 81 per salvare 2 byte).

Ecco la "stringa magica" che ho creato insieme a un modello regex (senza distinzione tra maiuscole e minuscole) che doveva corrispondere (ho aggiunto "ed" per renderlo lungo 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.*'

Come tale può essere compresso, cercando undici sottotitoli come parole nel dizionario di Jelly (la maggior parte delle quali utilizza il valore predefinito di spazio iniziale):

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

che risulta nella stringa compressa di Jelly, “¥ŒƲVĊ⁾|W£⁼³ƭÇuʋụzḢĖ0ḢẆẠØsĠỌỊ»

Il resto del codice funziona come segue:

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

Provalo online!

Finalmente più corto di JS

JavaScript (ES6), 204 186 184 182 byte

Risparmiato 18 byte grazie a Neil
Salvato 2 byte grazie a ETHproductions
Risparmiato 2 byte grazie a YairRand

Abbattersi:

• Tabella di ricerca a 42 byte
• 162 144 142 140 byte di codice

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

dimostrazione

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

Volevo provare l'approccio suggerito da @ stewie-griffin e ho scelto bash + ImageMagick (per convertire una stringa in un'immagine) e Tesseract (per fare l'OCR). Ecco il mio codice, che funziona per la testcase "HELLO WORLD", ma fallisce gli altri. Forse qualche modifica ai parametri (carattere, dimensione del carattere, crenatura, spaziatura) aiuta.

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

Basta copiare e incollare l'arte ascii nella riga di comando dopo aver eseguito il comando. Termina l'immissione premendo ^ d.

Uscita corrente per i casi di test:

• CIAO MONDO: CIAO MONDO
• ASCII: H5511
• PPCG: PPOG

Scala, 184 181 byte

Una soluzione magica + modulo basata su 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

Prova online (Scalafiddle)

Più leggibile:

(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

spiegazioni

• La stringa iniziale (arte ASCII) è divisa in 5 righe (altezza del carattere ASCII)
• Ogni riga è divisa in elementi di 6 caratteri (larghezza del carattere ASCII + 1 spazio)
• Vengono mantenuti solo i primi 5 caratteri (lo spazio alla fine è inutile)
• Le linee vengono trasposte (ogni carattere ASCII è rappresentato come una sequenza di 25 caratteri (5x5), contenente '#'o ' ')
• Ogni rappresentazione (sequenza) di caratteri ASCII viene convertita in stringa e viene calcolato un hashcode assoluto per quella stringa (necessario in assoluto a causa del modulo successivo)
• % 106 % 79 % 47Vengono applicati 3 moduli consecutivi ( ) per associare un numero ∈ [0; 47[per ciascun carattere ASCII (vedere le spiegazioni di seguito)
• Questo numero viene utilizzato come indice della stringa magica

Come ottenere la corda magica?

Innanzitutto, ho rappresentato tutte le lettere in questo modo:

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

Quindi, ho creato un alfabeto contenente le rappresentazioni ASCII di tutti i caratteri:

Esempio :

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

diventa

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

Per ogni lettera è stato calcolato un hashcode assoluto (tutti gli hashcode sono distinti):

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

Quindi ho cercato di ridurre ogni codice, ma sempre rispettando il fatto che ogni codice deve essere univoco (l'elenco raggruppato dal codice deve contenere 27 elementi, 1 per ogni lettera). Quindi ho provato i primi 200 moduli:

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

Ho trovato 106il primo modulo da applicare:

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

Ho ripetuto i passaggi precedenti fino al modulo più piccolo. Ho trovato :

• 79
• 47
• 44
• 42

Nota: l'ultimo modulo che ho scelto ( 47) non è il più piccolo qui:

• Ho trovato 44, ma se avessi scelto 44, la stringa magica avrebbe dimensioni 44 (anziché 47) ma avrei dovuto scrivere %106%79%47%44(13 caratteri anziché %106%79%47= 10 caratteri). Quindi, in byte, il codice avrebbe dovuto avere le stesse dimensioni di quello che ho ottenuto
• Ci sono anche 42, ma il codice avrebbe dovuto avere 1 byte in più di quello che ho ricevuto

Successivamente, ho applicato il modulo consecutivo ( % 79 % 47) all'ultimo codes, per ottenere i codici definitivi associati a ciascuna lettera:

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

Infine, per costruire la stringa magica:

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"

Esempio: la lettera Asopra è associata a 46 ( 380997542 % 106 % 79 % 47) e il 46 ° elemento della stringa magica è A :)

Casi test

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

CIAO MONDO :

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

f(asciiArt)    // HELLO WORLD

ASCII:

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

f(asciiArt)    // ASCII

PPCG:

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

f(asciiArt)    // PPCG

Le modifiche

• Salvato 3 byte rimuovendo .prima map, toArrayemkString

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;

Provalo online!

allargato

$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

Conversione dell'input in un formato immagine

@Stevie Griffin cerca una soluzione per ottenere questo da un'immagine. Penso che non voglia davvero il formato immagine che ho usato.

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 può contenere parti HTML se incluse in un oggetto ForeignObject. Quindi ho inserito un pre-elemento in un SVG.

Uscita dell'immagine

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

Risolve da modifiche alle immagini

L'SVG è leggibile dalla macchina, quindi dopo aver salvato l'SVG come "i.svg" è sufficiente sostituirlo $_GET[0]con preg_replace("#(^.*e>)(.*)(</p.*$)#s","$2",join(file("i.svg")))nel modo con input normale + 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]})

Script di prova:

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

Produzione:

HELLO WORLD
ASCII
PPCG
 ABCDEFGHIJKLMNOPQRSTUVWXYZ

Nota:

1. $t|% s*g $c,5|% t*y|%{$s+=$s+$_} è una scorciatoia per $t.substring($c,5).toCharArray()|%{$s+=$s+$_}
2. ("abcd","efgh").substring(1,2) restituisce l'array ("bc","de")
3. ("bc","de").toCharArray() restituisce l'array ('b','c','d','e')

C,  225  209 byte

Grazie a @ceilingcat per aver salvato 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);}}

Provalo online!