Die meisten Menschen sind mit der Frage vertraut, wie man Schafe zählt, um einzuschlafen. Es gibt eine Schafherde, von denen einige über einen Zaun springen, und Sie zählen die Schafe, wenn sie springen. Angeblich hilft dies, Ihren Geist zu beruhigen und Sie in einen schlafähnlichen Zustand zu versetzen, so dass Sie einschlafen.

Hier ist ein ASCII-Schaf, das nach rechts zeigt und darauf wartet, gezählt zu werden:

'00^>
 ||

Hier ist ein ASCII-Schaf, das über einen Zaun springt:

'00^>
 /\
 ++

Hier ist eine nach links, die bereits gezählt wurde:

<^00'
  ||

Die Herausforderung

Bei zwei eingegebenen Ganzzahlen nund mmit der n > 2Beschreibung, wie viele Schafe insgesamt gezählt wurden und m > 0wie viele Schafe bereits gezählt wurden, wird eine ASCII-Kunstdarstellung zum Zählen von Schafen zum Einschlafen ausgegeben.

Nun zur Wendung:

• Aufgrund der Größe der Ställe, in denen sich die Schafe befinden, kann die oberste Reihe nur maximal 10Schafe aufnehmen, wobei die aktuell springenden Schafe nicht berücksichtigt werden, die sich ebenfalls immer in der obersten Reihe befinden müssen.
• In den folgenden Reihen dürfen sich die Schafe nicht außerhalb ihrer jeweiligen Ställe befinden (in der zweiten Reihe können Sie nicht mehr Schafe links haben als in der ersten Reihe, und rechts auch nicht).
• Wenn es 11mehr oder mehr Schafe gibt, muss die oberste Reihe 10plus die springenden Schafe enthalten.
• Führende / nachfolgende Leerzeichen und Leerzeichen zwischen den Schafen spielen keine Rolle, solange:
  1. Zwischen Schafen besteht mindestens ein Leerzeichen
  2. Alle Zeichen sind entsprechend ausgerichtet.

Solange diese Regeln eingehalten werden, liegt die tatsächliche Anordnung der Schafe bei Ihrer Umsetzung.

Beispiele

Hier ist zum Beispiel n=3und m=1der einfachste Fall.

         '00^>
'00^>     /\      <^00'
 ||       ++        ||

Hier ist n=11und m=6, die meisten Schafe, die auf eine horizontale Linie passen können.

                        '00^>
'00^> '00^> '00^> '00^>  /\   <^00' <^00' <^00' <^00' <^00' <^00'
 ||    ||    ||    ||    ++     ||    ||    ||    ||    ||    ||

Hier ist ein anderes Beispiel dafür, mit n=11undm=1

                                                      '00^>
'00^> '00^> '00^> '00^> '00^> '00^> '00^> '00^> '00^>  /\   <^00'
 ||    ||    ||    ||    ||    ||    ||    ||    ||    ++     || 

Ein größeres Beispiel mit n=30undm=12

                                                '00^>
'00^> '00^> '00^> '00^> '00^> '00^> '00^> '00^>  /\   <^00' <^00'
 ||    ||    ||    ||    ||    ||    ||    ||    ++     ||    || 

'00^> '00^> '00^> '00^> '00^> '00^> '00^> '00^>       <^00' <^00'
 ||    ||    ||    ||    ||    ||    ||    ||           ||    || 

'00^>                                                 <^00' <^00'
 ||                                                     ||    || 

                                                      <^00' <^00'
                                                        ||    || 

                                                      <^00' <^00'
                                                        ||    || 

                                                      <^00' <^00'
                                                        ||    || 

Hier ist ein Beispiel mit n=17undm=2

                                                '00^>
'00^> '00^> '00^> '00^> '00^> '00^> '00^> '00^>  /\   <^00' <^00'
 ||    ||    ||    ||    ||    ||    ||    ||    ++     ||    ||

'00^> '00^> '00^> '00^> '00^> '00^>
 ||    ||    ||    ||    ||    ||  

Hier ist ein Beispiel mit n=19undm=3

                                          '00^>
'00^> '00^> '00^> '00^> '00^> '00^> '00^>  /\   <^00' <^00' <^00'
 ||    ||    ||    ||    ||    ||    ||    ++     ||    ||    || 

'00^> '00^> '00^> '00^> '00^> '00^> '00^>
 ||    ||    ||    ||    ||    ||    ||  

'00^>
 ||  

Beachten Sie, dass dies alles Beispiele sind . Im letzten Fall können Sie auf der rechten Seite eine vertikale Reihe von Schafen erstellen, sodass die linke Seite stattdessen auf zwei Reihen passt. Oder vielleicht ein 2x2 Quadrat Schafe auf der rechten Seite, das auch die Schafe auf der linken Seite in zwei Reihen passen würde. Etc.

