你们中的许多人可能在某个时候与来自俄罗斯的人进行了互动，并且其中的一部分人可能已经注意到他们表达自己的方式有些奇怪。

例如 удали игру нуб)))

在)))为强调前面的语句而添加的地方，我一直在研究一个理论，即)s与其余字符串的比率与隐含强调的量成正比，但是我经常发现很难计算该比率快速进行中，因为我也在努力应对大量滥用情况，所以我想用最短的代码来帮助我计算出结果字符串应该是什么，对于原始值（介于0和500％之间）， ，热情的字符串，这将极大地帮助我的研究，因为每次我想检验我的假设时，我都不必键入笨拙的脚本。

因此，挑战在于：

编写一个完整的程序或函数，以整数格式（0到500之间）或十进制格式（0到5之间，有2个精度点）提供两个参数，一个未知长度的字符串和一个数字，将

• 返回/显示原始的字符串，与多个后缀)的
• 该数字将作为输入数字与字符串长度的比率计算得出。
• 因此，如果被提供的号码200，或2.00，所述串的200％，必须作为后缀)的
• 小数点后四舍五入的括号数量无关紧要。
• 需要脚本来支持可打印ASCII字符。
• 只需支持您选择的一种输入数字格式。

例子：

"codegolf" 125      = codegolf))))))))))
"codegolf" 75       = codegolf))))))
"noob team omg" 0.5 = noob team omg))))))
"hi!" 4.99          = hi!)))))))))))))))

示例代码（PowerShell）（带十进制输入）：

Function Get-RussianString ([string]$InputStr,[decimal]$Ratio){
    $StrLen = $InputStr.Length
    $SuffixCount = $StrLen * $Ratio
    $Suffix = [string]::New(")",$SuffixCount)
    return $InputStr + $Suffix
}

Get-RussianString "codegolf" 0.5
codegolf))))

这是代码高尔夫球，所以最短的代码获胜！

果冻，7 个字节

ȮL×Ċ”)x

在线尝试！

使用十进制格式。

怎么样？

ȮL×Ċ”)x - Main link: string, decimal
Ȯ       - print string
 L      - length(string)
  ×     - multiply by the decimal
   Ċ    - ceiling (since rounding method is flexible)
    ”)  - a ')' character
      x - repeated that many times
        - implicit print

Perl 6，21位元组

{$^a~")"x$^b*$a.comb}

普通Lisp 59 52 50

括号？我在。

(lambda(s n)(format()"~a~v@{)~}"s(*(length s)n)0))

细节

(lambda(s n)               ; two arguments (string and ratio)
  (format ()               ; format as string
          "~a~v@{)~}"      ; control string (see below)
          s                ; first argument (string)
          (* (length s) n) ; second argument (number of parens)
          0))              ; one more element, the value does not matter

格式控制字符串

• ~a ：漂亮的打印参数（此处为给定的字符串）
• ~v@{...~}：迭代块，仅限于V迭代，其中V作为参数，即(* ...)表达式。该迭代应该迭代一个列表，但是当您添加@修饰符时，该列表是format函数的其余参数列表。迭代列表中必须至少有一个元素（否则，我们将不考虑V退出）。这就是为什么格式（0）还有一个附加参数的原因。

由于列表中的任何元素都不被格式占用，因此循环是无限的，但是幸运的是，循环也受V限制，也就是要打印的括号数。

编辑：感谢Michael Vehrs指出不需要四舍五入数值参数（问题允许截断/四舍五入，但是我们想要的是默认行为）。

的JavaScript ES6，38个 31 30字节

s=>n=>s+')'.repeat(s.length*n)

f=s=>n=>s+')'.repeat(s.length*n)

console.log(f("hi!")(4.99))

Python 2，29个字节

lambda s,p:s+len(s)*p/100*')'

字符串中的s，p是百分比（整数）。

在线尝试！

05AB1E，9 8字节

g*ï')×¹ì

在线尝试！

g*       # Length, multiplied by emphasis.
  ï')×   # Covnerted to an integer, push that many parenthesis.
      ¹ì # Prepend original string.

