Sfida:

Ti verrà data un'immagine ASCII di una pila di pesi come input e dovrai produrre il peso combinato della pila.

Formato:

Ci sono 5 pesi diversi, del peso di 1, 2, 5, 10, 20 Passerees (o qualche altra unità arbitraria).

I pesi si presentano così, in ordine crescente:

1:   __
    |__|

2:   ______
    |______|

5:   ______
    |      |
    |______|

10:  ______________
    |              |
    |______________|

20:  ____________________
    |                    |
    |____________________|

Le pesate verranno posizionate simmetricamente (come nell'immagine di esempio), non necessariamente in un ordine ordinato. Le bilance condivideranno i confini, ove applicabile:

Casi test:

È possibile utilizzare tutti i pesi singoli anche come casi di test.

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

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

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

Regole aggiuntive:

• Si può non assumere ulteriori spazi iniziali. Il peso più grande sarà completamente a sinistra.
• Puoi assumere spazi finali e newline.
• Puoi presumere che ci saranno al massimo 10 pesi
• Puoi prendere l'input in un formato opzionale, ma non puoi sostituire i caratteri usati da qualcos'altro

Questo è code-golf, quindi il codice più breve in byte vince ogni lingua. Le spiegazioni sono incoraggiate come sempre.

Gelatina ,  24  23 byte

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

Provalo online!

Come?

I pesi possono essere identificati dalle loro larghezze e altezze. Le larghezze possono essere misurate osservando la distanza tra i |caratteri della linea . Se prima rimuoviamo tutti gli spazi, quei pesi di altezza due contribuiranno a tale linea con una larghezza misurata di uno.

I diversi pesi hanno larghezze di 3, 7, 7, 15, 21( 1, 2, 5, 10, 20rispettivamente per i pesi ). Aggiungendo un trailing 1per quelli di altezza due troviamo che [3],[7],[7,1],[15,1],[21,1]convertiamo da binari questi sono 3,7,15,31,43, numeri interi che si dividono per tre ci danno 1,2,5,10,14, che sono i pesi tranne che 14devono essere sostituiti da 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

In alternativa, sostituire le larghezze misurate 21con 30prima della conversione usando “ßœ‘y:

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

Python 2 , 77 byte

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

Provalo online!

[i/21, i%21, ' _'[i<50] for i in [23,48,69,224,440]]genererà le seguenti terzine [1, 2, '_'], [2, 6, '_'], [3, 6, ' '], [10, 14, ' '], [20, 20, ' ']che rappresentano il peso, la lunghezza e il carattere alla base di ciascun peso, che verranno utilizzate per creare una rappresentazione unica a linea singola di ciascun peso.
Poiché il 3o peso si sovrappone al 2o, sostituisco la sua base con il suo corpo ( _-> ) e riduco il valore a 3(conterà la base come 2e il corpo come 3, risultando 5)

Retina 0.8.2 , 60 byte

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

Provalo online! Spiegazione: Le |s vengono sostituite con !s per facilitare la corrispondenza, quindi i pesi vengono convertiti in unari e sommati. L'unica parte interessante è che il 5peso è considerato la somma di un 2e un 3peso, mentre i pesi 10e 20sono solo due linee della metà del peso.

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

Provalo online!

Python 3 , 76 byte

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

Provalo online!

Come?

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

Sono sicuro che ci sono alcuni miglioramenti da apportare, ma questo è quello che ho al momento:

Groovy, 131 byte

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

Converte l'input Stringin a Collection<String>e quindi somma i risultati per ciascuna riga per ottenere il totale. Utilizza un punto in Mapcui la chiave è il numero di spazi o caratteri di sottolineatura tra i caratteri di pipe e il valore è la quantità di Passerees corrispondente. La chiave viene inserita nella regex per determinare se la linea corrisponde a un modello significativo. L'unica avvertenza è il ternario per aggiungere 1 nel caso in cui la lunghezza della sottostringa tra i tubi sia 6 ed è composta da spazi (al contrario dei caratteri di sottolineatura). Se nessun motivo corrisponde, la linea ha un valore di 0.

Perl 6 , 57 byte

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

Provalo online!