Es ist wahrscheinlich, dass jeder, der Twitter vor ein paar Monaten nutzte, etwas über das 'Howdy! Ich bin der Sheriff von X "meme. Dort, wo ein einfaches Bild eines Sheriffs mit Emoji gezeichnet wird und sich an ein Thema anpasst. Deshalb dachte ich, es sei Zeit für den Sheriff von Code Golf. Hier ist er:

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

Insbesondere dieses hat "Pixel", die ein Zeichen breit und ein Zeichen hoch sind. Um ihn zu generieren, werden die Argumente 1 und 1 sein.

Was ist, wenn er breiter sein soll als er groß ist?

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

Er hat eine Höhe von 1, aber eine Breite von 2.

Regeln:

• Die Herausforderung besteht darin, Code zu schreiben, um Ihren eigenen Sheriff of Code Golf mit möglichst wenigen Zeichen zu zeichnen.
• Verwenden Sie eine beliebige Programmiersprache, die Ihr Herz begehrt.
• Ihr Code sollte zwei Argumente für die Höhe und Breite des Sheriffs enthalten. Beide Argumente sind Ganzzahlen.
• Die Ausgabe sollte aus einzelnen Leerzeichen für den Hintergrund und allen anderen Zeichen bestehen, die Sie für den Sheriff auswählen. (Ich habe Hashes für die Testfälle verwendet, aber es spielt keine Rolle, was Sie verwenden).
• Es sollte möglich sein, dass die Höhe eine negative ganze Zahl ist, die das Bild invertiert.
• Die Breite kann eine negative ganze Zahl sein. Da das Bild jedoch symmetrisch ist, entspricht es dem positiven Wert.
• Nachgestellte Leerzeichen sind irrelevant.
• Wenn eines der Argumente 0 ist, wird diese Dimension auf eine einzelne Zeile oder Spalte reduziert. Die Länge dieser Linie ist das andere Argument multipliziert mit der Höhe bzw. Breite des Sheriffs.
• Wenn beide Argumente 0 sind, werden beide Zeilen 'abgeflacht', so dass ein einziges positives Zeichen übrig bleibt.
• Nicht unbedingt erforderlich, aber fügen Sie bitte einen Link zu einem Online-Dolmetscher wie tio.run bei
• Die Ausgabe sollte eine Zeichenfolge über mehrere Zeilen oder eine Ausgabe an die Konsole sein.

Testfälle

1 hoch, 1 breit

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

2 hoch, 1 breit

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

1 hoch, 2 breit

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

2 hoch, 2 breit

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

-1 hoch, 1 breit

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

1 hoch, -1 breit

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

0 hoch, 0 breit

#

1 hoch, 0 breit

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

0 hoch, 2 breit

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

Viel Spaß euch allen!

JavaScript (ES6), 171 Byte

Übernimmt Eingaben in der Currying-Syntax (width)(height). Gibt einen Array von Strings.

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

Probieren Sie es online!

Wie?

Nur die linke Hälfte des Sheriffs wird als binäre Bitmasken codiert, einschließlich der mittleren Spalte:

    ##.         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 189 173 Bytes

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'#']

Probieren Sie es online!

Alternativen:

Python 2 , 173 Bytes

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 Bytes

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

Probieren Sie es online!

Vielleicht könnte durch ein bisschen herumspielen mehr erreicht werden.

Holzkohle , 61 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

ＮθＮη

Geben Sie die Abmessungen ein.

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

Wenn die Höhe nicht Null ist, schleife über die rechte Hälfte des Sheriffs ...

Ｅ↔θ

... die absolute Höhe mehrmals wiederholen ...

∨⭆ι×μ↔η#

... wenn die Breite ungleich Null ist, wird jedes Zeichen absolut wiederholt, andernfalls a #.

×#∨×⁵↔η¹

Aber wenn die Höhe Null ist, dann wiederhole #5 mal die absolute Breite, aber mindestens 1 #.

‖ＯＯ←∨↔η¹

Reflektiere, um die linke Hälfte des Sheriffs zu erhalten.

¿‹θ⁰‖↓

Wenn die Höhe negativ ist, drehen Sie den Sheriff um.

Python 2 , 217 216 Bytes

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]

Probieren Sie es online!

Ein pythonisches Riff über Arnauld .

Pfui! Funktioniert jetzt für alle Randbedingungen ...

Sauber , 299 275 272 Bytes

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

Probieren Sie es online!

Powershell, 174-170 Bytes

Inspiriert von Arnauld's Javascript

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

Ungolfed, erklärt und testgeschrieben:

<#

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
}