Znasz te półki, które można ustawiać jeden na drugim, które są po prostu drewnianymi skrzynkami, które można ze sobą łączyć? Zamierzamy symulować budowę niektórych półek z książkami z grafiką ASCII.

Wszystkie nasze książki są dogodnie jednolite pod względem wielkości i wszystkie wyglądają następująco:

|X|
|X|
|X|

Półki na książki to pojedyncze pudełka, zawsze po środku o wysokości trzech znaków (wystarczająco, by zmieścić książkę stojącą pionowo), złożone z |znaków po lewej i prawej stronie, -znaków na górze i na dole oraz wystarczająco szerokich, aby zmieściły się w Xksiążkach (gdzie Xjest wejście liczba całkowita). Oto na przykład półka o dużych rozmiarach 3:

|---------|
|         |
|         |
|         |
|---------|

ponieważ można 3do tego dopasować książki

|---------|
||X||X||X||
||X||X||X||
||X||X||X||
|---------|

Dane wejściowe będą dwie ściśle dodatnie liczby całkowite, Xa Ygdzie Xjest szerokość półek, które mamy (mierzone w książkach), i Yto, ile książek musimy ułożyć w stos. Jeśli mamy więcej książek niż mieści się na jednej półce, musimy dodać więcej półek na górę. Na przykład tutaj jest wejście 4 wide / 6 books:

|------------|
||X||X|      |
||X||X|      |
||X||X|      |
|------------|
|------------|
||X||X||X||X||
||X||X||X||X||
||X||X||X||X||
|------------|

Jeśli Y % X > 0, co oznacza, że ​​liczba książek nie jest całkowitą wielokrotnością rozmiaru półki, pozostałe książki powinny znaleźć się na najwyższym lewym skrajnym miejscu (jak w przypadku 4 6powyżej), a pozostała część tej półki powinna być wypełniona spacje.

Wkład

• Dwa ściśle dodatnie liczby całkowite w dowolnym, wygodnym formacie , każdy >0.
• Możesz wziąć dane wejściowe w dowolnej kolejności (np. Najpierw rozmiar półek, a następnie liczba książek lub odwrotnie). Podaj w swoim zgłoszeniu kolejność wprowadzania.
• Możesz bezpiecznie założyć, że żadne dane wejściowe nie będą większe niż domyślny [int]rozmiar twojego języka (lub równoważny).

Wydajność

Wynikowa reprezentacja artystyczna książek i półek ASCII.

Zasady

• Wiodące lub końcowe znaki nowej linii lub białe znaki są opcjonalne, o ile same znaki są odpowiednio ustawione w linii.
• Dopuszczalny jest pełny program lub funkcja. Jeśli funkcja, możesz zwrócić dane wyjściowe zamiast je wydrukować.
• Jeśli to możliwe, dołącz link do internetowego środowiska testowego, aby inni mogli wypróbować Twój kod!
• Standardowe luki są zabronione.
• To jest golf golfowy, więc obowiązują wszystkie zwykłe zasady gry w golfa, a wygrywa najkrótszy kod (w bajtach).

Dalsze przykłady

6 wide / 2 books
|------------------|
||X||X|            |
||X||X|            |
||X||X|            |
|------------------|

2 wide / 6 books
|------|
||X||X||
||X||X||
||X||X||
|------|
|------|
||X||X||
||X||X||
||X||X||
|------|
|------|
||X||X||
||X||X||
||X||X||
|------|

4 wide / 9 books
|------------|
||X|         |
||X|         |
||X|         |
|------------|
|------------|
||X||X||X||X||
||X||X||X||X||
||X||X||X||X||
|------------|
|------------|
||X||X||X||X||
||X||X||X||X||
||X||X||X||X||
|------------|

JavaScript (ES6), 100 99 98 bajtów

Pobiera szerokość wi liczbę książek bw składni curry (w)(b).

w=>g=(b,s=`|${'-'.repeat(w*3)}|
`,r=s.replace(/---/g,_=>b&&b--?'|X|':'   '))=>(b?g(b)+s:s)+r+r+r+s

Sformatowane i skomentowane

