Quantos elfos o Papai Noel precisa para entregar presentes?

23

Papai Noel precisa de ajuda para determinar quantos elfos ele precisará para ajudá-lo a entregar presentes para cada casa.

O carvão é consideravelmente mais pesado que os presentes, portanto, o Papai Noel precisará de três elfos para cada pessoa travessa da casa. Apenas dois elfos são necessários para ajudar o Papai Noel a levar presentes.

No mapa de santa, uma casa é representada por a *, e cada casa é dividida por a +.

Haverá um número em ambos os lados da casa - o da esquerda representando o número de pessoas malcriadas na casa e o da direita representando o número de pessoas legais na casa. Se não houver um número em um lado, ele será interpretado como um 0.

O Papai Noel não visita aqueles que não estão no espírito natalino (eles nem merecem carvão); portanto, às vezes, uma casa pode não ter um número em ambos os lados. Nesse caso, o Papai Noel não precisa da ajuda de nenhum elfo

Por exemplo, um dos mapas do Papai Noel pode ser assim

1*3+2*2+1*+*2

Na primeira casa há 1 safado e 3 agradáveis, o Papai Noel precisará de nove elfos. No segundo, existem 2 safados e 2 legais, o Papai Noel precisará de dez elfos. Na terceira casa tem 1 safada e 0 legal, o papai noel vai precisar três elfos, e na última casa há 0 impertinente e 2 legais, o Papai Noel precisará de quatro elfos.

Esta é uma versão simplificada de um dos mapas do Papai Noel. Normalmente, os mapas do Papai Noel têm várias linhas e têm uma forma quadrada para melhor se encaixar na lista dele. Um mapa normal pode se parecer com isso (a \nno final de cada linha)

1*2+*+*4+1*
2*4+3*+1*6+*
*+*+4*2+1*1
*4+*3+1*+2*3
3*10+2*+*5+*

Neste mapa, o Papai Noel precisa ((1 + 0 + 0 + 1 + 2 + 3 + 1 + 0 + 0 + 0 + 4 + 1 + 0 + 0 + 1 + 2 + 3 + 2 + 0 + 0) * 3) + ((2 + 0 + 4 + 0 + 4 + 0 + 6 + 0 + 0 + 0 + 2 + 1 + 4 + 3 + 0 + 3 + 10 + 0 + 5 + 0) * 2)= 151 elfos

Desafio

Ajude o Papai Noel a determinar quantos elfos ele precisa para entregar mercadorias em cada casa!

Moradias

  • Uma casa é representada por um *
  • Casas são divididas por +
  • O número à esquerda da casa simboliza o número de pessoas malcriadas (nenhum número significa 0)
  • O número à direita simboliza o número de pessoas legais (nenhum número significa 0)
  • Pode haver novas linhas ( \n) na entrada, que também devem ser tratadas como uma divisão

Elfos

  • Papai Noel precisa de ajuda de três elfos para pessoas malcriadas (o carvão é muito mais pesado que os presentes)
  • Papai Noel precisa da ajuda de dois elfos para pessoas legais
  • Se não houver número de cada lado, o Papai Noel não visitará a casa e, portanto, não precisará de elfos.

O que fazer

Imprima o número de elfos que o Papai Noel precisa para ajudá-lo a entregar presentes às casas. Como tudo que o Papai Noel precisa saber é quantos elfos levar, você só precisa imprimir o número adicional de elfos que ele precisa para a lista de casas.

Casos de teste

1*1 => 5
1*2 => 7
2*1 => 8
1* => 3
*1 => 2
* => 0

1*1+1*1 => 10
1*2+2*1 => 15
1*+*1 => 5
1*1+*+1*1 => 10
*+*+*+* => 0

Regras

  • A entrada pode ser tomada como argumento em uma função ou em STDIN ou equivalente
  • A saída pode ser o valor de retorno de uma função ou impressa em STDOUT ou equivalente
  • A entrada conterá apenas números, +,* , e novas linhas\n
  • A saída deve ser apenas o número total de elfos dos quais o Papai Noel precisa de ajuda para entregar no Natal
  • Aplicam-se brechas padrão

Pontuação

