Einführung

Für diejenigen, die nicht mit Dampf vertraut sind - oder zumindest diesen besonderen Aspekt:

In den Profilen von Personen werden häufig Kommentare mit den Worten "+ rep _____" oder "-rep _____" hinterlassen. Dies ist aus mehreren Gründen ein inoffizielles Mittel, um zu zeigen, ob jemand in der Community einen guten oder einen schlechten Ruf hat. Solche Kommentare sehen so aus:

+ Repräsentant eines guten Spielers

+ rep hilfreich

-rep Hacker

-rep Betrüger

Aufgabe

Das Programm muss auf einvernehmliche Weise Eingaben vornehmen. Die Eingabe besteht aus einer Zeichenfolge mit optionalen Zeilenumbrüchen ( \n). Ganz am Anfang jeder Zeile '+rep 'oder '-rep 'möglicherweise vorhanden. Der Rest der Zeile kann verworfen werden. Wenn die Zeile nicht mit '+rep 'oder beginnt '-rep '(beachten Sie das nachstehende Leerzeichen), sollte die Zeile ignoriert werden.

Das Programm muss dann einen Gesamt-Reputations-Score haben. Ab 0sollte diese Punktzahl in jeder Zeile, die mit beginnt, erhöht und in jeder Zeile, die mit beginnt, '+rep 'verringert werden '-rep '.

Dieses Ergebnis sollte auf eine vereinbarte Weise ausgegeben werden.

Testfälle

Input:
+rep fast trade
+rep nice person
-rep too good

Output: 1

Input:
-rep hacker
-rep scammer
-rep was mean

Output: -3

Input:
first
i don't like him
+rep good at cs go

Output: 1

Input (note the lack of a trailing space on the third line):    
+rep +rep
hi +rep
-rep

Output: 1

Input:
+ rep

Output: 0

Input:
+rep like
-thing

Output: 1

Bonus

Ich weiß nicht einmal, ob es möglich ist, aber Bonuspunkte, wenn Sie diese Kommentare irgendwie von Steam bekommen können.

05AB1E , 18 16 17 Bytes

2 Byte dank Okx
+ 1 Byte aufgrund von Änderungen in der Spezifikation eingespart, wobei auf rep jetzt ein Leerzeichen folgen muss.

|vy5£„+-S„·Ý «QÆO

Probieren Sie es online!

Erläuterung

|v                   # for each line of input
  y5£                # get the first 4 chars of input
     „+-S„·Ý «       # push the list ['+rep ','-rep ']
              Q      # check each for equality
                     # results in either [1,0] for +rep, [0,1] for -rep or [0,0] for others
               Æ     # reduce by subtraction, gives either 1, -1 or 0
                O    # sum

Python 3, 73 Bytes

Ich bin sicher, dass diese Antwort Müll ist und bald geschlagen wird, aber es gibt noch keine anderen Python-Antworten

lambda x:sum(["- +".index(i[0])-1for i in x.split('\n')if i[1:4]=="rep"])

Verwenden Sie wie folgt:

f = lambda x:sum(["- +".index(i[0])-1for i in x.split('\n')if i[1:4]=="rep"])
print(f("PUT INPUT HERE"))

Aus dem Dampf holen

Hier ist ein Beispielcode, der die ersten 100 Kommentare aus dem KennyS-Profil abruft und seinen Repräsentanten berechnet.

import requests
from bs4 import BeautifulSoup

# Kenny's profile as Steam ID 64
# You can adjust this to whatever numbers you want
STEAM_PROFILE_URL = "76561198024905796"
payload =  {"start" : 0, "count" : 100}
r = requests.post("http://steamcommunity.com/comment/Profile/render/{}/-1/".format(STEAM_PROFILE_URL), payload)

# Comments are html inside a json object
soup = BeautifulSoup(r.json()["comments_html"], "html.parser")

# Get raw text for every comment.
# The " ".join() strips out the newlines and tabs which are part of html
comments = [" ".join(s.text.split()) for s in soup.find_all("div", {"class" : "commentthread_comment_text"})]

calculateRep = lambda x:sum(["- +".index(i[0])-1for i in x.split('\n')if i[1:4]=="rep"])

print(calculateRep("\n".join(comments)))

Perl 5 , 25 Bytes

24 Byte Code + -pFlag.

