Inspiré par Golf, je suis un alphabet ASCII , dont le défi est (presque) un inverse.

Tâche:

Prenez une chaîne de texte ASCII et affichez le contenu du texte sous forme de texte ASCII normal.

Contribution:

Chaîne de texte ASCII-art.

L'entrée ne contiendra que des occurrences de caractères ASCII #, d'espaces et de 4 ou 5 nouvelles lignes (une nouvelle ligne est facultative). Toutes les lignes ont la même longueur. (C'est-à-dire que la dernière lettre ASCII-art est complétée par des espaces.) Vous pouvez utiliser un autre caractère ASCII imprimable à la place de #l'entrée si vous le souhaitez.

L'entrée contiendra des lettres A-ZASCII-art et des espaces ASCII-art (un bloc 5x5 d'espaces). Pas de ponctuation. Il n'y a qu'une ligne de texte ASCII-art (5 lignes réelles). Il n'y aura pas d'espaces artistiques ASCII de fin ou de fin, ni d'espaces artistiques ASCII adjacents.

La taille de la lettre est de 5x5 caractères. Il y a un espace de 1x5 entre chaque lettre. L'espace entre les mots est un bloc d'espaces de 5x5 (+ 1x5 de chaque côté car il ne s'agit que d'une autre lettre). Il n'y aura pas d'espace 1x5 à la fin ou au début, seulement entre les lettres ASCII-art.

Sortie:

Chaîne contenant le texte sous forme de caractères ASCII A-Z+ espaces. La sortie peut également être en minuscule, si cela est plus facile pour votre solution. Les cas mixtes sont également autorisés.

Les lettres ASCII-art:

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

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

L'espace:

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

Exemples:

Contribution:

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

Sortie: HELLO WORLD

Contribution:

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

Sortie: ASCII

Contribution:

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

Sortie: PPCG

C'est du code-golf , donc la réponse la plus courte en octets est gagnante.

Gelée ,  50 44  42 octets

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

