Herausforderung:

Als Eingabe erhalten Sie ein ASCII-Bild eines Gewichtsstapels und müssen das kombinierte Gewicht des Stapels ausgeben.

Format:

Es gibt 5 verschiedene Gewichte mit einem Gewicht von 1, 2, 5, 10, 20 Passanten (oder einer anderen willkürlichen Einheit).

Die Gewichte sehen in aufsteigender Reihenfolge so aus:

1:   __
    |__|

2:   ______
    |______|

5:   ______
    |      |
    |______|

10:  ______________
    |              |
    |______________|

20:  ____________________
    |                    |
    |____________________|

Die Wägungen werden symmetrisch platziert (wie im Beispielbild), nicht unbedingt in einer sortierten Reihenfolge. Wägungen teilen sich Grenzen, wo zutreffend:

Testfälle:

Sie können auch alle Einzelgewichte als Testfälle verwenden.

   __
 _|__|_
|______|
|      |
|______|
1 + 2 + 5 = 8

 ____________________
|                    |
|____________________|
   |              |
   |______________|
        _|__|_
       |______|
       |      |
       |______|          
20 + 10 + 1 + 2 + 5 = 38 

 ______
|______|
|______|
|______|
|______|
2 + 2 + 2 + 2 = 8

Zusätzliche Regeln:

• Sie dürfen keine zusätzlichen führenden Leerzeichen annehmen. Das größte Gewicht befindet sich ganz links.
• Sie können abschließende Leerzeichen und Zeilenumbrüche annehmen.
• Sie können davon ausgehen, dass maximal 10 Gewichte vorhanden sind
• Sie können die Eingabe in einem optionalen Format vornehmen, aber Sie können die von etwas anderem verwendeten Zeichen nicht ersetzen

Das ist Code-Golf, also gewinnt der kürzeste Code in Bytes jeder Sprache. Erklärungen sind wie immer erwünscht.

Gelee ,  24  23 Bytes

ḟ⁶Ỵẹ€”|IFṚ’œṗ$Ḅ:3“ÇÞ‘yS

Probieren Sie es online!

Wie?

Die Gewichte können durch ihre Breiten und Höhen identifiziert werden. Die Breite kann gemessen werden, indem der Abstand zwischen den |Zeichen der Linie betrachtet wird . Wenn wir zuerst alle Zwischenräume entfernen, tragen diese Gewichte der Höhe zwei zu einer solchen Linie mit einer gemessenen Breite von eins bei.

Die verschiedenen Gewichte haben Breiten von 3, 7, 7, 15, 21(jeweils für Gewichte 1, 2, 5, 10, 20). Hinzufügen eines nachlauf 1für die von der Höhe zwei finden wir die [3],[7],[7,1],[15,1],[21,1]Umwandlung von binären diese sind 3,7,15,31,43, ganze Zahl dividiert durch drei gibt uns 1,2,5,10,14, was sind die Gewichte außer 14Bedarf ersetzt durch 20.

ḟ⁶Ỵẹ€”|IFṚ’œṗ$Ḅ:3“ÇÞ‘yS - Link: list of characters    e.g. <example 2>
 ⁶                      - literal space character
ḟ                       - filter discard
  Ỵ                     - split at new lines
     ”|                 - literal pipe character
   ẹ€                   - get indices for €ach             [[],[1,2],[1,22],[1,2],[1,16],[2,5],[1,8],[1,2],[1,8]]
       I                - incremental differences          [[],[1],[21],[1],[15],[3],[7],[1],[7]]
        F               - flatten                          [1,21,1,15,3,7,1,7]
         Ṛ              - reverse                          [7,1,7,3,15,1,21,1]
             $          - last two links as a monad:
          ’             -   decrement                     [6,0,6,2,14,0,20,0]
           œṗ           -   partition at truthy indices   [[],[7,1],[7],[3],[15,1],[21,1]]
              Ḅ         - convert from binary             [0,15,7,3,31,43]
               :3       - integer divide by three         [0,5,2,1,10,14]
                 “ÇÞ‘   - code-page-indices               [14,20]
                     y  - translate                       [0,5,2,1,10,20]
                      S - sum                             38

