En l'honneur d'Adam West

90

Adam West est décédé et j'aimerais rendre hommage à sa mémoire ici sur PPCG, bien que je doute qu'il soit au courant de notre existence. Bien que cet homme soit connu pour beaucoup, beaucoup de choses différentes, aucune n’est plus importante que son rôle d’homme- batte originel . Je me souviendrai toujours de mon beau-père qui surveille toujours Batman et Robin, la vieille école, à ce jour. Ce défi est de nature simpliste et ne correspond en rien à l'homme compliqué qu'est Adam West. Cependant, c'est le meilleur que je pourrais trouver, car c'est l'image la plus emblématique de la carrière de l'homme.


Je voulais poster ceci plus tôt, mais j'attendais que quelqu'un propose quelque chose de mieux.


Générez les éléments suivants (avec ou sans espaces de fin / nouvelles lignes):

           *                         *
       ****          *     *          ****
     ****            *******            ****
   ******            *******            ******
  *********         *********         *********
 ***********************************************
*************************************************
*************************************************
*************************************************
 ***********************************************
  *****       *********************       *****
    ****       ***    *****    ***       ****
       **       *      ***      *       **

C'est le , le nombre d'octets le plus bas l'emporte.

Urne Magique De Pieuvre
la source
7
Vous devriez interdire les chaînes encodées. Ce n'est vraiment pas amusant!
sergiol
7
Il n'était pas le Batman original. Cet honneur appartient à Lewis Wilson.
Shaggy
42
Quand j'ai vu le titre, je pensais que le résultat serait "na-na-na-na-na-na-na-na-na-na-na-na-na-na".
D Krueger
3
@DKrueger: résumez-le dans une autre question :)
Olivier Dulac
4
Pourquoi cela n'a-t-il pas commencé l'année dernière? Carrie Fisher, Prince, David Bowie et Alan Rickman!
Caird coinheringaahing

Réponses:

47

Gelée , 44 octets

“¡©İ'¹!ðkW>ṅṙẏṙlœf:ߌÆ@Ƥ’b25o99Jx$ị⁾ *s25ŒBY

Essayez-le en ligne!

Comment ça fonctionne

“¡©İ'¹!ðkW>ṅṙẏṙlœf:ߌÆ@Ƥ’

Ceci est un littéral numérique. Tous les caractères sont remplacés par leurs index de base 1 dans la page de code de Jelly. Le résultat est interprété comme un entier bijectif en base 250, ce qui donne

58616171447449697510361193418481584558895594063391402

Ensuite, b25convertissez cet entier en base 25 et o99remplace 0 par 99 , donnant

11 1 20 4 10 1 8 4 12 4 3 6 12 4 2 9 9 5 1 99 1 24 2 5 7 11 4 4 7 3 4 3 7 2 7 1 6 2

Jx$remplace les j ème base-25 chiffres n par n copies de j , donnant

1 1 1 1 1 1 1 1 1 1 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 5 5 5 5 5 5 5 5 5 5 6 7 7 7 7 7 7 7 7 8 8 8 8 9 9 9 9 9 9 9 9 9 9 9 9 10 10 10 10 11 11 11 12 12 12 12 12 12 13 13 13 13 13 13 13 13 13 13 13 13 14 14 14 14 15 15 16 16 16 16 16 16 16 16 16 17 17 17 17 17 17 17 17 17 18 18 18 18 18 19 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 21 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 23 23 24 24 24 24 24 25 25 25 25 25 25 25 26 26 26 26 26 26 26 26 26 26 26 27 27 27 27 28 28 28 28 29 29 29 29 29 29 29 30 30 30 31 31 31 31 32 32 32 33 33 33 33 33 33 33 34 34 35 35 35 35 35 35 35 36 37 37 37 37 37 37 38 38

Maintenant, ị⁾ *indexe dans la paire de caractères. L'indexation étant basée sur 1 et modulaire, les nombres impairs sont remplacés par des espaces, même les astérisques. Cela donne

           *                    ****          *        ****            ****   ******            ****  *********         ***** *************************************************************************************************** ************************  *****       ***********    ****       ***    ***       **       *      **

s25hache le résultat en morceaux de longueur 25 . Si nous écrivons chaque morceau sur sa propre ligne, nous obtenons

           *             
       ****          *   
     ****            ****
   ******            ****
  *********         *****
 ************************
*************************
*************************
*************************
 ************************
  *****       ***********
    ****       ***    ***
       **       *      **

L’ atome de rebondŒB palindromise chaque bloc en ajoutant une copie inversée sans son premier caractère, ce qui donne

           *                         *           
       ****          *     *          ****       
     ****            *******            ****     
   ******            *******            ******   
  *********         *********         *********  
 *********************************************** 
*************************************************
*************************************************
*************************************************
 *********************************************** 
  *****       *********************       *****  
    ****       ***    *****    ***       ****    
       **       *      ***      *       **       

Enfin, Yintroduit les sauts de ligne réels.

Dennis
la source
1
Et je pensais “QƤḣọḲ£¿ẆịµñẒṢƊ¬ƒỤ2ỴÐ,ịṁ&Ḅ<ḋsḳn.⁷ṛḃṡ⁾6bḋeṁ’ṃ⁾ *s25ŒBYêtre assez court à 53 octets ...
Erik the Outgolfer
J'ai essayé comme 14 choses différentes, puis finalement j'y suis arrivé par essais et erreurs. Je n'ai pas compris ce que vous vouliez dire par "remplace 0 par 99" avant de l'avoir essayé moi-même.
Urne Magic Octopus
156

Wordfuck , 5761 2686 octets

J'imagine que l'utilisation de son nom comme code source procure à Adam West un honneur.

adam west adam west adam_wes t_a dam_we st_a dam_ west adam west adam west adam west_ad am_west_a dam_we st ad am we st ad am we st ad am west_a dam_we st_a dam_ west_ada m_w est ada m_w est ada m_west_ adam west_a dam_west_ adam_we st_ ad am_west ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am_wes t_ adam_w est_ adam west adam west adam west adam west adam we st_adam west_ad am we st ad am we st adam_w es t_ ad am west_ad am we st ad am we st ad am we st_ada m_ west_ad am we st ad am west_a da m_west_ ad am we st ad am we st ad am west_a da m_ we st adam_w es t_adam_ west_ad am we st ad am west_a da m_ we st adam_we st ad am we st ad am we st ad am we st_ada m_ we st ad am we st adam_we st ad am we st ad am we st ad am we st_ada m_ we st ad am_wes t_ adam_we st_adam we st ad am_wes t_ ad am we st ad am_west ad am we st ad am we st ad am we st adam_w es t_ ad am we st ad am_west ad am we st ad am we st ad am we st adam_w es t_ ad am we st adam_w es t_adam_ west_ad am we st_ada m_ we st ad am we st ad am west_ad am we st ad am we st ad am west_a da m_ we st ad am we st ad am_west ad am we st ad am we st ad am_wes t_ ad am we st ad am we st adam_w es t_adam_ west_ad am west_a da m_ we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st_ada m_ west_ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am west_a da m_west_ ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am_wes t_ adam_we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st adam_w es t_adam_ west_ad am west_a da m_ we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st_ada m_ west_ad am_west ad am west_a da m_ we st ad am_west ad am we st ad am we st_ada m_ we st ad am we st ad am we st ad am we st ad am we st ad am west_ad am we st ad am we st adam_w es t_ ad am we st_ada m_ west_ad am_west ad am we st adam_w es t_ ad am west_ad am we st ad am we st adam_w es t_ ad am_west ad am we st adam_w es t_ ad am we st_adam we st ad am west_a da m_ we st_adam we st ad am we st ad am_wes t_ ad am we st_ada m_ west_ad am_west ad am we st ad am we st_ada m_ we st_adam we st ad am we st ad am_wes t_ adam_we st ad am we st ad am_wes t_ ad am west_ad am we st ad am we st_ada m_ west_ad am we st ad am we st adam_w es t!