适用于整数和十进制，参数顺序： f(String, Double)

Python，30个字节

lambda s,r:s+')'*int(len(s)*r)

使用十进制输入。

在线尝试！

Pyth，8个字节

*\)s*lpz

在线测试！首先采取兴奋度，然后热情地对待。

说明：

      pz  print out the enthused string
     l    ... and get its length
    *...Q multiply that by the ratio
   s      floor to get an integer, let's call this S
 \)       single-character string ")"
* ")" S   multiply that integer by the string, which gives a string of )s of length S.
          implicitly print that string of S )s.

PowerShell，33字节

$a,$b=$args;$a+')'*($b*$a.Length)

在线尝试！

支持十进制格式。

R，62 46 42字节

带有字符串a和十进制的匿名函数，将n输出打印到stdout。

pryr::f(cat(a,rep(")",n*nchar(a)),sep=""))

Pyth，9个字节

*s*lpzE")

接受两行输入：字符串和比率（十进制）。

在pyth.herokuapp.com上尝试

说明

A表示函数的第一个参数，B第二个参数。

*s*lpzE")
    pz     # print the input string
   lAA     # take the length of the printed string
      E    # read the next line of input (the emphasis ratio)
  *AAAB    # multiply the length by the ratio
 sAAAAA    # floor the result
*AAAAAA")  # repeat ")" n times
           # implicit print

TI-Basic，33个字节

接受十进制输入。

