Decisione di Babbo Natale:

In questa sfida, aiuterai Babbo Natale a decidere se qualcuno nella loro lista è stato cattivo o simpatico, e successivamente ottenere coalo toys.

Ma, purtroppo, Babbo Natale è disorganizzata, in alcune delle sue voci, i naughty, nice e namecampi sono nell'ordine sbagliato.

Ingresso

L'input verrà nel seguente formato intercambiabile:

• il nome della persona (non può contenere solo due punti a-zA-Z0-9)
• la parola naughtyseguita direttamente da due punti e da un numero intero non negativo che rappresenta la quantità di volte in cui Babbo Natale ti ha sorpreso a essere cattivo
• la parola niceseguita direttamente da due punti e da un numero intero non negativo che rappresenta la quantità di volte in cui Babbo Natale ti ha scoperto essere gentile

Tutti separati con un unico spazio bianco (ASCII 32) tra ciascuno di essi.

Inoltre, il nome non avrà spazi bianchi tra le parti del nome Santa Claus-> SantaClaus.

Bonus:

• (25%) : è Babbo Natale, quindi deve controllare l'elenco due volte e assicurarsi che non vi siano duplicati. (Nel qual caso, ottiene solo i primi punteggi che l'utente ha)

Esempio:

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

Produzione:

L'output dovrebbe essere costituito da:

Il nome della persona seguito da:

• Se ci sono più punti in naughty, quindi coal:
• Se ci sono più punti nice, allora toys.

• Ma se naughtye nicesono uguali, alloraneeds more data

  Esempio di output:

• Con bonus organizzazione e doppio bonus di rimozione:

Quill coal
Doorknob toys
balpha needs more data
pops toys

• Senza bonus:

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

Vince il conteggio dei byte più basso!

Pyth, 68 byte - 25% = 51

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

Provalo online: dimostrazione

Julia, 176 169 byte

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

Questa è una funzione anonima che accetta una stringa e stampa il risultato su STDOUT. Per chiamarlo, dagli un nome, ad esf=s->... .

Ungolfed:

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

Pyth - 64 byte

Proverà ad usare stringhe piene.

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

Provalo online qui .

Rubino, 144 123 155 * .75 = 116,25 byte

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

Grazie all'istocratico per aver suggerito il grepmetodo.

164 * .75 = 123 byte

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

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

Ungolfed

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

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

include +1 per -p

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

Meno golf:

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)

• aggiornamento 113
  • salva 25 byte usando 1 lettera da niceo naughtycome nome di variabile;
  • perdere 5 byte correggendo il bug all'ultimo nome
• l'aggiornamento 105 salva 8 byte usando <=>per indicizzare un elenco di stringhe di output.
• aggiornamento 103 salva 2 byte usando regex per aggiungere una stringa di output
• aggiornamento 102 salva 1 byte usando l'ultima lettera niceo al naughtyposto della 2a.
• l'aggiornamento 96 salva 6 byte cambiando $$_ ? ... : ($$_++, ...)in $$_++ ? ... : ...
  (perché non l'ho visto prima).

JavaScript (ES6), 174 byte - 25% di bonus = 130,5 punti

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

Spiegazione

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

Test

var solution = 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``

<textarea rows="5" cols="40" id="input">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</textarea><br />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

CJam, 64 byte

qN/{S/':f/_{,1=},_@^$1f=:~:-g"needs more data
coal
toys"N/=S\N}/

Provalo online!

Lua, 329 byte - 25% di bonus = 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

Modificherò in versione non golfata e spiegazioni in seguito, un po 'stanco al momento. Tutti gli input vengono ricevuti dalla riga di comando, spazio separato.

Python 2, 206 byte - 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]

JavaScript (ES6) 120 (160-25%)

Funzione anonima che utilizza stringhe di modello, ci sono 4 newline significative e incluse nel conteggio dei byte

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