Plan de hauteur des boîtes

22

Jetez un œil à ce diagramme d'art ascii de différentes boîtes:

+--------------------------------------------------------------+
|                                                              |
|   +-------------------------------+          +-------+       |
|   |                               |          |       |       |
|   |                               |          |       |       |
|   |     +----------------+        |          |       |       |
|   |     |                |        |          +-------+       |
|   |     |                |        |                          |
|   |     |                |        |          +-------+       |
|   |     +----------------+        |          |       |       |
|   |                               |          |       |       |
|   |                               |          |       |       |
|   +-------------------------------+          +-------+       |
|                                                              |
+--------------------------------------------------------------+

Chaque boîte est formée de caractères de tuyau pour les parties verticales ( |), de tirets pour les parties horizontales ( -) et d'avantages pour les coins ( +).

Le diagramme montre également des boîtes à l'intérieur d'autres boîtes. Nous appellerons le nombre de boîtes qu'une boîte est contenue dans la couche de cette boîte . Voici à nouveau le diagramme avec le calque de chaque boîte annoté:

+--------------------------------------------------------------+
|                                                              |
|   +-------------------------------+          +-------+       |
|   |                               |          |       |       |
|   |                               |          |   1   |       |
|   |     +----------------+        |          |       |       |
|   |     |                |        |    0     +-------+       |
|   |     |        2       |   1    |                          |
|   |     |                |        |          +-------+       |
|   |     +----------------+        |          |       |       |
|   |                               |          |   1   |       |
|   |                               |          |       |       |
|   +-------------------------------+          +-------+       |
|                                                              |
+--------------------------------------------------------------+

Votre programme prendra en entrée un diagramme similaire à celui du haut. En sortie, votre programme devrait sortir le diagramme avec:

  • La case sur le calque 0 doit être remplie avec le caractère #(NB: il n'y aura qu'un seul case sur le calque 0);
  • Les cases du calque 1 doivent être remplies avec le caractère =;
  • Les cases du calque 2 doivent être remplies avec le caractère -;
  • Les cases du calque 3 doivent être remplies avec le caractère .;
  • Les cases de la couche 4 et au-dessus ne doivent pas être remplies.

Voici à quoi devrait ressembler la sortie de l'exemple d'entrée:

+--------------------------------------------------------------+
|##############################################################|
|###+-------------------------------+##########+-------+#######|
|###|===============================|##########|=======|#######|
|###|===============================|##########|=======|#######|
|###|=====+----------------+========|##########|=======|#######|
|###|=====|----------------|========|##########+-------+#######|
|###|=====|----------------|========|##########################|
|###|=====|----------------|========|##########+-------+#######|
|###|=====+----------------+========|##########|=======|#######|
|###|===============================|##########|=======|#######|
|###|===============================|##########|=======|#######|
|###+-------------------------------+##########+-------+#######|
|##############################################################|
+--------------------------------------------------------------+

Voici une autre entrée et sortie montrant les couches 3, 4 et 5. Notez les lignes horizontales en haut qui sont très rapprochées. Dans ces cas, il n'y a pas assez d'espace pour y remplir des caractères.

+-----------------------------------------------------------------------+
|     +--------------------------------------------------------------+  |
|     |      +-----------------------------------------------------+ |  |
|     |      |         +-----------------------------------------+ | |  |
|     |      |         |           +---------------------------+ | | |  |
|     |      |         |           |         +-------------+   | | | |  |
|     |      |         |           |         |             |   | | | |  |
|     |      |         |           |         +-------------+   | | | |  |
|     |      |         |           +---------------------------+ | | |  |
|     |      |         |                                         | | |  |
|     |      |         +-----------------------------------------+ | |  |
|     |      |                                                     | |  |
|     |      |                                                     | |  |
|     |      +-----------------------------------------------------+ |  |
|     |                                                              |  |
|     +--------------------------------------------------------------+  |
|                                                                       |
|                                                                       |
|                                                                       |
+-----------------------------------------------------------------------+

Le résultat:

+-----------------------------------------------------------------------+
|#####+--------------------------------------------------------------+##|
|#####|======+-----------------------------------------------------+=|##|
|#####|======|---------+-----------------------------------------+-|=|##|
|#####|======|---------|...........+---------------------------+.|-|=|##|
|#####|======|---------|...........|         +-------------+   |.|-|=|##|
|#####|======|---------|...........|         |             |   |.|-|=|##|
|#####|======|---------|...........|         +-------------+   |.|-|=|##|
|#####|======|---------|...........+---------------------------+.|-|=|##|
|#####|======|---------|.........................................|-|=|##|
|#####|======|---------+-----------------------------------------+-|=|##|
|#####|======|-----------------------------------------------------|=|##|
|#####|======|-----------------------------------------------------|=|##|
|#####|======+-----------------------------------------------------+=|##|
|#####|==============================================================|##|
|#####+--------------------------------------------------------------+##|
|#######################################################################|
|#######################################################################|
|#######################################################################|
+-----------------------------------------------------------------------+

