introduzione

Per coloro che non hanno familiarità con il vapore - o almeno questo aspetto particolare:

Spesso sui profili delle persone, le persone lasciano commenti dicendo "+ rep _____" o "-rep _____". Questi sono mezzi non ufficiali per dimostrare se pensi che qualcuno nella comunità abbia una buona o una cattiva reputazione, per una serie di ragioni. Tali commenti sembrano:

+ rep un buon giocatore

+ rep utile

-rep hacker

-rep scammer

Compito

Il programma deve accettare input in qualsiasi modo consensuale. L'input è costituito da una stringa con newline opzionali ( \n). All'inizio di ogni riga '+rep 'o '-rep 'potrebbe essere presente. Il resto della linea può essere scartato. Se la linea non inizia con '+rep 'o '-rep '(notare lo spazio finale), la linea deve essere ignorata.

Il programma deve quindi mantenere un punteggio di reputazione totale. A partire da 0, questo punteggio deve essere incrementato su ogni riga che inizia con '+rep 'e diminuito su ogni riga che inizia con '-rep '.

Questo risultato dovrebbe essere prodotto in qualsiasi modo concordato.

Casi test

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

indennità

Non so nemmeno se sia possibile, ma punti bonus se in qualche modo puoi ottenere questi commenti da Steam.

05AB1E , 18 16 17 byte

Salvato 2 byte grazie a Okx
+1 byte a causa della modifica delle specifiche in cui ora è necessario seguire uno spazio per il rappresentante.

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

Provalo online!

Spiegazione

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

Sono sicuro che questa risposta è spazzatura e sarà presto battuta, ma non ci sono ancora altre risposte in pitone

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

Usa così:

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

Recupero dal vapore

Ecco un codice di esempio che recupera i primi 100 commenti dal profilo di KennyS e calcola il suo rappresentante.

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 byte

24 byte di codice + -pflag.

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

Provalo online!

/^\+rep /ritorna 1se la linea inizia con +rep; /^-rep /ritorna 1se la linea inizia con -rep(quindi solo uno di essi sarà uno al massimo). Usiamo $\per archiviare il risultato, poiché è implicitamente stampato alla fine (grazie a -pflag e quelli senza eguali }{).

Python 2 , 54 byte

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

Provalo online!Accetta una stringa su più righe come input.

Conta le apparenze di '+rep 'e '-rep 'solo all'inizio delle righe cercando la stringa che segue un simbolo di nuova riga. Per catturare la prima riga, una nuova riga viene anteposta all'input.

Retina , 63 51 50 49 byte

Non ho rispettato le specifiche, quindi ho risolto alcuni problemi, ma ho anche risolto molto il problema (prendendo in prestito la prima riga dalla soluzione di Kritixi Lithos).

Ho salvato un altro byte grazie a Kritixi Lithos.

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

+`\+-|-\+

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

Provalo online!

Spiegazione

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

Innanzitutto, viene eliminato tutto dall'input, ad eccezione di +e -da qualsiasi +repo -repall'inizio di una riga.

+`\+-|-\+

Quindi le coppie adiacenti di +e -vengono rimosse fino a quando non è più possibile rimuoverle. Dopo ciò, ciò che resta è una serie di +s, una serie di -s o niente.

(.)+
$1$.&

Quindi una sequenza di uno o più caratteri (uno +o più -) viene sostituita con il personaggio che costituisce la sequenza seguito dalla lunghezza della sequenza. In questo modo, +viene preservato all'inizio per risultati positivi e -negativi.

T`+

Quindi +vengono rimossi tutti gli s, nel caso in cui il rappresentante sia positivo.

$^
0

Infine, se la stringa è vuota a questo punto, il rappresentante è 0, quindi scriviamo 0.

JavaScript, 55 byte

Grazie @Neil per giocare a golf da 12 byte Grazie @Arnauld per giocare a golf da 2 byte

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

Provalo 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 (codifica ISO 8859-1)

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

Funzione pura che accetta come input una stringa separata da una nuova riga e restituisce un numero intero. Si noti che le tre nuove righe nel codice sono affiancate da virgolette e sono quindi ognuna equivalente a "\n"una stringa (ma in questo modo è più corta di un byte di "\n"). StringCountfa il sollevamento pesante; aggiungiamo manualmente una nuova riga all'inizio della stringa in modo che la prima riga corrisponda quando appropriato. ±è una funzione di aiuto unaria per evitare la ripetizione di StringCount.

La soluzione alternativa

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

è più lungo di 4 byte, ma mi piace la sequenza ±"+"-±"-"....

Retina , 59 53 52 50 byte

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

+`\+-|-\+

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