E / A und Regeln

• Die Eingabe kann in jedem vernünftigen Format und mit jeder geeigneten Methode erfolgen .
• Führende / nachfolgende Zeilenumbrüche oder andere Leerzeichen sind optional, sofern die Zeichen entsprechend ausgerichtet sind.
• Entweder ein vollständiges Programm oder eine Funktion sind akzeptabel. Wenn es sich um eine Funktion handelt, können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
• Die Ausgabe kann an die Konsole erfolgen, als Liste von Zeichenfolgen, als einzelne Zeichenfolge usw. zurückgegeben werden.
• Standardlücken sind verboten.
• Dies ist Code-Golf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Bytes) gewinnt.

APL (Dyalog Unicode) , 118 Byte ^SBCS

Anonymes Infix Lambda. Nimmt nals linkes Argument und mals rechtes Argument. Gibt ein verschachteltes Array-Ergebnis zurück, aber die Standardanzeige dieses verschachtelten Arrays folgt den Spezifikationen. Verwendet bis zu neun Spalten für gezählte Schafe und verbleibende Spalten für wartende Schafe.

{(r⍴(×/r←d,⍨⌈w÷d←10-⍵⌊⊢/r)↑w⍴(w←⍺-⍵+1)⍴⊂s@2⌽S)(↑(s←'>',⍨¯1↓b)' /\' ' ++')(r⍴(×/r←9,⍨⌈⍵÷9)↑⍵⍴⊂S←⌽↑''(b←'''00^<')' ||')}

Probieren Sie es online aus!

{… } Anonymes Lambda; ⍺ist linkes Argument, ⍵ist rechtes Argument

Diese Funktion besteht aus drei Teilen: Warten , Springen und Zählen . Jedes ist in Klammern gesetzt, sodass das Ergebnis eine Liste mit drei Elementen ist.

Zählte (r⍴(×/r←9,⍨∘⌈⍵÷9)↑⍵⍴⊂S←⌽↑''(b←'''00^<')' ||')

''(… )' ||' Die drei Linien eines gespiegelten gezählten Schafs, wobei die mittlere lautet:

 b←'''00^<' der Körper und ist zugeordnet b

↑ Mischen Sie die Liste der Zeichenfolgen in eine Zeichenmatrix (Auffüllen mit Leerzeichen).

⌽ spiegeln das wider

S← zuweisen S(großes S heep)

⊂ Legen Sie es bei, damit wir es als Einheit behandeln können

⍵⍴ Verwenden Sie die Anzahl der gezählten Schafe, um diese zyklisch umzugestalten

(… )↑ Nehmen Sie die folgende Anzahl von Elementen daraus (Auffüllen mit prototypischen Elementen, dh dasselbe Array, wobei jedoch alle Zeichen durch Leerzeichen ersetzt werden)

 ⍵÷9 ein Neuntel der Anzahl der gezählten Schafe

 ⌈ zusammenfassen

 9,⍨ füge 9 hinzu

 r← zuweisen r(was wir wollen r eshape mit, Zeilen und Spalten)

 ×/ Produkt dieser Liste (so viele Elemente benötigen wir, einschließlich Füllungen)

r⍴ Formen Sie das zu einem Array mit den Bemaßungslängen um r

Springen (↑(s←'>',⍨¯1↓b)' /\' ' ++')

(… )' /\' ' ++' Die drei Linien eines springenden Schafs, die erste ist:

 ¯1↓b Löschen Sie das letzte Zeichen von b

 '>',⍨ einen nach rechts gerichteten Kopf anhängen

 s← store in s(kleinen s heep)

↑ Mischen Sie die Liste der Zeichenfolgen in eine Zeichenmatrix (Auffüllen mit Leerzeichen).

Warten (r⍴(×/r←d,⍨⌈w÷d←10-⍵⌊⊢/r)↑w⍴(w←⍺-⍵+1)⍴⊂s@2⌽S)

⌽S Spiegel S

s@2 setzt s in Zeile 2 , daß (die aktuellen Daten dort ersetzen)

⊂ Legen Sie es bei, damit wir es als Einheit behandeln können

(… Das )⍴ zyklisch auf folgende Größe umformen:

 ⍵+1 die Anzahl der gezählten Schafe plus eins

 ⍺- subtrahieren Sie das von der Summe

 w← zuweisen w( w arte)

(… )↑ Nehmen Sie die folgende Anzahl von Elementen daraus (Polsterung mit prototypischen Elementen)

 ⊢/r das am weitesten rechts stehende Element von r(dh die Anzahl der verwendeten Spalten für gezählte Schafe)

 ⍵⌊ das Minimum von total und das

 10- subtrahieren Sie das von zehn

 d← zuweisen d( d ifference; fehlende Spalten)

 w÷wdurch das  teilen

 ⌈ aufrunden (gibt die Anzahl der benötigten Zeilen an)

 d,⍨ anhängen d

 r← zuweisen r(was wir wollen r eshape mit, Zeilen und Spalten)

 ×/ Produkt dieser Liste (so viele Elemente benötigen wir, einschließlich Füllungen)

r⍴ Formen Sie das zu einem Array mit den Bemaßungslängen um r

Javascript, 281 , 293 , 288 Bytes

a="      ";c=((n,m)=>{b="";for(i=0;i<(q=m>(o=(l=(t=n-m-1)?t:0)/9)?m:o);++i){for(j=0;j<3;++j){b+=[a,"'00^> "," ||   "][j].repeat(r=l>i*9?(z=o-i)>1?9:Math.ceil(z*9):0)+a.repeat((l>9?9:l)-r)+(i?"     ":["'00^>"," /\\  "," ++  "][j])+[a," <^00'","   || "][j].repeat(m>i?1:0)+"\n"}}return b});

Seien Sie vorsichtig, wenn Sie das folgende Snippet verwenden. Es besteht ein hohes Risiko für plötzlich induzierte Narkolepsie.

  <form id="form">
    <input type="text" name="n" placeholder="n (sheep total)">
    <input type="text" name="m" placeholder="m (sheep in right hand field)">
    <button type="submit">Let's Go!</button>    
  </form>

  <pre id="output">
  </pre>

  <script>
    a="      ";c=((n,m)=>{b="";for(i=0;i<(q=m>(o=(l=(t=n-m-1)?t:0)/9)?m:o);++i){for(j=0;j<3;++j){b+=[a,"'00^> "," ||   "][j].repeat(r=l>i*9?(z=o-i)>1?9:Math.ceil(z*9):0)+a.repeat((l>9?9:l)-r)+(i?"     ":["'00^>"," /\\  "," ++  "][j])+[a," <^00'","   || "][j].repeat(m>i?1:0)+"\n"}}return b});
      form.addEventListener("submit", function(e){
        e.preventDefault();
  
        var n = parseInt(form.n.value);
        var m = parseInt(form.m.value);
  
        if(n != NaN && m != NaN){
          if(m > n){
            output.innerText = "C'mon man, how can you have more sheep in the right hand field than there are sheep in general?";
          }
          else{
            output.innerText = c(n, m);
          }
        }
        else{
          output.innerText = "Numbers only please.";
        }
      });
    </script>

C 392 Bytes

Vielen Dank an @Jonathan Frech für das Speichern eines Bytes!

#define F;for(
x,y,k;p(L,a,b,t)char L[][78];{F k=5;k--;)L[x=a*4+(t<2)][y=b*6+k]=t?"'00^>"[k]:"<^00'"[k];L[++x][y-=~!t]=47;L[x][++y]=92;L[x][--y]=L[x+=(t>1)][y]=t<2?'|':43;}i,l;f(n,m){char L[i=n*4][78]F;i--;){F L[i][l=77]=0;l--;)L[i][l]=32;}F l=n+~m;++i<l&&i<9+!m;)p(L,0,i,1);l-=i;p(L,0,i++,2)F;i<11&&m--;)p(L,0,i++,0)F i=0;l--;)p(L,++i,0,1)F i=1;m-->0;)p(L,i++,10,0)F l=0;l<i*4;)puts(L+l++);}

