La decisión de santa

29

Decisión de Papá Noel:

En este desafío, ayudará a Santa Claus decidir si alguien en su lista ha sido malo o bueno, y posteriormente obtener coalo toys.

Pero, por desgracia, Santa no está organizado, en algunas de sus entradas, las naughty, nice y los namecampos están en el orden equivocado.

Entrada

La entrada vendrá en el siguiente formato intercambiable:

  • el nombre de la persona (solo no puede contener dos puntos a-zA-Z0-9)
  • la palabra naughtyseguida directamente por dos puntos y un número entero no negativo que representa la cantidad de veces que Santa te atrapó siendo travieso
  • la palabra niceseguida directamente por dos puntos y un número entero no negativo que representa la cantidad de veces que Santa te sorprendió siendo amable

Todos separados con un solo espacio en blanco (ASCII 32) entre cada uno de ellos.

Además, el nombre no tendrá espacios en blanco entre las partes del nombre Santa Claus-> SantaClaus.

Prima:

  • (25%) : Él es Santa Claus, por lo que debe verificar la lista dos veces y asegurarse de que no haya duplicados. (En cuyo caso, solo obtiene los primeros puntajes que tiene el usuario)

Ejemplo:

Quill naughty:4 nice:0
naughty:0 Doorknob nice:3
naughty:2 Quill nice:6
nice:3 balpha naughty:3
pops nice:4 naughty:2

Salida:

La salida debe consistir en:

El nombre de la persona seguido de:

  • Si hay más puntos naughty, entonces coal:
  • Si hay más puntos nice, entonces toys.
  • Pero si naughtyy niceson iguales, entoncesneeds more data

    Salida de ejemplo:

  • Con bonificación de organización y bonificación por eliminación de duplicados:

Quill coal
Doorknob toys
balpha needs more data
pops toys
  • Sin bonificación:

Quill coal
Doorknob toys
Quill toys
balpha needs more data
pops toys

¡El conteo de bytes más bajo gana!

Pluma
fuente
44
También hay un error tipográfico en los casos de prueba. Escribiste mal el nombre de nuestro glorioso mod DorkNoob : ^)
FryAmTheEggman
9
@FryAmTheEggman ಠ_ಠ
Pomo
2
No, travieso o agradable son nombres válidos
Quill
1
Esa es una buena idea ... supongo que siempre habrá la próxima vez ...
Quill
1
"Balpha necesita más datos" Eso parece correcto.
Adam Davis

Respuestas:

4

Pyth, 68 bytes - 25% = 51

V.zI-hA.g}\:kcNdY=+YGjd+G@c"needs more data
coal
toys"b._-Fmsecd\:SH

Pruébelo en línea: demostración

Jakube
fuente
5

Julia, 176 169 bytes

s->for l=split(s,"\n") M(r)=parse(matchall(r,l)[1]);g=M(r"e:\K\d+");b=M(r"y:\K\d+");println(replace(l,r" *\w+:\d+ *","")," ",g>b?"toys":b>g?"coal":"needs more data")end

Esta es una función anónima que acepta una cadena e imprime el resultado en STDOUT. Para llamarlo, asígnele un nombre, p. Ej.f=s->... .

Sin golf:

function santa(s::AbstractString)
    # Split the input on newlines and process each line separately
    for l in split(s, "\n")
        # Define a function to get the number from the result of a
        # regular expression match
        M(r) = parse(matchall(r, l)[1])

        # Goodness
        g = M(r"e:\K\d+")

        # Badness
        b = M(r"y:\K\d+")

        # Get the name by replacing the naughty and nice specifications
        # with empty strings and print the line to STDOUT
        println(replace(l, r" *\w+:\d+ *", ""), " ",
                g > b ? "toys" : b > g ? "coal" : "needs more data")
    end
end
Alex A.
fuente
4

Pyth - 64 bytes

Intentará usar cadenas empaquetadas.

jmj\ +hK.g@k\:cd\ @c"needs more data
coal
toys"b._-Fmseck\:SeK.z

Pruébelo en línea aquí .

Maltysen
fuente
Este lenguaje es tecnología suficientemente avanzada.
Robert Grant
3

Ruby, 144 123 155 * .75 = 116.25 bytes

->s{d={}
s.split("
").map{|l|
a=l.split
b=a.grep /:/
i,j,v=(b.sort*'').scan(/\d+/)+a-b
d[v]||(d[v]=0
puts v+' '+['needs more data','coal','toys'][i<=>j])}}

Gracias a histocrat por sugerir grepmétodo.

164 * .75 = 123 bytes

->s{d={}
s.split("
").map{|l|
a=l.split
b=a.select{|t|t[?:]}
i,j,v=(b.sort*'').scan(/\d+/)+a-b
d[v]||(d[v]=0
puts v+' '+['needs more data','coal','toys'][i<=>j])}}

144 bytes

