Molti di voi potrebbero aver interagito con persone provenienti dalla Russia su Internet ad un certo punto, e un sottoinsieme di voi potrebbe aver notato il metodo leggermente strano che hanno per esprimersi.

per esempio удали игру нуб)))

dove )))sono aggiunti per enfatizzare la precedente affermazione, ho lavorato su una teoria secondo cui il rapporto di )'s con il resto della stringa è direttamente proporzionale alla quantità di enfasi implicita, tuttavia spesso trovo difficile calcolare il rapporto al volo, poiché sto anche cercando di far fronte a una serie di abusi, quindi vorrei il codice più breve possibile per aiutarmi a calcolare quale dovrebbe essere la stringa risultante, per un valore di entusiasmo compreso tra 0 e 500%, dato l'originale , stringa non entusiasta, questo mi aiuterà molto nella mia ricerca in quanto non dovrò scrivere script ingombranti ogni volta che desidero testare la mia ipotesi.

Quindi, la sfida:

scrivere un programma o una funzione completi, che, forniti due argomenti, una stringa di lunghezza sconosciuta e un numero, in formato intero (tra 0 e 500) o in formato decimale (tra 0 e 5, con 2 punti di precisione)

• restituisce / visualizza la stringa originale, con il suffisso di un numero di )'s
• il numero sarà calcolato come rapporto tra il numero di input e la lunghezza della stringa.
• quindi se è stato fornito il numero 200, o 2.00, il 200% della stringa deve essere suffisso come )'s
• il numero di parentesi arrotondate in in decimali non ha importanza.
• lo script è necessario per supportare i caratteri ASCII stampabili.
• deve supportare solo un formato numerico di input, a scelta.

Esempi:

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

Codice di esempio (PowerShell) (con input decimale):

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

Questo è code-golf, quindi vince il codice più corto!

Gelatina , 7 byte

ȮL×Ċ”)x

Provalo online!

Utilizza il formato decimale.

Come?

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

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

Lisp comune, 59 52 50

Parentesi? Io sono in.

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

Dettagli

(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

Stringa di controllo del formato

• ~a : pretty print argomento (qui la stringa data)
• ~v@{...~}: blocco di iterazione, limitato a V iterazione, dove V è preso come argomento, vale a dire l' (* ...)espressione. L'iterazione dovrebbe iterare su un elenco, ma quando si aggiunge il @modificatore, l'elenco è l'elenco rimanente di argomenti alla funzione di formattazione. Ci deve essere almeno un elemento nell'elenco iterato (altrimenti usciamo, ignorando V). Ecco perché c'è un ulteriore argomento da formattare (0).

Poiché nessun elemento dell'elenco viene utilizzato dal formato, il ciclo è infinito ma per fortuna, è anche limitato da V, ovvero il numero di parentesi da stampare.

Modifica: grazie a Michael Vehrs per aver sottolineato che non è necessario arrotondare l'argomento numerico (la domanda consente di troncare / arrotondare come vogliamo, quindi il comportamento predefinito funziona qui).

JavaScript ES6, 38 31 30 byte

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

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

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

Python 2 , 29 byte

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

s nella stringa, p è la percentuale (numero intero).

Provalo online!

05AB1E , 9 8 byte

g*ï')×¹ì

Provalo online!

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

Funziona con numeri interi e decimali, gli argomenti sono ordinati: f(String, Double)

Python, 30 byte

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

Utilizza l'input decimale.

Provalo online!

Pyth, 8 byte

*\)s*lpz

Test online! Prende prima il rapporto di eccitazione, quindi la stringa da entusiasmare.

Spiegazione:

      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 byte

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

Provalo online!

Supporta il formato decimale.

R, 62 46 42 byte

Funzione anonima che accetta stringhe ae decimali n, stampa l'output su stdout.

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

Pyth, 9 byte

*s*lpzE")

Accetta due righe di input: stringa e rapporto (decimale).

Provalo su pyth.herokuapp.com

Spiegazione