w =>                                // main function: takes width 'w' as input, returns 'g'
  g = (                             // g = recursive function with:
    b,                              //   - b = number of books
    s = `|${'-'.repeat(w * 3)}|\n`, //   - s = top/bottom of shell, filled with '-'
    r = s.replace(                  //   - r = pattern of the current row of books,
      RegExp('---', 'g'),           //         using 's' as a template and updating
      _ => b && b-- ? '|X|' : '   ' //         'b' while building it
    )                               // NB: 'r' must be defined in the scope of 'g',
  ) =>                              //     otherwise it would be overwritten by
    (                               //     subsequent calls
      b ?                           // if there are remaining books:
        g(b) + s                    //   do a recursive call and append shell top
      :                             // else:
        s                           //   just append shell top
    ) + r + r + r + s               // append book rows and shell bottom

Przypadki testowe

let f =

w=>g=(b,s=`|${'-'.repeat(w*3)}|
`,r=s.replace(/---/g,_=>b&&b--?'|X|':'   '))=>(b?g(b)+s:s)+r+r+r+s

console.log(f(6)(2))
console.log(f(2)(6))
console.log(f(4)(9))

Bash (+ narzędzia), 130, 108, 106 bajtów

Pojedynczy, ciągły potok powłoki do renderowania twoich półek na książki.

Dziennik zmian:

• Zoptymalizowane pierwsze wyrażenie sed nieco, -12 bajtów (Thx @ Riley!)
• Zastąpiony printf + seqnieprzetworzonym printfbajtem -10
• Refaktoryzacja drugiego wyrażenia sed, -2 bajty

Grał w golfa

printf %$2s\\n|fold -$1|sed "s/ /|X|/g;:;/.\{$[$1*3]\}/!s/$/ /;t;h;s/./-/gp;x;p;p;p;x"|sed 's/.*/|&|/'|tac

$./shelf 6 8
|------------------|
||X||X|            |
||X||X|            |
||X||X|            |
|------------------|
|------------------|
||X||X||X||X||X||X||
||X||X||X||X||X||X||
||X||X||X||X||X||X||
|------------------|

Wypróbuj online!

Jak to działa

$./shelf 2 3

printf %$2s\\n- generuj n białych znaków, po jednym na książkę (pokazane jako _)

___

fold -$1 - złóż je według długości półki

__
_

sed "s/ /|X|/g;"- wymień _się X, dodawać okładki książki

|X||X|
|X|

:;/.\{$[$1*3]\}/!s/$/ /;t- prawa podkładka ze spacjami (pokazane jako _)

|X||X|
|X|___

h;s/./-/gp;x;p;p;p;x- trzykrotnie każdą linię i dodaj ---przed i po niej.

------
|X||X|
|X||X|
|X||X|
------
------
|X|   
|X|   
|X|   
------

sed 's/.*/|&|/'|tac- zawiń linie | |, odwróć za pomocą tac

|------|
||X|   |
||X|   |
||X|   |
|------|
|------|
||X||X||
||X||X||
||X||X||
|------|

Python 2, 133 113 105 bajtów

Jestem pewien, że jest lepszy sposób ...

X,Y=input()
k='|'+'---'*X+'|'
while Y:g=Y%X or X;print k+'\n'+('|'+'|X|'*g+'   '*(X-g)+'|'+'\n')*3+k;Y-=g

Dane wejściowe są pobierane width, books

-20 bajtów dzięki @ovs za zauważenie niepotrzebnej funkcji lambda!
-8 bajtów dzięki @ovs za skrócenie danych wejściowych.

Partia, 261 bajtów

@set/an=~-%1%%%2+1,b=%1-n
@set s=
@set t=
@for /l %%i in (1,1,%2)do @call set t=---%%t%%&if %%i gtr %n% (call set s=%%s%%   )else call set s=%%s%%X
@for %%s in ("|%t%|" "|%s:X=|X|%|" "|%s:X=|X|%|" "|%s:X=|X|%|" "|%t%|")do @echo %%~s
@if %b% gtr 0 %0 %b% %2

Wykorzystuje moją sztuczkę z odpowiedzi partii na Zagrajmy w tenisa, aby łatwo wydrukować wiele |postaci.

Haskell , 100 bajtów

x#yzwraca ciąg znaków dla szerokości xi yksiążek.

s?n=[1..n]>>s
x#y|x<y=x#(y-x)++x#x|w<-"---"?x,b<-"|X|"?y++"   "?(x-y)=[w,b,b,b,w]>>=('|':).(++"|\n")

Wypróbuj online!

