Einführung

In dieser Herausforderung erhalten Sie als Eingabe die ASCII-Darstellung des Netzes (entfaltete Oberfläche) eines rechteckigen Quaders (3D-Box). Das Format ist folgendes:

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

Jede Fläche des Quaders ist ein #von +-|-Zeichen umgebenes Rechteck aus s . Die Außenseite des Netzes ist mit .s gefüllt . Das Netz hat immer die gleiche Ausrichtung: Es gibt eine Mittelfläche, die von den vier benachbarten Flächen umgeben ist, und das Gegenstück der Mittelfläche befindet sich am rechten Rand der Eingabe. Die Eingabe wird mit .s zu einer rechteckigen Form aufgefüllt und enthält keine zusätzlichen Zeilen oder Spalten mit .s.

Die Aufgabe

Ihre Aufgabe ist es, als Eingabe ein Diagramm wie oben zu nehmen und das Volumen des Quaders zu berechnen, das es darstellt, das nur das Produkt seiner Höhe, Breite und Tiefe ist. Sie können die Eingabe als durch Zeilenumbrüche getrennte Zeichenfolge oder als Array von Zeichenfolgen verwenden.

Die Länge jeder Kante ist der Abstand zwischen den +Zeichen an den beiden Enden. Beispielsweise hat die horizontale Kante +--+die Länge 3 und die vertikale Kante

+
|
|
|
+

hat die Länge 4. Die minimale Länge einer Kante ist 1. Der obige Beispielquader hat das Volumen 2 * 3 * 4 = 24.

Regeln und Wertung

Sie können ein vollständiges Programm oder eine Funktion schreiben, und die niedrigste Byteanzahl gewinnt.

Testfälle

.++..
+++++
+++++
.++..
1

...++....
...||....
...||....
+--++--++
+--++--++
...||....
...||....
...++....
3

..+-+....
..|#|....
+-+-+-+-+
|#|#|#|#|
|#|#|#|#|
+-+-+-+-+
..|#|....
..+-+....
12

.+---+.....
++---++---+
||###||###|
||###||###|
||###||###|
++---++---+
.+---+.....
16

....++.....
....||.....
....||.....
....||.....
+---++---++
|###||###||
|###||###||
|###||###||
+---++---++
....||.....
....||.....
....||.....
....++.....
16

...+--+......
...|##|......
...|##|......
+--+--+--+--+
|##|##|##|##|
+--+--+--+--+
...|##|......
...|##|......
...+--+......
18

....+--+.......
....|##|.......
....|##|.......
....|##|.......
+---+--+---+--+
|###|##|###|##|
+---+--+---+--+
....|##|.......
....|##|.......
....|##|.......
....+--+.......
24

....+-----+..........
....|#####|..........
....|#####|..........
....|#####|..........
+---+-----+---+-----+
|###|#####|###|#####|
|###|#####|###|#####|
|###|#####|###|#####|
|###|#####|###|#####|
+---+-----+---+-----+
....|#####|..........
....|#####|..........
....|#####|..........
....+-----+..........
120

Retina , 29 28 Bytes

T`.p`xy`\G\..+¶
xy

¶\|
$`
y

Probieren Sie es online!

In der Netzhaut gibt es viele Möglichkeiten, sich dem anzunähern, je nachdem, welchen Bereich Sie mit welcher Seite multiplizieren möchten. Daher bin ich mir nicht sicher, wie optimal dies ist, aber es ist tatsächlich schon viel kürzer, als ich gedacht hätte.

Ich habe derzeit zwei andere Lösungen mit der gleichen Byteanzahl, die ein bisschen besser zu sein scheinen als der obige Ansatz:

\G\..+¶

¶\|
$'¶
G`\.
T`.|+

¶\||\+¶\.\D+
$'¶
G`\.
T`.|+

In diesen könnte ich zwar jeweils ein Byte speichern, wenn ich davon ausgehe, dass die Eingabe mit einem nachgestellten Zeilenvorschub endet, aber ich würde mich lieber nicht darauf verlassen müssen.

Und noch eine mit 28 Bytes (diese multipliziert drei Seiten, anstatt einen Bereich mit einer Seite zu multiplizieren):

