Kebanyakan orang terbiasa dengan kiasan tentang menghitung domba untuk tertidur. Ada kawanan domba, beberapa dari mereka melompati pagar, dan Anda menghitung domba ketika mereka melompat. Seharusnya, ini membantu menenangkan pikiran Anda dan membuat Anda menjadi seperti tidur sehingga Anda akan tertidur.

Inilah domba ASCII yang menghadap ke kanan, menunggu untuk dihitung:

'00^>
 ||

Inilah seekor domba ASCII yang melompati pagar:

'00^>
 /\
 ++

Ini satu menghadap ke kiri, yang sudah dihitung:

<^00'
  ||

Tantangan

Diberi dua bilangan bulat input, ndan m, dengan n > 2menggambarkan berapa total domba, dan m > 0mengatakan berapa banyak domba telah dihitung, mengeluarkan representasi seni ASCII untuk menghitung domba yang tertidur.

Sekarang untuk twist:

• Karena ukuran kandang domba, baris atas hanya dapat menampung maksimal 10domba, tidak termasuk domba yang saat ini melompat yang juga harus selalu berada di baris atas.
• Baris berikutnya tidak dapat memiliki domba di luar kandang masing-masing (Anda tidak dapat memiliki lebih banyak domba di kiri di baris kedua daripada yang Anda lakukan di baris pertama, dan sama untuk kanan).
• Jika ada 11atau lebih domba total, baris paling atas harus 10ditambah dengan domba yang melompat di dalamnya.
• Memimpin / mengikuti spasi, dan spasi putih antara domba tidak masalah, asalkan:
  1. Ada minimal satu karakter spasi putih antara domba
  2. Semua karakter berbaris dengan tepat.

Selama aturan-aturan ini dipenuhi, pengaturan domba yang sebenarnya terserah implementasi Anda.

Contohnya

Misalnya, ini adalah n=3dan m=1, kasus paling sederhana.

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

Inilah n=11dan m=6, domba terbanyak yang dapat ditampung dalam satu garis horizontal.

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

Berikut adalah contoh berbeda dari itu, dengan n=11danm=1

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

Contoh yang lebih besar dengan n=30danm=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'
                                                        ||    || 

Inilah contoh dengan n=17danm=2

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

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

Inilah contoh dengan n=19danm=3

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

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

'00^>
 ||  

Perhatikan bahwa semua ini adalah contoh . Untuk yang terakhir, Anda dapat membuat susunan domba vertikal di sisi kanan, yang memungkinkan sisi kiri masuk ke dua baris. Atau mungkin 2 x 2 kuadrat domba di sisi kanan, yang juga akan cocok domba sisi kiri ke dua baris. Dll

I / O dan Aturan

• Input dapat diambil dalam format apa pun yang masuk akal dan dengan metode apa pun yang praktis .
• Leading / trailing newlines atau spasi putih lainnya adalah opsional, asalkan karakternya berbaris dengan tepat.
• Program lengkap atau fungsi dapat diterima. Jika suatu fungsi, Anda dapat mengembalikan output daripada mencetaknya.
• Output bisa ke konsol, dikembalikan sebagai daftar string, dikembalikan sebagai string tunggal, dll.
• Celah standar dilarang.
• Ini adalah kode-golf sehingga semua aturan golf biasa berlaku, dan kode terpendek (dalam byte) menang.

APL (Dyalog Unicode) , 118 byte ^SBCS

Lambda infix Anonim. Dibawa nsebagai argumen kiri dan msebagai argumen kanan. Mengembalikan hasil array bersarang, tetapi tampilan default array bersarang ini mengikuti spesifikasi. Menggunakan hingga sembilan kolom untuk domba yang dihitung dan kolom yang tersisa untuk domba yang menunggu.

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

Cobalah online!

{... } lambda anonim; ⍺adalah argumen kiri, ⍵adalah argumen benar

Fungsi ini memiliki tiga bagian berbeda: Waiting , Jumping , and Counted . Masing-masing tanda kurung, menyebabkan hasilnya menjadi daftar tiga elemen.

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

