¿Cuántos elfos necesita Papá Noel para entregar regalos?

23

Santa necesita ayuda para determinar cuántos elfos necesitará para ayudarlo a entregar regalos a cada casa.

El carbón es considerablemente más pesado que los regalos, por lo que santa necesitará tres duendes por cada persona traviesa en la casa. Solo se necesitan dos duendes para ayudar a santa a llevar regalos.

En el mapa de santa, una casa está representada por a *, y cada casa está dividida por a +.

Habrá un número a cada lado de la casa: el de la izquierda que representa el número de personas traviesas en la casa y el de la derecha que representa el número de personas agradables en la casa. Si no hay un número en un lado, se interpreta como un 0.

Papá Noel no visita a aquellos que no están en el espíritu navideño (ni siquiera merecen carbón), por lo que a veces, una casa puede no tener un número a cada lado. En este caso, santa no necesita ayuda de ningún elfo

Por ejemplo, uno de los mapas de santa puede verse así

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

En la primera casa hay 1 travieso y 3 lindos, santa necesitará nueve elfos. En el segundo, hay 2 traviesos y 2 simpáticos, santa necesitará diez duendes. En la tercera casa hay 1 travieso y 0 simpático, santa necesitará tres duendes, y en la última casa hay 0 travieso y 2 simpáticos, santa necesitará cuatro duendes.

Sin embargo, esta es una versión demasiado simplificada de uno de los mapas de santa. Normalmente, los mapas de Papá Noel tienen varias líneas y tienen una forma cuadrada para ajustarse mejor a su lista. Un mapa normal podría verse más o menos así ( \na al final de cada línea)

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

En este mapa, santa necesita ((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

Reto

¡Ayuda a santa a determinar cuántos elfos necesita para entregar bienes a cada casa!

Casas

  • Una casa está representada por un *
  • Las casas están divididas por +
  • El número a la izquierda de la casa simboliza el número de personas traviesas (ningún número significa 0)
  • El número a la derecha simboliza el número de personas agradables (ningún número significa 0)
  • Puede haber nuevas líneas ( \n) en la entrada, que también se deben manejar como una división

Duendes

  • Santa necesita ayuda de tres duendes para personas traviesas (el carbón es mucho más pesado que los regalos)
  • Santa necesita ayuda de dos duendes para gente agradable
  • Si no hay un número a cada lado, santa no visitará esa casa y, por lo tanto, no necesita ningún elfo

Qué hacer

Imprime el número de duendes que santa necesita para ayudarlo a entregar regalos a las casas. Debido a que todo lo que Santa necesita saber es cuántos elfos traer, solo necesita imprimir la cantidad adicional de elfos que necesita para la lista de casas

Casos de prueba

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

Reglas

  • La entrada puede tomarse como argumento en una función, o desde STDIN o equivalente
  • La salida puede ser el valor de retorno de una función o imprimirse en STDOUT o equivalente
  • La entrada sólo contendrá los números, +, *, y saltos de línea\n
  • La salida debería ser solo el número total de elfos de los que Santa necesita ayuda para entregar en Navidad
  • Se aplican lagunas estándar

Tanteo

El trineo de Papá Noel está lleno de regalos que le dan menos espacio para ejecutar el código, por lo que necesita el código más corto que pueda obtener (no se preocupe si esto no tiene sentido. Si cuestiona la lógica de Papá Noel, terminará en la lista traviesa ) Debido al razonamiento CORRECTO de Santa , ¡el envío más corto en bytes gana!

Tabla de clasificación

Este es un fragmento de pila que genera una tabla de clasificación y una descripción general de los ganadores por idioma.

Para asegurarse de que su respuesta se muestre, comience con un título usando la siguiente plantilla de Markdown

## Language Name, N bytes

Donde N es el tamaño, en bytes, de su envío

Si desea incluir varios números en su encabezado (por ejemplo, tachar los puntajes antiguos o incluir marcas en el recuento de bytes), solo asegúrese de que el puntaje real sea el último número en su encabezado

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

Mostrar fragmento de código

code-golf string Jojodmo
fuente
1
Me pregunto, ya que Santa se detendrá en cualquier casa, ¿no necesitaría un máximo de max(naughty) + max(nice)elfos para toda la ruta? Pensé que tenía un montón de elfos volando con él, pero tal vez tengas información privilegiada sobre eso y necesito mirar más de cerca este año. :)
insertusernamehere
8
@insertusernamehere Actualmente trabajo en Santa Inc. y puedo decirle que nuestra infraestructura funciona de manera muy asíncrona. No quiere que sus recursos se mueran de hambre, por lo que asignamos tantos trabajadores como sea necesario. En caso de que necesitemos un ELF adicional, podemos compilar uno en pocos segundos hello-world.c. Los elfos trabajadores se asignan ansiosamente a los objetivos como dijo Jojodmo (estoy seguro de que conozco a Jojodmo, debe ser nuestro sistema) y luego usan una devolución de llamada para notificar cuándo es el momento de reinsertarse en la piscina de trineos o cuando un niño los vio.
Stefano Sanfilippo
2
@StefanoSanfilippo Ah, ya veo. Gracias por todos los conocimientos detallados de esta información clasificada. Y feliz navidad. :)
insertusernamehere
Esto tiene mucho sentido. Santa necesita el código más corto porque imprime cada carácter del código con una impresora y luego los coloca en su trineo antes de ejecutarlos.
A̲̲

