Introducción

Para aquellos que no están familiarizados con el vapor, o al menos con este aspecto en particular:

A menudo en los perfiles de las personas, las personas dejan comentarios diciendo "+ rep _____" o "-rep _____". Estos son un medio no oficial de mostrar si cree que alguien en la comunidad tiene una buena o mala reputación, por varias razones. Tales comentarios se parecen a:

+ representante de un buen jugador

+ representante útil

pirata informático

estafador

Tarea

El programa debe recibir información a través de cualquier forma consensuada. La entrada consiste en una cadena con nuevas líneas opcionales ( \n). Al comienzo de cada línea, '+rep 'o '-rep 'podría estar presente. El resto de la línea se puede descartar. Si la línea no comienza con '+rep 'o '-rep '(tenga en cuenta el espacio final), la línea debe ignorarse.

El programa debe mantener un puntaje de reputación total. Comenzando en 0, este puntaje debe incrementarse en cada línea que comience '+rep 'y disminuirse en cada línea que comience con '-rep '.

Este resultado se debe generar de cualquier forma acordada.

Casos de prueba

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

Prima

Ni siquiera sé si es posible, pero puntos de bonificación si de alguna manera puedes obtener estos comentarios de Steam.

05AB1E , 18 16 17 bytes

Ahorró 2 bytes gracias a Okx
+1 byte debido a un cambio en la especificación donde el representante ahora debe ir seguido de un espacio.

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

Pruébalo en línea!

Explicación

|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

Estoy seguro de que esta respuesta es basura y será superada pronto, pero aún no hay otras respuestas de Python

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

Usar así:

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

Obteniendo vapor

Aquí hay un código de muestra que obtiene los primeros 100 comentarios del perfil de KennyS y calcula su 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 + -pbandera.

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

Pruébalo en línea!

/^\+rep /regresa 1si la línea comienza con +rep; /^-rep /regresa 1si la línea comienza con -rep(por lo que solo uno de ellos será uno como máximo). Usamos $\para almacenar el resultado, ya que se imprime implícitamente al final (gracias a -pflag y aquellos que no coinciden }{).

Python 2 , 54 bytes

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

Pruébalo en línea! Toma una cadena multilínea como entrada.

Cuenta las apariencias '+rep 'y '-rep 'solo al comienzo de las líneas buscando la cadena que sigue a un símbolo de nueva línea. Para capturar la primera línea, se antepone una nueva línea a la entrada.

Retina , 63 51 50 49 bytes

No cumplí con la especificación, así que solucioné algunos problemas, pero también jugué mucho (tomando prestada la primera línea de la solución de Kritixi Lithos).

Salvó otro byte gracias a Kritixi Lithos.

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

+`\+-|-\+

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

Pruébalo en línea!

Explicación

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

Primero, se elimina todo de la entrada, excepto el +y -de cualquiera +repo -repal comienzo de una línea.

+`\+-|-\+

Luego, los pares adyacentes de +y -se eliminan hasta que no se puedan eliminar más. Después de esto, lo que queda es una serie de +s, una serie de -s, o nada.

(.)+
$1$.&

Luego, una serie de uno o más caracteres (uno +o más -) se reemplaza con el personaje que forma la serie seguido de la longitud de la serie. De esta manera, +se conserva al principio para obtener resultados positivos y -negativos.

T`+

Luego +se eliminan todos los s, en el caso de que el representante sea positivo.

$^
0

Finalmente, si la cadena está vacía en este punto, el representante es 0, entonces escribimos 0.

JavaScript, 55 bytes

Gracias @Neil por jugar golf con 12 bytes Gracias @Arnauld por jugar golf con 2 bytes

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

Pruébalo en línea!

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 (codificación ISO 8859-1)

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

Función pura que toma una cadena separada por una nueva línea como entrada y devuelve un entero. Tenga en cuenta que las tres nuevas líneas en el código están flanqueadas por comillas y, por lo tanto, cada una es equivalente a "\n"una cadena (pero de esta manera es un byte más corto que "\n"). StringCounthace el trabajo pesado; agregamos manualmente una nueva línea al comienzo de la cadena para que la primera línea coincida cuando sea apropiado. ±es una función de ayuda unaria para evitar la repetición de StringCount.

La solución alternativa

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

es 4 bytes más largo, pero me gusta la secuencia ±"+"-±"-"...

Retina , 59 53 52 50 bytes

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

+`\+-|-\+

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

Pruébalo en línea!

¡Mira la respuesta más corta de Basic Sunset en el mismo idioma!

Explicación

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

Elimina todo excepto el [+-]reps.

+`\+-|-\+

Repetidamente elimina 1 -por cada +y viceversa.

-+
-$.&

Anteponga a -(porque el número es negativo) a -s y reemplace -s por el número de -s.

\+
$.&

Haga lo mismo para +s, pero no anteponga a -.

^$
0

Finalmente, si no hay nada, reemplácelo con 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=="");}

Pruébalo en línea!

Usado así:

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}

Pruébalo en línea!

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

Tratando de hacer esto más corto usando Stream's

Apilado , 45 bytes

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

Pruébalo en línea!

Alternativamente (49 bytes):

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

Explicación

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

Básicamente, esto extrae todo +o se -adjunta al comienzo de la línea y rep. Luego, a cada uno, antepone a #. Entonces, a todo, 0se antepone a. #~evalúa la cadena, que ahora se parece a:

0#+#+#-

#+es incremento y #-es decremento. Por lo tanto, obtenemos nuestro resultado deseado.

Retina , 38 bytes

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

*\M1!`-
[+-]

Pruébalo en línea!

Una solución diferente (y más corta) que las ya publicadas en Retina.

Explicación

M!m`^[+-]rep 

(Esta línea tiene un espacio final). Mantenga solo las partes relevantes de la entrada, es decir, +repo -repal comienzo de una línea.

Os`.

Ordenar todos los caracteres (incluidas las nuevas líneas). esto pondrá + sy -s uno al lado del otro.

+`\+-

Retirar repetidamente las +-parejas hasta que como máximo quede uno de los dos signos.

*\M1!`-

Haga coincidir el primero -(si está presente) e imprímalo sin modificar la cadena.

[+-]

Cuente el número de signos restantes e imprímalo ya que esta es la etapa final del 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;}

Función anónima que divide la cadena de entrada utilizando el carácter de nueva línea, busca la cadena "rep" con el prefijo de un carácter y, si la encuentra, incrementa la reputación (la nvariable) en 1 o -1.

Programa completo con método no protegido y casos de prueba:

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

Tenga en cuenta que el código ASCII para +es 43 y para -es 45. Este método pasa todos los casos de prueba del OP. Sin embargo, si el primer personaje es otra cosa, ¡esto dará lugar a respuestas incorrectas!

Esto se puede arreglar a un costo de 17 bytes:

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

La función anónima modificada verificará si hay un signo +o -como el primer carácter en cada línea.

Japt , 14 bytes

r`œp`1 f".%d 

Pruébalo en línea!

+1 byte para -xbandera

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

Pruébalo en línea!

C # , 104 bytes

A pesar de que ya existe una solución, y la mía es más larga, sigo pensando que debería publicarla, ya que el encendido aquí podría fallar si algo así se '=rep 'interpone en su camino.

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

Sin golf

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

Legible sin golf

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

Lanzamientos

• v1.0 - 104 bytes- Solución inicial.

Notas

Nada que añadir

Ruby, 46 bytes

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

Obtenga todo el +/- rep de entrada, y junte en una sola cadena. Luego evalúe eso 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`+`)

Intentalo

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

Sin golf

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

Historia

85 bytes

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