Prompt Str1,A
")
For(I,0,9
Ans+Ans
End
Str1+sub(Ans,1,AI

Perl 5，29个字节

sub{($_=pop).')'x(y///c*pop)}

（数字是第一个arg，字符串是第二个。）

在线尝试！

CJam，9个字节

l_,ld*')*

在线尝试！

在第一行输入字符串，第二行的增强比在0到5范围内。

说明

l    e# Read input string.
_,   e# Duplicate, get length.
ld   e# Read emphasis ratio.
*    e# Multiply by length.
')*  e# Get that many parentheses.

MATL，11 10 8字节

yn*:"41h

此解决方案使用第二个输入的十进制形式

在线尝试！

说明

        % Implicitly grab first input as a string
        % Implicitly grab the second input as a number
y       % Make a copy of the first input
n       % Compute the length of the string
*       % Multiply the decimal by the length to determine the # of )'s (N)
:       % Create the array [1...N]
"       % For each element in this array
  41    % Push 41 to the stack (ACSII for ")")
  h     % Horizontally concatenate this with the current string
        % Implicit end of for loop and display

sB〜，17个字节

i\,N?\;')'*(N*l(\

解释：

i\,N    input a string and a number
?\;     print the string
')'*    also print ) multiplied by...
(N*l(\  the number times the string length.

括号自动关闭

如果您感兴趣，这是编译器的输出：

 INPUT  S$ ,N? S$ ;")"*(N* LEN(  S$ ))

该版本的编译器于2017年1月27日晚上11:12编写，这可能是在发布此问题后几分钟。因此，这里是一个适用于最早的编译器版本的版本，该版本早于一个小时编写：iS$,N?S$;')'*(N*l(S$))（22字节）

PostgreSQL，102字节

create function q(text,int)returns text as $$select rpad($1,(100+$2)*length($1)/100,')')$$language sql

细节

使用整数输入格式。

这只是将输入字符串右击，并把它们减至目标长度。

create function q(text,int)
returns text as $$
    select rpad($1,             -- Pad the string input
        (100 + $2) *            -- to 100 + int input % ...
        length($1) / 100,       -- ...of the input string
        ')')                    -- with ) characters
$$ language sql

用

select q('codegolf', 125), q('codegolf', 75);
select q('noob team omg', 50), q('hi!', 499);

Bash + coreutils，45个字节

echo $1`seq -s\) $[${#1}*$2/100+1]|tr -cd \)`

在线尝试！

整数输入。

Groovy，27个字节

简单的解决方案

{s,r->s+')'*(s.length()*r)}

测试程序：

def f = {s,r->s+')'*(s.length()*r)}

println f("hi!", 4.99)
println f("noob team omg", 0.5)

Rebol，39个字节

func[a b][append/dup a")"b * length? a]

Clojure，40个字节

相当无聊的解决方案：

#(reduce str %(repeat(*(count %)%2)")"))

只需str对带有字符串作为初始参数的右括号列表进行归约。

在线查看：https：//ideone.com/5jEgWS

不太闷的解决方案（64字节）：

#(.replace(str(nth(iterate list(symbol %))(*(count %)%2)))"(""")

将输入字符串转换为符号（以消除引号），并list在其上反复应用函数，生成无限序列，如下所示：(a (a) ((a)) (((a))) ... )。Takes nth元素将其转换为字符串，并将所有开头的括号替换为空白。

在线查看：https：//ideone.com/C8JmaU

SimpleTemplate，92个字节

将字符串作为第一个参数，并将“比率”作为第二个参数。
该比率在0到5之间，有2个小数位。

{@echoargv.0}{@callstrlen intoL argv.0}{@set*Y argv.1,L}{@callstr_repeat intoO")",Y}{@echoO}

如您所见，它不是最佳的。那里
的2 {echo}可以减少为1。
由于编译器中的错误，此代码无法进一步减少。

取消高尔夫：

{@echo argv.0}
{@call strlen into length argv.0}
{@set* ratio argv.1, length}
{@call str_repeat into parenthesis ")", ratio}
{@echo parenthesis}

如果不存在错误，则代码将如下所示，为86个字节：

{@callstrlen intoL argv.0}{@set*Y argv.1,L}{@callstr_repeat intoO")",Y}{@echoargv.0,O}

C＃Interactive， 77 67字节

string r(string s,int p)=>s+new string(')',(int)(s.Length*p/100d));

C＃交互式很不错。

SmileBASIC，29个字节

INPUT S$,N?S$;")"*(LEN(S$)*N)

Gol> <>（Golfish），17个字节

i:a=?v
R*Il~/Hr)`

在这里尝试。

第一行读取字符（i），直到找到换行符（ASCII 10，a），然后向下（v）。

然后，我们使用丢弃一个字符（换行符）~，增加堆栈的长度（l），读取一个float（I），将两者相乘，然后重复（R）多次将字符“）”按下。最后，反转堆栈（r），将其输出并暂停（H）。

PHP，50个字节

<?=str_pad($s=$argv[1],strlen($s)*++$argv[2],")");

以字符串和十进制数作为命令行参数；减少填充。用-r;

分解

<?=                     // print ...
str_pad(                    // pad
    $s=$argv[1],            // string=argument 1
    strlen($s)*++$argv[2],  // to string length*(1+argument 2) 
    ")"                     // using ")" as padding string
);

Ruby，25个字节

->(s,n){s+')'*(s.size*n)}

我正在使用lambdas。测试程序将类似于：

f=->(s,n){s+')'*(s.size*n)}
f.("codegolf", 1.5)        # => "codegolf))))))))))))"
f.("hi!", 4.99)            # => "hi!))))))))))))))"

Clojure，68个字节

接受十进制输入的匿名函数。

(fn [s n] (print (str s (reduce str (repeat (* n (count s)) ")")))))

从字面上看，这是我编写的第一个Lisp程序！我已经很开心了

C ++ 14，43个字节

由于未命名的lambda修改了其输入，因此假设s与std::string（具有.append(int,char)并且假设p为浮点类型：

[](auto&s,auto p){s.append(s.size()*p,41);}

用法：

#include<string>
#include<iostream>

auto f=
[](auto&s,auto p){s.append(s.size()*p,41);}
;


int main() {
 std::string s = "abcdefghijk";
 f(s,0.75);
 std::cout << s << std::endl;
}

Haskell，37个字节

s!n=s++([1..div(n*length s)100]>>")")

在线尝试！用法："codegolf" ! 125

带有十进制数字的版本：（41个字节）

s!n=s++([1..n*toRational(length s)]>>")")

在线尝试！用法："codegolf" ! 1.25