Scaffali ASCII


27

Conosci quegli scaffali impilabili che sono fondamentalmente solo scatole di legno che possono essere impilati insieme? Simuleremo la costruzione di alcuni scaffali di libri con quelli con qualche arte ASCII.

I nostri libri sono tutti di dimensioni convenientemente uniformi e sembrano tutti i seguenti:

|X|
|X|
|X|

Gli scaffali sono scatole individuali, sempre tre caratteri in alto all'interno (abbastanza per adattarsi a un libro in posizione verticale), composti da |personaggi a sinistra e a destra, -caratteri per la parte superiore e inferiore e abbastanza ampi da contenere i Xlibri (dove Xc'è un input numero intero). Ad esempio, ecco uno scaffale di dimensioni 3:

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

perché puoi inserire 3libri in questo modo

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

L'input sarà due numeri interi assolutamente positivi Xe Y, dov'è Xla larghezza degli scaffali che abbiamo (misurata in libri), ed Yè quanti libri dobbiamo impilare. Se disponiamo di più libri di quanti ce ne siano su un singolo ripiano, dobbiamo aggiungere più ripiani in cima. Ad esempio, ecco l'input 4 wide / 6 books:

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

Se Y % X > 0, il che significa che il numero di libri non è un multiplo intero delle dimensioni dello scaffale, i libri rimanenti dovrebbero andare nella posizione più in alto a sinistra (come nel caso 4 6sopra, sopra) e la parte rimanente di quello scaffale riempita con spazi.

Ingresso

  • Due numeri interi strettamente positivi in qualsiasi formato conveniente , ciascuno >0.
  • Puoi prendere l'input in entrambi gli ordini (ad esempio, prima le dimensioni degli scaffali, quindi il numero di libri o viceversa). Si prega di indicare nell'invio l'ordine di input.
  • Puoi tranquillamente supporre che nessuno dei due input sarà più grande del valore predefinito della tua lingua [int] dimensione (o equivalente).

Produzione

La risultante rappresentazione artistica ASCII dei libri e degli scaffali.

Regole

  • Le nuove linee iniziali o finali o gli spazi bianchi sono tutti opzionali, purché i personaggi stessi si allineino correttamente.
  • È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
  • Se possibile, includi un collegamento a un ambiente di test online in modo che altre persone possano provare il tuo codice!
  • Scappatoie standardSono vietate le .
  • Si tratta di quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

Ulteriori esempi

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

Posso farlo in modo che lo scaffale con il minor numero di libri sia sul fondo, in modo che si riempia dall'alto verso il basso
Golden Ratio

1
@GoldenRatio No, i libri devono essere riempiti dal basso verso l'alto, da sinistra a destra.
AdmBorkBork

Risposte:


14

JavaScript (ES6), 100 99 98 byte

Accetta la larghezza we il numero di libri bnella sintassi del 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

Formattato e commentato

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

Casi test


9

Bash (+ utility), 130, 108, 106 byte

Una singola pipeline continua per il rendering degli scaffali.

changelog:

  • Espressione della prima sed ottimizzata un po ', -12 byte (Thx @Riley!)
  • Sostituito printf + seqcon un grezzo printf, -10 byte
  • Rifattorizzata la seconda espressione sed, -2 byte

golfed

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

Provalo online!

Come funziona

$./shelf 2 3

printf %$2s\\n- genera n caratteri di spazi bianchi, uno per libro (mostrato come _)

___

fold -$1 - piegali per la lunghezza del ripiano

__
_

sed "s/ /|X|/g;"- Sostituisci _con X, aggiungi copertine di libri

|X||X|
|X|

:;/.\{$[$1*3]\}/!s/$/ /;t- pad destro con spazi (mostrato come _)

|X||X|
|X|___

h;s/./-/gp;x;p;p;p;x- triplica ogni riga e aggiungi ---prima e dopo di essa.

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

sed 's/.*/|&|/'|tac- avvolgere le linee | |, invertire con tac

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

Nella prima seduta puoi usare un'etichetta senza nome, e tinvece bnon ti serve {}. Puoi saltare il s/./-/gperché sono già -s. Provalo online!
Riley

@Riley È un consiglio eccellente, grazie!
Zeppelin,

6

Python 2, 133 113 105 byte

Sono sicuro che c'è un modo migliore ...

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

Viene inserito l'input width, books

-20 byte grazie a @ovs per aver notato una funzione lambda non necessaria!
-8 byte grazie a @ovs per accorciare l'input.


X,Y=input()è un modo più breve di prendere i valori to.
Ovs

@ovs Oh aspetta, l'ho messo lì per il mio primo tentativo. Ops. Bella cattura, grazie!
HyperNeutrino

1
@ovs Grazie, quindi l'input è preso come X, Y, giusto?
HyperNeutrino

2
Penso che puoi salvare due byte definendo '|'come variabile.
Ørjan Johansen

6

Lotto, 261 byte

@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

Usa il mio trucco dalla mia risposta Batch a Let's play tennis per stampare facilmente molti |personaggi.


5

Haskell , 100 byte

x#yrestituisce la stringa per larghezza xe ylibri.

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

Provalo online!

La funzione / operatore principale è #. Quando x<ydivide i libri in y-xe x, quindi, recluta. Quando x>=y, we bsono i due tipi di linea, meno l'esterno| s e il ritorno a capo.

L'operatore helper s?nconcatena le ncopie della stringa s.


5

PowerShell , 149 134 byte

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

Provalo online!

Accetta l'input $width e ooks $b. Imposta la stringa $scome uno degli scaffali orizzontali. Quindi abbiamo due ifdichiarazioni.