Une autre entrée, cette fois avec les lignes verticales rapprochées:

+-------------+
|+-----------+|
||           ||
||           ||
||           ||
|+-----------+|
+-------------+

Le résultat:

+-------------+
|+-----------+|
||===========||
||===========||
||===========||
|+-----------+|
+-------------+

Notes complémentaires

  • Il peut y avoir des espaces autour de la boîte la plus à l'extérieur.
  • Les boîtes ne peuvent pas avoir une largeur ou une hauteur interne de 0 (elles auront donc toujours de l'espace à l'intérieur)
  • Les boîtes sur le même calque peuvent se toucher.
code-golf  ascii-art 
— Absinthe
source

Réponses:

3

Rubis 163 164

w=l=-1
x=$<.map{|l|w=l.size;l}.join
b=[]
x.size.times{|i|c=x[i]
x[i..i+1]=='+-'&&(x[i+w]!=?|?b-=[i%w]:b<<i%w)
c>?z&&l+=b&[i%w]!=[]?1:-1
$><<(c==' '&&'#=-.'[l]||c)}

Essayez en ligne: cas de test # 1 , cas de test # 2 .

Le programme non golfé: 

  # read all lines from STDIN
  input = $<.map{|l|l}.join
  width = input.index(?\n)+1

  box_left_margins = []
  current_layer = -1

  input.size.times{|i|
    c = input[i]

    if c == ?+ && input[i+1] == ?-
      #we're at a box's left margin
      if input[i+width] == ?|
        # we're at the box's top - mark this index as a left margin
        box_left_margins << i%width
      else
        # we're at the box's bottom - this index is no longer a left margin
        box_left_margins-=[i%width]
      end
    end

    if c == ?|
      if box_left_margins.include? (i%width)
        current_layer += 1
      else
        current_layer -= 1
      end
    end

    if c == ' '
      $><< ('#=-.'[current_layer]||' ')
    else
      $><<c
    end
  }
— Cristian Lupascu
source
2

Java, 476 466 octets

import java.util.*;class H{public static void main(String[]a){Scanner p=new Scanner(System.in);char[]l=p.nextLine().toCharArray(),d={'#','=','-','.'};int s=l.length,b,i;int[]m=new int[s];String o=new String(l);for(;;){o+='\n';l=p.nextLine().toCharArray();if(l[0]=='+')break;o+='|';b=0;for(i=1;i<s;++i){char c=l[i];switch(c){case' ':c=b>3?' ':d[b];break;case'+':m[i]=l[i-1]=='-'?-++m[i]:- --m[i];break;case'|':b+=m[i];}o+=c;}}o+=new String(l);System.out.println(o);}}

Ceci lit la première ligne pour déterminer la largeur (s) de la boîte la plus externe. Avec cela, il conserve un tableau de longueur s. Ce tableau stocke de gauche à droite où les boîtes commencent et se terminent et est initialisé avec 0s. Il stocke également la hauteur de la boîte.

