Muchos de ustedes pueden haber interactuado con personas de Rusia en Internet en algún momento, y un subconjunto de ustedes puede haber notado el método un poco extraño que tienen para expresarse.

p.ej удали игру нуб)))

donde )))se agregan para enfatizar la afirmación anterior, he estado trabajando en una teoría de que la relación de )'s con el resto de la cadena es directamente proporcional a la cantidad de énfasis implícito, sin embargo, a menudo me resulta difícil calcular la relación sobre la marcha, ya que también estoy tratando de hacer frente a una gran cantidad de abusos, por lo que me gustaría que el código más corto posible me ayudara a calcular cuál debería ser la cadena resultante, por un valor de entusiasmo entre 0 y 500%, dado el original , una cadena poco entusiasta, esto ayudará mucho a mi investigación, ya que no tendré que escribir scripts voluminosos cada vez que desee probar mi hipótesis.

Entonces, el desafío:

escribir un programa o función completa que, con dos argumentos, una cadena de longitud desconocida y un número, en formato entero (entre 0 y 500) o en formato decimal (entre 0 y 5, con 2 puntos de precisión)

• retorno / mostrar la cadena original, con el sufijo con un número de )'s
• el número se calculará como una relación entre el número de entrada y la longitud de la cadena.
• así que si se proporcionó el número 200, o 2.00, el 200% de la cadena debe tener el sufijo )'s
• el número de corchetes redondeados en situaciones decimales no importa.
• Se requiere un script para admitir caracteres ASCII imprimibles.
• solo tiene que admitir un formato de número de entrada, de su elección.

Ejemplos:

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

Código de ejemplo (PowerShell) (con 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))))

Este es el código de golf, ¡el código más corto gana!

Jalea , 7 bytes

ȮL×Ċ”)x

Pruébalo en línea!

Utiliza el formato decimal.

¿Cómo?

Ȯ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 común, 59 52 50

Paréntesis? Estoy en.

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

Detalles

(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

Cadena de control de formato

• ~a : argumento de impresión bonita (aquí la cadena dada)
• ~v@{...~}: bloque de iteración, limitado a la iteración V, donde V se toma como argumento, es decir, la (* ...)expresión. Se supone que la iteración itera sobre una lista, pero cuando agrega el @modificador, la lista es la lista restante de argumentos a la función de formato. Debe haber al menos un elemento en la lista iterada (de lo contrario, salimos, sin tener en cuenta V). Es por eso que hay un argumento adicional para formatear (0).

Dado que el formato no consume ningún elemento de la lista, el bucle es infinito pero, afortunadamente, también está limitado por V, también conocido como el número de paréntesis que se imprimirán.

Editar: gracias a Michael Vehrs por señalar que no hay necesidad de redondear el argumento numérico (la pregunta permite truncar / redondear como queramos, por lo que el comportamiento predeterminado funciona aquí).

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 en la cadena, p es el porcentaje (entero).

Pruébalo en línea!

05AB1E , 9 8 bytes

g*ï')×¹ì

Pruébalo en línea!

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

Funciona tanto para entero como decimal, orden de argumentos: f(String, Double)

Python, 30 bytes

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

Utiliza la entrada decimal.

Pruébalo en línea!

Pyth, 8 bytes

*\)s*lpz

¡Prueba en línea! Primero toma la proporción de emoción, luego la cuerda de la que debe entusiasmarse.

Explicación:

      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)

Pruébalo en línea!

Soporta formato decimal.

R, 62 46 42 bytes

Función anónima que toma cadenas ay decimales n, imprime la salida en stdout.

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

Pyth, 9 bytes

*s*lpzE")

Toma dos líneas de entrada: cadena y relación (decimal).

Pruébalo en pyth.herokuapp.com

Explicación

Adenota el primer argumento de una función, Bsu 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)}

(El número es el primer argumento, la cadena es el segundo).

Pruébalo en línea!

CJam , 9 bytes

l_,ld*')*

Pruébalo en línea!

Cadena de entrada en la primera línea, relación de énfasis en el rango de 0 a 5 en la segunda.

Explicación

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 solución usa la forma decimal de la segunda entrada

Pruébalo en línea!

Explicación

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

Los paréntesis se cierran automáticamente.

Aquí está la salida del compilador, si está interesado:

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

Esta versión del compilador se escribió el 27/01/2017 a las 11:12 p.m., lo que podría haber sido unos minutos después de que se publicara esta pregunta. Aquí hay una versión que funciona en la versión más antigua del compilador, escrita una 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

Detalles

Utiliza el formato de entrada entero.

Esto simplemente rellena a la derecha la cadena de entrada con parens a la longitud objetivo.

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

Llamado con

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

Pruébalo en línea!

Entrada entera.

Groovy, 27 bytes

Solución directa

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

Programa de prueba :

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

Solución bastante aburrida:

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

Simplemente reduce la strfunción en una lista de paréntesis de cierre con una cadena como parámetro inicial.

Véalo en línea: https://ideone.com/5jEgWS

Solución no tan aburrida (64 bytes):

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

Convierte la cadena de entrada a un símbolo (para deshacerse de las cotizaciones) y en repetidas ocasiones se aplica la función listen él generando secuencia infinita de esta manera: (a (a) ((a)) (((a))) ... ). El nthelemento Takes lo convierte en cadena y reemplaza todos los paréntesis de apertura por nada.

Véalo en línea: https://ideone.com/C8JmaU

SimpleTemplate, 92 bytes

Toma la cadena como el primer parámetro y la "relación" como el segundo.
La relación es entre 0 y 5, con 2 decimales.

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

Como puede ver, no es óptimo.
El 2 {echo}podría reducirse a 1.
Debido a un error en el compilador, este código no puede reducirse mucho más.

Sin golf:

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

Si no existiera ningún error, el código se vería así, 86 bytes:

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

C # interactivo, 77 67 bytes

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

C # interactivo es dulce.

SmileBASIC, 29 bytes

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

Gol> <> (Golfish), 17 bytes

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

Pruébalo aquí .

La línea superior lee los caracteres ( i) hasta que encuentra una nueva línea (ASCII 10, a), luego baja ( v).

Luego descartamos un carácter (la nueva línea) con ~, empujamos la longitud de la pila ( l), leemos un float ( I), multiplicamos los dos y repetidamente ( R) empujamos el carácter ")" tantas veces. Finalmente, invierta la pila ( r), envíela y detenga ( H).

PHP, 50 bytes

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

toma una cadena y un número decimal como argumentos de la línea de comando; Corta el acolchado. Correr con -r;

Descompostura

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

Rubí, 25 bytes

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

Estoy usando lambdas . El programa de prueba sería algo como:

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

Clojure, 68 bytes

Una función anónima que acepta entrada decimal.

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

¡Literalmente el primer programa Lisp que he escrito! Ya me estoy divirtiendo

C ++ 14, 43 bytes

Como lambda sin nombre que modifica su entrada, se supone que ses similar a std::string(has .append(int,char)y se supone pque es del tipo de coma flotante:

[](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]>>")")

Pruébalo en línea! Uso:"codegolf" ! 125

Una versión que toma un número decimal: (41 bytes)

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

Pruébalo en línea! Uso:"codegolf" ! 1.25