\G\.
x
-(?<=^.+)
$`
¶\|
$`
x

Erläuterung

Die Hauptidee besteht darin, den oberen Bereich der Fläche mit der Länge der vertikalen Seite zu multiplizieren, die den Längenrand der Eingabe berührt.

Ich werde die folgende Eingabe als Beispiel verwenden (sie hat die Seitenlängen 2, 3 und 4, also eine Fläche von 24):

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

Stufe 1: Transliterieren

T`.p`xy`\G\..+¶

Der reguläre Ausdruck \G\..+¶stimmt mit einer Zeile überein, die mit .der vorherigen Zeile beginnt und unmittelbar an diese angrenzt. Dies entspricht also allen Linien, die die Oberseite enthalten. Die Bühne selbst wird .zu xund alle anderen Charaktere (von |+-#) zu y. Dies ergibt folgendes Ergebnis:

xxxyyyyyxxxxxxx
xxxyyyyyxxxxxxx
xxxyyyyyxxxxxxx
+--+---+--+---+
|##|###|##|###|
+--+---+--+---+
...|###|.......
...|###|.......
...+---+.......

Dies hat eine Spalte mehr, yals wir brauchen, um den Bereich der Oberseite darzustellen. Wir beheben dies mit der nächsten Stufe.

Stufe 2: Ersetzen

xy

Also stimmen wir mit a überein, dem ein yvorangestellt ist x(das ist genau einer von ihnen pro Zeile) und entfernen beide aus der Zeichenfolge. Wir bekommen das:

xxyyyyxxxxxxx
xxyyyyxxxxxxx
xxyyyyxxxxxxx
+--+---+--+---+
|##|###|##|###|
+--+---+--+---+
...|###|.......
...|###|.......
...+---+.......

Jetzt haben wir den Bereich der Oberseite, der durch die Anzahl von ys dargestellt wird.

Stufe 3: Ersetzen

¶\|
$`

Unser Ziel hier ist es, diesen Bereich Amit der fehlenden Seitenlänge zu multiplizieren , die der Zahl |am Anfang einer Zeile plus 1 entspricht. Es ist jedoch tatsächlich einfacher, mit einer Zahl zu multiplizieren, n+1da wir bereits eine Kopie von Ain der Zeichenfolge haben . Wenn wir nDinge durch ersetzen A, erhalten wir n+1Kopien von A. Das macht es uns viel leichter.

Also ersetzen wir einfach jeden |sofort nach einem Zeilenvorschub mit allem, was vor dem Spiel steht. Dies zerfleischt die Saite ziemlich und macht sie ein bisschen größer als wir brauchen, aber die Anzahl der ys ist das Ergebnis, das wir suchen:

xxyyyyxxxxxxx
xxyyyyxxxxxxx
xxyyyyxxxxxxx
+--+---+--+---+xxyyyyxxxxxxx
xxyyyyxxxxxxx
xxyyyyxxxxxxx
+--+---+--+---+##|###|##|###|
+--+---+--+---+
...|###|.......
...|###|.......
...+---+.......

Stufe 4: Match

y

Jetzt müssen Sie nur noch die Anzahl ys zählen, die am Ende als Dezimalzahl ausgegeben wird.

Python 2, 57 Bytes

lambda l:l[0].find('+')*~l[0].count('-')*~`l`.count("'|")

Eine Funktion, die eine Liste von Zeichenfolgen aufnimmt.

Legt die 3 Dimensionen separat fest:

l[0].find('+')
Der Index des Ersten +in der ersten Zeile.

-~l[0].count('-')
Die Anzahl der -Zeichen in der ersten Reihe.

~`l`.count("'|")
Die Anzahl der Zeilen, die mit dem |Symbol beginnen, über die Zeichenfolgendarstellung der Liste, vor der ein Anführungszeichen steht.

62 Bytes:

def f(l):a=l[0].find('+');print(len(l[0])/2-a)*(len(l)-a+~a)*a

Eine Funktion, die eine Liste von Zeichenfolgen aufnimmt und das Ergebnis druckt.

Findet eine Dimension aals Index +in der ersten Zeile. Daraus werden die beiden anderen Dimensionen sowie die Breite und Höhe des Eingaberechts abgeleitet.

