Défi:

Vous recevrez une image ASCII d'un tas de poids en entrée, et vous devrez sortir le poids combiné du tas.

Format:

Il existe 5 poids différents, pesant 1, 2, 5, 10, 20 passagers (ou une autre unité arbitraire).

Les poids ressemblent à ceci, dans l'ordre croissant:

1:   __
    |__|

2:   ______
    |______|

5:   ______
    |      |
    |______|

10:  ______________
    |              |
    |______________|

20:  ____________________
    |                    |
    |____________________|

Les pesées seront placées symétriquement (comme dans l'image d'exemple), pas nécessairement dans un ordre trié. Les pesées partageront les limites, le cas échéant:

Cas de test:

Vous pouvez également utiliser tous les poids uniques comme cas de test.

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

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

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

Règles supplémentaires:

• Vous ne pouvez pas supposer d’espaces de début supplémentaires. Le poids le plus important sera tout le chemin vers la gauche.
• Vous pouvez supposer des espaces de fin et des retours à la ligne.
• Vous pouvez supposer qu'il y aura au maximum 10 poids
• Vous pouvez prendre l'entrée sur un format facultatif, mais vous ne pouvez pas remplacer les caractères utilisés par autre chose

Il s'agit de code-golf, donc le code le plus court en octets de chaque langue gagne. Les explications sont encouragées comme toujours.

Gelée ,  24  23 octets

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

Essayez-le en ligne!

Comment?

Les poids peuvent être identifiés par leurs largeurs et hauteurs. Les largeurs peuvent être mesurées en regardant la distance entre les |caractères de la ligne . Si nous supprimons d'abord tous les espaces, ces poids de hauteur deux contribueront à une telle ligne avec une largeur mesurée de un.

Les différents poids ont des largeurs de 3, 7, 7, 15, 21(pour les poids 1, 2, 5, 10, 20respectivement). En ajoutant un suivi 1pour ceux de la hauteur deux, nous trouvons la [3],[7],[7,1],[15,1],[21,1]conversion de binaire ce sont 3,7,15,31,43, l'entier divisé par trois nous donne 1,2,5,10,14, qui sont les poids sauf les 14besoins remplacés par 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

Vous pouvez également remplacer les largeurs mesurées de 21avec 30avant la conversion en utilisant “ßœ‘y:

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

Python 2 , 77 octets

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

Essayez-le en ligne!

[i/21, i%21, ' _'[i<50] for i in [23,48,69,224,440]]générera les triplets suivants [1, 2, '_'], [2, 6, '_'], [3, 6, ' '], [10, 14, ' '], [20, 20, ' ']qui représentent le poids, la longueur et le caractère dans la base de chaque poids, qui seront utilisés pour faire une représentation unique sur une seule ligne de chaque poids.
Étant donné que le 3e poids chevaucherait le 2e, je remplace sa base par son corps ( _-> ) et réduit la valeur à 3(il comptera la base comme 2et le corps comme 3, résultant en 5)

Retina 0.8.2 , 60 octets

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

Essayez-le en ligne! Explication: Les |s sont remplacés par des !s pour faciliter l'appariement, puis les poids sont convertis en unaires et totalisés. La seule partie intéressante est que le 5poids est considéré comme la somme de a 2et d'un 3poids, tandis que les poids 10et ne 20sont que deux lignes de la moitié du poids.

JavaScript (Node.js) , 73 octets

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

Essayez-le en ligne!

Python 3 , 76 octets

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

Essayez-le en ligne!

Comment?

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

Je suis sûr qu'il y a des améliorations à apporter, mais c'est ce que j'ai en ce moment:

Groovy, 131 octets

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

Convertit l'entrée Stringen a Collection<String>puis additionne les résultats de chaque ligne pour obtenir le total. Utilise un Mapoù la clé est le nombre d'espaces ou de traits de soulignement entre les caractères de canal et la valeur est le montant correspondant des passagers. La clé est branchée sur l'expression régulière pour déterminer si la ligne correspond à un motif significatif. La seule mise en garde est le ternaire pour ajouter 1 dans le cas où la longueur de la sous-chaîne entre les tuyaux est de 6 et est composée d'espaces (par opposition aux traits de soulignement). Si aucun motif ne correspond, la ligne a une valeur de 0.

Perl 6 , 57 octets

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

Essayez-le en ligne!