Essayez-le en ligne! (coup de tête transpilé)

Adam West chante (merci @carusocomputing)

Uriel
la source
69
C'est terrible. J'aime cela.
TheWanderer
25
Hmm. Oui. Assez bien, mais je pense que vous avez oublié un trait de soulignement sur la ligne 1.
Mateen Ulhaq
2
Y a-t-il un moyen de tester cela?
Shaggy
4
@Wilf Bienvenue à PCCG! nous ne sommes pas vraiment concurrentiels sur ce site. Bien sûr, ce n’est pas la solution gagnante, mais c’est une idée hilarante et ambitieuse, de sorte qu’il soit voté de manière à ce que plus de personnes puissent en profiter. En espérant avoir vos réponses bientôt!
Uriel
3
@Shaggy Essayez-le en ligne! (STDERR)
Adám le
67

Python, 530 529 528 524 octets

import zlib as Holy
B=list("NNAAAnAAnnAnaAannnaaaaNaAAnNanAaAanNNaNNaNaanNNANanNNANaAnAaANANAAnAaANNnAanAaNnAaAANNAaAnNANAaaANNAanAaNaNNNAaNNanAAnNNnaaaNANANANnnaaaNaaAAAANaNaNaNAnNAAAAaaaaANAaNnnAaAaNAAaANNnaaNnNnaannaaAaananannNnAAAAAanAananANAnaAAnANAAaaaAaaanaaAAaanNAnanAAnnnANAnNAnnAnnnanaNNaaaNaNNaAAnNAaaANNNANAnAaaAaNaANnNNNaaAanaaaanaaaaaAaAaNnNnnaAnANaNnnANanNA")
A=dict(N='11',A='01',n='10',a='00')   
T=""
POP=BIFF=POW=OOF=lambda:A[B.pop()]
while B:T+=chr(int(POP()+POW()+BIFF()+OOF(),2))
print Holy.decompress(T)
Rrauenza
la source
5
Oh Seigneur, je n'ai pas autant ri depuis longtemps. NAanANANaNANaNAANnAnaNANanaNA
Urne Magique Octopus
9
En code golf, nous sommes supposés réduire le nombre d'octets, mais votre entrée est plutôt lourde . ;)
PM 2Ring
34
À l'occasion, il faut faire des sacrifices pour le plus grand bien.
Rrauenza
1
Cela ressemble à quelque chose que Batman dirait. ;) Je dois admettre que je trouve le B.pop(0)légèrement ennuyeux. Pourquoi ne pas inverser Bafin que vous puissiez utiliser le beaucoup plus efficace (et plus court) B.pop()? Le pop(0)doit déplacer tous les éléments de liste restants vers le bas d'un emplacement. Bien sûr, cela se produit à la vitesse du disque, mais cela reste moins efficace que de sauter à la fin de la chaîne.
PM le 2
5
Les alias pour POP, BIFF, POW, OOFm'a fait cracher ce que je buvais sur mon moniteur. Merci lol. +1
rayryeng
21

JavaScript (ES6), 148 146 octets

_=>`n2zh2
f8l2b2l8
b8pep8
7cpepc
5ijiji
3yyq
0
0
0
3yyq
5afy8fa
98f69a96f8
f4f2d6d2f4`.replace(/./g,c=>'* '[(n=parseInt(c,36))&1].repeat(n/2||49))

Démo

Arnauld
la source
12

Python, 149 142 octets

7 octets enregistrés grâce à @ PM2Ring

for l in"b1d 74a13 54c4 36c4 2995 1o 0p 0p 0p 1o 257b 447343 727162".split():x=''.join(s*int(k,36)for s,k in zip(' *'*3,l));print(x+x[-2::-1])
Uriel
la source
Agréable. Vous pouvez x=''.join(s*int(k,36)for s,k in zip(' *'*3,l))
supprimer
Pas de soucis. J'ai réussi à écrire une version encore plus courte de Python. ;)
PM 2Ring
1
@ PM2Ring tu as mon +1
Uriel
12

MATL , 61 59 octets

' *'60:'*u9|K9j[~F9R,>ejc4Q,7;F\1l_=7sFR'F11:ZaY"13e)25ZvZ)

Essayez-le en ligne!

Comment ça fonctionne