O trenó do Papai Noel está cheio de presentes, dando-lhe menos espaço para executar o código, então ele precisa do código mais curto possível (não se preocupe se isso não fizer sentido. Se você questionar a lógica do Papai Noel, você terminará na lista impertinente ) Devido ao raciocínio CORRETO do Papai Noel , o menor envio em bytes vence!

Entre os melhores

Este é um snippet de pilha que gera um placar de líderes e uma visão geral dos vencedores por idioma.

Para garantir que sua resposta seja exibida, inicie sua resposta com um título, usando o seguinte modelo de remarcação

## Language Name, N bytes

Onde N é o tamanho, em bytes, do seu envio

Se você deseja incluir vários números no seu cabeçalho (por exemplo, localizar pontuações antigas ou incluir sinalizadores na contagem de bytes), verifique se a pontuação real é o último número no cabeçalho

## Language Name, <s>K</s> X + 2 = N bytes

Mostrar snippet de código

code-golf string Jojodmo
fonte
1
Eu me pergunto, como o Papai Noel vai parar em qualquer casa, ele não precisaria apenas de um máximo de max(naughty) + max(nice)elfos para toda a rota? Eu pensei que ele tinha um monte de elfos voando com ele, mas talvez você tenha informações privilegiadas sobre isso e eu preciso olhar mais de perto este ano. :)
insertusernamehere
8
@insertusernamehere atualmente trabalho na Santa Inc. e posso dizer que nossa infraestrutura opera de maneira altamente assíncrona. Ele não quer que seus recursos passem fome, então alocamos quantos trabalhadores forem necessários. Caso necessitemos de um ELF extra, podemos compilar um em alguns segundos a partir de hello-world.c. Os elfos trabalhadores são alocados ansiosamente aos alvos, como Jojodmo disse (tenho certeza de que conheço Jojodmo, ele deve ser nosso administrador de sistemas) e, em seguida, usamos um retorno de chamada para notificar quando é hora de ser reinserido na piscina de trenós ou quando uma criança os viu.
Stefano Sanfilippo
2
@StefanoSanfilippo Ah, entendo. Obrigado por todas as informações detalhadas dessas informações classificadas. E Feliz Natal. :)
insertusernamehere
Isso faz totalmente sentido. Papai Noel precisa do código mais curto, porque ele imprime todos os caracteres do código com uma impressora e os coloca em seu trenó antes de executá-los.
A

Respostas:

2

Pitão, 21 bytes

ssMs*VCcR\*scR\+.z_S3

Exemplo de várias linhas

Conjunto de teste de linha única

ssMs*VCcR\*scR\+.z_S3
                .z        Take a input, as a list of lines.
            cR\+          Chop each line on '+'.
           s              Flatten into list of strings.
       cR\*               Chop each line on '*'.
      C                   Transpose, into a list of naughty and nice.
    *V            _S3     Vectorized multiplication with [3, 2, 1]. This replicates
                          the naughty list 3 times and the nice list 2 times.
   s                      Flatten.
 sM                       Convert each string to an int.
s                         Sum.
isaacg
fonte
Sério ... Há algo que Pyth não possa fazer em menos de 30 bytes?
Jojodmo
2
@Jojodmo Não se eu posso ajudá-lo ...
isaacg
13

JavaScript (ES6), 52 bytes

s=>eval(s.replace(/\D|$/g,m=>`.0*${m=="*"?3:2}+`)+0)

Explicação

Converte a entrada em uma instrução JavaScript válida. Substitui todos *por .0*3+e todos os outros símbolos (sem dígito) por .0*2+. Por exemplo, 8*9+*10torna-se 8.0*3+9.0*2+.0*3+10. Finalmente, ele anexa .0*2ao final a última contagem legal. Isso funciona porque n.0= ne .0= 0.

s=>
  eval(                      // execute the formed equation
    s.replace(/\D|$/g,       // replace each symbol (and also add to the end) with:
      m=>`.0*${m=="*"?3:2}+` // case * = ".0*3+", else replace with ".0*2+"
    )
    +0                       // add "0" to the end for the trailing "+"
  )

Teste

Mostrar snippet de código

user81655
fonte
9
+1 para a .0ideia.
N
3

Flex + C, 112 90 bytes

 m=3,t;