Il primo controlla se abbiamo libri "rimanenti". In tal caso, produciamo lo scaffale, il (numero di libri più il numero di spazi) *3e un altro scaffale.

Successivamente, vediamo se rimangono ancora dei libri dopo aver rimosso i resti ( $a). Stesso tipo di configurazione, tranne per il fatto che stiamo usando il $wnumero di libri. Poiché a questo punto, $bè garantito che sia un multiplo di $w(poiché abbiamo rimosso il resto $a), non dobbiamo preoccuparci di arrotondare.

Rimossa la [math]::Floor()chiamata, salvando 15 byte

Tutte queste stringhe vengono lasciate sulla pipeline e implicite si Write-Outputverificano al completamento del programma.


4

CJam , 62 61 byte

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

Accetta input come width books

Provalo online!

Spiegazione

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

4

Python 3, 142 byte

Ci sto ancora lavorando. bè per "numero di libri" ed wè per larghezza scaffale.

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

Benvenuti in PPCG! Questo non funziona per me a meno che non R=b%wvenga spostato alla riga successiva. Inoltre, dovresti essere in grado di rimuovere lo spazio bianco attorno a questi tre =per salvare alcuni byte.
Business Cat

Benvenuti in PPCG!
AdmBorkBork

È possibile sostituire d+3*p+d if R!=0 else ''conR and d+3*p+d or''
shooqie

@shooqie Sono curioso, come potrebbe valutare questo risultato d+3*p+d?
Juan Meleiro

1
È possibile salvare alcuni byte inserendo tutte le definizioni in una riga usando i punti e virgola.
L3viathan,

3

AHK, 208 byte

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%

Ci sono alcune cose che mi spingono ulteriormente dal golf:

  • AutoHotkey non ha una funzione di ripetizione integrata
  • Non è possibile utilizzare direttamente gli argomenti passati ( %1%& %2%) nelle funzioni matematiche perché si aspettano input di variabili o numeri e supporrà che l'escaped 1sia il numero uno anziché il nome della variabile
  • Non sono molto bravo a giocare a golf

Una versione più facile da leggere di quanto sopra appare così:

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%

Se a Loopnon usa parentesi {}, solo la riga successiva fa parte del ciclo. Se si imposta il valore di una variabile usando:= invece di =, è possibile eliminare i caratteri di escape del segno di percentuale. Tilde n è il personaggio newline.


3

Java 7, 230 224 222 byte

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

Spiegazione:

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

Codice di prova:

Provalo qui.

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

Produzione:

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


@ OlivierGrégoire Considerando che l'ho pubblicato circa 1,5 anni fa, non mi sorprende che possa essere giocato a golf in modo sostanziale. ;)
Kevin Cruijssen,

Ow ... Non avevo verificato la data: ho visto solo che questa domanda era attiva e che era possibile un altro algoritmo completo per Java. Mio cattivo ...
Olivier Grégoire,

@ OlivierGrégoire Nessun problema e ben fatto con la tua risposta. :) Sembra quasi nostalgico guardare indietro a questa risposta quando stavo ancora aggiungendo i casi di test e l'output alla risposta, e ho risposto a tutto in Java 7, perché non avevo ancora capito Java 8. XD
Kevin Cruijssen,

2

PowerShell, 109 byte

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

Script di test meno golfato:

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

Produzione:

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

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

1

Python 2 , 120 118 byte

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

Provalo online!

Ho avuto intenzione di provare questo negli ultimi giorni. Ora che ho finalmente il tempo di farlo c'è già una risposta Python più breve. Oh bene, appena pubblicato come alternativa.

Input preso come larghezza, libri


1

SOGL , 64 byte

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

Spiegazione: Prima funzione:

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

seconda funzione:

           →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|"]]

questa funzione prevede un numero (conteggio libri) in pila e genera i libri degli scaffali

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

Ulteriore esempio riportato di seguito è e = 3 (larghezza dello scaffale) eb = 8 (importo del libro)

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

questa è la riga superiore / inferiore dello scaffale e rimane sempre in pila prima parte (scaffale mezzo vuoto)

Prima parte principale

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

E l'ultima parte

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


0

PHP> = 7,1, 138 byte

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

Versione online


0

Tela , 33 byte

|X|3*×⁷3×⇵-×|3*×╫│;22╋P
%?%⁸}÷[⁷⁸

Provalo qui!

Spiegazione (alcuni personaggi sono stati sostituiti per sembrare più 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

0

Pip -n , 45 byte

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

Accetta la larghezza e il conteggio dei libri, rispettivamente, come argomenti della riga di comando. Provalo online!

Spiegazione

Eseguiamo un ciclo per stampare gli scaffali uno per uno dall'alto verso il basso. Ad ogni iterazione, aggiorniamo b(il numero di libri da stampare) sottraendo y(il numero di libri stampati su quell'iterazione). Quando braggiunge 0, il loop si chiude.

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)

Perché questo è un po 'coinvolto, ecco un esempio della prima iterazione quando 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|   |"];"|---------|"]

che quindi stampa come

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

0

Pyth , 56 byte

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

Accetta la larghezza dello scaffale, il conteggio dei libri come argomenti separati in quell'ordine. Provalo online qui o verifica tutti i casi di test contemporaneamente qui .

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

0

Forth (gforth) , 622 byte (ridotto a icona (rimuovi commenti, rientro, nomi di parole a 1 carattere) a 303 byte)

Il mio primo gioco con Forth :)

: 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

Provalo online!

Produzione

| ------------------ |
|| 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 ||
| ------------ |
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.