Provalo online!

Scopri la risposta più breve di Basic Sunset nella stessa lingua!

Spiegazione

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

Rimuove tutto tranne che per [+-]reps.

+`\+-|-\+

Rimuove ripetutamente 1 -per ogni +e viceversa.

-+
-$.&

Prepara a -(perché il numero è negativo) a -s e sostituisce -s con il numero di -s.

\+
$.&

Fai lo stesso per +s, ma non anteporre a -.

^$
0

Infine, se non c'è nulla, sostituirlo con a 0.

PHP, 118 byte

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=="");}

Provalo online!

Usato così:

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

Röda , 53 byte

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

Provalo online!

Java, 109 byte

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

Cercando di fare questa breve utilizzando Streams'

Impilato , 45 byte

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

Provalo online!

In alternativa (49 byte):

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

Spiegazione

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

Questo in sostanza estrae tutto +o -allegato all'inizio della riga e rep. Quindi, a ciascuno, antepone a #. Quindi, per tutto, 0viene anteposto un. #~valuta la stringa, che ora assomiglia a:

0#+#+#-

#+è incremento ed #-è decremento. Pertanto, otteniamo il risultato desiderato.

Retina , 38 byte

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

*\M1!`-
[+-]

Provalo online!

Una soluzione diversa (e più breve) rispetto a quelle già pubblicate in Retina.

Spiegazione

M!m`^[+-]rep 

(Questa riga ha uno spazio finale). Mantenere solo le parti pertinenti dell'ingresso, cioè la +repo -repall'inizio di una riga.

Os`.

Ordina tutti i caratteri (comprese le nuove righe). questo metterà + se e -s uno accanto all'altro.

+`\+-

Rimuovere ripetutamente le +-coppie fino a quando rimane al massimo uno dei due segni.

*\M1!`-

Abbina il primo -(se presente) e stampalo senza modificare la stringa.

[+-]

Contare il numero di segni rimanenti e stamparlo poiché questa è la fase finale del programma.

C #, 87 byte

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

Funzione anonima che divide la stringa di input usando il carattere di nuova riga, cerca la stringa "rep" preceduta da un carattere e, se lo trova, incrementa la reputazione (la nvariabile) di 1 o -1.

Programma completo con metodo non golfizzato e casi di test:

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

Si noti che il codice ASCII per +è 43 e per -è 45. Questo metodo passa tutti i casi di test dall'OP. Tuttavia, se il primo personaggio è qualcos'altro, questo porterà a risposte sbagliate!

Questo può essere risolto al costo di 17 byte:

C # fisso, 104 byte

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

La funzione anonima modificata verificherà la presenza di un segno +o -come primo carattere in ogni riga.

Japt , 14 byte

r`œp`1 f".%d 

Provalo online!

+1 byte per -xflag

C ++, 144 byte

#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;}

Provalo online!

C # , 104 byte

Nonostante esista già una soluzione - e la mia sia più lunga - penso ancora che dovrei pubblicarla, dal momento che l'attivazione già qui potrebbe non riuscire se qualcosa di simile si '=rep 'mette in mezzo.

golfed

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

Leggibile non golfato

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

Codice completo

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();
      }
   }
}

Uscite

• v1.0 - 104 bytes- Soluzione iniziale.

Appunti

Niente da aggiungere

Rubino, 46 ​​byte

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

Ottieni tutto il +/- rep dall'input e riuniscili in un'unica stringa. Quindi valutare quello per rep = 1.

JavaScript ES6, 85 79 byte

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

Provalo

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

Storia

85 byte

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