Santa's Entscheidung:

Bei dieser Herausforderung helfen Sie dem Weihnachtsmann, zu entscheiden, ob jemand auf seiner Liste frech oder nett war, und erhalten anschließend coaloder toys.

Leider ist der Weihnachtsmann in einigen seiner Einträge unorganisiert naughty , nice und nameFelder sind in der falschen Reihenfolge.

Eingang

Die Eingabe erfolgt in folgendem austauschbaren Format:

• der Name der Person (darf nur keinen Doppelpunkt enthalten) a-zA-Z0-9 )
• das Wort naughty direkt gefolgt von einem Doppelpunkt und einer nicht-negativen Ganzzahl, die angibt, wie oft der Weihnachtsmann Sie als ungezogen empfunden hat
• Das Wort wird nicedirekt gefolgt von einem Doppelpunkt und einer nicht-negativen Ganzzahl, die angibt, wie oft der Weihnachtsmann Sie nett erwischt hat

Alle werden durch ein einzelnes Leerzeichen (ASCII 32) voneinander getrennt.

Darüber hinaus wird der Name kein Leerzeichen zwischen den Teilen des Namens haben Santa Claus-> SantaClaus.

Bonus:

• (25%) : Er ist Weihnachtsmann, also muss er die Liste zweimal überprüfen und sicherstellen, dass es keine Duplikate gibt. (In diesem Fall erhält es nur die ersten Punkte, die der Benutzer hat.)

Beispiel:

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

Ausgabe:

Die Ausgabe sollte bestehen aus:

Der Name der Person, gefolgt von:

• Wenn mehr Punkte drin sind naughty, danncoal :
• Wenn mehr Punkte drin sind nice, dann toys.

• Aber wenn naughtyund nicegleich sind, dannneeds more data

  Beispielausgabe:

• Mit Organisationsbonus und Doppelentfernungsbonus:

Quill coal
Doorknob toys
balpha needs more data
pops toys

• Ohne Bonus:

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

Die niedrigste Byteanzahl gewinnt!

Pyth, 68 Bytes - 25% = 51

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

Probieren Sie es online aus: Demonstration

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

Dies ist eine anonyme Funktion, die eine Zeichenfolge akzeptiert und das Ergebnis an STDOUT ausgibt. Um es zu nennen, geben Sie ihm einen Namen, z f=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 Bytes

Versucht, gepackte Zeichenfolgen zu verwenden.

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

Probieren Sie es hier online aus .

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

Vielen Dank an Histocrat für den Vorschlag der grepMethode.

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

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

Verwendung:

# 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

beinhaltet +1 für -p

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

Weniger golfen:

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)

• Update 113
  • Speichern Sie 25 Bytes, indem Sie einen Buchstaben von niceoder naughtyals Variablennamen verwenden.
  • Lose 5 Bytes durch Beheben des Fehlers, wenn der Name der letzte ist
• Update 105 spart 8 Bytes durch <=>Indizieren einer Liste von Ausgabezeichenfolgen.
• Update 103 spart 2 Bytes, indem Regex zum Anhängen der Ausgabezeichenfolge verwendet wird
• update 102 speichere 1 Byte, indem du den letzten Buchstaben von niceoder naughtyanstelle des zweiten verwendest.
• update 96 spart 6 bytes durch wechseln $$_ ? ... : ($$_++, ...)in $$_++ ? ... : ...
  (warum habe ich das vorher nicht gesehen).

JavaScript (ES6), 174 Bytes - 25% Bonus = 130,5 Punkte

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

Erläuterung

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

Prüfung

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 Bytes

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

Probieren Sie es online!

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

Wird in ungolfed version und erklärungen später etwas müde editieren. Alle Eingaben werden über die Befehlszeile eingegeben, wobei die Leerzeichen voneinander getrennt sind.

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]

JavaScript (ES6) 120 (160-25%)

Bei der anonymen Funktion mit Vorlagenzeichenfolgen gibt es 4 Zeilenumbrüche, die von Bedeutung sind und in der Byteanzahl enthalten sind

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