introduction

Pour ceux qui ne connaissent pas la vapeur - ou du moins cet aspect particulier:

Souvent sur les profils des gens, les gens laissent des commentaires disant "+ rep _____" ou "-rep _____". Ce sont des moyens officieux de montrer si vous pensez que quelqu'un dans la communauté a une bonne ou une mauvaise réputation, pour plusieurs raisons. De tels commentaires ressemblent à:

+ rep un bon joueur

+ représentant utile

-rep pirate

-rep arnaqueur

Tâche

Le programme doit recevoir des informations par tout moyen consensuel. L'entrée se compose d'une chaîne avec des retours à la ligne facultatifs ( \n). Au tout début de chaque ligne, '+rep 'ou '-rep 'peut être présent. Le reste de la ligne peut être jeté. Si la ligne ne commence pas par '+rep 'ou '-rep '(notez l'espace de fin), la ligne doit être ignorée.

Le programme doit alors conserver un score de réputation total. À partir de 0, ce score doit être incrémenté sur chaque ligne commençant par '+rep 'et décrémenté sur chaque ligne commençant par '-rep '.

Ce résultat doit être produit de la manière convenue.

Cas de 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

Prime

Je ne sais même pas si c'est possible, mais des points bonus si vous pouvez en quelque sorte obtenir ces commentaires de Steam.

05AB1E , 18 16 17 octets

Enregistrement de 2 octets grâce à Okx
+1 octet en raison d'un changement de spécification où le représentant doit maintenant être suivi d'un espace.

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

Essayez-le en ligne!

Explication

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

Je suis sûr que cette réponse est une ordure et sera bientôt battue, mais il n'y a pas encore d'autres réponses en python

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

Utilisez comme ceci:

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

Récupérer de la vapeur

Voici un exemple de code qui récupère les 100 premiers commentaires du profil de KennyS et calcule son représentant.

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 octets

24 octets de code + -pindicateur.

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

Essayez-le en ligne!

/^\+rep /renvoie 1si la ligne commence par +rep; /^-rep /renvoie 1si la ligne commence par -rep(donc un seul d'entre eux le sera au maximum). Nous utilisons $\pour stocker le résultat, car il est implicitement imprimé à la fin (grâce au -pdrapeau et à ceux inégalés }{).

Python 2 , 54 octets

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

Essayez-le en ligne! Prend une chaîne multiligne en entrée.

Compte les apparences de '+rep 'et '-rep 'uniquement au début des lignes en recherchant la chaîne suivant un symbole de nouvelle ligne. Pour attraper la première ligne, une nouvelle ligne est ajoutée à l'entrée.

Rétine , 63 51 50 49 octets

Je ne me suis pas tout à fait conformé à la spécification, j'ai donc résolu certains problèmes, mais je l'ai également beaucoup joué (en empruntant la première ligne à la solution de Kritixi Lithos).

Un autre octet enregistré grâce à Kritixi Lithos.

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

+`\+-|-\+

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

Essayez-le en ligne!

Explication

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

Tout d'abord, tout de l'entrée est supprimé, à l'exception de +et -de tout +repou -repau début d'une ligne.

+`\+-|-\+

Ensuite, les paires adjacentes de +et -sont supprimées jusqu'à ce que plus rien ne puisse être supprimé. Après cela, ce qui reste est soit une série de +s, une série de -s, ou rien.

(.)+
$1$.&

Ensuite, une séquence d'un ou plusieurs caractères (soit +ou -) est remplacée par le caractère constituant la séquence suivi de la durée de la séquence. De cette façon, +est conservé au départ pour des résultats positifs et -pour des négatifs.

T`+

Ensuite, tous les +s sont supprimés, dans le cas où le représentant est positif.

$^
0

Enfin, si la chaîne est vide à ce stade, la répétition est 0, nous écrivons donc 0.

JavaScript, 55 octets

Merci @Neil d'avoir joué au golf 12 octets Merci @Arnauld d'avoir joué au golf 2 octets

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

Essayez-le en ligne!

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 octets (codage ISO 8859-1)

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

Fonction pure prenant une chaîne séparée par des sauts de ligne en entrée et retournant un entier. Notez que les trois sauts de ligne dans le code sont flanqués de guillemets et sont donc chacun équivalent à "\n"une chaîne (mais de cette façon est un octet plus court que "\n"). StringCountfait le gros du travail; nous ajoutons manuellement une nouvelle ligne au début de la chaîne afin que la première ligne corresponde le cas échéant. ±est une fonction d'aide unaire pour éviter la répétition de StringCount.

La solution alternative

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

est de 4 octets de plus, mais j'aime la séquence ±"+"-±"-"....

Rétine , 59 53 52 50 octets

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

+`\+-|-\+

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

Essayez-le en ligne!

Découvrez la réponse courte de Basic Sunset dans la même langue!

Explication

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

Supprime tout sauf l' [+-]repart.

+`\+-|-\+

Supprime à plusieurs reprises 1 -pour chaque +et vice versa.

-+
-$.&

Ajoutez a -(car le nombre est négatif) à -s et remplacez le -s par le nombre de -s.

\+
$.&

Faites de même pour +s, mais ne ajoutez pas a -.

^$
0

Enfin, s'il n'y a rien, remplacez-le par un 0.

PHP, 118 octets

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

Essayez-le en ligne!

Utilisé comme ceci:

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

Röda , 53 octets

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

Essayez-le en ligne!

Java, 109 octets

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

Essayer de faire ce court en utilisant Stream« s

Empilé , 45 octets

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

Essayez-le en ligne!

Alternativement (49 octets):

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

Explication

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

Cela extrait essentiellement tout +ou -attaché au début de la ligne et rep. Ensuite, à chacun, il ajoute un #. Ensuite, pour le tout, un 0est ajouté. #~évalue la chaîne, qui ressemble maintenant à quelque chose comme:

0#+#+#-

#+est incrément et #-décrément. Ainsi, nous obtenons notre résultat souhaité.

Rétine , 38 octets

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

*\M1!`-
[+-]

Essayez-le en ligne!

Une solution différente (et plus courte) que celles déjà publiées dans Retina.

Explication

M!m`^[+-]rep 

(Cette ligne a un espace de fin). Ne conservez que les parties pertinentes de l'entrée, c'est-à-dire le +repou -repau début d'une ligne.

Os`.

Triez tous les caractères (y compris les sauts de ligne). cela mettra + s et -s côte à côte.

+`\+-

Retirez les +-couples à plusieurs reprises jusqu'à ce qu'il ne reste plus qu'un des deux signes.

*\M1!`-

Faites correspondre le premier -(le cas échéant) et imprimez-le sans modifier la chaîne.

[+-]

Comptez le nombre de panneaux restants et imprimez-le car il s'agit de la dernière étape du programme.

C #, 87 octets

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

Fonction anonyme qui fractionne la chaîne d'entrée en utilisant le caractère de nouvelle ligne, recherche la chaîne "rep" préfixée par un caractère et, si elle la trouve, incrémente la réputation (la nvariable) de 1 ou -1.

Programme complet avec méthode non golfée et cas de 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
    }
}

Notez que le code ASCII pour +est 43 et pour -est 45. Cette méthode passe tous les cas de test de l'OP. Cependant, si le premier caractère est autre chose, cela entraînera de mauvaises réponses!

Cela peut être résolu au prix de 17 octets:

C # fixe, 104 octets

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 fonction anonyme modifiée recherchera un +ou un -signe comme premier caractère de chaque ligne.

Japt , 14 octets

r`œp`1 f".%d 

Essayez-le en ligne!

+1 octet pour le -xdrapeau

C ++, 144 octets

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

Essayez-le en ligne!

C # , 104 octets

Malgré une solution déjà existante - et la mienne étant plus longue - je pense toujours que je devrais la publier, car le déjà là pourrait échouer si quelque chose comme ça se '=rep 'met en travers.

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

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

Non lisible non lisible

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

Code complet

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

Communiqués

• v1.0 - 104 bytes- Solution initiale.

Remarques

Rien à ajouter

Rubis, 46 octets

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

Obtenez toutes les répétitions +/- de l'entrée et réunissez-les dans une seule chaîne. Évaluez ensuite cela pour rep = 1.

JavaScript ES6, 85 79 octets

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

Essayez-le

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

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

Histoire

85 octets

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