Respuestas:

2

Pyth, 21 bytes

ssMs*VCcR\*scR\+.z_S3

Ejemplo de líneas múltiples

Conjunto de pruebas de una línea

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
fuente
En serio ... ¿Hay algo que Pyth no pueda hacer en menos de 30 bytes?
Jojodmo
2
@Jojodmo No, si puedo evitarlo ...
isaacg
13

JavaScript (ES6), 52 bytes

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

Explicación

Convierte la entrada en una declaración de JavaScript válida. Reemplaza todos *con .0*3+y todos los demás símbolos (sin dígitos) con .0*2+. Por ejemplo se 8*9+*10convierte 8.0*3+9.0*2+.0*3+10. Finalmente se agrega .0*2al final para el último buen recuento. Esto funciona porque n.0= ny .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 "+"
  )

Prueba

Mostrar fragmento de código

usuario81655
fuente
99
+1 por la .0idea.
nimi
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);}

El primer personaje es un espacio. Compilar con:

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

Lee desde STDIN, escribe en STDOUT. La entrada es terminada por EOF (Ctrl + D en la consola).

Stefano Sanfilippo
fuente
2

Mathematica, 70 bytes

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

Usos StringExtractpara extraer los números individuales.

LegionMammal978
fuente
2

CJam, 23 bytes

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

Pruébalo aquí.

Explicación

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
fuente
2

En serio, 38 30 bytes

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

Hex Dump:

272a57736027302b272a407327f79c4d3472522a604de42b272b2c575858

Esta nueva versión rompe el intérprete en línea, pero funciona bien localmente. Aquí hay un ejemplo de ejecución:

$ 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

Explicación:

'*                              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.

Versión antigua:

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

Hex Dump:

272bee272a602b272b2b2c60ce587360f760bb6027302b272a4073bd4d5b332c325d2a604de4

Pruébalo en línea

Explicación:

  ε'*                                   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

Esto podría ser más corto si simplemente convirtiera cada línea por separado y las sumara todas al final. Lo investigaré más tarde.

quintapia
fuente
2

PowerShell, 52 bytes

El uso de variación de user81655 's .0truco

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

Versión sin golf

$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

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

Esto se puede probar en SwiftStub, aquí

Sin golf

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
fuente
1

Python 3, 141 114 112 bytes

Toma entradas de varias líneas 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("*")))

Sin golf:

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
fuente
1

Llego muy tarde, pero de todos modos quería intentarlo.

Ruby , 84 55 bytes

Encontré esta pregunta nuevamente después de tantos años y estaba pensando en una nueva respuesta antes de darme cuenta de que ya había respondido esto antes. Whoops! De todos modos, aquí hay una respuesta mejorada drásticamente.

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

Pruébalo en línea!

Antigua respuesta de 84 bytes de cuando respondí esto por primera vez hace 2 años:

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

Pruébalo en línea!

Tinta de valor
fuente
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

Pruébalo en línea!

101 bytes sin expresiones regulares

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

Pruébalo en línea!

Matthew Jensen
fuente