Introdução

Para quem não conhece o vapor - ou pelo menos esse aspecto em particular:

Frequentemente, nos perfis das pessoas, as pessoas deixam comentários dizendo "+ rep _____" ou "-rep _____". Esse é um meio não oficial de mostrar se você acha que alguém da comunidade tem uma reputação boa ou má, por várias razões. Esses comentários são parecidos com:

+ rep um bom jogador

+ rep útil

-rep hacker

-rep scammer

Tarefa

O programa deve receber informações de qualquer maneira consensual. A entrada consiste em uma sequência com novas linhas opcionais ( \n). No início de cada linha, '+rep 'ou '-rep 'pode estar presente. O restante da linha pode ser descartado. Se a linha não começar com '+rep 'ou'-rep ' (observe o espaço à direita), a linha deve ser ignorada.

O programa deve manter uma pontuação total de reputação. Começando em 0, essa pontuação deve ser incrementada em todas as linhas que começam com '+rep 'e diminuída em todas as linhas que começam com '-rep '.

Esse resultado deve ser produzido de qualquer maneira acordada.

Casos de teste

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

Bônus

Eu nem sei se é possível, mas pontos de bônus, se você puder obter esses comentários do Steam.

05AB1E , 18 16 17 bytes

Economizou 2 bytes graças ao Okx
+1 byte devido a alterações nas especificações, onde agora o representante precisa ser seguido por um espaço.

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

Experimente online!

Explicação

|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

Tenho certeza de que essa resposta é lixo e será vencida em breve, mas ainda não há outras respostas em python

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

Use assim:

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

Buscando do vapor

Aqui está um exemplo de código que busca os 100 primeiros comentários do perfil de KennyS e calcula seu representante.

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 bytes de código + -psinalizador.

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

Experimente online!

/^\+rep /retorna 1se a linha começa com +rep; /^-rep /retorna 1se a linha começa com -rep(portanto, apenas um deles será um no máximo). Usamos $\para armazenar o resultado, pois ele é impresso implicitamente no final (graças ao -psinalizador e aos inigualáveis }{).

Python 2 , 54 bytes

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

Experimente online! Pega uma sequência multilinha como entrada.

Conta as aparências '+rep 'e '-rep 'somente no início das linhas, procurando a sequência seguindo um símbolo de nova linha. Para capturar a primeira linha, uma nova linha é anexada à entrada.

Retina , 63 51 50 49 bytes

Como não cumpri bem as especificações, resolvi alguns problemas, mas também joguei bastante (emprestando a primeira linha da solução da Kritixi Lithos).

Guardou outro byte graças a Kritixi Lithos.

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

+`\+-|-\+

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

Experimente online!

Explicação

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

Primeiro, tudo da entrada é excluído, exceto o +e -de qualquer um +repou -repno início de uma linha.

+`\+-|-\+

Em seguida, pares adjacentes de +e -são removidos até que não mais possam ser removidos. Depois disso, o que resta é uma sequência de +s, uma sequência de -s ou nada.

(.)+
$1$.&

Em seguida, uma corrida de um ou mais caracteres ( +ou -) é substituída pelo caractere que compõe a corrida seguido pelo comprimento da corrida. Dessa forma, +é preservada no início para resultados positivos e -negativos.

T`+

Todos os +s são removidos, caso o representante seja positivo.

$^
0

Finalmente, se a string estiver vazia neste momento, o representante será 0, então escrevemos 0.

JavaScript, 55 bytes

Obrigado @ Neil por jogar fora 12 bytes Obrigado @Arnauld por jogar fora 2 bytes

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

Experimente 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 bytes (codificação ISO 8859-1)

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

Função pura, tendo como entrada uma string separada por nova linha e retornando um número inteiro. Observe que as três novas linhas no código são flanqueadas por aspas e, portanto, são equivalentes a "\n"uma sequência de caracteres (mas dessa maneira é um byte menor que "\n"). StringCountfaz o trabalho pesado; adicionamos manualmente uma nova linha ao início da string para que a primeira linha corresponda quando apropriado. ±é uma função de ajuda unária para evitar a repetição de StringCount.

A solução alternativa

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

é 4 bytes mais, mas eu gosto da sequência ±"+"-±"-"....

Retina , 59 53 52 50 bytes

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

+`\+-|-\+

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

Experimente online!

Confira a resposta mais curta do Basic Sunset no mesmo idioma!

Explicação

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

Remove tudo, exceto [+-]reps.

+`\+-|-\+

Remove repetidamente 1 -para cada +e vice-versa.

-+
-$.&

Anexe um a -(porque o número é negativo) a -s e substitua os -s pelo número de -s.

\+
$.&

Faça o mesmo para +s, mas não inclua a -.

^$
0

Finalmente, se não houver nada, substitua-o por a 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=="");}

Experimente online!

Usado assim:

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}

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

Tentando diminuir isso usando Stream's

Empilhados , 45 bytes

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

Experimente online!

Como alternativa (49 bytes):

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

Explicação

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

Basicamente, isso extrai tudo +ou é -anexado ao início da linha e rep. Então, para cada um, ele precede a #. Então, para a coisa toda, a 0é anexado. #~avalia a string, que agora se parece com:

0#+#+#-

#+é incremento e #-é decremento. Assim, obtemos o resultado desejado.

Retina , 38 bytes

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

*\M1!`-
[+-]

Experimente online!

Uma solução diferente (e mais curta) do que as que já foram publicadas na Retina.

Explicação

M!m`^[+-]rep 

(Esta linha tem um espaço à direita). Mantenha apenas as partes relevantes da entrada, ou seja, o +repou -repno início de uma linha.

Os`.

Classifique todos os caracteres (incluindo novas linhas). isso colocará + se -s próximos um do outro.

+`\+-

Remova os +-casais repetidamente até que no máximo um dos dois sinais permaneça.

*\M1!`-

Combine o primeiro -(se houver) e imprima-o sem modificar a sequência.

[+-]

Conte o número de placas restantes e imprima-o, pois esta é a etapa final do programa.

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

A função anônima que divide a string de entrada usando o caractere de nova linha, procura a string "rep" prefixada por um caractere e, se a encontrar, aumenta a reputação (a propriedade n variável) em 1 ou -1.

Programa completo com método não destruído e casos de teste:

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

Observe que o código ASCII para +é 43 e para- é 45. Esse método passa todos os casos de teste do OP. No entanto, se o primeiro caractere for outra coisa, isso levará a respostas erradas!

Isso pode ser corrigido ao custo de 17 bytes:

C # fixo, 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;}

A função anônima modificada procurará um sinal +ou -como o primeiro caractere em cada linha.

Japt , 14 bytes

r`œp`1 f".%d 

Experimente online!

+1 byte para -xsinalizador

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

Experimente online!

C # , 104 bytes

Apesar de já existir uma solução - e a minha ser mais longa - ainda acho que devo publicá-la, pois o que já está aqui pode falhar se algo assim '=rep 'atrapalhar.

Golfe

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 legible

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

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

Lançamentos

• v1.0 - 104 bytes- Solução inicial.

Notas

Nada para adicionar

Ruby, 46 bytes

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

Obtenha todo o representante +/- da entrada e monte em uma única sequência. Em seguida, avalie isso para rep = 1.

JavaScript ES6, 85 79 bytes

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

Tente

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

História

85 bytes

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