$\+=/^\+rep /-/^-rep /}{

Probieren Sie es online!

/^\+rep /Gibt zurück, 1wenn die Zeile mit beginnt +rep. /^-rep /Gibt zurück, 1wenn die Zeile mit beginnt -rep(also höchstens eine). Wir verwenden $\, um das Ergebnis zu speichern, da es implizit am Ende gedruckt wird (dank -pFlag und denen, die nicht übereinstimmen }{).

Python 2 , 54 Bytes

q=('\n'+input()).count;print q('\n+rep ')-q('\n-rep ')

Probieren Sie es online! Nimmt eine mehrzeilige Zeichenfolge als Eingabe.

Zählt das Auftreten von '+rep 'und '-rep 'nur am Zeilenanfang, indem nach der Zeichenfolge gesucht wird, die auf ein Zeilenumbruchsymbol folgt. Um die erste Zeile abzufangen, wird der Eingabe eine neue Zeile vorangestellt.

Retina , 63 51 50 49 Bytes

Entsprach nicht ganz der Spezifikation, deshalb habe ich einige Probleme behoben, aber auch viel Golf gespielt (indem ich die erste Zeile aus Kritixi Lithos 'Lösung ausgeliehen habe).

Dank Kritixi Lithos wurde ein weiteres Byte gespeichert.

ms`(?!^[+-]rep ).

+`\+-|-\+

(.)+
$1$.&
T`+
$^
0

Probieren Sie es online!

Erläuterung

ms`(?!^[+-]rep ).

Zunächst wird alles aus der Eingabe gelöscht, mit Ausnahme des +und -von einem +repoder -repam Anfang einer Zeile.

+`\+-|-\+

Dann werden benachbarte Paare von +und -entfernt, bis nicht mehr entfernt werden kann. Was danach übrig bleibt, ist entweder ein Lauf von +s, ein Lauf von -s oder nichts.

(.)+
$1$.&

Dann wird ein Lauf aus einem oder mehreren Zeichen (entweder +oder -) durch das Zeichen ersetzt, aus dem der Lauf besteht, gefolgt von der Länge des Laufs. Auf diese Weise +bleibt am Anfang für positive Ergebnisse und -für negative Ergebnisse gesorgt.

T`+

Dann werden alle +s entfernt, falls die Wiederholung positiv ist.

$^
0

Wenn der String zu diesem Zeitpunkt leer ist, ist die Wiederholung 0, also schreiben wir 0.

JavaScript, 55 Byte

Vielen Dank, @Neil, für das Golfen mit 12 Bytes. Vielen Dank, @Arnauld, für das Golfen mit 2 Bytes

x=>x.split(/^\+rep /m).length-x.split(/^-rep /m).length

Probieren Sie es online!

var y=x=>(x.match(/^\+rep /gm)||'').length-(x.match(/^-rep /gm)||'').length

document.querySelector('div').innerText=y(document.querySelector('textarea').value)

textarea{
  width: 95%;height: 100px;
  }

<textarea oninput = "document.querySelector('div').innerText=y(this.value)">
-rep Cheater!!
+rep very good, fun to play with
+rep my friend +rep
good
</textarea>
<div></div>

Mathematica, 47 Byte (ISO 8859-1-Codierung)

(±c_:=StringCount["
"<>#,c];±"
+rep"-±"
-rep")&

Reine Funktion, die eine durch Zeilenumbrüche getrennte Zeichenfolge als Eingabe verwendet und eine Ganzzahl zurückgibt. Beachten Sie, dass die drei Zeilenumbrüche im Code von Anführungszeichen flankiert werden und daher jeweils "\n"einer Zeichenfolge entsprechen (dies ist jedoch ein Byte kürzer als "\n"). StringCountmacht das schwere Heben; Wir fügen manuell eine neue Zeile am Anfang der Zeichenfolge hinzu, damit die erste Zeile bei Bedarf übereinstimmt. ±ist eine unäre Hilfsfunktion, um Wiederholungen zu vermeiden StringCount.

Die alternative Lösung

(±c_:=StringCount["
"<>#,"
"<>c<>"rep"];±"+"-±"-")&

ist 4 bytes länger, aber ich mag die folge ±"+"-±"-"....

Retina , 59 53 52 50 Bytes

ms`(?!^[+-]rep ).

+`\+-|-\+

-+
-$.&
\++
$.&
^$
0

Probieren Sie es online!

Sehen Sie sich die kürzere Antwort von Basic Sunset in derselben Sprache an!

Erläuterung

ms`(?!^[+-]rep ).

Entfernt alles außer [+-]reps.

+`\+-|-\+

Entfernt wiederholt 1 -für alle +und umgekehrt.

-+
-$.&

Stellen Sie a -(da die Zahl negativ ist) vor -s und ersetzen Sie das -s durch die Zahl von -s.

\+
$.&

Machen Sie dasselbe für +s, aber stellen Sie a nicht voran -.

^$
0

Schließlich, wenn es nichts gibt, ersetzen Sie es mit einem 0.

PHP, 118 Bytes

function s($a,$c=0){foreach(explode("
",$a)as$b){$b=substr($b,0,1).'1';if(is_numeric($b){$c+=$b});}return$c-($a=="");}

Probieren Sie es online!

So verwendet:

echo s("-rep bad
+rep good
+rep very good
+rep exceeds expectation");

Röda , 53 Bytes

{{|l|[1]if[l=~`\+rep .*`];[-1]if[l=~`-rep .*`]}_|sum}

Probieren Sie es online!

Java, 109 Bytes

l->{int i=0;for(String s:l.split("\n")){if(s.startsWith("+rep "))i++;if(s.startsWith("-rep "))i--;}return i;}

Versuchen, dies mit Stream's zu verkürzen

Gestapelt , 45 Bytes

'^([+-])rep |.'{.a:''['#'a+]a if}mrepl'0'\+#~

Probieren Sie es online!

Alternativ (49 Bytes):

lines'^[-+]rep 'match$#'YES[0#0# '#'\+]"!''#`0\#~

Erläuterung

'^([+-])rep |.'{.a:''['#'a+]a if}mrepl'0'\+#~

Dies extrahiert im Grunde alle +oder -an den Anfang der Zeile angehängten und rep. Dann stellt es jedem a voran #. Dann 0wird dem Ganzen ein vorangestellt. #~wertet den String aus, der jetzt ungefähr so ​​aussieht:

0#+#+#-

#+ist Inkrement und #-ist Dekrement. So erhalten wir unser gewünschtes Ergebnis.

Retina , 38 Bytes

M!m`^[+-]rep 
Os`.
+`\+-

*\M1!`-
[+-]

Probieren Sie es online!

Eine andere (und kürzere) Lösung als die bereits in Retina veröffentlichten.

Erläuterung

M!m`^[+-]rep 

(Diese Zeile hat ein Leerzeichen am Ende). Behalten Sie nur die relevanten Teile der Eingabe bei, dh das +repoder -repam Anfang einer Zeile.

Os`.

Sortieren Sie alle Zeichen (einschließlich Zeilenumbrüche). Dadurch werden + s und -s nebeneinander gesetzt.

+`\+-

Entfernen Sie wiederholt +-Paare, bis höchstens eines der beiden Zeichen übrig bleibt.

*\M1!`-

Passen Sie die erste an -(falls vorhanden) und drucken Sie sie aus, ohne die Zeichenfolge zu ändern.

[+-]

Zählen Sie die Anzahl der verbleibenden Zeichen und drucken Sie sie aus, da dies die letzte Phase des Programms ist.

C # 87 Bytes

s=>{int n=0;foreach(var t in s.Split('\n'))n+=t.IndexOf("rep ")==1?44-t[0]:0;return n;}

Anonyme Funktion, die die Eingabezeichenfolge mithilfe des Zeilenumbruchs aufteilt, nach der Zeichenfolge "rep" sucht, der ein Zeichen vorangestellt ist, und die Reputation erhöht, wenn sie gefunden wird (das n Variable) um 1 oder -1 .

Volles Programm mit ungolfed Methode und Testfällen:

using System;

class P
{
    static void Main()
    {
        Func<string, int> f =
        s=>
        {
            int n = 0;
            foreach (var t in s.Split('\n'))
                n += t.IndexOf("rep ") == 1 ?
                    44 - t[0]
                    :
                    0;

            return n;
        };

        // test cases:
        Console.WriteLine(f(@"+rep fast trade
+rep nice person
-rep too good"));       // 1

        Console.WriteLine(f(@"-rep hacker
-rep scammer
-rep was mean"));       // -3

        Console.WriteLine(f(@"first
i don't like him
+rep good at cs go"));  // 1

        Console.WriteLine(f(@"+rep +rep
hi +rep
-rep"));            // 1

        Console.WriteLine(f(@"+ rep"));     // 0

        Console.WriteLine(f(@"+rep like
-thing"));          // 1
    }
}

Beachten Sie, dass der ASCII-Code für +43 und für ist- 45 ist. Diese Methode übergibt alle Testfälle vom OP. Wenn das erste Zeichen jedoch etwas anderes ist, führt dies zu falschen Antworten!

Dies kann auf Kosten von 17 Byte behoben werden:

C # fest, 104 Bytes

s=>{int n=0;foreach(var t in s.Split('\n'))n+=t.IndexOf("rep ")==1?t[0]==43?1:t[0]==45?-1:0:0;return n;}

Die geänderte anonyme Funktion sucht in jeder Zeile nach einem +oder --Zeichen als erstem Zeichen.

Japt , 14 Bytes

r`œp`1 f".%d 

Probieren Sie es online!

+1 Byte für -xFlag

C ++, 144 Bytes

#import<iostream>
int f(){int r=0;for(std::string s;std::getline(std::cin,s);)if((s[0]==43|s[0]==45)&s.substr(1,4)=="rep ")r-=s[0]-44;return r;}

Probieren Sie es online!

C # , 104 Bytes

Obwohl es bereits eine Lösung gibt - und meine länger ist - denke ich immer noch, dass ich sie posten sollte, da die hier bereits vorhandene möglicherweise fehlschlägt, wenn etwas '=rep 'in die Quere kommt.

Golf gespielt

i=>{var c=0;foreach(var o in i.Split('\n'))c+=o.IndexOf("rep ")!=1?0:o[0]==43?1:o[0]==45?-1:0;return c;}

Ungolfed

i => {
   var c = 0;

   foreach( var o in i.Split( '\n' ) )
      c += o.IndexOf( "rep " ) != 1
         ? 0
         : o[ 0 ] == 43
            ? 1
            : o[ 0 ] == 45
               ? -1
               : 0;

   return c;
}

Ungolfed lesbar

i => {
   // Counter for the 'reputation'
   var c = 0;

   // Cycle through every line
   foreach( var o in i.Split( '\n' ) )
      // Check if the "rep " string has index 1
      //   ( Index 0 should be the sign )
      c += o.IndexOf( "rep " ) != 1
         // Add 0 if the rep isn't on the right position
         ? 0
         // Check for the '+' sign
         : o[ 0 ] == 43
            // Add 1 if the sign is found
            ? 1
            // Check for the '-' sign
            : o[ 0 ] == 45
               // Add -1 if the sign is found
               ? -1
               // Add 0 if another char is found
               : 0;

   // Return the 'reputation'
   return c;
}

Vollständiger Code

using System;
using System.Collections.Generic;

namespace Namespace {
   class Program {
      static void Main( String[] args ) {
         Func<String, Int32> f = i => {
            var c = 0;

            foreach( var o in i.Split( '\n' ) )
               c += o.IndexOf( "rep " ) != 1
               ? 0
                  : o[ 0 ] == 43
                  ? 1
                  : o[ 0 ] == 45
                     ? -1
                     : 0;

            return c;
         };

         List<String>
            testCases = new List<String>() {
               @"+rep fast trade
+rep nice person
-rep too good",
               @"-rep hacker
-rep scammer
-rep was mean",
               @"first
i don't like him
+rep good at cs go",
               @"+rep +rep
hi +rep
-rep",
               @"+ rep",
               @"+rep like
-thing",
         };

         foreach( String testCase in testCases ) {
            Console.WriteLine( $"{testCase}\n{f( testCase )}\n" );
         }

         Console.ReadLine();
      }
   }
}

Releases

• v1.0 - 104 bytes- Anfangslösung.

Anmerkungen

Nichts hinzuzufügen

Ruby, 46 Bytes

->x{rep=1;eval ?0+x.map{|a|a[/^[+-]rep /]}*''}

Holen Sie sich alle +/- Wiederholungen von der Eingabe und fügen Sie sie in einer einzigen Zeichenfolge zusammen. Werten Sie das dann für rep = 1 aus.

JavaScript ES6, 85 79 Bytes

l=>eval(l.split`
`.map(i=>(r=i.slice(0,5))==`+rep `?1:r==`-rep `?-1:0).join`+`)

Versuch es

f=l=>eval(l.split`
`.map(i=>(r=i.slice(0,5))==`+rep `?1:r==`-rep `?-1:0).join`+`);

console.log(f(`+rep fast trade
+rep nice person
-rep too good`));

console.log(f(`-rep hacker
-rep scammer
-rep was mean`));

console.log(f(`first
i don't like him
+rep good at cs go`));

console.log(f(`+rep +rep
hi +rep
-rep`));

console.log(f(`+ rep`));

console.log(f(`+rep like
-thing`));

Ungolfed

const repcount=list=>{
    let array=list.split("\n");
    let values=array.map(item=>{
        let rep=item.slice(0,5);
        return rep==="+rep "?1:rep==="-rep "?-1:0;
    });
    let result=values.reduce((a,b)=>a+b);
    return result;
};

Geschichte

85 Bytes

l=>l.split`\n`.map(i=>(r=i.slice(0,5))=="+rep "?1:r=="-rep "?-1:0).reduce((a,b)=>a+b)