Adenota il primo argomento di una funzione, il Bsuo secondo argomento.

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

Accetta l'input decimale.

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

Perl 5, 29 byte

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

(Il numero è il primo argomento, la stringa è il secondo.)

Provalo online!

CJam , 9 byte

l_,ld*')*

Provalo online!

Immettere la stringa sulla prima riga, il rapporto di enfasi nell'intervallo da 0 a 5 sulla seconda.

Spiegazione

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 byte

yn*:"41h

Questa soluzione utilizza la forma decimale del secondo input

Provalo online!

Spiegazione

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

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

Ha spiegato:

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

Le parentesi si chiudono automaticamente

Ecco l'output del compilatore, se sei interessato:

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

Questa versione del compilatore è stata scritta il 27/01/2017 alle 23:12, che potrebbe essere passata qualche minuto dopo la pubblicazione della domanda. Quindi ecco una versione che funziona con la versione più vecchia del compilatore, scritta un'ora prima: iS$,N?S$;')'*(N*l(S$))(22 byte)

PostgreSQL, 102 byte

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

Dettagli

Utilizza il formato di input intero.

Questo semplicemente riempie a destra la stringa di input con parentesi alla lunghezza target.

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

Chiamato con

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

Bash + coreutils, 45 byte

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

Provalo online!

Input intero.

Groovy, 27 byte

Soluzione semplice

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

Programma di test:

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

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

Rebol, 39 byte

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

Clojure, 40 byte

Soluzione abbastanza noiosa:

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

Riduce semplicemente la strfunzione in un elenco di parentesi chiuse con una stringa come parametro iniziale.

Guardalo online: https://ideone.com/5jEgWS

Soluzione non così noiosa (64 byte):

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

Converte stringa di input a un simbolo (per sbarazzarsi di virgolette) e ripetutamente si applica la funzione listsu di esso generare sequenza infinita in questo modo: (a (a) ((a)) (((a))) ... ). Takes nthelement lo converte in stringa e sostituisce tutte le parentesi aperte con nulla.

Guardalo online: https://ideone.com/C8JmaU

SimpleTemplate, 92 byte

Prende la stringa come primo parametro e il "rapporto" come secondo.
Il rapporto è compreso tra 0 e 5, con 2 cifre decimali.

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

Come puoi vedere, non è ottimale.
Il 2 {echo}potrebbe essere ridotto a 1.
A causa di un bug nel compilatore, questo codice non può essere ulteriormente ridotto.

Ungolfed:

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

Se non esistesse alcun bug, il codice sarebbe simile a questo, 86 byte:

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

C # Interactive, 77 67 byte

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

C # interattivo è dolce.

SmileBASIC, 29 byte

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

Gol> <> (Golfish), 17 byte

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

Provalo qui .

La riga superiore legge i caratteri ( i) fino a quando non trova una nuova riga (ASCII 10, a), quindi scende ( v).

Quindi scartiamo un carattere (la nuova riga) con ~, spingiamo la lunghezza della pila ( l), leggiamo un float ( I), moltiplichiamo i due e ripetutamente ( R) spingiamo il carattere ")" più volte. Infine, inverti lo stack ( r), emettilo e halt ( H).

PHP, 50 byte

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

accetta stringa e numero decimale come argomenti della riga di comando; taglia l'imbottitura. Corri con -r;

abbattersi

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

Rubino, 25 byte

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

Sto usando lambdas . Il programma di test sarebbe simile a:

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

Clojure, 68 byte

Una funzione anonima che accetta input decimali.

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

Letteralmente il primo programma Lisp che abbia mai scritto! Mi sto già divertendo.

C ++ 14, 43 byte

Come lambda senza nome che modifica il suo input, assumendo sè simile a std::string(has .append(int,char)e presupponendo pche sia di tipo a virgola mobile:

[](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 byte

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

Provalo online! Uso:"codegolf" ! 125

Una versione che accetta un numero decimale: (41 byte)

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

Provalo online! Uso:"codegolf" ! 1.25