Desafío:

Se le dará una imagen ASCII de un montón de pesas como entrada, y deberá generar el peso combinado de la pila.

Formato:

Hay 5 pesos diferentes, con un peso de 1, 2, 5, 10, 20 pasajeros (o alguna otra unidad arbitraria).

Los pesos se ven así, en orden ascendente:

1:   __
    |__|

2:   ______
    |______|

5:   ______
    |      |
    |______|

10:  ______________
    |              |
    |______________|

20:  ____________________
    |                    |
    |____________________|

Los pesos se colocarán simétricamente (como en la imagen de ejemplo), no necesariamente en un orden ordenado. Los pesos compartirán límites, cuando corresponda:

Casos de prueba:

También puede usar todos los pesos individuales como casos de prueba.

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

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

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

Reglas adicionales:

• Es posible que no asumirá los espacios iniciales adicionales. El mayor peso estará completamente a la izquierda.
• Puede asumir espacios finales y líneas nuevas.
• Puede suponer que habrá un máximo de 10 pesos
• Puede tomar la entrada en un formato opcional, pero no puede sustituir los caracteres utilizados por otra cosa.

Este es el código de golf, por lo que gana el código más corto en bytes de cada idioma. Se alientan las explicaciones como siempre.

Jalea ,  24  23 bytes

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

Pruébalo en línea!

¿Cómo?

Los pesos pueden identificarse por sus anchos y alturas. Los anchos se pueden medir observando la distancia entre los |caracteres de la línea . Si primero eliminamos todos los espacios, esos pesos de altura dos contribuirán con una línea con un ancho medido de uno.

Los diferentes pesos tienen anchuras de 3, 7, 7, 15, 21(para pesos 1, 2, 5, 10, 20respectivamente). Agregando un final 1para los de la altura dos, encontramos que la [3],[7],[7,1],[15,1],[21,1]conversión de binarios es 3,7,15,31,43, un entero dividido por tres nos da 1,2,5,10,14, que son los pesos, excepto las 14necesidades de reemplazo por 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

Alternativamente reemplazar las anchuras medidas de 21con 30el uso antes de la conversión “ßœ‘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])

Pruébalo en línea!

[i/21, i%21, ' _'[i<50] for i in [23,48,69,224,440]]generará los siguientes tripletes [1, 2, '_'], [2, 6, '_'], [3, 6, ' '], [10, 14, ' '], [20, 20, ' ']que representan el peso, la longitud y el carácter en la base de cada peso, que se utilizarán para hacer una representación única de una sola línea de cada peso.
Como el tercer peso se superpondría con el segundo, reemplazo su base con su cuerpo ( _-> ) y reduzco el valor a 3(contará la base como 2y el cuerpo como 3, lo que da como resultado 5)

Retina 0.8.2 , 60 bytes

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

Pruébalo en línea! Explicación: Los |s se reemplazan por !s para facilitar la coincidencia, luego los pesos se convierten en unarios y se suman. La única parte interesante es que el 5peso se considera la suma de a 2y un 3peso, mientras que los pesos 10y 20son solo dos líneas de la mitad del peso.

JavaScript (Node.js) , 73 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

¿Cómo?

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

Estoy seguro de que hay algunas mejoras por hacer, pero esto es lo que tengo en este momento:

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

Convierte la entrada Stringen Collection<String>ay luego suma los resultados de cada línea para obtener el total. Utiliza un Mapdonde la clave es el número de espacios o guiones bajos entre los caracteres de la tubería y el valor es la cantidad correspondiente de Passerees. La clave se conecta a la expresión regular para determinar si la línea coincide con un patrón significativo. La única advertencia es el ternario para agregar 1 en el caso en que la longitud de la subcadena entre las tuberías es 6 y está compuesta de espacios (en lugar de guiones bajos). Si ningún patrón coincide, la línea tiene un valor de 0.

Perl 6 , 57 bytes

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

Pruébalo en línea!