Uma pilha de pesos

13

Desafio:

Você receberá uma imagem ASCII de uma pilha de pesos como entrada e deverá gerar o peso combinado da pilha.

insira a descrição da imagem aqui

Formato:

Existem 5 pesos diferentes, pesando 1, 2, 5, 10, 20 Passerees (ou alguma outra unidade arbitrária).

Os pesos são assim, em ordem crescente:

1:   __
    |__|

2:   ______
    |______|

5:   ______
    |      |
    |______|

10:  ______________
    |              |
    |______________|

20:  ____________________
    |                    |
    |____________________|

As pesagens serão colocadas simetricamente (como na imagem de exemplo), não necessariamente em uma ordem classificada. As pesagens compartilharão limites, quando aplicável:

Casos de teste:

Você também pode usar todos os pesos únicos como casos de teste.

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


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


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

Regras adicionais:

  • Você não pode assumir espaços iniciais adicionais. O maior peso estará todo o caminho para a esquerda.
  • Você pode assumir espaços à direita e novas linhas.
  • Você pode assumir que haverá no máximo 10 pesos
  • Você pode colocar a entrada em um formato opcional, mas não pode substituir os caracteres usados ​​por outra coisa

Isso é código-golfe, portanto o código mais curto em bytes que cada idioma ganha. As explicações são incentivadas como sempre.

code-golf ascii-art Stewie Griffin
fonte
Seu desafio me inspirou a escrever este . Todas as dicas são apreciadas!
tgrass12

Respostas:

7

Geléia ,  24  23 bytes

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

Experimente online!

Quão?

Os pesos podem ser identificados por suas larguras e alturas. As larguras podem ser medidas olhando a distância entre os |caracteres da linha . Se primeiro removermos todos os espaços, esses pesos de altura dois contribuirão com uma linha com uma largura medida de um.

Os pesos diferentes têm larguras de 3, 7, 7, 15, 21(para pesos 1, 2, 5, 10, 20respectivamente). Adicionando um trailing 1para aqueles de altura dois, achamos que [3],[7],[7,1],[15,1],[21,1]convertendo de binários 3,7,15,31,43, o número inteiro dividido por três nos dá 1,2,5,10,14, quais são os pesos, exceto as 14necessidades de substituição 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, substitua as larguras medidas de 21por 30antes da conversão usando “ßœ‘y:

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

Python 2 , 77 bytes

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

Experimente online!

[i/21, i%21, ' _'[i<50] for i in [23,48,69,224,440]]irá gerar os seguintes trigêmeos [1, 2, '_'], [2, 6, '_'], [3, 6, ' '], [10, 14, ' '], [20, 20, ' ']que representam o peso, o comprimento e o caractere na base de cada peso, que serão usados ​​para fazer uma representação única de linha única de cada peso.
Como o 3º peso se sobrepõe ao 2º, substituo a base pelo corpo ( _-> ) e reduzi o valor para 3(ele contará a base como 2e o corpo como 3, resultando em 5)

Cajado
fonte
4

Retina 0.8.2 , 60 bytes

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

Experimente online! Explicação: Os |s são substituídos por !s para facilitar a correspondência e, em seguida, os pesos são convertidos em unários e totalizados. A única parte interessante é que o 5peso é considerado a soma de um 2e um 3peso, enquanto os pesos 10e 20são apenas duas linhas da metade do peso.

Neil
fonte
2

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

Experimente online!

Quão?

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
RootTwo
fonte
1

Tenho certeza de que há algumas melhorias a serem feitas, mas é isso que tenho no 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}}

Converte a entrada Stringem a Collection<String>e soma os resultados para cada linha para obter o total. Usa um Maponde a chave é o número de espaços ou sublinhados entre os caracteres do canal e o valor é a quantidade correspondente de Passerees. A chave é conectada ao regex para determinar se a linha corresponde a um padrão significativo. A única ressalva é o ternário para adicionar 1 no caso em que o comprimento da subcadeia entre os tubos é 6 e é composto por espaços (em oposição a sublinhados). Se nenhum padrão corresponder, a linha terá um valor 0.

TheJizel
fonte