Główną funkcją / operatorem jest #. Kiedy x<ydzieli książki na y-xi x, a następnie powraca. Kiedy x>=y, wi bsą dwa typy linii, minus zewnętrzne |s oraz znak nowej linii.

Operator pomocnika s?nłączy nkopie ciągu s.

PowerShell , 149 134 bajtów

param($w,$b)$s="|$('-'*$w*3)|"
if($a=$b%$w){,$s+,"|$('|X|'*$a)$(' '*3*($w-$a))|"*3+$s}
if($b-=$a){(,$s+,"|$('|X|'*$w)|"*3+$s)*($b/$w)}

Wypróbuj online!

Pobiera wejściowy idth $wi $books. Ustawia sznurek $sjako jedną z poziomych półek. Mamy więc dwa ifstwierdzenia.

Pierwszy sprawdza, czy mamy „resztki” książek. Jeśli tak, wysyłamy półkę, (liczbę książek plus liczba miejsc) *3i kolejną półkę.

Następnie sprawdzamy, czy po usunięciu pozostałych ( $a) pozostały jeszcze książki . Taki sam rodzaj konfiguracji, z tą różnicą, że wykorzystujemy $wliczbę książek. Ponieważ w tym momencie $bjest gwarantowana wielokrotność $w(ponieważ usunęliśmy resztę $a), nie musimy się martwić o zaokrąglanie.

Usunięto [math]::Floor()połączenie, oszczędzając 15 bajtów

Wszystkie te ciągi są pozostawione w potoku, a domniemane Write-Outputdzieje się po zakończeniu programu.

CJam , 62 61 bajtów

q~1a*W$/W$f{0e]}{{"|X|"S3*?}%s__'-3*W$*_}%1m>W%"|
|"*"||"\*o;

Pobiera dane wejściowe jako width books

Wypróbuj online!

Wyjaśnienie

q~           Read and eval input (pushes width W and books B to the stack)
1a*          Push an array containing  the number 1 B times
W$/          Split it into chunks of size W
W$f{0e]}     Pad each chunk to width W by adding 0's to the right (the last chunk might be 
              shorter than W)
{            Apply the following to each chunk:
 {            Apply the following to each number in the chunk:
  "|X|"S3*?    Push "|X|" if the number is 1, or "   " if it's 0
 }%           (end of block)
 s            Stringify (joins with no separator)
 __           Duplicate twice (each shelf is 3 identical lines)
 '-3*W$*_     Push a string containing '-' repeated 3×W times, then duplicate it
}%           (end of block)
              At this point we have an array containing sequences of 3 identical lines 
              each followed by two lines of -'s
1m>          Rotate the array 1 to the right; brings the final line of -'s to the start
W%           Reverse the array, so that the top shelf is the partially empty one
"|\n|"*      Join the array with the string "|\n|", to build the sides of the shelves
"||"\*       Join the string "||" with the shelf string (adds the first and last | chars)
o            Print the result
;            Pop and discard W

Python 3, 142 bajty

Nadal nad tym pracuję. bdotyczy „liczby książek” i wszerokości półki.

def s(b,w):
 R=b%w
 B='|\n'
 I='|'
 X='|X|'
 d=I+3*w*'-'+B
 f=I+X*w+B
 p=I+R*X+3*(w-R)*' '+B
 print(R and d+3*p+d or" ")+b//w*(d+3*f+d))

AHK, 208 bajtów

AutoTrim,Off
w=%1%
b=%2%
f:=Mod(b,w)
Loop,%w%
s=%s%---
s=|%s%|`n
If (f>0) {
Loop,%f%
t=%t%|X|
Loop,% w-f
t=%t% ` ` `
t=|%t%|`n
t:=s t t t s
}
Loop,%w%
r=%r%|X|
r=|%r%|`n
Loop,% (b-f)/w
t:=t s r r r s
Send,%t%

Kilka rzeczy mnie frustruje od dalszego grania w golfa:

• AutoHotkey nie ma wbudowanej funkcji powtarzania
• Nie można bezpośrednio używać argumentów przekazanych w argumentach ( %1%& %2%) w funkcjach matematycznych, ponieważ oczekują one wprowadzenia zmiennej lub liczby i przyjmie, że nieskalowany 1będzie numerem jeden, a nie nazwą zmiennej
• Nie jestem zbyt dobry w golfa

Łatwiejsza do odczytania wersja powyższego wygląda następująco:

AutoTrim,Off
w=%1%
b=%2%
f:=Mod(b,w)

