介绍

对于不熟悉蒸汽的人-或至少不熟悉此特定方面的人：

人们经常在人们的个人资料上留下评论，说“ + rep _____”或“ -rep _____”。这些是一种非官方的方法，可以出于多种原因显示您认为社区中某人的声誉良好或不良。这样的注释看起来像：

+代表一个好球员

+ rep有帮助

-rep黑客

-rep骗子

任务

该程序必须通过任何协商一致的方式获取输入。输入由带有可选换行符（\n）的字符串组成。在每行的开始处，'+rep '或者'-rep '可能存在。该行的其余部分可以丢弃。如果该行不是以'+rep '或开头'-rep '（请注意尾随空格），则应忽略该行。

然后，该程序必须保持总信誉得分。0从此开始，此分数应在以开头的每一行上递增，'+rep '并在以开头的每一行上递减'-rep '。

该结果应以任何商定的方式输出。

测试用例

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

奖金

我什至不知道是否可能，但是如果您能以某种方式从Steam上获得这些评论，则可以得到加分。

05AB1E，18 16 17字节

由于规格更改，Okx
+1个字节节省了2个字节，其中rep现在需要在其后跟一个空格。

|vy5£„+-S„·Ý «QÆ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个字节

我确定这个答案是垃圾，很快就会被击败，但是还没有其他的python答案。

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

像这样使用：

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

从蒸汽中提取

这是一些示例代码，可从KennyS的个人资料中获取前100条评论并计算其代表。

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个字节

24个字节的代码+ -p标志。

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

在线尝试！

/^\+rep /返回1该行是否以+rep; 开头 如果该行以开头，则/^-rep /返回（因此，其中只有一个将是最多一个）。我们用来存储结果，因为它在末尾隐式打印（感谢flag和那些不匹配的结果）。1-rep$\-p}{

Python 2，54个字节

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

在线尝试！将多行字符串作为输入。

通过搜索换行符后的字符串来计算行的出现'+rep '和'-rep '仅在行的开头。要捕获第一行，在输入之前添加换行符。

视网膜，63 51 50 49字节

不太符合规范，所以我解决了一些问题，但也打了很多球（借用Kritixi Lithos解决方案的第一行）。

多亏了Kritixi Lithos，保存了另一个字节。

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

+`\+-|-\+

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

在线尝试！

说明

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

首先，删除输入中的所有内容，除了+和之外的-任何内容+rep或-rep行首。

+`\+-|-\+

然后，将+和的相邻对-删除，直到无法删除为止。之后，剩下的要么是+s的运行，要么是s的运行-，否则什么也没有。

(.)+
$1$.&

然后将一个或多个字符（+或-）的运行替换为组成运行的字符，再加上运行的长度。这样，+一开始就保留了正面结果和-负面结果。

T`+

然后+，如果rep为正，则将所有s都删除。

$^
0

最后，如果此时字符串为空，则rep为0，因此我们将其写为0。

JavaScript，55个字节

感谢@Neil打高尔夫球12个字节感谢@Arnauld打高尔夫球2个字节

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

在线尝试！

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个字节（ISO 8859-1编码）

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

纯函数，以换行符分隔的字符串作为输入并返回整数。请注意，代码中的三行换行符用引号引起来，因此每行都等效"\n"于一个字符串（但这种方式比短一字节"\n"）。StringCount做繁重的工作；我们会在字符串的开头手动添加换行符，以便第一行在适当的时候匹配。±是避免重复的一元帮助功能StringCount。

替代解决方案

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

是4字节长，但我确实喜欢序列±"+"-±"-"....

视网膜，59 53 52 50字节

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

+`\+-|-\+

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

在线尝试！

看看基本日落的短 用相同的语言答案！

说明

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

删除除以下内容之外的所有内容 [+-]rep s。

+`\+-|-\+

-每次重复删除1+反之亦然。

-+
-$.&

-在-s前面加上a （因为数字为负），并-用的数字替换s- s。

\+
$.&

对+s做相同的操作，但不要在之前加上-。

^$
0

最后，如果没有任何内容，请将其替换为0。

PHP，118字节

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

在线尝试！

像这样使用：

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

罗达（Röda），53个字节

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

在线尝试！

Java，109个字节

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

试图让这个较短的使用Stream的

堆叠，45字节

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

在线尝试！

或者（49个字节）：

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

说明

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

这基本上提取了所有+或-附加到行开头的和rep。然后，对每个对象都加一个#。然后，在整个过程中，先0添加a。#~计算字符串，现在看起来像：

0#+#+#-

#+是增量，#-是递减。因此，我们获得了期望的结果。

视网膜，38字节

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

*\M1!`-
[+-]

在线尝试！

与Retina中已经发布的解决方案不同（且更短）的解决方案。

说明

M!m`^[+-]rep 

（此行具有尾随空格）。仅保留输入的相关部分，即行的+rep或-rep。

Os`.

对所有字符（包括换行符）进行排序。这将使+ s和-s彼此相邻。

+`\+-

反复去除+-夫妻，直到两个征象中最多只有一个。

*\M1!`-

匹配第一个-（如果存在）并打印而不修改字符串。

[+-]

计算剩余的标志数量，并打印出来，因为这是程序的最后阶段。

C＃，87个字节

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

匿名函数使用换行符分割输入字符串，搜索以字符为前缀的“ rep”字符串，如果找到该字符串，则将信誉（n变量）增加1或-1。

完整的程序，包含未使用的方法和测试用例：

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

请注意， +是43- 45。此方法通过了OP中的所有测试用例。但是，如果第一个字符是其他字符，则会导致错误的答案！

可以将其固定为17个字节：

固定C＃，104个字节

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 +或-符号。

Japt，14个字节

r`œp`1 f".%d 

在线尝试！

+1字节的-x标志

C ++，144个字节

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

在线尝试！

C＃，104字节

尽管已经存在一个解决方案-并且我的解决方案更长了-我仍然认为应该发布它，因为如果'=rep '遇到类似问题，此处已经存在的解决方案可能会失败。

打高尔夫球

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

不打高尔夫球

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

非高尔夫可读

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

完整代码

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

发布

• 1.0 - 104 bytes-初始溶液。

笔记

没有补充

Ruby，46个字节

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

从输入中获取所有+/- rep，并将其放到一个字符串中。然后评估rep = 1。

的JavaScript ES6，85 79个字节

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

试试吧

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

不打高尔夫球

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

历史

85字节

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