%%
[0-9]+ t+=m*atoi(yytext);
\* m=2;
[+\n] m=3;
%%
main(){yylex();printf("%d",t);}

O primeiro caractere é um espaço. Ajuntar com:

flex -o santa.c santa.l
cc santa.c -o santa -ll

Lê de STDIN, grava em STDOUT. A entrada é finalizada por EOF (Ctrl + D no console).

Stefano Sanfilippo
fonte
2

Mathematica, 70 bytes

a=Tr[FromDigits/@StringExtract[#,"
"|"+"->;;,"*"->#2]]&;3#~a~1+2#~a~2&

Usa StringExtractpara extrair os números individuais.

LegionMammal978
fonte
2

CJam, 23 bytes

q'+NerN/{'*/3*5<:~~}%1b

Teste aqui.

Explicação

q      e# Read all input.
'+Ner  e# Replaces all "+" with linefeeds.
N/     e# Split the string around linefeeds (i.e. into houses).
{      e# Map this block over the list of house...
  '*/  e#   Split the string around the "*".
  3*   e#   Repeat the times.
  5<   e#   Truncate to 5 elements, keeping 3 copies of the naughty number and 2 copies of
       e#   the nice number.
  :~   e#   Evaluate each number (which may be an empty string which pushes nothing).
  ~    e#   Dump the list of numbers on the stack.
}%
1b     e# Sum all the numbers.
Martin Ender
fonte
2

Sério, 38 30 bytes

'*Ws`'0+'*@s'≈£M4rR*`MΣ+'+,WXX

Hex Dump:

272a57736027302b272a407327f79c4d3472522a604de42b272b2c575858

Esta nova versão interrompe o intérprete online, mas funciona bem localmente. Aqui está um exemplo de execução:

$ python2 seriously.py -f elves.srs
1*2+*+*4+1*
2*4+3*+1*6+*
*+*+4*2+1*1
*4+*3+1*+2*3
3*10+2*+*5+*

151

Explicação:

'*                              Push a "*" to make the stack truthy
  W                        W    Repeat while the top of stack is truthy
                                  (A whole bunch of instructions just turn the "*" into a
                                  zero on the first pass, so I'll list them here in the
                                  order they actually accomplish useful things:)
                          ,     Read in a line of input
   s                    '+      Split it on occurrence of "+"
    `               `M          Map this function over the list of strings.
     '0+                        Prepend a "0" to ensure a naughty number exists
        '*@s                    Split the string on "*"
            '≈£M                Map over the string with int() to convert it to int
                4rR             Push [3,2,1,0]
                   *            Dot product
                      Σ+        Sum all the houses, and add it to the results
                                  from the previous line of input
                            XX  Pop the "" and '+ from the stack, leaving only the
                                result to be implicitly output.

Versão antiga:

'+ε'*`+'++,`╬Xs`≈`╗`'0+'*@s╜M[3,2]*`MΣ

Hex Dump:

272bee272a602b272b2b2c60ce587360f760bb6027302b272a4073bd4d5b332c325d2a604de4

Experimente Online

Explicação:

  ε'*                                   Initialize with two strings so the first + works
     `+'++,`╬                           Read in strings and compile them until "" is read
             X                          Throw away the ""
'+            s                         Split on +
               `≈`╗                     Chuck int function into reg0 to use within function
                   `               `M   Map this function over the list of houses
                    '0+                 Prepend a "0" to ensure a naughty number exists
                       '*@s             Split on *
                           ╜M           Convert the resulting list to ints with stored func
                             [3,2]*     Dot product with [3,2]
                                     Σ  Sum all houses

Talvez isso pudesse ser mais curto se eu apenas convertesse cada linha separadamente e as somasse no final. Vou dar uma olhada mais tarde.

quintopia
fonte
2

PowerShell, 52 bytes

Usando variação de user81655 's .0truque

$OFS='+';"$("$args"-replace'\*','.0*3+2*0'|iex)"|iex

Versão ungolfed

$OFS='+' # Set Output Field Separator to '+'
         # So if $arr = 1,2,3 then "$arr" will output 1+2+3

" # Cast result of subexpression to string using $OFS

    $( # Subexpression

        "$args" # Input is an array of arguments. Casting it to string using "$args"
                # is shorter then acessing the first element using $args[0]
                # $OFS wouldn't affect this, because input has only 1 element.

        -replace '\*' , '.0*3+2*0' # Replace every * with .0*3+2*0
                                   # Example: 1*+*1 becomes 1.0*3+2*0+.0*3+2*01

    ) | Invoke-Expression # Execute a result of subexpression as PS code.
                          # This will execute resulting multiline string line-by line
                          # and return an array of values, e.g.: 18,38,21,29,45

" Cast the aray above to string using '+' as Output Field Separator, e.g: 18+38+21+29+45

| Invoke-Expression # Execute the string above as PS code to get final result.
                    # E.g.: 18+38+21+29+45 = 151

Exemplo de uso

$Map = @'
1*2+*+*4+1*
2*4+3*+1*6+*
*+*+4*2+1*1
*4+*3+1*+2*3
3*10+2*+*5+*
'@

PS > .\SantaMap.ps1 $Map
151
beatcracker
fonte
1

Swift 2, 283 211 bytes

func f(s:String)->Int{var r=0;for p in(s.characters.split{$0=="\n"}.map(String.init)){for v in p.utf8.split(43){let k="0\(v)".utf8.split(42);r+=(Int("\(k[0])")!)*3;r+=(k.count<2 ?0:Int("\(k[1])")!)*2}};return r}

Isso pode ser testado no SwiftStub, aqui

Ungolfed

func f(s: String) -> Int{
    var r = 0

    //for every value in the input, split every "\n" and mapped
    //to a String array
    for p in (s.characters.split{$0=="\n"}.map(String.init)){

        //for every value in the split input, split again at every + (Decimal 43)
        for v in p.utf8.split(43){
            //change the value to "0" + v, which doesn't change the
            //input, but in the event that there is no input on the
            //left side, a "0" will be used
            //
            //then split on every * (Decimal 42)
            let k = "0\(v)".utf8.split(42)

           //add to the total count of elves the number on the left * 3
            r+=(Int("\(k[0])")!) * 3

            //add to the total count of elves the number on the left * 2
            r+=(k.count < 2 ? 0 : Int("\(k[1])")!) * 2
        }

        //return the number of elves
        return r
    }
}
Jojodmo
fonte
1

Python 3, 141 114 112 bytes

Aceita entradas de várias linhas como esta c("1*2+*+*4+1*\n2*4+3*+1*6+*\n*+*+4*2+1*1\n*4+*3+1*+2*3\n3*10+2*+*5+*")

lambda s:sum(a and(3-z)*int(a)or 0for j in s.split("\n")for i in j.split("+")for z,a in enumerate(i.split("*")))

Ungolfed:

def c(s):
    t = 0
    for j in s.split("\n"):
        for i in j.split("+"):
            for z,a in enumerate(i.split("*"))
                if a == "":
                    a = 0
                else:
                    a = int(a)
                t += (3-z) * a  # alternate a*3 and a*2
    return t
Sherlock9
fonte
1

Estou super atrasada, mas queria tentar de qualquer maneira.

Ruby , 84 55 bytes

Encontrei essa pergunta novamente depois de tantos anos e estava pensando em uma nova resposta antes de perceber que já tinha respondido isso antes. Ops! De qualquer forma, aqui está uma resposta drasticamente melhorada.

->m{m.scan(/(\d*)\*(\d*)/).sum{|a,b|3*a.to_i+2*b.to_i}}

Experimente online!

Resposta antiga de 84 bytes de quando eu respondi pela primeira vez há 2 anos:

->m{m.split(/[+\n]/).map{|h|b,g=h.split(?*).map &:to_i
3*(b||0)+2*(g||0)}.inject :+}

Experimente online!

Value Ink
fonte
1

Python 3 , 96 bytes

lambda s:sum(int('0'+n)*(3-i%2)for i,n in enumerate(re.sub('[*\s]','+',s).split('+')));import re

Experimente online!

101 bytes sem regex

lambda s:sum(int('0'+n)*(3-i%2)for i,n in enumerate(s.replace('*','+').replace('\n','+').split('+')))

Experimente online!

Matthew Jensen
fonte