Inspiriert von Golf me ein ASCII-Alphabet , von dem diese Herausforderung (fast) eine direkte Umkehrung ist.

Aufgabe:

Nehmen Sie eine ASCII-Zeichenfolge und geben Sie den Textinhalt als normalen ASCII-Text aus.

Eingang:

Zeichenfolge aus ASCII-Kunsttext.

Die Eingabe enthält nur ASCII-Zeichen #, Leerzeichen und 4 oder 5 Zeilenumbrüche (ein abschließender Zeilenumbruch ist optional). Alle Zeilen haben die gleiche Länge. (Das heißt, der letzte ASCII-Zeichenbuchstabe wird mit nachgestellten Leerzeichen aufgefüllt.) Sie können anstelle #der Eingabe ein anderes druckbares ASCII-Zeichen verwenden, wenn Sie dies wünschen.

Die Eingabe enthält ASCII-Kunst-Buchstaben A-Zund ASCII-Kunst-Leerzeichen (ein 5x5-Block mit Leerzeichen). Keine Interpunktion. Es gibt nur eine Zeile ASCII-Text (5 tatsächliche Zeilen). Es gibt keine nachgestellten oder führenden ASCII-Zeichenbereiche und keine benachbarten ASCII-Zeichenbereiche.

Die Buchstabengröße beträgt 5x5 Zeichen. Zwischen jedem Buchstaben steht ein Leerzeichen von 1x5. Das Leerzeichen zwischen den Wörtern ist ein 5x5-Whitespace-Block (+ 1x5-Leerzeichen auf jeder Seite, da es sich nur um einen anderen Buchstaben handelt). Es wird am Ende oder am Anfang kein 1x5-Leerzeichen geben, nur zwischen ASCII-Zeichen.

Ausgabe:

Zeichenfolge, die den Text als ASCII-Zeichen A-Z+ Leerzeichen enthält. Die Ausgabe kann auch in Kleinbuchstaben erfolgen, wenn dies für Ihre Lösung einfacher ist. Ein gemischter Fall ist ebenfalls zulässig.

Die ASCII-Art Buchstaben:

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

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

Der Raum:

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

Beispiele:

Eingang:

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

Ausgabe: HELLO WORLD

Eingang:

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

Ausgabe: ASCII

Eingang:

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

Ausgabe: PPCG

Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.

Jelly ,  50 44  42 Bytes

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

Probieren Sie es online! (Beachten Sie, dass für das Argument kein Zeilenumbruch erforderlich ist. Da Zeilenumbrüche am Anfang und am Ende keine Auswirkungen haben, habe ich einen eingefügt, um die Lesbarkeit der mehrzeiligen Zeichenfolge zu verbessern.)

Die Ergebnisse sind gemischte Groß- und Kleinschreibung (wie vom OP in einem Kommentar zugelassen ).

Wie?

Teilt neue Zeilen, transponiert und fügt Unterschichten von (bis zu) sechs zusammen, um die Zeichendarstellungen zu erhalten, und kehrt jede um (wobei die spätere Basisumwandlung für das letzte Zeichen der Länge 25 allen anderen Zeichen der Länge 30 gleichgesetzt wird). Dann ordnet '#'und ' 'auf eins bzw. null zu, wobei die Tatsache verwendet wird, dass '#'eine ungerade Ordnungszahl vorliegt, während ' 'eine gerade Eins vorliegt . Liest jedes als wäre es eine Zahl zur Basis sieben. Nimmt effektiv Modulo 81 von jedem (um 27 eindeutige Werte für die 27 möglichen Fälle zu erhalten) und indiziert schließlich eine "magische Zeichenfolge" mit den richtigen Zeichen an den richtigen Indizes (Modulo-Indizierung wird mit einer magischen Zeichenfolge der Länge 81 verwendet, um zu speichern 2 Bytes).

Hier ist die "magische Zeichenfolge", die ich zusammen mit einem Regex-Muster (ohne Berücksichtigung der Groß- und Kleinschreibung) erstellt habe, das übereinstimmen musste (ich habe "ed" hinzugefügt, damit es die Länge 81 hat):

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

Als solches kann es komprimiert werden, indem elf Sub-Slices als Wörter in Jellys Wörterbuch nachgeschlagen werden (die meisten verwenden die Standardeinstellung für das führende Leerzeichen):

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

was zu der Jelly komprimierten Saite führt, “¥ŒƲVĊ⁾|W£⁼³ƭÇuʋụzḢĖ0ḢẆẠØsĠỌỊ»

Der Rest des Codes funktioniert wie folgt:

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

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

Probieren Sie es online!

Endlich kürzer als JS

JavaScript (ES6), 204 186 184 182 Byte

18 Bytes dank Neil
gespeichert 2 Bytes dank ETHproductions
gespeichert 2 Bytes dank YairRand gespeichert

Nervenzusammenbruch:

• 42-Byte-Nachschlagetabelle
• 162 144 142 140 Byte Code

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

Demo

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 Bytes

Ich wollte den von @ stewie-griffin vorgeschlagenen Ansatz ausprobieren und entschied mich für bash + ImageMagick (um einen String in ein Bild umzuwandeln) und Tesseract (um die OCR durchzuführen). Hier ist mein Code, der für den 'HELLO WORLD'-Testfall funktioniert, die anderen jedoch nicht. Vielleicht hilft eine Änderung der Parameter (Schriftart, Schriftgröße, Kerning, Abstand).

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

