Décision du père Noël:

Dans ce défi, vous aiderez le Père Noël à décider si quelqu'un sur sa liste a été méchant ou gentil, puis à obtenir coalou toys.

Mais malheureusement, le Père Noël est inorganisé, dans certaines de ses entrées, les naughty, nice et les namechamps sont dans le mauvais ordre.

Contribution

L'entrée se fera dans le format interchangeable suivant:

• le nom de la personne (ne peut pas contenir deux-points, seulement a-zA-Z0-9)
• le mot naughtysuivi directement par deux points et un entier non négatif représentant le nombre de fois où le Père Noël vous a surpris en train d'être méchant
• le mot nicesuivi directement par deux points et un entier non négatif représentant le nombre de fois où le Père Noël vous a surpris en train d'être gentil

Tous séparés par un seul espace (ASCII 32) entre chacun d'eux.

De plus, le nom n'aura aucun espace entre les parties du nom Santa Claus-> SantaClaus.

Prime:

• (25%) : Il est le Père Noël, il doit donc vérifier la liste deux fois et s'assurer qu'il n'y a pas de doublons. (Dans ce cas, il obtient simplement les premiers scores de l'utilisateur)

Exemple:

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

Sortie:

La sortie doit consister en:

Le nom de la personne suivi de:

• S'il y a plus de points naughty, alors coal:
• S'il y a plus de points nice, alors toys.

• Mais si naughtyet nicesont égaux, alorsneeds more data

  Exemple de sortie:

• Avec bonus d'organisation et bonus de suppression des doublons:

Quill coal
Doorknob toys
balpha needs more data
pops toys

• Sans bonus:

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

Le nombre d'octets le plus bas gagne!

Pyth, 68 octets - 25% = 51

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

Essayez-le en ligne: Démonstration

Julia, 176 169 octets

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

Il s'agit d'une fonction anonyme qui accepte une chaîne et imprime le résultat dans STDOUT. Pour l'appeler, donnez-lui un nom, par exemple f=s->....

Non 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

Pyth - 64 octets

J'essaierai d'utiliser des chaînes compressées.

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

Essayez-le en ligne ici .

Rubis, 144 123 155 155 * 0,75 = 116,25 octets

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

Merci à l'histocrate d'avoir suggéré une grepméthode.

164 * 0,75 = 123 octets

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

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

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

Usage:

# 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 105 103 102 96 - 25% = 72

comprend +1 pour -p

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

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

• mise à jour 113
  • économisez 25 octets en utilisant 1 lettre de niceou naughtycomme nom de variable;
  • perdre 5 octets en corrigeant le bug lors du dernier nom
• mise à jour 105 enregistrer 8 octets en utilisant <=>pour indexer une liste de chaînes de sortie.
• mise à jour 103 enregistrer 2 octets en utilisant l'expression régulière pour ajouter la chaîne de sortie
• mise à jour 102 enregistrer 1 octet en utilisant la dernière lettre de niceou naughtyau lieu de 2e.
• mise à jour 96 enregistrer 6 octets en changeant $$_ ? ... : ($$_++, ...)en $$_++ ? ... : ...
  (pourquoi je ne l'ai pas vu avant).

JavaScript (ES6), 174 octets - 25% de bonus = 130,5 points

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

Explication

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

Tester

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 octets

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

Essayez-le en ligne!

Lua, 329 octets - 25% de 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

Éditera en version non golfée et explications plus tard, un peu fatigué pour le moment. Toutes les entrées sont prises en ligne de commande, séparées par des espaces.

Python 2, 206 octets - 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%)

Fonction anonyme utilisant des chaînes de modèle, il y a 4 nouvelles lignes significatives et incluses dans le nombre d'octets

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