Beaucoup d'entre vous ont peut-être déjà interagi avec des Russes russes sur Internet, et un sous-ensemble d'entre vous a peut-être remarqué la méthode un peu étrange dont ils disposent pour s'exprimer.

par exemple удали игру нуб)))

là où les )))sont ajoutés pour mettre l'accent sur l'énoncé précédent, j'ai travaillé sur une théorie selon laquelle le rapport de )'au reste de la chaîne est directement proportionnel à la quantité d'emphase implicite, bien que je trouve souvent difficile de calculer le rapport. à la volée, comme je tente également de faire face à une série d'abus, je voudrais donc le code le plus court possible pour m'aider à calculer ce que devrait être la chaîne résultante, pour une valeur d'enthousiasme comprise entre 0 et 500%, compte tenu de l'original , chaîne peu enthousiaste, cela facilitera grandement mes recherches car je n’aurai pas à taper des scripts volumineux à chaque fois que je souhaite tester mon hypothèse.

Alors, le challenge:

écrivez un programme complet ou une fonction qui, avec deux arguments, une chaîne de longueur inconnue et un nombre, au format entier (entre 0 et 500) ou au format décimal (entre 0 et 5, avec 2 points de précision)

• retourne / affiche la chaîne originale, suffixée d'un nombre de )'
• le nombre correspondra au rapport entre le nombre saisi et la longueur de la chaîne.
• Donc, si le nombre 200 ou 2.00 a été fourni, 200% de la chaîne doit être suffixé comme )'s
• le nombre de parenthèses arrondies à des décimales importe peu.
• Un script est requis pour prendre en charge les caractères ASCII imprimables.
• ne doit prendre en charge qu’un seul format numérique de votre choix.

Exemples:

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

Exemple de code (PowerShell) (avec entrée décimale):

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

C'est du code-golf, donc le code le plus court gagne!

Gelée , 7 octets

ȮL×Ċ”)x

Essayez-le en ligne!

Utilise le format décimal.

Comment?

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

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

Common Lisp, 59 52 50

Des parenthèses? Je suis dedans.

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

Détails

(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

Chaîne de contrôle de format

• ~a : joli argument d'impression (ici la chaîne donnée)
• ~v@{...~}: bloc d'itération, limité à V itération, où V est pris comme argument, à savoir l' (* ...)expression. L'itération est censée parcourir une liste, mais lorsque vous ajoutez le @modificateur, la liste est la liste d'arguments restante de la fonction de formatage. Il doit y avoir au moins un élément dans la liste itérée (sinon nous sortons, sans tenir compte de V). C'est pourquoi il existe un argument supplémentaire pour formater (0).

Comme aucun élément de la liste n'est consommé par le format, la boucle est infinie mais heureusement, elle est également délimitée par V, c'est-à-dire le nombre de parenthèses à imprimer.

Edit: merci à Michael Vehrs d’avoir fait remarquer qu’il n’était pas nécessaire d’arrondir l’argument numérique (la question permet de tronquer / arrondir comme on veut, donc le comportement par défaut fonctionne ici).

JavaScript ES6, 38 31 30 octets

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

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

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

Python 2 , 29 octets

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

s dans la chaîne, p est le pourcentage (entier).

Essayez-le en ligne!

05AB1E , 9 à 8 octets

g*ï')×¹ì

Essayez-le en ligne!

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

Fonctionne pour les nombres entier et décimal, ordre des arguments: f(String, Double)

Python, 30 octets

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

Utilise l’entrée décimale.

Essayez-le en ligne!

Pyth, 8 octets

*\)s*lpz

Test en ligne! Prend d'abord le taux d'excitation, puis la corde pour s'enthousiasmer.

Explication:

      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 octets

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

Essayez-le en ligne!

Prend en charge le format décimal.

R, 62 46 42 octets

Fonction anonyme qui prend des chaînes aet des décimales n, affiche la sortie sur stdout.

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

Pyth, 9 octets

*s*lpzE")

Prend deux lignes d’entrée: chaîne et ratio (décimal).

Essayez-le sur pyth.herokuapp.com