Le programme lit l'entrée ligne par ligne et surveille les caractères suivants:

  • '+' est, comme nous le savons, le bord d'une boîte. Si le caractère d'entrée à gauche est un «-», c'est la fin de la boîte, sinon c'est le début. Le tableau de marqueurs est mis à jour comme suit:
    • Si le marqueur de cet index est 0, définissez la valeur sur 1 (début) ou -1 (fin).
    • Sinon, mettez la valeur à 0. (Nous avons atteint le bas de la boîte, ce n'est plus important)
  • «|» modifie la hauteur de la boîte actuelle par le marqueur à l'index actuel.
  • '' Chaque caractère obtient la sortie telle qu'elle était, à l'exception des blancs, qui sont remplacés en fonction de la hauteur de la boîte actuelle.

Edit: Merci à TheNumberOne pour la suggestion. J'ai également remplacé while (true) par for (;;).

— ECS
source
1
Vous pouvez remplacer import java.util.Scannerparimport java.util.*
— TheNumberOne
2

CJam, 114 111 108 104 103 102 102 98 octets

q"-+":R/Ws*N/z{_,{"|1"/Bs*}*}%z{_,,{_I=S&{_I>_1sf&s,\"|+"f&s,m5e<" #=2."=I\t}&}fI}%N*Ws/R*Cs"|-"er

Essayez-le en ligne dans l' interpréteur CJam .

Comment ça marche

q               e# Read all input from STDIN.
"-+":R/Ws*      e# Replace each "-+" with "-1".
N/z             e# Split at linefeeds and zip. Pushes the array of columns.
{               e# For each column:
  _,            e#   Push its length.
  {             e#   Do that many times:
    "|1"/Bs*    e#   Replace each "|1" with "11".
  }*            e#
}%              e#
z               e# Transpose. Goes back to array of rows.
{               e# For each row:
  _,,           e#   Push the array of its indexes.
  {             e#   For each index I:
    _I=         e#     Get the Ith character of the row.
    S&{         e#     If it is a space:
      _I>       e#       Get the characters after the Ith.
      _1sf&s,   e#       Count how many characters are 1's.
      \"|+"f&s, e#       Count how many are |'s or +'s.
      m5e<      e#       Subtract and truncate at 5.
      " #=2."=  e#       Retrieve the corresponding character.
      I\t       e#       Replace the Ith character of the row with that one.
    }&          e#
  }fI           e#
}%              e#
N*              e# Join the rows, separating by linefeeds.
Ws/R*           e# Turn "-1"s back to "-+"s.
Cs"|-"er        e# Turn 1's and 2's into |'s and -'s.
— Dennis
source
2

JavaScript ( ES6 ) 156

Exécutez l'extrait dans Firefox pour tester

F=b=>(
  r=b.split(/\n/),q=[n=0],
  r.map((r,i)=>(
    [...r].map((c,p)=>c=='+'?(q[p]=r[p-1]=='-'?-1:1,c):c<'!'?' #=-.'[n]||' ':((n+=q[p]|0),c)).join(''))
  ).join('\n')
)

// TEST

o=x=>O.innerHTML += x+'\n\n'


;[`+--------------------------------------------------------------+
|                                                              |
|   +-------------------------------+          +-------+       |
|   |                               |          |       |       |
|   |                               |          |       |       |
|   |     +----------------+        |          |       |       |
|   |     |                |        |          +-------+       |
|   |     |                |        |                          |
|   |     |                |        |          +-------+       |
|   |     +----------------+        |          |       |       |
|   |                               |          |       |       |
|   |                               |          |       |       |
|   +-------------------------------+          +-------+       |
|                                                              |
+--------------------------------------------------------------+`
,`+-----------------------------------------------------------------------+
|     +--------------------------------------------------------------+  |
|     |      +-----------------------------------------------------+ |  |
|     |      |         +-----------------------------------------+ | |  |
|     |      |         |           +---------------------------+ | | |  |
|     |      |         |           |         +-------------+   | | | |  |
|     |      |         |           |         |             |   | | | |  |
|     |      |         |           |         +-------------+   | | | |  |
|     |      |         |           +---------------------------+ | | |  |
|     |      |         |                                         | | |  |
|     |      |         +-----------------------------------------+ | |  |
|     |      |                                                     | |  |
|     |      |                                                     | |  |
|     |      +-----------------------------------------------------+ |  |
|     |                                                              |  |
|     +--------------------------------------------------------------+  |
|                                                                       |
|                                                                       |
|                                                                       |
+-----------------------------------------------------------------------+`
,`+-------------+
|+-----------+|
||           ||
||           ||
||           ||
|+-----------+|
+-------------+`  
].forEach(t=>o(t+'\n'+F(t)+'\n'))
pre { font-size:10px;}
<pre id=O></pre>
Développer l'extrait

— edc65
source
1

CJam, 76 74 octets

q:Q"-+":R/Ws*{_"| "#"]_QN#~%'|m0='+=2*(U+:U+~; \"#=-.\"+U5e<= "S/=~}%Ws/R*

Essayez-le en ligne dans le interpréteur CJam .

Comment ça marche

q:Q        e# Read all input from STDIN and save it in the variable Q.
"-+":R/Ws* e# Replace each "-+" with "-1".
           e# This allows us to easily keep track of right corners.
{          e# For each charcter in the modified input:
  _"| "#   e#   Push its index in the string (0 for '|', 1 for ' ', -1 otherwise).

  "]_QN#~%'|m0='+=2*(U+:U+~; \"#=-.\"+U5e<= "S/

           e#   Split the pushed string at spaces, which results in three chunks:

           e#     ]        Turn the entire stack into a string.
           e#     _QN#     Compute the first index of a linefeed (row length).
           e#     ~%       Retrieve every previous character in the current column,
           e#              starting with the last.
           e#     '|m0=    Get the first character that is not a vertical bar.
           e#     '+=2*(   Push 1 if it's a plus sign and -1 otherwise.
           e#     U+:U     Add to U (initially 0) to keep track of the layer.
           e#     +~;      Add U to the string (casts to Array), dump and discard U.

           e#     "#=-."+  Concatenate this string with the space on the stack.
           e#     U5e<     Truncate U at 5.
           e#     =        Retrieve the corresponding character to replace the space.

           e#     (empty)

  =~       e#   Select and execute the proper chunk.
}%         e#
Ws/R*      e# Replace each "-1" with "-+".
— Dennis
source
1

APL (Dyalog Unicode) , 50 octets SBCS

s[⊃¨0~¨⍨a,¨5|5⌊+⍀+\(⊢ׯ1*+⍀++\)5=a←⎕⍳⍨s←' #=-.+|']

Essayez-le en ligne!

s←' #=-.+|' affecter une chaîne à une variable s

⎕ entrée évaluée, il doit s'agir d'une matrice de caractères

⎕⍳⍨sremplacer chaque élément de ⎕son indexs

a← affecter à a

5=retourne une matrice booléenne de l'endroit où les +-es sont a( s[5]est '+')

(⊢ׯ1*+⍀++\)c'est un train de fonctions:

  • +\ matrice des sommes partielles par ligne

  • + plus

  • +⍀ matrice des sommes partielles par colonne

  • ¯1* négatif à la puissance de - transformer les cotes en ¯1 et égaliser en 1

  • ⊢× multiplier par l'argument du train - zéro tout sauf les coins de boîte

+⍀+\ sommes partielles par colonne de sommes partielles par ligne

5⌊ minimum de cela et 5

5| modulo 5

a,¨jumeler les éléments de aet de la matrice actuelle

0~¨⍨ supprimer 0 des paires

⊃¨ d'abord chacun de ce qui reste

s[ ] utiliser chaque élément comme index dans s

— ngn
source
— Erik the Outgolfer le
@EriktheOutgolfer Pas besoin de s'inquiéter, la réponse est correcte :) L'expression qui prépare l'argument (mélange les lignes d'entrée brutes dans une matrice) devrait l'inverser car ↑⍞⍞...⍞évalue de droite à gauche. Pour le premier exemple, cela n'avait pas d'importance et j'ai oublié de le mentionner.
— ngn
— Erik the Outgolfer
@EriktheOutgolfer ah, je vois ... Je vais supprimer la réponse maintenant et je la corrigerai plus tard. Merci.
— ngn
devrait être corrigé maintenant
— ngn
0

> <> , 118 115 87 octets

]0{i:0(?;:"-"=?\:"+"=?\:" "=?\$3l$g+}:ob(?
~$?:g2.10p1+4f:<p3l+10/.16@:$/>.!0"#"$
 #=-.

Essayez-le en ligne!

Si l'un des symboles n'était pas un, -cela pourrait être 6 octets plus court. Eh, j'ai réussi un peu plus petit de toute façon

Comment ça marche:

] Resets the stack
 0{ Pushes a 0 and rotates the stack
    If the stack is empty, this initialises 0 as the counter
    Otherwise it adds an extra 0 to the stack and pushes the counter to the top
   i:0(?; Gets input and ends if it is EOF
         :"-"=?\ If the inputted character is a -
         p1+4f:< Put a - at cell (19, 1)
      .10        And skip to the end of this line

         :"+"=?\ Else if the inputted character is +
            ?10/ Generate either -1 or 1, depending on what was last put into cell (19,1)
                 The question mark represents cell (19,1), which is either + or -
         p3l     Put this number on (3, length of the stack)
.10p1+4f:<       Repeat the exact same code as with the -, except we put a + at cell (19,1)
         :" "=?\ Else if the character is a space
            @:$/ Create a copy of the counter
         .16     Skip to cell (1,6)
      g2         Get the cell (2, counter) (the  #=-.)
   ~$?           If that cell is a zero, pop it, leaving the initial space. 
                 Else pop the space, leaving the fetched character
        Else if the character is a | or a newline
        $3l$g+   Get the cell at (3, length of the stack) and add it to the counter
    For everything but the last else, we are at the end of the second line
       >.!0"#"$ Skip to the 35th instruction on the first line

 } Push the counter to the bottom of the stack
  :o Output the current character
    b(? If the character is smaller than 11 (a newline)
 ]          Skip the clear stack at the start of the line
 Repeat this until EOF
— Jo King
source
0

C (gcc) , 190 179 octets

-11 octets grâce au plafond

Échoue si sizeof (int)> 9, mais alors vous pouvez vous consoler du fait que votre ordinateur est du futur.

l;*H,*h,d;f(S){h=H=calloc(l=index(S,10)-S,9);for(char*s=S;*s;s++)h=*s^10?h:H-1,d=*s-43?d:s!=S&s[-1]==45|s-S>l&s[~l]=='|'?-1:1,*h+=*s^45?0:d,h+=write(1,*s^32|*h>4?s:" #=-."+*h,1);}

Essayez-le en ligne!

— gastropner
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.