Eine 63-Byte-Alternative, bei der die Dimensionen separat ermittelt werden:

lambda l:l[0].find('+')*~l[0].count('-')*~zip(*l)[0].count('|')

Bash + Coreutils, 8377 Bytes

EDITS:

• 6 Bytes gespart, indem "Here String" verwendet und der reguläre Ausdruck ein wenig optimiert wurde

Golf gespielt

bc<<<`sed -rn '1{s/(.+)[^\.]*\1/(0\1)*(0/
s/\./+1/gp;a)*(-1
}
/^[+|]/a+1
'`\)

Erklärt

Transformiere mit sed :

....+--+....... => (0+1+1+1+1)*(0+1+1+1 )*(-2 +1
. =>()
. =>()
. =>()
. =>()
+ => +1
| => +1
+ => +1
. =>()
. =>()
. =>()
. =>()

Befreien Sie sich von Zeilenumbrüchen mit Backticks (Anhängen)

=> (0+1+1+1+1)*(0+1+1+1 )*(-2 +1 +1 +1 +1)

Füttere den resultierenden Ausdruck an bc

=> 24

Prüfung

./box <<EOF
.++..
+++++
+++++
.++..
EOF

1

./box <<EOF
...++....
...||....
...||....
+--++--++
+--++--++
...||....
...||....
...++....
EOF

3

./box <<EOF
....+--+.......
....|##|.......
....|##|.......
....|##|.......
+---+--+---+--+
|###|##|###|##|
+---+--+---+--+
....|##|.......
....|##|.......
....|##|.......
....+--+.......
EOF

24

Probieren Sie es online! (Verwendet die Bash-arithmetische Erweiterung anstelle von bc , da diese nicht verfügbar ist.)

Schnecken , 19 Bytes

AM
=~d^.+\+.+l.+^.2

_{Probieren Sie es online aus.}

Die Idee ist, dass wir irgendwo am äußersten rechten Rand des Netzes beginnen und dann irgendwohin im untersten Gesicht reisen. Die Länge der Kante und die Fläche der Fläche werden mit dem Mechanismus zum Zählen aller übereinstimmenden Pfade multipliziert.

AM   ,, A -> count all matching paths
     ,, M -> first char matched is the one in the current direction
     ,,      from the starting location, rather than directly on it
=~          ,, check that we are on the right edge of the grid
d ^.+ \+    ,, go down, matching one or more non-'.' characters, then a '+'
.+          ,, go down one or more times
l .+        ,, go left one or more times
^. 2        ,, match two further characters which aren't '.' to the left

JavaScript (ES6), 67 91

s=>(a=~-s.search`
`/2-(b=s.indexOf`+`))*b*(s.split`
`.length-1-2*b)

Prüfung

F=
s=>(a=~-s.search`
`/2-(b=s.indexOf`+`))*b*(s.split`
`.length-1-2*b)

out=x=>O.textContent+=x+'\n\n'

;`.++..
+++++
+++++
.++..
1

...++....
...||....
...||....
+--++--++
+--++--++
...||....
...||....
...++....
3

..+-+....
..|#|....
+-+-+-+-+
|#|#|#|#|
|#|#|#|#|
+-+-+-+-+
..|#|....
..+-+....
12

.+---+.....
++---++---+
||###||###|
||###||###|
||###||###|
++---++---+
.+---+.....
16

....++.....
....||.....
....||.....
....||.....
+---++---++
|###||###||
|###||###||
|###||###||
+---++---++
....||.....
....||.....
....||.....
....++.....
16

...+--+......
...|##|......
...|##|......
+--+--+--+--+
|##|##|##|##|
+--+--+--+--+
...|##|......
...|##|......
...+--+......
18

....+--+.......
....|##|.......
....|##|.......
....|##|.......
+---+--+---+--+
|###|##|###|##|
+---+--+---+--+
....|##|.......
....|##|.......
....|##|.......
....+--+.......
24

....+-----+..........
....|#####|..........
....|#####|..........
....|#####|..........
+---+-----+---+-----+
|###|#####|###|#####|
|###|#####|###|#####|
|###|#####|###|#####|
|###|#####|###|#####|
+---+-----+---+-----+
....|#####|..........
....|#####|..........
....|#####|..........
....+-----+..........
120`
.split('\n\n').forEach(t=>{
  t=t.split('\n')
  k=+t.pop()
  t=t.join('\n')
  v=F(t)
  out(v+' '+k +' '+(v==k?'OK':'KO')+'\n'+t)
})

<pre id=O></pre>

Rubin, 44

Funktioniert nach einem ähnlichen Prinzip wie bei anderen Antworten: Suchen Sie den Ersten +, um die Tiefe zu ermitteln, suchen Sie den Nächsten .nach dem +, um die Breite zu ermitteln, und zählen Sie die Anzahl |der Zeilenenden und addieren Sie 1, um die Höhe zu ermitteln.

->s{(s=~/\+/)*($'=~/\./)*s.split("|
").size}

im Testprogramm ungolfed

f=->s{(s=~/\+/)*    # index of first match of /\+/ in s
($'=~/\./)*         # $' is a special variable, contains string to right of last match. index of /\./ in $' 
s.split("|
").size}            # split the string at |\n to form an array and count the members

puts f[".++..
+++++
+++++
.++.."]

puts f["...++....
...||....
...||....
+--++--++
+--++--++
...||....
...||....
...++...."]

#etc.

05AB1E , 21 Bytes

Sei Wund Hsei jeweils die Breite und die Höhe der Eingabe - nicht das Kästchen. Dann werden die Box - Maße A, Bund Cdiese Regeln befolgen:

W = 2(A+C)+1
H = B+2C+1

Die folgende Abbildung zeigt , was A, Bund Csind in Bezug auf die Kante Namen:

....AAAA.......
....|##|.......
....|##|.......
....|##|.......
B---+--CCCCC--+
B###|##|###|##|
B---+--+---+--+
....|##|.......
....|##|.......
....|##|.......
....+--+.......

Daher die obigen Formeln. Dieses Programm berechnet A, leitet die Werte von Bund ab Cund berechnet schließlich ihr Produkt.

S'.ÊO<D¹g<;-(D·|g-()P

S'.Ê                  From each character of the first line, yield 0 if it is '.' or 1 otherwise. The result is stored in an array
    O<D               A = sum(array) - 1
       ¹g<;-(D        C = (W-1)/2 - A
              ·|g-(   B = H-1-2*C
                   )  Yield [A,C,B]
                    P Take the product and implicitly display it

Probieren Sie es online!

Frühere Version - Anderer Ansatz - 26 Bytes

|vyS'.Ê})¬O<sø¬O<s€O¬Ê1k)P

|                          Take the input as an array of lines (strings)
 vy                        For each line
   S'.Ê                    For each character in the line, yield 0 if it is '.' or 1 otherwise
       }                   End For
        )                  Wrap the results as an array
         ¬O<               A = sum(first_line) - 1
            sø             Transpose the box pattern
              ¬O<          B = sum(first_line) - 1 ; since the pattern is transposed, it corresponds to the first column
                 s€O       Sum every line from the transposed pattern
                    ¬Ê1k   C = index of the first line that has a different sum from the first line
                        )  Yield [A, B, C]
                         P Take the product A*B*C and implicitly display it

Befunge 93 , 56 Bytes

~2%#^_1+
  @.*+<
`"z"~<|:`~0+
5*\`#^_\1>*\~7
%2~\<\+1_^#

Probieren Sie es online!

Erläuterung:

Das Volumen des Kästchens kann berechnet werden, indem die Anzahl von .s in der ersten Zeile vor anderen Zeichen mit der Anzahl von +und -s in der ersten Zeile - 1 und der Anzahl von Zeilen, die mit |+ 1 beginnen, multipliziert wird .

~2%#^_1+         Uses the ASCII value % 2 of a character to count the .s

%2~\<\+1_^#      IP wraps around to the bottom. Counts the non . chars
                 Works because ("+" % 2) == ("-" % 2) == 1

5*\`#^_\1>*\~7   Multiplies the previous 2 results and cycles through
                 characters until it hits a newline or EOF

`"z"~<|:`~0+     Adds 1 to the 3rd dimension if the following char is a "|"
                 Also checks for EOF; If there is more input, goes back to
                 previous line. Otherwise, goes to the last line

  @.*+<          Adds 1 to the 3rd dimension, multiplies it to the rest,
                 prints the volume, and ends the program

Ich musste die IP-Zeilen nach oben anstatt nach unten verschieben, um die Vertikale zu verwenden, wenn in der 3. Zeile. Wenn die IP-Adresse nach unten zeigt, wird durch das vertikale if die Stapelspitze auf 1 gesetzt, wenn das folgende horizontale if getroffen wird, und in die falsche Richtung gesendet.

Haskell, 64 56 Bytes

f(x:r)=sum$fst(span(>'+')x)>>[1|'|':_<-"|":r,'-'<-'-':x]

Probieren Sie es online!

Erläuterung

Es wird erwartet, dass die Eingabe eine Liste von Zeichenfolgen für jede Zeile ist, sodass fder Parameter xdie erste Zeile und reine Liste der verbleibenden Zeilen enthält.

1. fst(span(>'+')x)gibt das .-prefix der ersten Zeile als String zurück, also length(fst(span(>'+')x))die erste Dimension d1.
2. Ein Listenverständnis kann als Filter fungieren, z. B. ['-' | '-' <- x]gibt eine Zeichenfolge von allen -in der ersten Zeile zurück und 1 + length['-' | '-' <- x]ergibt so die zweite Dimension d2.
3. Analog kann die Anzahl der |in der ersten Zeile gezählt werden, ebenso 1 + length['|' | '|':_ <- r]die dritte Dimension d3.

Die Liste Comprehensions von 2. und 3. kann verkürzt werden 1+sum[1|'-'<-x]und 1+sum[1|'|':_<-r]‚|‘ - ‚‘ oder für jedes Auftreten durch den Aufbau einer Liste von Einsen und dann die Summe nehmen. Wir können weiterhin die äußere setzen 1+in die Liste Verständnis durch Anhängen -an xund "|"zu rzu erhalten sum[1|'-'<-'-':x]und sum[1|'|':_<-"|":r]. Jetzt können wir beide Listenverständnisse kombinieren, indem wir beide Prädikate in dasselbe Verständnis setzen: sum[1|'|':_<-"|":r,'-'<-'-':x]Zweckmäßigerweise berechnet dies genau das Produkt der beiden Dimensionen, da für Listen Fund Gdas folgende Listenverständnis das kartesische Produkt ist F x G =[(a,b)|a<-F,b<-G].

Schließlich können wir, anstatt 1. mit der Kombination aus 2. und 3. zu multiplizieren, den >>Operator für Listen verwenden: F>>GWiederholungen G length Fund Verkettung des Ergebnisses. So fst(span(>'+')x)>>[1|'|':_<-"|":r,'-'<-'-':x]wiederholt sich die Liste der d2*d3diejenigen d1Zeiten, eine Liste von was d1*d2*d3diejenigen , die dann summiert werden , um die Lautstärke zu erhalten.

Java 8, 185 129 Bytes

Danke an Zgarb für -56 Bytes

Golf gespielt:

int g(String[]i){int h=0;for(String k:i){if(k.charAt(0)=='.')h++;else break;}return((i[0].length()-2*h-1)/2)*(i.length-2*h-1)*h;}

ungolfed:

int g(String[] i) {
    int h = 0;
    for (String k : i) {
        if (k.charAt(0) == '.') h++;
        else break;
    }
    return ((i[0].length()-2*h-1)/2)*(i.length-2*h-1)*h;
}

Erläuterung

a*b*h = ((length_of_line-2*h-1)/2)*(number_of_lines-2*h-1)*h

Wo aund bsind die Abmessungen der Basis und hist die Höhe. Sie finden, hindem Sie die ersten hZeilen zählen, in denen Sie mit a beginnen ..

Java, 112 Bytes

int v(String[]s){int a=s[0].lastIndexOf('+')-s[0].indexOf('+'),b=s[0].length()/2-a;return a*b*(s.length-2*b-1);}

Erweitert:

int v(String[] s)
{
  // length of the edge in the first line
  int a = s[0].lastIndexOf('+') - s[0].indexOf('+');
  // length of the second edge
  // int b = s[0].length() - 2 * a - 1; <-- multiplied by 2
  int b = s[0].length()/2 - a; // <-- hack, length is always odd
  // length of the third edge in ()
  // volume
  return a * b * (s.length - 2 * b - 1);
} // end method v

Powershell, 68 67 Bytes

($c="$args"|% i*f +)*($args[0].Length/2-.5-$c)*($args.Count-1-2*$c)

Hinweis: "$args"|% i*f + ist eine Abkürzung für"$args".indexOf('+')

Erläuterung

Eine gute Erklärung ergab sich aus der Antwort des Osable :

Sei Wund Hsei jeweils die Breite und die Höhe der Eingabe - nicht das Kästchen. Dann werden die Box - Maße A, Bund Cdiese Regeln befolgen:

W = 2(A+C)+1
H = B+2C+1

Die folgende Abbildung zeigt , was A, Bund Csind in Bezug auf die Kante Namen:

CCCCAAAA.......
....|##|.......
....|##|.......
....|##|.......
B---+--+---+--+
B###|##|###|##|
B---+--+---+--+
....|##|.......
....|##|.......
....|##|.......
....+--+.......

Und Cist die Position des Ersten +in der ersten Zeile der Eingabe.

Testskript:

$f = {

($c="$args"|% i*f +)*($args[0].Length/2-.5-$c)*($args.Count-1-2*$c)

}

@(

,(1, ".++..",
     "+++++",
     "+++++",
     ".++..")

,(3,"...++....",
    "...||....",
    "...||....",
    "+--++--++",
    "+--++--++",
    "...||....",
    "...||....",
    "...++....")

,(12,"..+-+....",
     "..|#|....",
     "+-+-+-+-+",
     "|#|#|#|#|",
     "|#|#|#|#|",
     "+-+-+-+-+",
     "..|#|....",
     "..+-+....")

,(16,".+---+.....",
     "++---++---+",
     "||###||###|",
     "||###||###|",
     "||###||###|",
     "++---++---+",
     ".+---+.....")

,(16,"....++.....",
     "....||.....",
     "....||.....",
     "....||.....",
     "+---++---++",
     "|###||###||",
     "|###||###||",
     "|###||###||",
     "+---++---++",
     "....||.....",
     "....||.....",
     "....||.....",
     "....++.....")

,(18,"...+--+......",
     "...|##|......",
     "...|##|......",
     "+--+--+--+--+",
     "|##|##|##|##|",
     "+--+--+--+--+",
     "...|##|......",
     "...|##|......",
     "...+--+......")


,(24,"....+--+.......",
     "....|##|.......",
     "....|##|.......",
     "....|##|.......",
     "+---+--+---+--+",
     "|###|##|###|##|",
     "+---+--+---+--+",
     "....|##|.......",
     "....|##|.......",
     "....|##|.......",
     "....+--+.......")

,(120,"....+-----+..........",
      "....|#####|..........",
      "....|#####|..........",
      "....|#####|..........",
      "+---+-----+---+-----+",
      "|###|#####|###|#####|",
      "|###|#####|###|#####|",
      "|###|#####|###|#####|",
      "|###|#####|###|#####|",
      "+---+-----+---+-----+",
      "....|#####|..........",
      "....|#####|..........",
      "....|#####|..........",
      "....+-----+..........")

) | % {
    $expected,$s = $_
    $result = &$f @s
    "$($result-eq$expected): $result"
}

Ausgabe:

True: 1
True: 3
True: 12
True: 16
True: 16
True: 18
True: 24
True: 120

Wolfram Language (Mathematica) , 64 Byte

(2(x=#@"
")-(y=#@"|")-9)((9-5x+y)^2-9#@".")/54&@*CharacterCounts

Probieren Sie es online!

Verwendet die Anzahl von ., |und \nZeichen in der Eingabe, um nach dem Volume zu suchen. Es sieht dumm aus, weil es eine aktuelle neue Zeile anstelle von gibt \n.

Wenn A,, Bund Cdie Seiten sind, dann . = 2C(A+2C), | = 5B+4C-9und \n = B+2C, dann können wir das Volumen ABCin Bezug auf diese drei Zeichenzahlen auflösen.