Explication

Adénote le premier argument d'une fonction, Bson second argument.

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

Prend une entrée décimale.

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

Perl 5, 29 octets

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

(Le nombre est le premier argument, la chaîne est la seconde.)

Essayez-le en ligne!

CJam , 9 octets

l_,ld*')*

Essayez-le en ligne!

Chaîne d'entrée sur la première ligne, rapport d'emphase compris entre 0 et 5 sur la seconde.

Explication

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 octets

yn*:"41h

Cette solution utilise la forme décimale de la deuxième entrée

Essayez-le en ligne!

Explication

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

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

A expliqué:

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

Les parenthèses sont fermées automatiquement

Voici la sortie du compilateur, si cela vous intéresse:

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

Cette version du compilateur a été écrite le 27/01/2017 à 23h12, soit quelques minutes après la publication de cette question. Voici donc une version qui fonctionne sur la version la plus ancienne du compilateur, écrite une heure plus tôt: iS$,N?S$;')'*(N*l(S$))(22 octets)

PostgreSQL, 102 octets

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

Détails

Utilise le format de saisie entier.

Ceci a simplement pour effet d'ajouter à la longueur cible la chaîne d'entrée avec des parens.

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

Appelé avec

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

Bash + coreutils, 45 octets

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

Essayez-le en ligne!

Entrée entière.

Groovy, 27 octets

Solution simple

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

Programme de test:

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

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

Rebol, 39 octets

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

Clojure, 40 octets

Solution assez ennuyeuse:

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

Réduit simplement la strfonction sur une liste de parenthèses fermantes avec une chaîne comme paramètre initial.

Voir en ligne: https://ideone.com/5jEgWS

Solution pas si ennuyeuse (64 octets):

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

Convertit la chaîne d'entrée à un symbole (pour se débarrasser des guillemets) et applique de façon répétée la fonction listsur elle générer suite infinie comme ceci: (a (a) ((a)) (((a))) ... ). L' nthélément Takes le convertit en chaîne et remplace toutes les parenthèses ouvrantes par rien.

Voir en ligne: https://ideone.com/C8JmaU

SimpleTemplate, 92 octets

Prend la chaîne en tant que premier paramètre et le "ratio" en tant que second.
Le rapport est compris entre 0 et 5, avec 2 décimales.

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

Comme vous pouvez le constater, ce n'est pas optimal.
Le 2 {echo}il pourrait être réduit à 1.
En raison d'un bogue dans le compilateur, ce code ne peut pas être réduit beaucoup plus loin.

Ungolfed:

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

Si aucun bug n’existait, le code ressemblerait à ceci, 86 octets:

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

C # Interactive, 77 à 67 octets

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

C # interactive est doux.

SmileBASIC, 29 octets

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

Gol> <> (Golfish), 17 octets

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

Essayez ici .

La ligne du haut lit les caractères ( i) jusqu'à trouver une nouvelle ligne (ASCII 10 a), puis diminue ( v).

Ensuite, nous ignorons un caractère (la nouvelle ligne) avec ~, poussons la longueur de la pile ( l), lisons un float ( I), multiplions les deux et répétons ( R) poussons le caractère ")" à plusieurs reprises. Enfin, inversez la pile ( r), sortez-la et arrêtez ( H).

PHP, 50 octets

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

prend une chaîne et un nombre décimal comme arguments de ligne de commande; coupe le rembourrage. Courez avec -r;

panne

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

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

J'utilise des lambdas . Le programme de test serait quelque chose comme:

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

Clojure, 68 octets

Une fonction anonyme qui accepte les entrées décimales.

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

Littéralement le premier programme Lisp que j'ai écrit! Je m'amuse déjà.

C ++ 14, 43 octets

Comme lambda sans nom modifie son entrée, supposant sest similaire à std::string(a .append(int,char)et supposant pêtre de type virgule flottante:

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

Usage:

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

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

Essayez-le en ligne! Usage:"codegolf" ! 125

Une version qui prend un nombre décimal: (41 octets)

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

Essayez-le en ligne! Usage:"codegolf" ! 1.25