Il est probable que quiconque a utilisé Twitter il y a quelques mois connaîtrait le «Howdy! Je suis le shérif de la mème X ". Où une simple image d'un shérif est dessinée avec des emoji et change pour s'adapter à un thème. J'ai donc pensé qu'il était temps pour le shérif de Code Golf. Le voici:

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

Celui-ci en particulier a des «pixels» qui font un caractère de large et un caractère de haut. Pour le générer, les arguments seront 1 et 1.

Et s'il devait être plus large que grand?

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

Il a une hauteur de 1, mais une largeur de 2.

Règles:

• Le défi consiste à écrire du code pour dessiner votre propre shérif de Code Golf, dans le moins de caractères possible.
• Utilisez n'importe quel langage de programmation que votre cœur désire.
• Votre code doit prendre deux arguments, tous deux des entiers, pour la hauteur et la largeur du shérif.
• La sortie doit être composée d'espaces blancs simples pour l'arrière-plan et de tout autre caractère que vous choisissez pour le shérif. (J'ai utilisé des hachages pour les cas de test, mais peu importe ce que vous utilisez).
• Il devrait être possible que la hauteur soit un entier négatif, inversant l'image.
• La largeur peut être un entier négatif, mais comme l'image est symétrique, elle sera identique à sa valeur positive.
• Les espaces blancs à la fin ne sont pas pertinents.
• Si l'un des arguments est 0, cette dimension est «aplatie» en une seule ligne ou colonne. La longueur de cette ligne est l'autre argument multiplié par la hauteur ou la largeur du shérif, respectivement.
• Si les deux arguments sont 0, les deux lignes sont «aplaties», laissant un seul caractère positif.
• Pas indispensable, mais veuillez inclure un lien vers un interprète en ligne tel que tio.run
• La sortie doit être une chaîne, sur plusieurs lignes, ou sortie vers la console.

Cas de test

1 haut, 1 large

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

2 haut, 1 large

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

1 haut, 2 large

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

2 haut, 2 large

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

-1 haut, 1 large

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

1 haut, -1 large

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

0 haut, 0 large

#

1 haut, 0 large

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

0 haut, 2 large

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

Amusez-vous bien!

JavaScript (ES6), 171 octets

Prend une entrée dans la syntaxe de curry (width)(height). Renvoie un tableau de chaînes.

w=>h=>[...Array((h>0?h:-h)*16||1)].map((_,y)=>'012345678'.replace(/./g,x=>' #'[((c=+'3733317900134444'[(h<0?16-~y/h:y/h)|0]||17)>>4-x|c>>x-4)&1|!h].repeat(w>0?w:-w))||'#')

Essayez-le en ligne!

Comment?

Seule la moitié gauche du shérif est codée sous forme de masques binaires binaires, y compris la colonne du milieu:

    ##.         00011     3
   ###..        00111     7
    ##.         00011     3
    ##.         00011     3
    ##.         00011     3
     #          00001     1
   ###..        00111     7
  #  #  .       01001     9
 #   #   .  --> 10001 --> 17
 #   #   .      10001     17
     #          00001     1
    ##.         00011     3
   #   .        00100     4
   #   .        00100     4
   #   .        00100     4
   #   .        00100     4

$9$$17$$0$

'3733317900134444'

$0 \le x \le 8$$0 \le y \le 15$$(x,y)$

' #'[                                  // character lookup:
  (                                    //   0 = space
    (                                  //   1 = '#'
      c = +'3733317900134444'[y] || 17 // extract the bitmask for this row; 0 -> 17
    )   >> 4 - x                       // test the left part, middle column included
    | c >> x - 4                       // test the right part, middle column also included
  ) & 1                                // isolate the least significant bit
]                                      // end of character lookup

Python 2 , 228 218 202 202 189 173 octets

lambda h,w:sum(([''.join('# '[int(n)]*abs(w)for n in bin([62,120,224,238,438,750][int(l)])[2:])or'#']*abs(h)for l in'1211102455013333'),[])[::1-(h<0)*2]or['#'*9*abs(w)or'#']

Essayez-le en ligne!

Alternatives:

Python 2 , 173 octets

lambda h,w:sum(([''.join('# '[int(n)]*abs(w)for n in bin(ord(' >w(8\x96I'[l])*l)[2:])or'#']*abs(h)for l in map(int,'3433314655132222')),[])[::1-(h<0)*2]or['#'*9*abs(w)or'#']

lambda h,w:sum(([''.join('# '[int(n)]*abs(w)for n in bin(ord(' >w(8\x96I'[int(l)])*int(l))[2:])or'#']*abs(h)for l in'3433314655132222'),[])[::1-(h<0)*2]or['#'*9*abs(w)or'#']

Perl 5 , 169 166 157 157 octets

@a=map"$_\n",(split 1,'  #####1   ###1    #1 #  #  #1#   #   #1  #   #')
[1011120344215555=~/./g];
print s/./$&x abs"@F"/ger x abs$F[1]for$F[1]<0?reverse@a:@a;

Essayez-le en ligne!

Peut-être pourrait-on gagner plus en tripotant un peu.

Fusain , 61 octets

ＮθＮη¿θＦ⪪”{“↷Ｃ¿2t´⁴Ｑ19·“*Ｔy”!Ｅ↔θ∨⭆ι×μ↔η#×#∨×⁵↔η¹‖ＯＯ←∨↔η¹¿‹θ⁰‖↓

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

ＮθＮη

Saisissez les dimensions.

¿θＦ⪪”{“↷Ｃ¿2t´⁴Ｑ19·“*Ｔy”!

Si la hauteur n'est pas nulle, bouclez sur la moitié droite du shérif ...

Ｅ↔θ

... en répétant la hauteur absolue nombre de fois ...

∨⭆ι×μ↔η#

... si la largeur est différente de zéro, répéter chaque caractère le nombre absolu de fois, sinon a #.

×#∨×⁵↔η¹

Mais si la hauteur est nulle, répétez #5 fois la largeur absolue, mais au moins 1 #.

‖ＯＯ←∨↔η¹

Réfléchissez pour produire la moitié gauche du shérif.

¿‹θ⁰‖↓

Si la hauteur est négative, retournez le shérif.

Python 2 , 217 216 octets

h,w=input();t=[];w=abs(w)
for i in range(16):c=bin(32+int('37333179HH134444'[i],26))[-5:];t+=[[''.join(abs(w)*' #'[d>'0']for d in c+c[3::-1]),'#'][w==0]]*abs(h)
print['\n'.join(t[::[1,-1][h<0]]),'#'*(w*16or 1)][h==0]

Essayez-le en ligne!

Un riff Pythonique sur l'approche d'Arnauld .

Pouah! Fonctionne maintenant pour toutes les conditions de bord ...

Nettoyer , 299 275 272 octets

import StdEnv,Data.List
f=flatlines
r=repeatn
$0 0=['#']
$h w#w=abs w
|h==0=r(w*9)'#'
|w<1=f(r(abs h*16)['#'])
=f(if(h<0)reverse id[cjustify(w*9)(intercalate(spaces((0xde35945rem n)*10/n*w))(r((0xc8d88154f8fberem n)*10/n)(r w'#')))\\n<-map((^)10o~)[-16..0],_<-[1..abs h]])

Essayez-le en ligne!

Powershell, 174 170 octets

Inspiré par le Javascript d' Arnauld

param($w,$h)('CGCCCAGIQQACDDDD'[((0..15),(15..0))[$h-lt0]],31)[!$h]|%{$n=+$_
,(-join(4..0+1..4|%{,' #'[($n-shr$_)%2]*[Math]::Abs($w)}),'#')[!$w]*[Math]::Abs(($h,1)[!$h])}

Non golfé, expliqué et script scripté:

<#

Script uses 5 bits of integer as 5 left chars of a line of a sheriff
Script ignores other bits in this integer, so we can use 6 bit to take a ASCII letter
    ##.         1 00011     C
   ###..        1 00111     G
    ##.         1 00011     C
    ##.         1 00011     C
    ##.         1 00011     C
     #          1 00001     A
   ###..        1 00111     G
  #  #  .       1 01001     I
 #   #   .  --> 1 10001 --> Q
 #   #   .      1 10001     Q
     #          1 00001     A
    ##.         1 00011     C
   #   .        1 00100     D
   #   .        1 00100     D
   #   .        1 00100     D
   #   .        1 00100     D

#>

$f = {

param($w,$h)
(
    'CGCCCAGIQQACDDDD'[             # 5 bits of each char correspond to 5 left symbols of line of sheriff.
        ((0..15),(15..0))[$h-lt0]], # forward or reverse sequence of chars
    31                              # or sequence of one element = 11111
)[!$h]|%{                           # choose a sequence and for each
    $n=+$_                          # integer or ASCII code
    ,(  -join(
            4..0+1..4|%{            # loop on bit range 4..0 and append fliped range 1..4
                ,' #'[($n-shr$_)%2]*[Math]::Abs($w)
            }                       # returns space or # depend on bit, repeat $w times
        ),
        '#'                         # returns # for $w equal 0
    )[!$w]*[Math]::Abs(($h,1)[!$h]) # choose a sheriff line, repeat $h times
}

}

@(
    ,(1,0)
    ,(0,1)
    ,(1,-1)
    ,(0,0)
    ,(1,1)
    ,(0,0)
    ,(-2,-1)
    ,(0,0)
    ,(2,2)
) | % {
    $w,$h = $_
    $r = &$f $w $h
    $r
}