Höhenkarte der Boxen

22

Schauen Sie sich dieses ASCII-Grafikdiagramm verschiedener Boxen an:

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

Jedes Feld besteht aus Pipe-Zeichen für die vertikalen Teile ( |), Bindestrichen für die horizontalen Teile ( -) und Pluszeichen für die Ecken ( +).

Das Diagramm zeigt auch Kästchen innerhalb anderer Kästchen. Wir nennen die Anzahl der Boxen, die eine Box in der Ebene dieser Box enthält . Hier ist noch einmal das Diagramm, in dem der Layer der einzelnen Felder mit Anmerkungen versehen ist:

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

Ihr Programm nimmt ein Boxdiagramm als Eingabe, das dem oben gezeigten ähnlich ist. Als Ausgabe sollte Ihr Programm das Boxdiagramm ausgeben mit:

  • Das Kästchen auf Ebene 0 sollte mit dem Zeichen gefüllt sein #(Hinweis: Es wird immer nur ein Kästchen auf Ebene 0 geben).
  • Felder auf Ebene 1 sollten mit dem Zeichen gefüllt sein =.
  • Felder auf Ebene 2 sollten mit dem Zeichen gefüllt sein -.
  • Felder auf Ebene 3 sollten mit dem Zeichen gefüllt sein ..
  • Felder auf Ebene 4 und höher sollten nicht ausgefüllt werden.

So sollte die Ausgabe der Beispieleingabe aussehen:

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

Hier ist eine weitere Eingabe und Ausgabe, die die Ebenen 3, 4 und 5 zeigt. Beachten Sie die horizontalen Linien oben, die sehr nahe beieinander liegen. In diesen Fällen ist nicht genügend Platz vorhanden, um die Zeichen dort zu füllen.

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

Die Ausgabe:

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

Eine weitere Eingabe, diesmal mit den vertikalen Linien in der Nähe:

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

Die Ausgabe:

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

Zusätzliche Bemerkungen

  • Um das äußerste Feld kann ein Leerzeichen stehen.
  • Boxen dürfen keine interne Breite oder Höhe von 0 haben (daher bleibt immer etwas Platz in ihnen)
  • Felder auf derselben Ebene können sich berühren.
code-golf ascii-art Absinth
quelle

Antworten:

3

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

Online testen : Testfall Nr. 1 , Testfall Nr. 2 .

Das ungolfed Programm: 

  # 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
quelle
2

Java, 476 466 Bytes

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

Dies liest die erste Zeile, um die Breite (n) des äußersten Kastens zu bestimmen. Dabei bleibt ein Array mit der Länge s erhalten. Dieses Array speichert von links nach rechts, wo Felder beginnen und enden, und wird mit 0 initialisiert. Es speichert auch die Kastenhöhe.

Das Programm liest die Eingabe zeilenweise und achtet auf folgende Zeichen:

  • '+' ist, wie wir wissen, der Rand einer Box. Wenn das Eingabezeichen links ein "-" ist, ist es das Ende des Kästchens, ansonsten der Anfang. Das Marker-Array wird wie folgt aktualisiert:
    • Wenn der Marker an diesem Index 0 ist, setzen Sie den Wert auf 1 (Anfang) oder -1 (Ende).
    • Andernfalls setzen Sie den Wert auf 0. (Wir haben den unteren Rand der Box erreicht, es ist nicht mehr wichtig)
  • '|' Ändert die aktuelle Kastenhöhe um den Marker am aktuellen Index.
  • '' Jedes Zeichen wird so ausgegeben, wie es war, mit Ausnahme von Leerzeichen, die entsprechend der aktuellen Kastenhöhe ersetzt werden.

Edit: Danke an TheNumberOne für den Vorschlag. Ich habe dabei auch (true) durch (;;) ersetzt.

ECS
quelle
1
Sie können import java.util.Scannermitimport java.util.*
TheNumberOne
2

CJam, 114 111 108 104 103 102 98 Bytes

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

Probieren Sie es online im CJam-Interpreter aus .

Wie es funktioniert

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

JavaScript ( ES6 ) 156

Führen Sie zum Testen das Snippet in Firefox aus

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>
Erweitern Sie das Snippet

edc65
quelle
1

CJam, 76 74 Bytes

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

Probieren Sie es online im CJam-Interpreter aus .

Wie es funktioniert

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

APL (Dyalog Unicode) , 50 Byte SBCS

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

Probieren Sie es online!

s←' #=-.+|' Weisen Sie der Variablen eine Zeichenfolge zu s

⎕ ausgewertete Eingabe, es muss eine Zeichenmatrix sein

⎕⍳⍨sErsetzen Sie jedes Element von ⎕durch seinen Index ins

a← zuweisen a

5=gibt eine boolesche Matrix zurück, in der sich die +-es befinden a( s[5]is '+')

(⊢ׯ1*+⍀++\)dies ist ein Zug von Funktionen:

  • +\ Matrix von Teilsummen pro Zeile

  • + Plus

  • +⍀ Matrix von Teilsummen pro Spalte

  • ¯1* Negativ eins hoch - verwandle die Quote in ¯1 und gleicht sie in 1 aus

  • ⊢× multiplizieren Sie mit dem Argument des Zuges - setzen Sie alles außer den Ecken der Kisten auf Null

+⍀+\ Teilsummen pro Spalte oder Teilsummen pro Zeile

5⌊ Minimum davon und 5

5| Modulo 5

a,¨Verbinde die Elemente der aund der aktuellen Matrix

0~¨⍨ entferne 0 von den Paaren

⊃¨ zuerst alles was noch übrig ist

s[ ] Verwenden Sie jedes Element als Index in s

ngn
quelle
Ach nein!
Erik der Outgolfer
@EriktheOutgolfer Keine Sorge, die Antwort ist richtig :) Der Ausdruck, der das Argument vorbereitet (mischt rohe Eingabezeilen in eine Matrix), sollte es umkehren, da ↑⍞⍞...⍞von rechts nach links ausgewertet wird. Für das erste Beispiel war das egal und ich habe vergessen, dies zu erwähnen.
9.
außer dass es sich immer noch mit .s füllt, wo es nicht sein sollte
Erik the Outgolfer
@EriktheOutgolfer ah, ich verstehe ... Ich werde die Antwort jetzt löschen und sie später beheben. Vielen Dank.
9.
sollte jetzt behoben sein
ngn
0

> <> , 118 115 87 Bytes

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

Probieren Sie es online!

Wenn eines der Symbole kein Symbol ist, -kann es 6 Byte kürzer sein. Eh, habe es ein bisschen gemacht sowieso kleiner geworden

Wie es funktioniert:

] 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
Scherzen
quelle
0

C (gcc) , 190 179 Bytes

-11 bytes dank ceilingcat

Schlägt fehl, wenn sizeof (int)> 9, aber dann können Sie Trost in der Tatsache, dass Ihr Computer aus der Zukunft ist.

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

Probieren Sie es online!

Gastropner
quelle