Loop,%w%
   s=%s%---
s=|%s%|`n

If (f>0) {
   Loop,%f%
      t=%t%|X|
   Loop,% w-f
      t=%t% ` ` `
   t=|%t%|`n
   t:=s t t t s
}

Loop,%w%
   r=%r%|X|
r=|%r%|`n

Loop,% (b-f)/w
   t:=t s r r r s

Send,%t%

Jeśli a Loopnie używa nawiasów {}, to tylko następny wiersz jest częścią pętli. Jeśli ustawiasz wartość zmiennej za pomocą :=zamiast =, możesz upuścić znaki zmiany znaczenia dla znaku procentu. Tylda n jest znakiem nowej linii.

Java 7, 230 224 222 bajtów

String c(int w,int b){String r="",n="|\n",z="|";int i=0,j,k,t=b%w<1?w:b%w,x=b/w+(t!=w?1:0);for(;i++<w;z+="---");z+=n;for(i=0;i<x;i++){r+=z;for(j=0;j++<3;r+=n){r+="|";for(k=0;k<w;r+=i<1&k++>=t?"   ":"|X|");}r+=z;}return r;}

Wyjaśnienie:

String c(int w, int b){                // Method with two integer parameters and String return-type
  String r = "",                       //  The return-String
         n = "|\n",                    //  Part that's used multiple times in the code
         z = "|";                      //  Shelf part of the book-boxes
  int i = 0, j, k,                     //  Indexes used in the for-loops
      t = b%w < 1 ? w : b%w,           //  Books on top shelf
      x = b/w + (t != w ? 1 : 0);      //  Amount of shelves
  for(; i++ < w; z += "---"); z += n;  //  Create the shelf-part ("|---|"; with w times "---")
  for(i = 0; i < x; i++){              //  Loop over the rows
    r += z;                            //   Append the result with the shelf-part
    for(j = 0; j++ < 3; ){             //   Loop three times (the height of the books & boxes)
      r += "|";                        //    Append the result-String with "|"
      for(k = 0; k < w;                //    Loop over the columns
          r +=                         //     And append the result-String with:
           i < 1                       //      If this is the first row:
           & k++ >= t ?                //      And the current column is larger or equal to the amount of books in the top shelf
             "   "                     //       Use an empty space
           :                           //      Else:
             "|X|"                     //       Use the book-part
            );                         //    End of columns loop
         r += n;                       //    Append the result-String with a "|" and a new-line
       }                               //   End of the loop of three
      r += z;                          //   Append the result-String with the shelf-part
    }                                  //  End of rows loop
    return r;                          //  Return the result-String
 }                                     // End of method

Kod testowy:

Wypróbuj tutaj.

class M{
  static String c(int w,int b){String r="",n="|\n",z="|";int i=0,j,k,t=b%w<1?w:b%w,x=b/w+(t!=w?1:0);for(;i++<w;z+="---");z+=n;for(i=0;i<x;i++){r+=z;for(j=0;j++<3;r+=n){r+="|";for(k=0;k<w;r+=i<1&k++>=t?"   ":"|X|");}r+=z;}return r;}

  public static void main(String[] a){
    System.out.println(c(6, 2));
    System.out.println(c(2, 6));
    System.out.println(c(4, 9));
  }
}

Wydajność:

|------------------|
||X||X|            |
||X||X|            |
||X||X|            |
|------------------|

|------|
||X||X||
||X||X||
||X||X||
|------|
|------|
||X||X||
||X||X||
||X||X||
|------|
|------|
||X||X||
||X||X||
||X||X||
|------|

|------------|
||X|         |
||X|         |
||X|         |
|------------|
|------------|
||X||X||X||X||
||X||X||X||X||
||X||X||X||X||
|------------|
|------------|
||X||X||X||X||
||X||X||X||X||
||X||X||X||X||
|------------|

PowerShell, 109 bajtów

param($w,$b)for(;$b;$b-=$c){if(!($c=$b%$w)){$c=$w}($l="|$('-'*$w*3)|")
,"|$('|X|'*$c)$(' '*($w-$c)*3)|"*3
$l}

Skrypt testu mniej golfowego:

$f = {

param($w,$b)
for(;$b;$b-=$c){
    if(!($c=$b%$w)){$c=$w}
    ($l="|$('-'*$w*3)|")
    ,"|$('|X|'*$c)$(' '*($w-$c)*3)|"*3
    $l
}

}