''(... )' ||' tiga baris domba yang dihitung cermin, yang tengah adalah:

 b←'''00^<' tubuh dan ditugaskan b

↑ mencampur daftar string menjadi matriks karakter (padding dengan spasi)

⌽ cerminkan itu

S← assign to S(big S heep)

⊂ lampirkan sehingga kita bisa menghadapinya sebagai satu kesatuan

⍵⍴ menggunakan jumlah domba yang dihitung untuk membentuk kembali secara siklis itu

(... )↑ ambil jumlah elemen berikut dari itu (padding dengan item prototipikal, yaitu array yang sama tetapi dengan semua karakter diganti dengan spasi)

 ⍵÷9 kesembilan dari jumlah domba yang dihitung

 ⌈ pembulatan

 9,⍨ tambahkan 9 untuk itu

 r← menetapkan ke r(apa yang kita akan r eshape dengan; baris dan kolom)

 ×/ produk dari daftar itu (ini adalah berapa banyak elemen yang kita butuhkan, termasuk isi)

r⍴ membentuk kembali itu ke array dengan panjang dimensi r

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

(... )' /\' ' ++' tiga baris domba yang melompat, yang pertama adalah:

 ¯1↓b jatuhkan karakter terakhir dari b

 '>',⍨ tambahkan kepala yang menghadap ke kanan

 s← simpan di s( s kecil heep)

↑ mencampur daftar string menjadi matriks karakter (padding dengan spasi)

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

⌽S cermin S

s@2 letakkan s di baris 2 itu (mengganti data saat ini di sana)

⊂ lampirkan sehingga kita bisa menghadapinya sebagai satu kesatuan

(... )⍴ membentuk ulang secara siklis ke ukuran berikut:

 ⍵+1 jumlah domba yang dihitung ditambah satu

 ⍺- kurangi dari total

 w← tetapkan ke w( w aiting)

(... )↑ ambil sejumlah elemen berikut dari itu (diisi dengan barang-barang prototipikal)

 ⊢/r elemen paling kanan r(yaitu jumlah kolom yang digunakan untuk domba yang dihitung)

 ⍵⌊ minimum total dan itu

 10- kurangi dari sepuluh

 d← tetapkan ke d( d ifference; kolom yang hilang)

 w÷ dibagi wdengan itu

 ⌈ round up (memberikan jumlah baris yang dibutuhkan)

 d,⍨ menambahkan d

 r← menetapkan ke r(apa yang kita akan r eshape dengan; baris dan kolom)

 ×/ produk dari daftar itu (ini adalah berapa banyak elemen yang kita butuhkan, termasuk isi)

r⍴ membentuk kembali itu ke array dengan panjang dimensi 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});

Hati-hati saat menggunakan cuplikan di bawah ini, ada risiko besar narkolepsi yang diinduksi tiba-tiba.

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

Terima kasih kepada @Jonathan Frech karena telah menghemat satu byte!

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

Cobalah online!

Belum dibuka:

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

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

Cobalah online!

AWK , 293 byte

{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" "}}

Cobalah online!

Saya mencoba menggunakan pergantian string untuk menghindari beberapa loop, tetapi butuh lebih banyak kode.

Penjelasan

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

Saya harus mengatakan seni domba agak lucu. :)

Arang , 98 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

Ｎθ

Masukkan jumlah domba yang sudah dihitung.

≔⁻⊖Ｎθη

Masukkan jumlah total domba dan hitung berapa yang masih perlu dihitung.

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

Buat array dua array. Setiap array memiliki elemen-elemen berikut:

• Seutas tali berisi setengah dari domba yang melompat
• Jumlah domba di sisi pagar itu
• Jumlah domba dalam satu baris di sisi pagar itu, yang baik
  • jumlah domba di sisi pagar itu, jika kurang dari 5, atau
  • 10 - jumlah domba di sisi lain pagar, jika kurang dari 5, atau
  • 5, jika kedua belah pihak memiliki setidaknya 5 domba

Ｊ⁰¦⁰‖Ｔ§ι⁰↗

Refleksikan kanvas dan cetak setengah domba yang melompat.

Ｆ§ι¹«

Loop melalui domba di sisi itu.

<^00'¶  || ↗

Cetak domba.

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

Jika ini adalah akhir dari baris maka cetak beberapa baris dan spasi baru untuk memulai domba berikutnya.