Ceci utilise les techniques standard suivantes:

  • Comme l'image est symétrique horizontalement , seule la moitié gauche (y compris la colonne centrale) est codée.
  • L'image est linéarisée en ordre de colonne majeur (bas, puis en travers) et la séquence résultante est codée en longueur .
  • Les durées résultantes prennent des valeurs allant de 1à 11, de sorte que la séquence de durées est compressée par conversion de base, de base 11en base 94(caractères ASCII imprimables à l'exception des guillemets simples, qui auraient besoin d'un caractère d'échappement).
Luis Mendo
la source
1
Il y a 60 exécutions en ordre de colonne majeur, mais seulement 38 en rangée majeure. Est-ce que cela économiserait des octets?
Dennis
@Dennis Le problème est que, dans ce cas, les longueurs d'exécution sont [1:12 20 24 99]ce qui rend la compression plus difficile. Ma meilleure tentative est à 60 octets
Luis Mendo
Plutôt que de construire le jeu exact, avez-vous essayé simplement d’utiliser la base 25 et de remplacer 0 par 99 avec, par exemple Y|,? Je ne connais pas assez de guichets automatiques MATL pour vérifier si c'est effectivement plus court ...
Dennis
@ Dennis Cela semble prometteur. En utilisant l'ensemble [1:24 99]j'ai enlevé un octet . Si j'utilise [0:24](base 25) je ne sais pas comment me transformer 0en 99quelques octets
Luis Mendo
1
Right Y|ne fonctionne pas dans MATL / Octave comme dans Jelly / Python. Dans ce dernier, 0 or 99donne 99 ...
Dennis
7

05AB1E , 47 octets

„ *19×S•«M;Ó8ζ?èYÑ?½¨/Ž´.δòÈÖ<•25вт<19ǝ×J13ä€û»

Essayez-le en ligne!

Emigna
la source
L'algorithme de Dennis porté, non?
Erik l'Outgolfer
@EriktheOutgolfer: Emprunté replace 99 trickà lui (sauvegardé 4 octets sur le chemin direct). Toujours à la recherche d'un meilleur moyen cependant.
Emigna
-1 en utilisant à la .∞place de €û»(les miroirs joignent implicitement les listes sur les nouvelles lignes en premier dans la version héritée, avant d'appliquer le miroir). J'ai aussi essayé d'utiliser au ₂вlieu de 25в, mais malheureusement l'entier compressé est alors 1 octet plus aussi bien, il ne sauve rien: •2Ø°×á[1∊Œ)’˜Àå<тIÞ‡p5ÉQ•₂в.
Kevin Cruijssen
7

vim, 168 156 octets

:nm N a <C-v><ESC>
:nm A a*<C-v><ESC>
:nm B aY<C-v><ESC>yyp!!rev<C-v><CR>kJh4xo<C-v><ESC>
11NA13NB7N4A10NA3NB5N4A12N4AB3N6A12N4AB2N9A9N5ABN24AB25ABkyyppjN24AB2N5A7N11AB4N4A7N3A4N3AB7N2A7NA6N2ABdd

Cela suppose un environnement Unix, pour rev. J'utilise un (compter, caractère) assez simple encodage, avec N et A un appending et *respectivement, et B faire la copie et la marche arrière.

Dans le fichier réel, les entrées entre crochets sont remplacées par les octets littéraux qu'elles représentent. <C-v>est 0x16, <ESC>est 0x1b et <CR>est 0x0d.

Essayez-le en ligne

Rayon
la source
Je pense qu'il serait plus rapide de ne pas prendre la peine de créer les macros "b" et "c", mais de les remapper directement. :nm N a <C-v><esc>et:nm A a*<C-v><esc>
DJMcMayhem
@DJMcMayhem Donc, c'est le cas. Pour une raison quelconque, j’ai pensé qu’il serait plus difficile de stocker le <C-v>fichier dans un fichier qu’il ne l’est. J’ai donc utilisé la méthode du rond-point afin de pouvoir le tester { cat foo.vim; echo ':wq'; } | vim out.txt. Je ne sais pas pourquoi il ne m'est pas venu à l'esprit d'essayer <C-v><C-v>hier.
Ray
Je suis content de savoir que ça fonctionne! Essayez-le en ligne pour tester les réponses de vim pour plus de commodité . , qui utilise vraiment un esolang que j'ai écrit, mais de toute façon, il est (généralement) rétro-compatible. Le -vdrapeau vous permet d’utiliser les descriptions de la clé vim (comme <C-v>et d’autre
chose
@DJMcMayhem Très bien. Merci.
Ray
Tu ne peux pas écrire <NL>au lieu de <NEWLINE>?
L3viathan
7

Charbon de bois , 69 54 52 48 octets

E⪪”|↖y{{﹪yc›o”n↗πf>T≔Y¿PN|ωπQβ” ⪫Eιק* μ⌕βλω‖O←

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Edit: Merci à @ ASCII seulement, sauvé 4 octets par le passage d'un indicateur distinct en boucle sur indices, 7 octets en utilisant le (non documenté?) ⸿Caractère, et 4 autres octets en utilisant l'alphabet pour le codage de longueur d'exécution. Enregistré 2 autres octets, car AtIndexprend automatiquement le modulo. Enregistré 4 octets supplémentaires car Mapcrée automatiquement une variable d'index. Explication:

Print(Map(

L'extérieur Maprenvoie un tableau. Printpoignées en imprimant chaque élément sur une ligne, ce qui évite d' avoir à la main Joinentre eux avec \n.

Split("anb adbke eme fjj y z z z y lhf dedhe cgbhc" " "),

La chaîne code toutes les demi-lignes de la sortie. Les lettres en alternance font référence au nombre de *s et d'espaces ( a=0est utilisé pour gérer une ligne commençant par un espace). L'espace est un choix commode de délimiteur, mais s'avère également bien compresser (x se compresse également sur un total de 55 octets). Chaque ligne est traitée séparément. (Remarque: le déverbosifiant ne parvient pas à supprimer le séparateur entre une chaîne compressée et non compressée, sinon le code aurait une ,lisibilité.)

Join(Map(i, Times(AtIndex("* ", m), Find(b, l))), w)));

Boucle sur chaque lettre, en développant le nombre approprié de *s ou d'espaces. La variable mest l'index de boucle interne pour cela Map, alors que lcontient la lettre. Le résultat est ensuite Joinédité dans une seule chaîne en utilisant la chaîne vide prédéfinie w.

ReflectOverlap(:Left);

Une fois toutes les lignes imprimées, faites tout ce qui est à gauche, en superposant la colonne du milieu.

J'ai essayé de gérer les nouvelles lignes, les espaces et les étoiles dans une boucle, mais il a fallu deux octets supplémentaires de cette façon:

Print(Join(Map("anb adbke eme fjj y z z z y lhf dedhe cgbhc", Ternary(Equals(" ", i), "\n", Times(AtIndex("* ", k), Find(b, i)))), w));
ReflectOverlap(:Left);
Neil
la source
1
+1 J'ai vraiment besoin d'apprendre le charbon de bois (ainsi que Hexagony et Cubix). Trois de mes langages de programmation préférés que je vois ici. Btw, je suppose que vous aviez déjà l'intention de le faire, mais pourriez-vous ajouter une explication?
Kevin Cruijssen
@KevinCruijssen Hmm, je suppose que même le code détaillé doit être clarifié ... cela suffit-il?
Neil
Ah, je n'avais pas remarqué que le TIO contenait la version verbeuse tbh. Mais néanmoins, une explication dans la réponse elle-même ne fait jamais de mal, alors merci d'avoir pris le temps de l'écrire.
Kevin Cruijssen
Je veux apprendre le fusain, mais il faut une page comme 05AB1E, qui explique ce que fait chaque caractère de la page de code sans avoir à plonger dans le code.
Urne Magic Octopus
2
@carusocomputing Ce n'est pas si mal: en plus des chaînes compressées, vous avez des chaînes normales (caractères ASCII et pilcrow), des nombres (chiffres en exposant), des flèches (... des flèches), des commandes (généralement des lettres majuscules) et des opérateurs (tout sinon), afin que vous puissiez ensuite les rechercher sur la page appropriée du wiki.
Neil
6

Clojure, 833 437 octets

Presque par définition, Clojure ne gagnera jamais de prix pour plus de brièveté, mais comme je me réjouissais CHAQUE SEMAINE DE COMMENCER aux DEUX épisodes (count 'em - DEUX ) de Batman (même temps de Bat, même canal de Bat!), Il est clair qu'il y a pas de temps a perdre!

Rapide Robin - à la Bat-REPL !!!

(defn r[c n](clojure.string/join(repeat n c)))(defn pl[col](loop[i 0 c " "](print(r c (nth col i)))(if(< i (dec (count col)))(recur (inc i) (if (= c " ") "*" " "))(println))))(defn p[](loop[lines [[11 1 25 1][7 4 10 1 5 1 10 4][5 4 12 7 12 4][3 6 12 7 12 6][2 9 9 9 9 9][1 47][0 49][0 49][0 49][1 47][2 5 7 21 7 5][4 4 7 3 4 5 4 3 7 4][7 2 7 1 6 3 6 1 7 2]] i 0] (pl (nth lines i))(if (< i (dec (count lines)))(recur lines (inc i))nil)))

Version non-golfée:

(defn repstr [c n]
  (clojure.string/join (repeat n c)))

(defn print-bat-signal-line [col]
  (loop [i  0
         c  " "]
    (print (repstr c (nth col i)))
    (if (< i (dec (count col)))
      (recur (inc i) (if (= c " ") "*" " "))
      (println))))

(defn print-bat-signal []
  (loop [lines [[11 1 25 1]  ; spaces asterisks spaces asterisks
                [7 4 10 1 5 1 10 4]
                [5 4 12 7 12 4]
                [3 6 12 7 12 6]
                [2 9 9 9 9 9]
                [1 47]
                [0 49]
                [0 49]
                [0 49]
                [1 47]
                [2 5 7 21 7 5]
                [4 4 7 3 4 5 4 3 7 4]
                [7 2 7 1 6 3 6 1 7 2]]
        i      0]
    (print-bat-signal-line (nth lines i))
    (if (< i (dec (count lines)))
      (recur lines (inc i))
      nil)))

RIP Adam West. Aussi ridicules que soient ces émissions, ceux d’entre nous qui sommes des enfants vous saluent.

Bob Jarvis
la source
Bien que non joué au golf, il bat toujours la réponse du chat heh.
Urne magique Octopus
Version golfée ajoutée. Je le tournerais de côté pour lui donner l'impression de grimper sur un mur si je le pouvais. :-)
Bob Jarvis le
6

C (gcc) , 191 octets

#define x 16777215
char*b,*c,a[50];l[]={4096,122888,491535,2064399,4186143,x/2,x,x,x,x/2,4064255,983495,98435,0},*p=l;main(){for(;*p;p++,puts(a))for(b=c=a+23;b>=a;*p/=2)*b--=*c++=" *"[*p&1];}

Essayez-le en ligne!

Hagen von Eitzen
la source
6

Diverses solutions, toutes utilisant le codage par longueur, avec diverses techniques pour coder les données RLE.

Python 3, 125 121 octets

Cette version utilise un bytes chaîne pour stocker les données.

s=''
for c in b'<)@4/:),0/>/,3>/*981(WYYY(W*14=./4-.-4+4)2+':s+=' *'[c%2]*(c//2-19);s*=len(s)<25or print(s+s[-2::-1])or 0

Soit sune chaîne d'étoiles ou d'espaces. Ensuite, le ncodage en octets sest donné par

n = 38 + 2*len(s) + (s[0]=='*')

Python 2, 133 126 octets

Cette version utilise un codage alphabétique. La valeur de la lettre détermine la longueur de la chaîne de sortie, la casse de la lettre détermine si elle est composée d'espaces ou d'étoiles.

s=''
for c in'kAmgDjAceDlDcFlDbIiEaXYYYaXbEgKdDgCdCgBgAfB':
 s+=' *'[c<'a']*(int(c,36)-9)
 if len(s)>24:print s+s[-2::-1];s='' 

Ma solution Python 2 originale de 133 octets.

Cette version utilise des chaînes de longueur nulle afin de pouvoir alterner facilement entre les chaînes étoiles et les chaînes spatiales.

s=''
for c,n in zip(24*' *','b1d074a13054c436c429951o0p0p0p1o257b447343727162'):
 s+=c*int(n,36)
 if len(s)>24:print s+s[-2::-1];s=''

Juste pour le plaisir, voici un one-line utilisant le codage alphabétique.

Python 2, 148 octets

print'\n'.join(''.join(s+s[-2::-1])for s in zip(*[iter(''.join(' *'[c<'a']*(int(c,36)-9)for c in'kAmgDjAceDlDcFlDbIiEaXYYYaXbEgKdDgCdCgBgAfB'))]*25))

Pour encore plus de plaisir, voici un motif du Game of Life de Conway qui génère une version du logo Batman. J'ai dû doubler chaque ligne pour que le rapport d'aspect soit à peu près identique à celui de la version texte. Ce modèle ne calcule pas vraiment le logo (bien qu’il soit possible de faire des calculs dans Life - c’est Turing-complet), il le rejoue simplement à partir de boucles mémoire, donc je suppose que je ne peux pas l’afficher sous forme d’entrée de Je l’ ai créé en utilisant un script Python que j’ai écrit il ya quelques années). ;)

Il est encodé dans un format RLE assez standard que la plupart des moteurs Life peuvent charger. Si vous ne possédez pas de programme GoL (par exemple, Golly ), vous pouvez le visualiser en action en ligne avec ce moteur de vie en ligne , qui peut importer des fichiers Life RLE. Voici une version PNG de ce modèle de vie . Certains programmes Life (y compris Golly) peuvent charger des modèles de vie à partir de fichiers PNG et de divers autres formats de fichier image.

PM 2Ring
la source
6

T-SQL, 283 276 222 octets

SELECT CAST(DECOMPRESS(CAST('H4sIAAAAAAAEAFNQgAMtBVxAi5cLxgICdB3IAkAAVYuqEsLHIgRWjV0KqxBIvZYWujQeEaAGLdIALxeJGuinhXSvQEMCPVSQAbIcJPJQReGSSHxU9WAeSppAqEMoBwCfudAGawIAAA=='as XML).value('.','varbinary(max)'))AS varchar(max))

Implémentation de la compression GZIP de la chaîne batman d'origine, via la méthode publiée ici . Cela ne fonctionne que dans SQL 2016 et versions ultérieures.

Pour les versions SQL antérieures, utilisez ma méthode précédente ( 276 octets ):

DECLARE @ CHAR(999)=REPLACE(REPLACE(REPLACE('PRINT SPACE(11#1$25#1&$7#4$10#1$5#1$10#4&$5#4$12#7$12#4&$3#6$12#7$12#6&$2#9$9#9$9#9&$1#47&#49&#49&#49&$1#47&$2#5$7#21$7#5&$4#4$7#3$4#5$4#3$7#5&$7#2$7#1$6#3$6#1$7#2)','#',')+REPLICATE(''*'','),'$',')+SPACE('),'&',')+CHAR(13')EXEC(@)

En gros, je code manuellement une chaîne géante qui détermine ce qu'il faut imprimer ensuite, en utilisant la méthode suivante:

  • #7 est remplacé par +REPLICATE('*',7)
  • $4 est remplacé par +SPACE(4)
  • & est remplacé par +CHAR(13)

Après remplacement, la chaîne de caractères complète de 958 ressemble à (avec des sauts de ligne à chaque ligne du symbole Batman:

PRINT 
SPACE(11)+REPLICATE('*',1)+SPACE(25)+REPLICATE('*',1)+CHAR(13)
+SPACE(7)+REPLICATE('*',4)+SPACE(10)+REPLICATE('*',1)+SPACE(5)+REPLICATE('*',1)+SPACE(10)+REPLICATE('*',4)+CHAR(13)
+SPACE(5)+REPLICATE('*',4)+SPACE(12)+REPLICATE('*',7)+SPACE(12)+REPLICATE('*',4)+CHAR(13)
+SPACE(3)+REPLICATE('*',6)+SPACE(12)+REPLICATE('*',7)+SPACE(12)+REPLICATE('*',6)+CHAR(13)
+SPACE(2)+REPLICATE('*',9)+SPACE(9)+REPLICATE('*',9)+SPACE(9)+REPLICATE('*',9)+CHAR(13)
+SPACE(1)+REPLICATE('*',47)+CHAR(13)
+REPLICATE('*',49)+CHAR(13)
+REPLICATE('*',49)+CHAR(13)
+REPLICATE('*',49)+CHAR(13)
+SPACE(1)+REPLICATE('*',47)+CHAR(13)
+SPACE(2)+REPLICATE('*',5)+SPACE(7)+REPLICATE('*',21)+SPACE(7)+REPLICATE('*',5)+CHAR(13)
+SPACE(4)+REPLICATE('*',4)+SPACE(7)+REPLICATE('*',3)+SPACE(4)+REPLICATE('*',5)+SPACE(4)+REPLICATE('*',3)+SPACE(7)+REPLICATE('*',5)+CHAR(13)
+SPACE(7)+REPLICATE('*',2)+SPACE(7)+REPLICATE('*',1)+SPACE(6)+REPLICATE('*',3)+SPACE(6)+REPLICATE('*',1)+SPACE(7)+REPLICATE('*',2)

Ce qui est exécuté en tant que SQL dynamique, produisant la sortie suivante:

           *                         *
       ****          *     *          ****
     ****            *******            ****
   ******            *******            ******
  *********         *********         *********
 ***********************************************
*************************************************
*************************************************
*************************************************
 ***********************************************
  *****       *********************       *****
    ****       ***    *****    ***       *****
       **       *      ***      *       **
BradC
la source
5

PHP , 137 octets

<?=gzinflate(base64_decode(U1CAAy0FXECLC8YAAnQNyAJAwIVFIYSPRYgLLkWEYrByLS10WTwiXAgmcYCLRPV00kGyN6BhgB4eyABZjgstyqAsuDpU5YjEgJIOEKoQigE));

Essayez-le en ligne!

PHP , 177 octets

foreach(["9zojk",a2878,aa4nb,b7u9z,chbf3,eze2n,jz6rj,jz6rj,jz6rj,eze2n,cepdr,ako8z,a1pc1]as$v)echo$t=strtr(substr(base_convert($v,36,2),1),10,"* "),"* "[$k++<2],strrev($t),"\n";

Essayez-le en ligne!

PHP , 179 octets

for(;$o=ord(kAlgDjAbeDlCcFlCbIiDaWXXXaWbEgJdDgCdBgBgAfA[$i++]);($x+=$s)%24?:print$r.("* "[$k++<2]).strrev($r)."\n".$r="")$r.=strtr(str_repeat($b=+($o>96),$s=$o-64-$b*32),10," *");

Essayez-le en ligne!

Jörg Hülsermann
la source
Votre premier exemple a besoin de citations
Steven Penny
2
@StevenPenny Non, ce n'est pas le cas. Avez-vous vérifié le lien d' essayer en ligne ?
Ovs le
1
@StevenPenny Dans ce cas, PHP utilise le transtypage de constantes non existantes en chaînes. Je jette seulement une erreur de notification qui est autorisée dans Codegolf. Et le "=" manquant à la fin de la chaîne encodée en base64 sera ajouté automatiquement
Jörg Hülsermann
4

Java, 296 214 octets

Golfé:

()->{String r="";boolean b=1<0;for(int a:";1I1074:151:4054<7<4036<7<6029999901_10a10a10a01_0257E570447345437407271636172".toCharArray()){for(int i=0;i<a-48;++i)r+=(b?'*':' ');if(a<49)r+='\n';else b=!b;}return r;}

Ungolfed:

public class InHonorOfAdamWest {

  public static void main(String[] args) {
    System.out.println(f(() -> {
      String r = "";
      boolean b = 1 < 0;
      for (int a : ";1I1074:151:4054<7<4036<7<6029999901_10a10a10a01_0257E570447345437407271636172".toCharArray()) {
        for (int i = 0; i < a - 48; ++i) {
          r += (b ? '*' : ' ');
        }
        if (a < 49) {
          r += '\n';
        }
        else {
          b = !b;
        }
      }
      return r;
    }));
  }

  private static String f(java.util.function.Supplier<String> f) {
    return f.get();
  }
}

la source
Pourrait utiliser ";1I1074:151:4054<7<4036<7<6029999901_10a10a10a01_0257E570447345437407271636172"pour les données, et en for(char a:x){a=(int)a-48; [...]gros ajoute 48 à chacun des nombres et les convertit en leur équivalent en caractères ASCII. Je crois que cela vous fera économiser 70 à 80 octets. De plus, je pense que le codage en dur des données dans le lamba réduira également le nombre d'octets.
Urne Magic Octopus
Aussi boolean b=false;peut être boolean b=1<0, ou mieux encore , vous pouvez utiliser un intet combiner également la déclaration pour isur la même ligne;).
Urne Magic Octopus
1
@carusocomputing merci, je n'ai pas pensé à l'enfiler dans une chaîne. La vôtre avait une mauvaise valeur Unicode, je devais la régénérer et la sortie s’affiche correctement.
Puisque vous n'utilisez pas idans votre boucle, je pense que vous pouvez utiliser for(int i=0;i++<a-48;)comme fortête de ligne.
Roman Gräf
3

Bubblegum , 75

xxd dump:

00000000: cd92 b501 8050 1043 fb4c 91fa efbf 1f0e  .....P.C.L......
00000010: 2f87 d371 5814 37d3 7c35 4d2b 1826 64f6  /..qX.7.|5M+.&d.
00000020: d8aa 419c 2a11 3e75 ce25 6d1e ee9d 22e0  ..A.*.>u.%m...".
00000030: bb11 f04f 0d7f 2e38 dfc8 6926 3dad 0871  ...O...8..i&=..q
00000040: f316 1071 6db8 fc07 a408 f7              ...qm......

Essayez-le en ligne .

Trauma numérique
la source
3

Coffeescript (282 octets)

t=['6bk','59mw','l2j3','2ghsf','4zg2n','9zldr','jz6rj','4u7zz','165qf','47wj']
[0,1,2,3,4,5,6,6,6,5,7,8,9].map((d)->parseInt(t[d], 36).toString(2).padStart 25, '0').forEach (d)->console.log (d+d.split('').reverse().join('').substring(1)).replace(/0/g, ' ').replace(/1/g,'*')

Explication (utilisant ES6 en clair)

  • Comme mentionné par d’autres, l’image est symétrique, nous pouvons donc en jeter la moitié dans l’encodage.
  • Plusieurs lignes sont également répétées afin que nous puissions jeter chaque ligne dans une table de correspondance pour économiser quelques octets.
  • Nous convertissons chaque demi-ligne en binaire (en utilisant 0 comme espace et 1 en *), et nous l'encodons à la base la plus élevée en Javascript (36), ce qui donne le tableau de codage.
  • La première carte prend chaque ligne et la reconvertit dans sa demi-ligne de sortie finale, en la complétant avec des 0
  • La deuxième carte concatène chaque ligne avec sa moitié inversée (en lançant la colonne du milieu une seconde fois) et remplace les 0 et les 1 par des espaces et des * s

var t = [
    '6bk',
    '59mw',
    'l2j3',
    '2ghsf',
    '4zg2n',
    '9zldr',
    'jz6rj',
    '4u7zz',
    '165qf',
    '47wj'
];
[0,1,2,3,4,5,6,6,6,5,7,8,9].map((d) => {
    return parseInt(t[d], 36).toString(2).padStart(25, '0');
})
.forEach((d) => {
    console.log((d + d.split('').reverse().join('').substring(1))
        .replace(/0/g, ' ')
        .replace(/1/g, '*'));
});

cjbrooks12
la source
Cool réponse! Bienvenue sur le site! :)
DJMcMayhem
2

V , 102 octets

i±³ *±± 
³ *± ´*· 
´*±² ´*µ 
´*±² ¶*³ 
µ*¹ ¹*  
²´* Ä3o²µ*jo±±*· µ*  
³*´ ³*· ´*´ 
**¶ *· **· Îæ$vp

Essayez-le en ligne!

Hexdump:

00000000: 69b1 b320 2ab1 b120 0ab3 202a b120 b42a  i.. *.. .. *. .*
00000010: b720 0ab4 2ab1 b220 b42a b520 0ab4 2ab1  . ..*.. .*. ..*.
00000020: b220 b62a b320 0ab5 2ab9 20b9 2a20 200a  . .*. ..*. .*  .
00000030: b2b4 2a20 1bc4 336f b2b5 2a1b 6a6f b1b1  ..* ..3o..*.jo..
00000040: 2ab7 20b5 2a20 200a b32a b420 b32a b720  *. .*  ..*. .*. 
00000050: b42a b420 0a2a 2ab6 202a b720 2a2a b720  .*. .**. *. **. 
00000060: 1bce e624 7670                           ...$vp

Ceci utilise le codage de longueur d'exécution pour générer la moitié de batman suivante:

             *           
   *          ****       
****            ****     
****            ******   
*****         *********  
************************ 
*************************
*************************
*************************
************************ 
***********       *****  
***    ***       ****    
**      *       **      

Et puis inverse et duplique chaque ligne.

DJMcMayhem
la source
2

Python 2 , 134 octets

for w in'1D 4A13 4C4 6C4 995 O P P P O 57B 47343 27162'.split():r=''.join(c*int(k,36)for c,k in zip(3*'* ',w));print'%25s'%r+r[-2::-1]

Essayez-le en ligne!

Run-length code chaque ligne à partir de la moitié gauche de la base 36. La met en miroir pour créer la ligne complète imprimée. Les espaces en tête ne sont pas codés; au lieu de cela, la moitié gauche est rembourrée à la longueur 25.

Xnor
la source
J'aimerais pouvoir utiliser cette astuce de rembourrage dans ma version ...
PM 2Ring
2

Mathematica 151 octets

Uncompress@"1:eJxTTMoPCm5iYmBQQAAtBVxAK8bA0AjGBgJ0PcgCQABXjaoWwsciBFWPXRKrEESHlha6AjwiYC1apAGQHhK10FsTOV6Chgp6CCEDZDlYdKKKw6WR+OjxD+KiJBSEQoR6AC49ZiI="

Pas cher et peu créatif. La chaîne provient uniquement de la Compresscommande intégrée utilisée sur la sortie requise.

Mise à jour:

Je pense que je peux faire mieux avec les fonctions ImportString\ ExportStringintégrées, mais je ne vois pas comment copier et coller ExportStringcorrectement les chaînes résultantes . Par exemple

b = "           *                         *\n       ****          *     *          ****\n     ****            *******            ****\n   ******            *******            ******\n  *********         *********         *********\n ***********************************************\n*************************************************\n*************************************************\n*************************************************\n ***********************************************\n  *****       *********************       *****\n    ****       ***    *****    ***       ****\n       **       *      ***      *       **"
ExportString[b,"GZIP"]
ImportString[%,"GZIP"]

Je n'arrive pas à copier le texte de la deuxième ligne pour remplacer le texte de %la troisième.

Ian Miller
la source
2

Bash ,407 322 octets

w=`yes 1|head -30|tr -d '\n'`
for i in B1C000 74A120 54C003 36C003 299004 1C0506 0D0506 0D0506 0D0506 1C0506 257505 447342 727161
{ read a b c d e f <<<$(echo $i| fold -1| xargs)
x=`printf "%.$[0x${a}]d%.$[0x${b}]s%.$[0x${c}]d%.$[0x${d}]s%.$[0x${e}]d%.$[0x${f}]s" 0 $w 0 $w 0 $w`
echo -n $x$[f<1?0:1]
rev<<<$x
}|tr 01 \ \*

Essayez-le en ligne!

vraiment horrible, besoin de plus de temps ou d’aide à jouer au golf. il génère la sortie avec 0 et 1 et translittère à la fin. La valeur 0 et 1 est codée en hexa chiffres, en prenant soin de faire le dernier chiffre 0 pour les deux premières lignes en tant qu'indicateur pour la colonne du milieu en sortie. Utilise printf pressision en chiffres ou en chaîne pour les sorties 0 et 1. pense que le %.$[0x${X}]Cmotif pourrait être utilisé pour le jouer.

w=`yes 1|head -30|tr -d '\n'`  # w=111111111111111111111111111111   
for i in B1C000 74A120 54C003 36C003 299004 1C0506 0D0506 0D0506 0D0506 1C0506 257505 447342 727161
{ read a b c d e f <<<$(echo $i| fold -1| xargs)
printf "%.$[0x${a}]d
%.$[0x${b}]s
%.$[0x${c}]d
%.$[0x${d}]s
%.$[0x${e}]d
%.$[0x${f}]s" 0 $w 0 $w 0 $w
echo -n $[f<1?0:1]
printf "%.$[0x${f}]s
%.$[0x${e}]d
%.$[0x${d}]s
%.$[0x${c}]d
%.$[0x${b}]s
%.$[0x${a}]d\n" $w 0 $w 0 $w 0 
}|tr 01 \ \*
marcosme
la source
2

Python 3, 232 197 183 164 octets

Encore une autre réponse en python. Pas de code de compression ennuyeux cependant. Code de compression excitant.

for s in map(lambda x:x+x[-2::-1],b".$; *',$' ('.* &).* %,+, $R #T #T #T $R %()8 '')&&( *%)$(&".split()):print(*((u-35)*" "+(v-35)*"*"for u,v in zip(*[iter(s)]*2)))

J'utilise le nombre magique 35 car de cette manière, aucun caractère de contrôle, espace ou élément à échapper ne se produit. Triste de devoir traiter les espaces et les étoiles séparément, cela me coûte un peu.

Ungolfed:

for s in map(lambda x:x+x[-2::-1],   # map a list to the list and itself reversed,
                                     # minus the last (center) element
# magic string:
".$; *',$' ('.* &).* %,+, $R #T #T #T $R %()8 '')&&( *%)$(&"
.split()):                           # split on whitespace to divide into lines
 print(*(                            # unpack generator expression
(ord(s[i])-35)*" "                   # convert character to int, -25, times space
+(ord(s[i+1])-35)*"*"                # same thing with "*"
for i in range(0,len(s)-1,2)))       # for every pair in the list
L3viathan
la source
Cette méthode d'encodage est meilleure que la base 36. J'espère que cela ne vous dérange pas que je l'ai adaptée pour ma dernière solution. ;) Il y a quelques choses que vous pouvez faire pour réduire votre nombre d'octets. 1 Vous pouvez enregistrer un octet en plaçant l’ printappel sur la même ligne que le symbole for. 2 Si vous utilisez une byteschaîne, vous pouvez vous débarrasser de ces ordappels. 3 Vous pouvez remplacer le rangeen zippant une paire d'itérateurs. Voici un générateur qui combine ces deux idées: ((u-35)*" "+(v-35)*"*"for u,v in zip(*[iter(s)]*2)). Ces changements vous ramèneront à 164.
2
@ PM2Ring Cela ne me dérange pas du tout. Vous partez en vacances pour quelques semaines alors n'hésitez pas à modifier vos modifications.
L3viathan
Ah d'accord. Mais je vous laisse faire la nouvelle version sans golf.
PM le 2
@ PM2Ring déjà dans un bus, j'espère donc que quelqu'un d'autre l'approuvera
L3viathan
2

PowerShell, 305 octets, 307 octets , 316 octets

[IO.StreamReader]::new(([IO.Compression.GZipStream]::new([IO.MemoryStream]::new(([Convert]::FromBase64String('H4sIAAAAAAAEAL1SOQ4AIAjbTfwDc///QFE8gKAJi53sNQASbYBuQC3rxfANLTBm1iaFB9JIx1Yo9Tzg7YfCBeRQS7Lwr5IfZW7Cb0VDe3I8q25TcXvrTsyXOLGTbuHBUsBqAgAA')),0,102),[IO.Compression.CompressionMode]::Decompress))).ReadToEnd()

Peut-être que quelqu'un d'autre peut m'aider à raccourcir davantage, bien que je ne puisse pas comprendre comment, sauf s'il existe un moyen plus concis de définir un accélérateur de type personnalisé.

Edit: version abrégée (merci @ root). La chaîne encodée (encodage pré-base64) peut être coupée de huit positions de tableau et la plage peut ainsi être réduite. Vous ne savez pas pourquoi StreamWriter introduit ce problème dans le MemoryStream. Un aperçu du comportement sous-jacent serait apprécié.

[IO.StreamReader]::new(([IO.Compression.GZipStream]::new([IO.MemoryStream]::new(([Convert]::FromBase64String('H4sIAAAAAAAEAL1SOQ4AIAjbTfwDc///QFE8gKAJi53sNQASbYBuQC3rxfANLTBm1iaFB9JIx1Yo9Tzg7YfCBeRQS7Lwr5IfZW7Cb0VDe3I8q25TcXvrTsyXOLGTbg')),0,94),[IO.Compression.CompressionMode]::Decompress))).ReadToEnd()

Ungolfed:

#Read decoded stream 
[IO.StreamReader]::new(
    (
        #Reverse GZip encoding
        [IO.Compression.GZipStream]::new(
            #Load GZip encoded string into a memory stream
            [IO.MemoryStream]::new(
                (
                    # Convert Base64 back to GZip encoded string
                    [Convert]::FromBase64String('H4sIAAAAAAAEAL1SOQ4AIAjbTfwDc///QFE8gKAJi53sNQASbYBuQC3rxfANLTBm1iaFB9JIx1Yo9Tzg7YfCBeRQS7Lwr5IfZW7Cb0VDe3I8q25TcXvrTsyXOLGTbuHBUsBqAgAA')
                ),
                #Start of range
                0,
                #End of range. Stick the Memory Stream into a variable and use .Length here for non golf code
                102
            ),
            #Specify that we are decompressing
            [IO.Compression.CompressionMode]::Decompress
        )
    )
).ReadToEnd()

Code de compression:

$s = '           *                         *
       ****          *     *          ****
     ****            *******            ****
   ******            *******            ******
  *********         *********         *********
 ***********************************************
*************************************************
*************************************************
*************************************************
 ***********************************************
  *****       *********************       *****
    ****       ***    *****    ***       ****
       **       *      ***      *       **'

#Create Memory Stream
$ms = [IO.MemoryStream]::new()
#Initialize a stream
$sw = [IO.StreamWriter]::new(
    #Create GZip Compression stream
    [IO.Compression.GZipStream]::new(
        #Reference Memory Stream
        $ms,
        #Set mode to compress
        [IO.Compression.CompressionMode]::Compress
    )
)
#Write input into stream
$sw.Write($s)
#Close the stream
$sw.Close()

#Convert Array to Base64 string
[Convert]::ToBase64String(
    #Retrieve Memory Stream as an array
    ($ms.ToArray() | select -SkipLast 8)
)
Chirishman
la source
1
Pourquoi 102? 99 fonctionne de la même manière[IO.StreamReader]::new(([IO.Compression.GZipStream]::new([IO.MemoryStream]::new(([Convert]::FromBase64String('H4sIAAAAAAAEAL1SOQ4AIAjbTfwDc///QFE8gKAJi53sNQASbYBuQC3rxfANLTBm1iaFB9JIx1Yo9Tzg7YfCBeRQS7Lwr5IfZW7Cb0VDe3I8q25TcXvrTsyXOLGTbuHBUsBqAgAA')),0,102),[IO.Compression.CompressionMode]::Decompress))).ReadToEnd()
racine
@ root, oui, mais je ne suis pas sûr de savoir pourquoi cela fonctionne. Vous pouvez en fait le réduire de huit à 94 et supprimer les huit derniers caractères de la chaîne de saisie codée. J'ai du mal à comprendre pourquoi cela fonctionne et je ne veux pas l'ajouter à ma réponse avant que je le fasse. Ma fonction de compression ajoute-t-elle par erreur des bourrages supplémentaires?
Chirishman
1
Dans votre code de compression, les deux dernières valeurs de $ms.ToArray()0 sont toutes deux égales à 0. Sont-elles nécessaires?
racine le
Et en essayant différentes chaînes d'entrée, il semble logique que ce soit exactement deux positions de tableau inutiles à la fin. Je vais ajouter une clause pour ignorer les deux derniers éléments dans mon script de compression. J'aurais quand même aimé savoir pourquoi le rédacteur de flux ajoutait les
valeurs null à
1
Vous avez raison, il ne s'agit pas que des deux personnages, il s'agit de 8. Les 8 dernières positions du tableau ('225','193','82','192','106','2','0','0')peuvent être supprimées pour créer H4sIAAAAAAAEAL1SOQ4AIAjbTfwDc///QFE8gKAJi53sNQASbYBuQC3rxfANLTBm1iaFB9JIx1Yo9Tzg7YfCBeRQS7Lwr5IfZW7Cb0VDe3I8q25TcXvrTsyXOLGTbg==. Je ne comprends pas d'où ils viennent.
racine le
2

Perl 5, 168 octets

$_="11 *25 
7 4*10 *5 *10 4
5 4*12 7*12 4
3 6*12 7*12 6
2 9*9 9*9 9
 47
49
49
49
 47
  5*7 21*7 5
4 4*7 3*4 5*4 3*7 4
7 **7 *6 3*6 *7 *";s/$/*/gm;say s/\d+(.)/$1x$&/ger

Notez l'espace de fin à la fin de la première ligne seulement. Requiert -M5.01, ce qui est gratuit.

Peut probablement être joué au golf un peu plus.

msh210
la source
2

LaTeX, 314 octets

\documentclass{book}\begin{document}\def\r#1#2{\ifnum#2>64#1\r#1{\numexpr#2-1}\fi}\catcode`.13\catcode`!13\catcode`-13\def!#1{\r*{`#1}}\def-#1{\r~{`#1}}\let.\par\tt-K!A-Y!A.-G!D-J!A-E!A-J!D.-E!D-L!G-L!D.-C!F-L!G-L!F.-B!I-I!I-I!I.-A!o.!q.!q.!q.-A!o.-B!E-G!U-G!E.-D!D-G!C-D!E-D!C-G!D.-G!B-G!A-F!C-F!A-G!B\enddocument

La version non-golfée avec explications:

\documentclass{book}
\begin{document}
% Macro for repeating #1 (#2-64) times
\def\r#1#2{\ifnum#2>64#1\r#1{\numexpr#2-1}\fi}
% Prepare '.', '!' and '-' for usage as macro names
\catcode`.13\catcode`!13\catcode`-13
% The ASCII code of #1 (a character) is used as the number of how often '*' will be printed with \r
\def!#1{\r*{`#1}}
% Same as ! but for spaces
\def-#1{\r~{`#1}}
% . becomes a line break
\let.\par
% Set monospace font
\tt
% And finally print the whole thing
-K!A-Y!A.-G!D-J!A-E!A-J!D.-E!D-L!G-L!D.-C!F-L!G-L!F.-B!I-I!I-I!I.-A!o.
!q.!q.!q.-A!o.-B!E-G!U-G!E.-D!D-G!C-D!E-D!C-G!D.-G!B-G!A-F!C-F!A-G!B
\enddocument
Siracusa
la source
2

C # (.NET Core) , 342 333 328 185 175 octets

_=>{var r="";for(int i=0,j,k=0;i<63;i++)for(j=0;j++<"-#;#4&,#'#,&.&.).&*(.).('+++++%Q#µ#Q%')7)'(&)%&'&%)&-$)#(%(#)$)"[i]-34;){r+=i%2<1?' ':'*';if(++k%49<1)r+='\n';}return r;}

Essayez-le en ligne!

Beaucoup d'octets enregistrés après le changement d'approche. En prenant le dessin comme un tableau 2D, j'ai calculé le codage RLE par fichiers:

{ 11, 1, 25, 1, 18, 4, 10, 1, 5, 1, 10, 4, 12, 4, 12, 7, 12, 4, 8, 6, 12, 7, 12, 6, 5, 9, 9, 9, 9, 9, 3, 47, 1, 147, 1, 47, 3, 5, 7, 21, 7, 5, 6, 4, 7, 3, 4, 5, 4, 3, 7, 4, 11, 2, 7, 1, 6, 3, 6, 1, 7, 2, 7 }

Les indices impairs correspondent à s et les indices pairs à *s. Ensuite, j'ai substitué chaque numéro à une représentation imprimable ASCII (en prenant le caractère '#' à 1) et j'ai obtenu:

-#;#4&,#'#,&.&.).&*(.).('+++++%Q#µ#Q%')7)'(&)%&'&%)&-$)#(%(#)$)

Donc, l'algorithme calcule simplement le dessin en décompressant cette chaîne et en ajoutant des nouvelles lignes aux endroits appropriés.

Charlie
la source
1
Pas besoin de définir lune variable, utilisez-la directement dans la boucle. .ToString(i, 2)-> .ToString(i,2)c'est-à-dire supprimer les espaces.
TheLethalCoder
Pouvez-vous sauvegarder des octets avec des représentations décimales ou scientifiques ( 1e10) pour ces nombres? Ce défi est réellement utile ici.
TheLethalCoder
@TheLethalCoder Nope. Je viens de vérifier (défi impressionnant, au fait) et j’utilise déjà la plus petite représentation possible, donc pas de chance. J'ai même essayé de trouver le plus grand commun diviseur entre eux pour voir si je pouvais diviser les nombres par une constante, mais c'est évidemment 1.
Charlie
2

PowerShell , 129 128 octets

-join('5+C+<.4+/+4.6.616.206160/33333-Y+s*t+Y-/1?1/0.1-./.-1.5,1+0-0+1,'|% t*y|%{(' ','*')[$i++%2]*($_-42)})-split'(.{49})'-ne''

Essayez-le en ligne!

Ungolfed:

-join(
    '5+C+<.4+/+4.6.616.206160/33333-Y+s*t+Y-/1?1/0.1-./.-1.5,1+0-0+1,'|% toCharArray|%{
        (' ','*')[$i++%2]*($_-42)
    }
)-split'(.{49})'-ne''

Sortie:

           *                         *           
       ****          *     *          ****       
     ****            *******            ****     
   ******            *******            ******   
  *********         *********         *********  
 *********************************************** 
*************************************************
*************************************************
*************************************************
 *********************************************** 
  *****       *********************       *****  
    ****       ***    *****    ***       ****    
       **       *      ***      *       **

L'idée principale est très simple

Le codage de l'emblème:

  1. Concaténer toutes les lignes d'emblème à une chaîne
  2. Compter les espaces et les astérisques
  3. Encode la longueur de chaque segment + 42 en tant que caractère

Décodage (ce script):

  1. Obtenir le code du caractère moins 42 pour chaque caractère de la chaîne cripto. C'est une longueur d'un segment
  2. Ajouter un segment, composé d'un espace ou d'un astérisque répété plusieurs Lengthfois
  3. Insérer une nouvelle ligne chaque 49 symboles pour diviser des lignes

Certaines choses intelligentes

  1. L'algorithme de codage suggère un symbole avec le code 189 pour afficher 3 lignes d'astérisque du milieu. Ce symbole n'est pas ASCII. Cela fonctionne normalement avec les environnements modernes, mais il y a des ambiguïtés quant à la longueur du script. Donc, je remplace le symbole non-ASCII ½par s*t(73 astérisques, 0 espaces, 74 astérisques).
  2. J'ai coupé les bons espaces dans la dernière ligne pour économiser 1 octet. Désolé, Batman.
  3. Pourquoi le décalage est de 42? Je voulais juste :) Et cripto-string a l'air bien.

Extra: Scipt pour le codage de l'emblème

(@"
           *                         *           
       ****          *     *          ****       
     ****            *******            ****     
   ******            *******            ******   
  *********         *********         *********  
 *********************************************** 
*************************************************
*************************************************
*************************************************
 *********************************************** 
  *****       *********************       *****  
    ****       ***    *****    ***       ****    
       **       *      ***      *       **       
"@ -replace"`n"-split'( +|\*+)'-ne''|%{[char]($_.Length+42)})-join''
mazzy
la source
1

Mathematica, 271 octets

T=Table;f[x_]:=""<>T["*",x];m={f@49};n={f@47};g[y_]:=""<>T[" ",y];k[a_,b_,c_,d_,e_]:={(s=f@a<>g@b<>f@c<>g@d<>f@e)<>StringDrop[StringReverse@s,1]};Grid@{k[1,13,0,0,0],k[4,10,1,3,0],k[4,12,0,0,4],k[6,12,0,0,4],k[9,9,0,0,5],n,m,m,m,n,k[5,7,0,0,11],k[4,7,3,4,3],k[2,7,1,6,2]}
J42161217
la source
1

Braingolf , 590 580 579 577 428 423 312 octets

-111 octets parce que LeakyNun est un dieu du golf

14#
46*6394943[92+.6,5][8]#.[# ]#*[# ]#*#
[# ][#*][# ]#*[# ]#*[# ]#*...#
[# ][#*][# ][#*][# ]#*...#
# ..[#*][# ][#*][# ][#*]#
# .[#*][# ][#*][# ][#*]#
# [#*]#
&@#0[#*]#
!&@!&@# &@#.[#*]"
  "&@4645*643646366556[#*][# ][#*][# ][#*]"
    "[#*][# ]#*..# ...[#*]# ...#*..[# ][#*]#
[# ]#*.[# ]#*[# ]#*..[# ]#*[# ]#*.&@

Essayez-le en ligne!

Braingolf n'est pas bon en art ASCII, mais bon sang j'ai essayé.

Je ne peux absolument pas expliquer ce clusterf ** k

Skidsdev
la source
1

/// , 171 166 octets

5 octets sauvés parce que j'utilisais \r\ndans la source, lol.

/-/  //,/!!//'/**//&/*"//%/--//#/,,,,,!*//"/%-//!/''/"% &""" *
" !"%*% &%!
% !""!'&"!
- !*&"!'&"!'
-,&- ,&- ,*
 #'
!#
!#
!#
 #'
-!& ,,!& !*
%!" '*%!*%'& !
" *& &'&& '

Essayez-le en ligne!

Compressé en utilisant des itérations successives pour remplacer les sous-chaînes "les plus économiques" par un seul caractère. C'est presque optimal, bien que l'une des deux choses pourrait être le cas:

  1. Je pourrais utiliser des méta-remplacements (par exemple, insérer dynamiquement des regex)
  2. Il est en quelque sorte plus avantageux de remplacer d’abord des sous-chaînes moins économiques (peu probable).
Conor O'Brien
la source