Kopieren Sie einfach die ASCII-Grafik in die Befehlszeile, nachdem Sie den Befehl ausgeführt haben. Beenden Sie Ihre Eingabe mit ^ d.

Stromausgang für die Testfälle:

• HALLO WELT: HALLO WELT
• ASCII: H5511
• PPCG: PPOG

Scala, 184 181 Bytes

Eine magische String + Modulo Lösung basierend auf 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

Online versuchen (Scalafiddle)

Besser lesbar:

(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

Erklärungen

• Die Anfangszeichenfolge (ASCII-Grafik) ist in 5 Zeilen unterteilt (Höhe des ASCII-Zeichens).
• Jede Zeile ist in 6-stellige Elemente unterteilt (Breite des ASCII-Zeichens + 1 Leerzeichen).
• Nur die ersten 5 Zeichen bleiben erhalten (das Leerzeichen am Ende ist unbrauchbar)
• Die Zeilen werden transponiert (jedes ASCII-Zeichen wird als Folge von 25 Zeichen (5 x 5) dargestellt, die entweder '#'oder enthalten ' ').
• Jede ASCII-Zeichendarstellung (Sequenz) wird in einen String konvertiert, und für diesen String wird ein absoluter Hashcode berechnet (absolut erforderlich aufgrund des nächsten Moduls).
• Es werden 3 aufeinanderfolgende Module ( % 106 % 79 % 47) angewendet, [0; 47[um jedem ASCII-Zeichen eine Zahl ∈ zuzuordnen (siehe Erläuterungen unten).
• Diese Nummer wird als Index der magischen Zeichenkette verwendet

Wie bekomme ich die magische Schnur?

Zuerst habe ich alle Buchstaben so dargestellt:

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

Dann habe ich ein Alphabet mit ASCII-Darstellungen aller Zeichen erstellt:

Beispiel

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

wird

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

Für jeden Buchstaben wurde ein absoluter Hashcode berechnet (alle Hashcodes sind unterschiedlich):

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

Dann habe ich versucht, jeden Code zu verringern, aber dabei immer darauf geachtet, dass jeder Code eindeutig sein muss (die durch den Code gruppierte Liste muss 27 Elemente enthalten, 1 für jeden Buchstaben). Also habe ich den ersten 200 Modul ausprobiert:

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

Ich fand 106als erstes Modulo, das angewendet wurde:

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

Ich habe die vorherigen Schritte bis zum kleinsten Modulo wiederholt. Ich fand :

• 79
• 47
• 44
• 42

Hinweis: Das zuletzt ausgewählte Modulo ( 47) ist hier nicht das kleinste:

• Ich habe 44 gefunden, aber wenn ich 44 gewählt hätte, hätte die magische Zeichenfolge die Größe 44 (statt 47), aber ich müsste schreiben %106%79%47%44(13 Zeichen statt %106%79%47= 10 Zeichen). In Bytes hätte der Code also die gleiche Größe haben müssen wie der, den ich bekommen habe
• Es gibt auch 42, aber dann hätte der Code 1 Byte mehr haben müssen als der, den ich bekommen habe

Als nächstes habe ich den konsekutiven Modul ( % 79 % 47) auf den letzten angewendet codes, um die definitiven Codes zu erhalten, die jedem Buchstaben zugeordnet sind:

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

Zum Schluss, um die magische Kette zu konstruieren:

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"

Beispiel: Der Buchstabe Aoben ist mit 46 ( 380997542 % 106 % 79 % 47) verknüpft , und das 46. Element der magischen Zeichenfolge ist A :)

Testfälle

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

HALLO WELT :

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

f(asciiArt)    // HELLO WORLD

ASCII:

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

f(asciiArt)    // ASCII

PPCG:

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

f(asciiArt)    // PPCG

Bearbeitungen

• Gespeichert 3 Bytes durch Entfernen .vor map, toArrayundmkString

PHP, 294 Bytes

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

Probieren Sie es online!

Erweitert

$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

Konvertieren der Eingabe in ein Bildformat

@Stevie Griffin sucht nach einer Lösung, um dies von einem Bild zu erhalten. Ich denke, er möchte nicht wirklich das Bildformat, das ich verwendet habe.

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 kann HTML-Teile enthalten, wenn diese in einem foreignObject enthalten sind. Also habe ich ein Pre-Element in eine SVG eingefügt.

Bildausgabe

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

Lösen von Bildänderungen

SVG ist maschinenlesbar so nach der SVG als „i.svg“ Speichern müssen Sie ersetzen nur $_GET[0]mit preg_replace("#(^.*e>)(.*)(</p.*$)#s","$2",join(file("i.svg")))der Art und Weise mit dem normalen Eingang + 55 Bytes

Powershell, 152 146 Bytes

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

Testskript:

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

Ausgabe:

HELLO WORLD
ASCII
PPCG
 ABCDEFGHIJKLMNOPQRSTUVWXYZ

Hinweis:

1. $t|% s*g $c,5|% t*y|%{$s+=$s+$_} ist Abkürzung für $t.substring($c,5).toCharArray()|%{$s+=$s+$_}
2. ("abcd","efgh").substring(1,2) Gibt das Array zurück ("bc","de")
3. ("bc","de").toCharArray() Gibt das Array zurück ('b','c','d','e')

C,  225  209 Bytes

Vielen Dank an @ceilingcat für das Speichern von 16 Bytes!

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

Probieren Sie es online!