Alternativ ersetzt die gemessenen Breiten 21mit 30vor der Umwandlung unter Verwendung von “ßœ‘y:

ḟ⁶Ỵẹ€”|IF“ßœ‘yṚ’œṗ$Ḅ:3S

Python 2 , 77 Bytes

lambda x:sum(i/21*x.count('|'+i%21*' _'[i<50]+'|')for i in[23,48,69,224,440])

Probieren Sie es online!

[i/21, i%21, ' _'[i<50] for i in [23,48,69,224,440]]erzeugt die folgenden Drillinge [1, 2, '_'], [2, 6, '_'], [3, 6, ' '], [10, 14, ' '], [20, 20, ' '], die das Gewicht, die Länge und das Zeichen in der Basis jedes Gewichts darstellen, die verwendet werden, um eine eindeutige einzeilige Darstellung jedes Gewichts zu erstellen.
Da sich das 3. Gewicht mit dem 2. Gewicht überschneiden würde, ersetze ich seine Basis durch seinen Körper ( _-> ) und reduziere den Wert auf 3(es wird die Basis als 2und den Körper als zählen 3, was zur Folge hat 5).

Retina 0.8.2 , 60 Bytes

T`|`!
!__!
1
!_{6}!
11
! {6}!
3$*
!.{14}!
5$*
!.{20}!
10$*
1

Probieren Sie es online! Erläuterung: Die |s werden !zur Vereinfachung des Abgleichs durch s ersetzt , dann werden die Gewichte in unäre umgewandelt und summiert. Der einzig interessante Teil ist, dass das 5Gewicht als die Summe von a 2und a betrachtet wird 3, während das Gewicht 10und 20nur zwei Zeilen des halben Gewichts sind.

JavaScript (Node.js) , 73 Byte

x=>x.replace(/\|.*\|/g,s=>u+=s.length/4*(s[1]<1?s[21]?29/11:1.5:1),u=0)|u

Probieren Sie es online!

Python 3 , 76 Bytes

lambda t:sum([1,2,3,5,5,9,11][len(x)//4+(x<'_')]for x in t.split('|')[1::2])

Probieren Sie es online!

Wie?

sum([1,2,3,5,5,9,11][len(x)//4+(x<'_')]for x in t.split('|')[1::2])
                                                t.split('|')         - split ascii art into pieces
                                                            [1::2])  - weights are at odd indexes
                                       for x in                      - iterates over the weights
                     len(x)//4                                       - map widths to 0,1,3,5,7
                              +(x<'_')                               - add 1 if the first row of 2-row weight
    [1,2,3,5,5,9,11][                 ]                              - value of each part of a weight
sum(                                                              )  - add 'em all up

Ich bin mir sicher, dass einige Verbesserungen vorgenommen werden müssen, aber das habe ich im Moment:

Groovy, 131 Bytes

def f(s){s.split('\n').sum{n=0;[2:1,6:2,14:5,20:10].each{k,v->if(it==~".*\\|[ _]{$k}\\|.*"){n=v+(!it.contains('_')&&k==6?1:0)}};n}}

Konvertiert die Eingabe Stringin a Collection<String>und summiert dann die Ergebnisse für jede Zeile, um die Summe zu erhalten. Verwendet aMap wobei der Schlüssel die Anzahl der Leerzeichen oder Unterstriche zwischen den Pipe-Zeichen ist und der Wert die entsprechende Passerees-Menge ist. Der Schlüssel wird in den regulären Ausdruck eingesteckt, um festzustellen, ob die Linie einem signifikanten Muster entspricht. Die einzige Einschränkung ist die ternäre Addition von 1 für den Fall, dass die Länge des Teilstrings zwischen den Rohren 6 beträgt und aus Leerzeichen besteht (im Gegensatz zu Unterstrichen). Wenn kein Muster übereinstimmt, hat die Linie den Wert 0.

Perl 6 , 57 Bytes

{sum map {.comb+>2*(1.5,3)[.comb>16]**!/_/},m:g/\|.*?\|/}

Probieren Sie es online!