Probieren Sie es online aus!

Abgerollt:

#define F;for(

x, y, k;
p(L, a, b, t) char L[][78];
{
    F k=5; k--;)
        L[x=a*4+(t<2)][y=b*6+k] = t ? "'00^>"[k] : "<^00'"[k];

    L[++x][y-=~!t] = 47;
    L[x][++y] = 92;
    L[x][--y] = L[x+=(t>1)][y] = t<2 ? '|' : 43;
}

i, l;
f(n, m)
{
    char L[i=n*4][78]
    F; i--;)
    {
        F L[i][l=77]=0; l--;)
            L[i][l] = 32;
    }

    F l=n+~m; ++i<l&&i<9+!m;)
        p(L,0,i,1);

    l-=i;
    p(L,0,i++,2)

    F; i<11&&m--;)
        p(L,0,i++,0)

    F i=0; l--;)
        p(L,++i,0,1)

    F i=1; m-->0;)
        p(L,i++,10,0)

    F l=0; l<i*4;)
        puts(L+l++);
}

Python 2 , 222 277 Bytes

n,m=input();n-=m+1
s=" '00^>"
j=1;L='  ||  '
a,b=[[[5,5],[10-m,m]][m<9],[n,10-n]][n<9]
print' '*6*a+s
while n>0 or 0<m:N,M=min(n,a),min(m,b);n-=a;m-=b;print '%-*s'%(6*a,N*s),'%5s'%('/\  '*j)+'%*s'%(6*b,M*" <^00'")+'\n'+'%*s'%(-6*a,N*L),'%5s'%('++  '*j),'%*s'%(6*b,M*L)+'\n';j=0