@(
    ,(6, 2, 
    "|------------------|",
    "||X||X|            |",
    "||X||X|            |",
    "||X||X|            |",
    "|------------------|")

    ,(2, 6,
    "|------|",
    "||X||X||",
    "||X||X||",
    "||X||X||",
    "|------|",
    "|------|",
    "||X||X||",
    "||X||X||",
    "||X||X||",
    "|------|",
    "|------|",
    "||X||X||",
    "||X||X||",
    "||X||X||",
    "|------|")

    ,(4, 9,
    "|------------|",
    "||X|         |",
    "||X|         |",
    "||X|         |",
    "|------------|",
    "|------------|",
    "||X||X||X||X||",
    "||X||X||X||X||",
    "||X||X||X||X||",
    "|------------|",
    "|------------|",
    "||X||X||X||X||",
    "||X||X||X||X||",
    "||X||X||X||X||",
    "|------------|")
) | % {
    $w,$b,$expected = $_
    $result = &$f $w $b
    "$result"-eq"$expected"
    $result
}

Wydajność:

True
|------------------|
||X||X|            |
||X||X|            |
||X||X|            |
|------------------|
True
|------|
||X||X||
||X||X||
||X||X||
|------|
|------|
||X||X||
||X||X||
||X||X||
|------|
|------|
||X||X||
||X||X||
||X||X||
|------|
True
|------------|
||X|         |
||X|         |
||X|         |
|------------|
|------------|
||X||X||X||X||
||X||X||X||X||
||X||X||X||X||
|------------|
|------------|
||X||X||X||X||
||X||X||X||X||
||X||X||X||X||
|------------|

PowerShell, 109 bajtów, alternatywa

param($w,$b)for(;$b;$b-=$c){($l="|$('---'*$w)|")
,"|$('|X|'*($c=(($b%$w),$w-ne0)[0]))$('   '*($w-$c))|"*3
$l}

Python 2 , 120 118 bajtów

i,j=input()
a=j%i
n='|\n'
x='|'+'---'*i+n
print(x+('|'+'|x|'*a+' '*(i-a)*3+n)*3,'')[a<1]+(x+('|'+'|x|'*i+n)*3)*(j/i)+x

Wypróbuj online!

Zamierzałem spróbować tego w ciągu ostatnich kilku dni. Teraz, kiedy wreszcie mam czas, jest już krótsza odpowiedź w języku Python. No cóż, właśnie napisane jako alternatywa.

Dane wejściowe przyjmowane jako szerokość, książki

SOGL , 64 bajty

be%→M"Q└ƨS‘*ač;┼→S%‘A |e3* -* |++M?tMSeM-9*@*a+┼Ot}be÷:?{teSa┼Ot

Objaśnienie: Pierwsza funkcja:

   →M  define function M which pushes
b      the book amount
  %    mod
 e     the bookshelf width

druga funkcja:

           →S  create function S (example input: 3)          [3]
"Q└ƨS‘         push the string "|||XXX|||" (the book)        [3, "|||XXX|||"]
      *        multiply by the number on stack (book count)  ["|||XXX||||||XXX||||||XXX|||"]
       a       push variable A (later defined "|||")         ["|||XXX||||||XXX||||||XXX|||", "|||"]
        č      chop into char array                          ["|||XXX||||||XXX||||||XXX|||", ["|", "|", "|"]]
         ;     swap top 2 on stack                           [["|", "|", "|"], "|||XXX||||||XXX||||||XXX|||"]
          ┼    horizontally append                           [["||X||X||X|", "||X||X||X|", "||X||X||X|"]]

ta funkcja oczekuje liczby (liczby książek) na stosie i wyświetla książki z półkami

["||X||X||X|",
 "||X||X||X|",
 "||X||X||X|"]

Dalszy podany przykład to e = 3 (szerokość półki) ib = 8 (kwota książki)

%‘A              var A = "|||"                        
    |            push "|"                      ["|"]                
     e3*         push E * 3                    ["|", 9]             
         -*      push that many "-"es          ["|", "---------"]   
            |+   append "|"                    ["|", "---------|"]  
              +  prepend the "|"               ["|---------|"]      

jest to górna / dolna linia półki i zawsze pozostaje na pierwszej części stosu (pół pusta półka)

Pierwsza główna część