->s{puts s.split("
").map{|l|b=(a=l.split).select{|t|t[?:]};i,j=(b.sort*'').scan(/\d+/);(a-b)[0]+' '+['needs more data','coal','toys'][i<=>j]}}

Sin golf

->s{
  d={}
  s.split("
  ").map{ |l|
    a = l.split
    b = a.grep /:/
    i, j, v = (b.sort * '').scan(/\d+/) + a-b
    d[v] ||
      (d[v]=0
       puts v + ' ' + ['needs more data','coal','toys'][i<=>j]
      )
  }
}

Uso:

# Assign the anonymous function to a variable
f = ->s{d={}
s.split("
").map{|l|
a=l.split
b=a.grep /:/
i,j,v=(b.sort*'').scan(/\d+/)+a-b
d[v]||(d[v]=0
puts v+' '+['needs more data','coal','toys'][i<=>j])}}

f["Quill naughty:4 nice:0
naughty:0 Doorknob nice:3
naughty:2 Quill nice:6
nice:3 balpha naughty:3
pops nice:4 naughty:2"]

Quill coal
Doorknob toys
balpha needs more data
pops toys
Vasu Adari
fuente
.select{|t|t[?:]}se puede jugar golf.grep(/:/)
histocrat
@histocrat Wow, olvidé totalmente ese método. Gracias :)
Vasu Adari
3

Perl, 138 113 105 103 102 96 - 25% de = 72

incluye +1 para -p

s/ *\w*(.):(\d+) */$$1=$2,()/eg;$$_++?$_='':s/\n/$".('needs more data',toys,coal)[$e<=>$y].$&/e

Menos golfizado:

s/ *\w*(.):(\d+) */$$1=$2,()/eg;    # strip naughty/nice, set $a to naughty, $i to nice
                                    # $_ is now the input name followed by \n
$$_++ ? $_='' :                     # only output once per name
s/\n/                               # replace newlines with:
  $".                               # a space,
  ('needs more data',toys,coal)     # one of these strings,
  [$e<=>$y]                         # indexed by -1, 0 or 1
  .$&                               # and the matched newline.
/ex                                 # (/x only for legibility)

  • actualización 113
    • guardar 25 bytes usando 1 letra de niceo naughtycomo nombre de variable;
    • perder 5 bytes reparando el error cuando el nombre es el último
  • la actualización 105 guarda 8 bytes utilizando <=>para indexar una lista de cadenas de salida.
  • la actualización 103 guarda 2 bytes utilizando expresiones regulares para agregar una cadena de salida
  • actualizar 102 guardar 1 byte utilizando la última letra de niceo en naughtylugar de 2nd.
  • la actualización 96 guarda 6 bytes cambiando $$_ ? ... : ($$_++, ...)a $$_++ ? ... : ...
    (por qué no lo vi antes).
Kenney
fuente
2

JavaScript (ES6), 174 bytes - 25% de bonificación = 130.5 puntaje

s=>s.split`
`.map(l=>l.split` `.map(p=>(m=p.match(/\w:\d+/))?(n=+m[0].slice(2),m>"f")?b=n:c=n:a=p)&&d[a]?"":d[a]=a+" "+(b>c?`coal
`:b<c?`toys
`:`needs more data
`),d={}).join``

Explicación

s=>
  s.split`
`.map(l=>                   // for each line l of Santa's list
    l.split` `.map(p=>      // for each word p in l
      (m=p.match(/\w:\d+/)) // m = "y:x" for naughty, "e:x" for nice or null for name
        ?(n=+m[0].slice(2), // n = number at end of match
          m>"f")?b=n:c=n    // if naughty matched b = n, if nice matched c = n
        :a=p                // if no match, a = name
    )
    &&d[a]?"":              // if the name has been used before, add nothing to output
    d[a]=                   // else set d[name] to true

      // Add the appropriate text to the output
      a+" "+(b>c?`coal
`:b<c?`toys
`:`needs more data
`),

    // NOTE: This line is executed BEFORE the code above it in the map function...
    d={}                    // d = list of names that have been output
  )
  .join``                   // return the list of outputs as a string

Prueba

usuario81655
fuente
2

Lua, 329 Bytes - 25% de bonificación = 246.75

a={...}p={}u=" "k=ipairs for i=1,#a/3 do p[i]={}end for i,v in k(a)do p[math.floor((i+2)/3)][(v:find("y:")and 3)or(v:find("e:")and 2)or 1]=v:gsub("%a+%:","")end for i,v in k(p)do d=tonumber b,g,n=d(v[3]),d(v[2]),v[1]if(not u:find(" "..n.." "))then u=u..n.." "print(n..(g<b and" coal"or g>b and" toys"or" needs more data"))end end

Se editará en versiones no explicadas y explicaciones más tarde, un poco cansado en este momento. Toda la entrada se toma a través de la línea de comando, separada por espacios.

Cyv
fuente
2

Python 2, 206 bytes - 25% = 154.5

s=[]
x=[0,0]
for p in zip(*(iter(input().split()),)*3):
 for w in p:
  j=w.find(':')+1
  if j:x[j<6]=int(w[j:])
  else:N=w
 b,g=x
 if N not in s:print N,['needs more data','coal','toys'][(b>g)-(g>b)];s+=[N]
TFeld
fuente
2

JavaScript (ES6) 120 (160-25%)

Función anónima que utiliza cadenas de plantilla, hay 4 nuevas líneas que son significativas e incluidas en el recuento de bytes

l=>l.split`
`.map(r=>k[r=r.replace(/\S+:(\d+)/g,(a,c)=>(t-=a[1]<'i'?c:-c,''),t=0).trim()]?'':k[r]=r+(t>0?` toys
`:t<0?` coal
`:` needs more data
`),k={}).join``
edc65
fuente