Essayez-le en ligne! (notez que l'argument n'exige pas la nouvelle ligne principale, mais comme les nouvelles lignes principales et suivantes n'ont aucun effet, j'en ai inclus un pour rendre la chaîne multiligne plus lisible par l'homme)

Les résultats sont mixtes (comme le permet le PO dans un commentaire ).

Comment?

Divise sur de nouvelles lignes, transpose et assemble des sous-tranches de (jusqu'à) six ensemble pour obtenir les représentations et inverses des caractères (équivalant à la conversion de base la plus récente pour le dernier caractère de longueur 25 à tous les autres de longueur 30). Puis les cartes '#'et ' 'à un et zéro respectivement en utilisant le fait qui '#'a un ordinal impair alors que ' 'a un pair. Lit chacun comme s'il s'agissait d'un nombre de base sept. Prend effectivement le modulo 81 de chacun (pour donner 27 valeurs uniques pour les 27 cas possibles), et finalement l'indexation dans une "chaîne magique" avec les caractères corrects aux index corrects (l'indexation modulo est utilisée avec une chaîne magique de longueur 81 pour la sauvegarde) 2 octets).

Voici la "chaîne magique" que j'ai créée avec un motif de regex (insensible à la casse) dont il a besoin pour correspondre (j'ai ajouté "ed" pour en faire la longueur 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.*'

En tant que tel, il peut être compressé, en recherchant onze sous-tranches sous forme de mots dans le dictionnaire de Jelly (dont la plupart utilise la valeur par défaut d'espace):

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

ce qui aboutit à la chaîne compressée Jelly, “¥ŒƲVĊ⁾|W£⁼³ƭÇuʋụzḢĖ0ḢẆẠØsĠỌỊ»

Le reste du code fonctionne comme suit:

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

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

Essayez-le en ligne!

Enfin plus court que JS

JavaScript (ES6), 204 186 184 182 octets

18 octets sauvés grâce à Neil
2 octets sauvés grâce à ETHproductions
2 octets sauvés grâce à YairRand

Panne:

• Table de consultation de 42 octets
• 162 144 142 140 octets de 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])

Démo

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 octets

Je voulais essayer l'approche suggérée par @ stewie-griffin et j'ai opté pour bash + ImageMagick (convertir une chaîne en image) et Tesseract (pour effectuer l'OCR). Voici mon code, qui fonctionne pour le test 'HELLO WORLD', mais échoue pour les autres. Peut-être que quelques ajustements des paramètres (police, taille de la police, crénage, espacement) peuvent vous aider.

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

Il suffit de copier-coller l’art ASCII dans la ligne de commande après avoir exécuté la commande. Terminez votre saisie en appuyant sur ^ d.

Sortie actuelle pour les cas de test:

• Bonjour tout le monde: Bonjour tout le monde
• ASCII: H5511
• PPCG: PPOG

Scala, 184 181 octets

Une chaîne magique + solution modulo basée sur 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

Essayer en ligne (Scalafiddle)

Plus lisible:

(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

Des explications

• La chaîne initiale (art ASCII) est divisée en 5 lignes (hauteur du caractère ASCII)
• Chaque ligne est divisée en éléments de 6 caractères (largeur du caractère ASCII + 1 espace)
• Seuls les 5 premiers caractères sont conservés (l'espace à la fin est inutile)
• Les lignes sont transposées (chaque caractère ASCII est représenté par une séquence de 25 caractères (5x5), contenant le '#'ou ' ').
• Chaque représentation de caractères ASCII (séquence) est convertie en chaîne et un hashcode absolu est calculé pour cette chaîne (absolu nécessaire en raison du module suivant).
• 3 modules consécutifs ( % 106 % 79 % 47) sont appliqués pour associer un nombre [0; 47[à chaque caractère ASCII (voir les explications ci-dessous)
• Ce nombre est utilisé comme un index de la chaîne magique

Comment obtenir la chaîne magique?

Tout d'abord, j'ai représenté toutes les lettres comme ceci:

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

Ensuite, j'ai créé un alphabet contenant les représentations ASCII de tous les caractères:

Exemple :

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

devient

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

Pour chaque lettre, un hashcode absolu a été calculé (tous les hashcodes sont distincts):

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

Ensuite, j'ai essayé de diminuer chaque code, mais en respectant toujours le fait que chaque code doit être unique (la liste groupée par code doit comporter 27 éléments, un pour chaque lettre). J'ai donc essayé le premier 200 module:

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

J'ai trouvé 106comme premier modulo à appliquer:

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

J'ai répété les étapes précédentes jusqu'au plus petit modulo. J'ai trouvé :

• 79
• 47
• 44
• 42

Note: Le dernier modulo que j'ai choisi ( 47) n'est pas le plus petit ici:

• J'ai trouvé 44, mais si j'avais choisi 44, la chaîne magique aurait une taille de 44 (au lieu de 47) mais je devrais écrire %106%79%47%44(13 caractères au lieu de %106%79%47= 10 caractères). Donc, en octets, le code aurait dû avoir la même taille que celui que j'ai obtenu
• Il y a aussi 42, mais alors le code aurait dû avoir 1 octet de plus que celui que j'ai obtenu

Ensuite, j'ai appliqué le dernier module ( % 79 % 47) au dernier codes, pour obtenir les codes définitifs associés à chaque lettre:

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

Enfin, pour construire la chaîne magique:

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"

Exemple: La lettre Aci-dessus est associée à 46 ( 380997542 % 106 % 79 % 47) et le 46ème élément de la chaîne magique est A :)

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

BONJOUR LE MONDE :

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

f(asciiArt)    // HELLO WORLD

ASCII:

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

f(asciiArt)    // ASCII

PPCG:

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

f(asciiArt)    // PPCG

Édite

• Enregistré 3 octets en supprimant .avant map, toArrayetmkString

PHP, 294 octets

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

Essayez-le en ligne!

Étendu

$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

Conversion de l'entrée en un format d'image

@Stevie Griffin recherche une solution pour obtenir cela à partir d'une image. Je pense qu'il ne veut pas vraiment le format d'image que j'ai utilisé.

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 peut contenir des parties HTML si elles sont ensuite incluses dans un foreignObject. Donc, je mets un pre Element dans un SVG.

Sortie d'image

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

Résoudre à partir de changements d'image

Le SVG est lisible par machine. Après avoir sauvegardé le SVG en tant que "i.svg", vous ne devez donc le remplacer $_GET[0]que preg_replace("#(^.*e>)(.*)(</p.*$)#s","$2",join(file("i.svg")))par une entrée normale + 55 octets.

Powershell, 152 146 octets

-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 de test:

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

Sortie:

HELLO WORLD
ASCII
PPCG
 ABCDEFGHIJKLMNOPQRSTUVWXYZ

Remarque:

1. $t|% s*g $c,5|% t*y|%{$s+=$s+$_} est un raccourci pour $t.substring($c,5).toCharArray()|%{$s+=$s+$_}
2. ("abcd","efgh").substring(1,2) renvoie le tableau ("bc","de")
3. ("bc","de").toCharArray() renvoie le tableau ('b','c','d','e')

C,  225  209 octets

Merci à @ceilingcat d'avoir économisé 16 octets!

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

Essayez-le en ligne!