M?               }               if the modulo != 0
  tM                             output the bookshelf top/bottom line
    S                            execute the S function width the modulo
     eM-                         push bookshelf width - modulo (empty space count)
        9*                       multiply by 9 (books are 3x3 so 3x3 spaces)
          @*                     get that many spaces
            a+                   append to that "|||"
              ┼                  horizontally append
               O                 output
                t                output the bookshelf top/bottom line

I ostatnia część

be÷            floor divide book amout by width (full shelves)
   :?          if not 0 (a bug makes all loops execute once)
     {         repeat
      t        output the bookshelf top/bottom line
       eS      execute S with shelf width (full shelf)
         a┼    horizontally append "|||"
           O   output
            t  output the bookshelf top/bottom line

Java (JDK) , 124 bajty

s->b->{for(int i=0;i++<(b-~s)/s*5;)System.out.printf("|%-"+s*3+"s|%n",i%5<2?"-".repeat(s*3):"|X|".repeat(i<5&b%s>0?b%s:s));}

Wypróbuj online!

Kredyty

• -2 bajty dzięki pułapkowi cat

PHP> = 7,1, 138 bajtów

for([,$w,$b]=$argv;$i<ceil($b/$w)*5;)echo str_pad("|".str_repeat(["","|X|"][$t=($i+1)%5>1],$i++<5&&$b%$w?$b%$w:$w),$w*3+1,"- "[$t])."|\n";

Wersja online

Płótno , 33 bajty

|X|３＊×⁷３×⇵-×|３＊×╫│；２２╋Ｐ
％？％⁸｝÷［⁷⁸

Wypróbuj tutaj!

Objaśnienie (niektóre postacie zostały zastąpione, aby wyglądały bardziej monospace):

|X|3*×⁷3×⇵-×|3*×╫│;22╋P  helper function. Prints a shelf with X books
|X|                      push "|X|"
   3*                    repeat it 3 times vertically
     ×                   repeat that horizontally by the item (X) below on the stack
      ⁷3×                push width * 3
         ⇵               ceiling divide that by 2
          -×             repeat "-" that many times
            |3*          repeat "|" vertically 3 times (aka "|¶|¶|")
               ×         prepend that to the dashes (aka ¼ of a bookshelf)
                ╫│       quad-palindromize with horizontal overlap of the remainder
                           taken before and vertical overlap of 1
                  ;      get the books on top
                   22╋   and at coordinates (2;2) in the shelf, place them in
                      P  print that whole thing

%?%⁸}÷[⁷⁸  
%?  }      if width%amount (!= 0)
  %⁸         execute the helper function with width%amount on the stack
     ÷[    repeat floor(width/amount) times
       ⁷     push width
        ⁸    execute the helper function

Pip -n , 45 bajtów

Wb-:yPPZ['-X3Xa"|X|"X(Yb%a|a).sX3Xa-yRL3]WR'|

Pobiera odpowiednio szerokość i liczbę książek jako argumenty wiersza poleceń. Wypróbuj online!

Wyjaśnienie

Wykonujemy pętlę, aby drukować półki jedna po drugiej od góry do dołu. Przy każdej iteracji aktualizujemy b(liczbę książek do wydrukowania) odejmując y(liczbę książek wydrukowanych na tej iteracji). Gdy bosiągnie wartość 0, pętla kończy się.

Wb-:yPPZ['-X3Xa"|X|"X(Yb%a|a).sX3Xa-yRL3]WR'|
                                               a is 1st cmdline arg (shelf width); b is 2nd cmdline
                                                 arg (# books); s is space; y is ""
                                               Note that "" becomes zero in numeric contexts
Wb-:y                                          While b decremented by y is nonzero:
                       b%a|a                    b mod a, or a if that quantity is zero
                      Y                         Yank that value into y
                     (      )                   This is the number of books on the current shelf
               "|X|"                            Book-spine string
                    X                           Repeated y times
                                  a-y           Number of empty slots on the current shelf
                              sX3X              Three spaces for each slot
                             .                  Concatenate to the book-spines string
                                     RL3        Make a list of 3 copies of that string
         '-X3Xa                                 3*a hyphens
        [                               ]       Put that string and the above list in a list
                                         WR'|   Wrap all strings in the nested list in |
      PZ                                        Palindromize the outer list (adding a copy of the
                                                hyphens to the end of it)
     P                                          Print, joining all sublists on newlines (-n flag)

Ponieważ jest to trochę skomplikowane, oto przykład pierwszej iteracji, gdy a = 3, b = 8:

Yb%a|a       2
"|X|"X ^     "|X||X|"
^ .sX3Xa-y   "|X||X|   "
^ RL3        ["|X||X|   ";"|X||X|   ";"|X||X|   "]
['-X3Xa ^ ]  ["---------";["|X||X|   ";"|X||X|   ";"|X||X|   "]]
^ WR'|       ["|---------|";["||X||X|   |";"||X||X|   |";"||X||X|   |"]]
PZ ^         ["|---------|";["||X||X|   |";"||X||X|   |";"||X||X|   |"];"|---------|"]

który następnie drukuje jako

|---------|
||X||X|   |
||X||X|   |
||X||X|   |
|---------|

Pyth , 56 bajtów

M++GHGV_fTs*V,]Q1.DEQjCg*5\|smgL\-*L3?d"|X|""   ".[*]1N0

Akceptuje szerokość półki, liczenie książek jako osobne argumenty w tej kolejności. Spróbuj go online tutaj , lub sprawdzić wszystkie przypadki testowe od razu tutaj .

M++GHGV_fTs*V,]Q1.DEQjCg*5\|smgL\-*L3?d"|X|""   ".[*]1N0Q   Implicit: Q=1st arg, E=2nd arg
                                                            Trailing Q inferred
M                                                           Define a function, g(G,H):
 ++GHG                                                        Return G + H + G
                 .DEQ                                       Divmod E by Q, yields [E//Q, E%Q]
             ,]Q1                                           [[Q], 1]
           *V                                               Vectorised multiply the two previous results
                                                              This yields Q repeated E//Q times, then E%Q
          s                                                 Flatten
        fT                                                  Filter out falsey values (i.e. trailing 0 if present)
       _                                                    Reverse (to put partially filled shelf on top)
      V                                                     For N in the above:
                                                    ]1        [1]
                                                   *  N       Repeat the above N times
                                                 .[    0Q     Pad the above on the right with 0, to length Q
                             m                                Map the above, as d, using:
                                     ?d"|X|""   "               If d != 0, yield "|X|", else "   "
                                  *L3                           Multiply each char by 3
                                                                  Yields ['|||','XXX','|||'] or ['   ','   ','   ']
                              gL\-                              Use g to wrap each element in '-'
                            s                                 Flatten
                       g*5\|                                  Use g to add '|||||' to start and end of the above
                      C                                       Transpose
                     j                                        Join on newlines, implicit print

Dalej (gforth) , 622 bajtów (zminimalizowane (usuń komentarze, wcięcia, nazwy słów 1-znakowych) do 303 bajtów)

Moja pierwsza gra z Forthem :)

: bar 124 EMIT ;

: delimline ( width -- )
    bar
    3 * 0 DO 45 EMIT LOOP
    bar CR
;

: bookline ( width books -- )
    bar
    DUP 0 DO bar 88 EMIT bar LOOP
    2DUP = IF
        DROP DROP
    ELSE
        - 0 do 3 SPACES LOOP
    THEN
    bar CR
;

: shelf ( width books -- )
    DUP 0 = IF
        DROP DROP
    ELSE
        OVER delimline
        3 0 DO OVER OVER bookline LOOP
        DROP delimline
    THEN
;

: stack ( width books -- )
    CR
    OVER OVER OVER MOD shelf
    OVER /
    DUP 0 = IF
        DROP DROP
    ELSE 
        0 DO DUP DUP shelf LOOP
    THEN
;

6 2 stack
2 6 stack
3 5 stack
4 4 stack

Wypróbuj online!

Wydajność

| ------------------ |
|| X || X | |
|| X || X | |
|| X || X | |
| ------------------ |

| ------ |
|| X || X ||
|| X || X ||
|| X || X ||
| ------ |
| ------ |
|| X || X ||
|| X || X ||
|| X || X ||
| ------ |
| ------ |
|| X || X ||
|| X || X ||
|| X || X ||
| ------ |

| --------- |
|| X || X | |
|| X || X | |
|| X || X | |
| --------- |
| --------- |
|| X || X || X ||
|| X || X || X ||
|| X || X || X ||
| --------- |

| ------------ |
|| X || X || X || X ||
|| X || X || X || X ||
|| X || X || X || X ||
| ------------ |