Muitos de vocês podem ter interagido com pessoas da Rússia na internet em algum momento, e um subconjunto de vocês deve ter notado o método um pouco estranho que eles têm para se expressar.

por exemplo удали игру нуб)))

onde )))são adicionados para enfatizar a declaração anterior, tenho trabalhado em uma teoria de que a proporção de )s para o restante da string é diretamente proporcional à quantidade de ênfase implícita; no entanto, muitas vezes acho difícil calcular a proporção em tempo real, como também estou tentando lidar com uma série de abusos, então eu gostaria que o código mais curto possível me ajudasse a calcular qual deveria ser a sequência resultante, para um valor de entusiasmo entre 0 e 500%, dado o original , seqüência sem entusiasmo, isso ajudará muito minha pesquisa, pois não precisarei digitar scripts volumosos toda vez que desejar testar minha hipótese.

Então, o desafio:

escreva um programa ou função completo que, desde dois argumentos, uma sequência de comprimento desconhecido e um número, seja no formato inteiro (entre 0 e 500) ou no formato decimal (entre 0 e 5, com 2 pontos de precisão)

• retorno / exibir a string original, seguida de uma série de )'s
• o número será calculado como uma proporção do número de entrada para o comprimento da string.
• portanto, se o número 200 ou 2,00 foi fornecido, 200% da string deve ser sufixado como )'s
• o número de parênteses arredondados para situações decimais não importa.
• É necessário um script para suportar caracteres ASCII imprimíveis.
• só precisa suportar um formato de número de entrada, de sua escolha.

Exemplos:

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

Código de exemplo (PowerShell) (com entrada decimal):

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

Isso é código-golfe, então o código mais curto vence!

Geléia , 7 bytes

ȮL×Ċ”)x

Experimente online!

Usa o formato decimal.

Quão?

Ȯ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 bytes

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

Lisp comum, 59 52 50.

Parênteses? Eu estou dentro

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

Detalhes

(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

Cadeia de controle de formato

• ~a : argumento de impressão bonita (aqui a string especificada)
• ~v@{...~}: bloco de iteração, limitado à iteração V, onde V é tomado como argumento, a (* ...)expressão. A iteração deve iterar sobre uma lista, mas quando você adiciona o @modificador, a lista é a lista restante de argumentos para a função de formato. Deve haver pelo menos um elemento na lista iterada (caso contrário, sairemos, desconsiderando V). É por isso que existe um argumento adicional para formatar (0).

Como nenhum elemento da lista é consumido pelo formato, o loop é infinito, mas felizmente também é limitado por V, também conhecido como número de parênteses a serem impressos.

Edit: obrigado a Michael Vehrs por apontar que não há necessidade de arredondar o argumento numérico (a pergunta permite truncar / arredondar como quisermos, portanto o comportamento padrão funciona aqui).

JavaScript ES6, 38 31 30 bytes

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

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

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

Python 2 , 29 bytes

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

s na string, p é a porcentagem (inteiro).

Experimente online!

05AB1E , 9 8 bytes

g*ï')×¹ì

Experimente online!

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

Funciona para números inteiros e decimais, ordem dos argumentos: f(String, Double)

Python, 30 bytes

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

Usa a entrada decimal.

Experimente online!

Pitão, 8 bytes

*\)s*lpz

Teste Online! Toma primeiro a razão de excitação, depois a corda para se entusiasmar.

Explicação:

      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 bytes

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

Experimente online!

Suporta formato decimal.

R, 62 46 42 bytes

Função anônima que recebe string ae decimal n, imprime a saída em stdout.

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

Pitão, 9 bytes

*s*lpzE")

Toma duas linhas de entrada: sequência e proporção (decimal).

Experimente em pyth.herokuapp.com

Explicação

Adenota o primeiro argumento de uma função, Bseu segundo argumento.

*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 bytes

Toma entrada decimal.

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

Perl 5, 29 bytes

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

(O número é o primeiro argumento, a sequência é o segundo.)

Experimente online!

CJam , 9 bytes

l_,ld*')*

Experimente online!

Insira a string na primeira linha, a taxa de ênfase no intervalo de 0 a 5 na segunda.

Explicação

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 bytes

yn*:"41h

Esta solução usa a forma decimal da segunda entrada

Experimente online!

Explicação

        % 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 bytes

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

Explicado:

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

Parênteses são fechados automaticamente

Aqui está a saída do compilador, se você estiver interessado:

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

Esta versão do compilador foi escrita em 27/01/2017 às 23:12, o que pode ter ocorrido alguns minutos após a publicação desta pergunta. Então, aqui está uma versão que funciona na versão mais antiga do compilador, escrita uma hora antes: iS$,N?S$;')'*(N*l(S$))(22 bytes)

PostgreSQL, 102 bytes

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

Detalhes

Usa o formato de entrada inteira.

Isso simplesmente acerta a seqüência de entrada com o tamanho do alvo.

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

Chamado com

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

Bash + coreutils, 45 bytes

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

Experimente online!

Entrada inteira.

Groovy, 27 bytes

Solução simples

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

Programa de teste:

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

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

Rebol, 39 bytes

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

Clojure, 40 bytes

Solução bastante chata:

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

Apenas reduz a strfunção em uma lista de parênteses de fechamento com uma string como parâmetro inicial.

Veja on-line: https://ideone.com/5jEgWS

Solução não tão chata (64 bytes):

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

Converte uma cadeia de entrada para um símbolo (para se livrar de aspas) e repetidamente aplica a função listnele gerando sequência infinita como este: (a (a) ((a)) (((a))) ... ). O nthelemento Takes converte-o em string e substitui todos os parênteses de abertura por nada.

Veja on-line: https://ideone.com/C8JmaU

SimpleTemplate, 92 bytes

Leva a string como o primeiro parâmetro e a "proporção" como o segundo.
A proporção está entre 0 e 5, com 2 casas decimais.

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

Como você pode ver, não é o ideal.
O número 2 {echo}pode ser reduzido para 1.
Devido a um erro no compilador, esse código não pode ser reduzido muito mais.

Ungolfed:

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

Se nenhum erro existisse, o código ficaria assim: 86 bytes:

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

C # interativo, 77 67 bytes

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

C # interativo é legal.

SmileBASIC, 29 bytes

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

Gol> <> (Golfe), 17 bytes

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

Experimente aqui .

A linha superior lê caracteres ( i) até encontrar uma nova linha (ASCII 10, a) e depois desce ( v).

Então descartamos um caractere (a nova linha) com ~, pressionamos o comprimento da pilha ( l), lemos um float ( I), multiplicamos os dois e repetidamente ( R) pressionamos o caractere ")" várias vezes. Finalmente, inverta a pilha ( r), faça a saída e pare ( H).

PHP, 50 bytes

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

toma string e número decimal como argumentos de linha de comando; corta o estofamento. Corra com -r;

demolir

<?=                     // 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 bytes

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

Estou usando lambdas . O programa de teste seria algo como:

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

Clojure, 68 bytes

Uma função anônima que aceita entrada decimal.

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

Literalmente, o primeiro programa Lisp que eu já escrevi! Eu já estou me divertindo.

C ++ 14, 43 bytes

Como lambda sem nome, modificando sua entrada, assumindo que sé semelhante a std::string(has .append(int,char)e assumindo pser do tipo de ponto flutuante:

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

Uso:

#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 bytes

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

Experimente online! Uso:"codegolf" ! 125

Uma versão que usa um número decimal: (41 bytes)

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

Experimente online! Uso:"codegolf" ! 1.25