Probieren Sie es online aus!

AWK , 293 Bytes

{f=" '00^>"
l="  ||  " 
L="  /\\   "
p="  ++   "
Y=$2
X=$1-Y-1
E="      "
x=$1>11?Y<5?10-Y:X>5?5:X:X
y=$1>11?X<5?10-X:5:Y
printf"%"6*(x+1)"s\n",f
for(;X>0||Y>0;A=B=""){for(i=0;i++<x;B=B (X>=0?l:E))A=A (--X>=0?f:E)
A=A L
B=B p
for(i=0;i++<y&&--Y>=0;B=B l)A=A"<^00' "
print A"\n"B"\n"
L=p=E" "}}

Probieren Sie es online aus!

Ich habe versucht, Zeichenfolgenersetzungen zu verwenden, um einige Schleifen zu vermeiden, aber es wurde viel mehr Code benötigt.

Erläuterung

{f=" '00^>"    Let's assign
l="  ||  "     some variables
L="  /\\   "   for the ASCII
p="  ++   "    pieces
Y=$2        The number of sheep that have already jumped
X=$1-Y-1    Sheep patiently waiting to jump
E="      "  A string to keep things spaced properly
x=$1>11?Y<5?10-Y:X>5?5:X:X  If there's enough sheep, let's use 5 per column
y=$1>11?X<5?10-X:5:Y        Otherwise, use enough to get 11 sheep in first row
printf"%"6*(x+1)"s\n",f     Print the top part of the jumping sheep
for(;X>0||Y>0;A=B=""){      Loop until we've printed all the sheep
  for(i=0;i++<x;              Loop over waiting sheep in this row
    B=B (X>=0?l:E))             Build the "legs" string
      A=A (--X>=0?f:E)            Build the "bodies" string
  A=A L                       Add the legs and post 
  B=B p                       for the jumping sheep
  for(i=0;i++<y&&--Y>=0;   Loop over the jumped sheep in this row
    B=B l) A=A"<^00' "     Add to the "legs" and "bodies" string 
  print A"\n"B"\n"         Print what we've got so far
  L=p=E" "                 Prevent the jumping sheep's parts from printing lots of times
}}

Ich muss sagen, dass die Schafkunst ziemlich süß ist. :) :)

Holzkohle , 98 Bytes

Ｎθ≔⁻⊖ＮθηＦ⟦⟦00¶/\¶++ θ⌊⟦⌈⟦⁵⁻χη⟧θ⟧⟧⟦0^>¶\¶+  η⌊⟦⌈⟦⁵⁻χθ⟧η⟧⟧⟧«Ｊ⁰¦⁰‖Ｔ§ι⁰↗Ｆ§ι¹«<^00'¶  || ↗¿¬﹪⊕κ§ι²”|Ｉ4Ｏ

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes. Erläuterung:

Ｎθ

Geben Sie die Anzahl der Schafe ein, die bereits gezählt wurden.

≔⁻⊖Ｎθη

Geben Sie die Gesamtzahl der Schafe ein und berechnen Sie, wie viele noch gezählt werden müssen.

Ｆ⟦⟦00¶/\¶++ θ⌊⟦⌈⟦⁵⁻χη⟧θ⟧⟧⟦0^>¶\¶+  η⌊⟦⌈⟦⁵⁻χθ⟧η⟧⟧⟧«

Erstellen Sie ein Array mit zwei Arrays. Jedes Array enthält die folgenden Elemente:

• Eine Schnur, die die Hälfte der springenden Schafe enthält
• Die Anzahl der Schafe auf dieser Seite des Zauns
• Die Anzahl der Schafe in einer Reihe auf dieser Seite des Zauns
  • die Anzahl der Schafe auf dieser Seite des Zauns, wenn weniger als 5, oder
  • 10 - die Anzahl der Schafe auf der anderen Seite des Zauns, wenn weniger als 5, oder
  • 5, wenn beide Seiten mindestens 5 Schafe haben

Ｊ⁰¦⁰‖Ｔ§ι⁰↗

Reflektiere die Leinwand und drucke das halb springende Schaf.

Ｆ§ι¹«

Schleife durch die Schafe auf dieser Seite.

<^00'¶  || ↗

Drucken Sie ein Schaf.

¿¬﹪⊕κ§ι²”|Ｉ4Ｏ

Wenn dies das Ende der Reihe ist, drucken Sie einige Zeilenumbrüche und Leerzeichen, um zum Anfang des nächsten Schafs zu gelangen.