Viele von Ihnen haben vielleicht irgendwann im Internet mit Menschen aus Russland interagiert, und eine Untergruppe von Ihnen hat vielleicht die etwas seltsame Methode bemerkt, sich auszudrücken.

z.B удали игру нуб)))

Wo die )))zur Betonung der vorherigen Aussage hinzugefügt wurden, habe ich an einer Theorie gearbeitet, die besagt, dass das Verhältnis von )'s zum Rest der Zeichenkette direkt proportional zur implizierten Betonung ist, aber ich finde es oft schwierig, das Verhältnis zu berechnen Da ich auch im Fluge versuche, mit einer Menge Missbrauch umzugehen, möchte ich den kürzestmöglichen Code, um zu berechnen, wie die resultierende Zeichenfolge laut Original aussehen soll, für einen Wert der Begeisterung zwischen 0 und 500% Dies erleichtert meine Recherche erheblich, da ich nicht jedes Mal, wenn ich meine Hypothese testen möchte, umfangreiche Skripte abtippen muss.

Die Herausforderung:

Schreiben Sie ein vollständiges Programm oder eine Funktion, die mit zwei Argumenten, einer Zeichenfolge unbekannter Länge und einer Zahl entweder im Ganzzahlformat (zwischen 0 und 500) oder im Dezimalformat (zwischen 0 und 5, mit 2 Genauigkeitspunkten) arbeitet

• Geben Sie die ursprüngliche Zeichenfolge mit den Suffixen )'s zurück bzw. zeigen Sie sie an
• Die Zahl wird als Verhältnis der eingegebenen Zahl zur Länge der Zeichenfolge berechnet.
• Wenn also die Zahl 200 oder 2.00 angegeben wurde, müssen 200% der Zeichenfolge mit dem Suffix )'s' versehen werden
• Die Anzahl der Klammern, auf die in Dezimalsituationen gerundet wird, spielt keine Rolle.
• Skript ist erforderlich, um druckbare ASCII-Zeichen zu unterstützen.
• Es muss nur ein Eingabezahlenformat Ihrer Wahl unterstützt werden.

Beispiele:

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

Beispielcode (PowerShell) (mit Dezimaleingabe):

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

Das ist Code-Golf, also gewinnt der kürzeste Code!

Gelee , 7 Bytes

ȮL×Ċ”)x

Probieren Sie es online!

Verwendet das Dezimalformat.

Wie?

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

Gemeines Lisp, 59 52 50

Klammern? Ich bin dabei.

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

Einzelheiten

(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

Formatieren Sie die Steuerzeichenfolge

• ~a : hübsches Druckargument (hier der angegebene String)
• ~v@{...~}: Iterationsblock, beschränkt auf V-Iteration, wobei V als Argument verwendet wird, nämlich der (* ...)Ausdruck. Die Iteration soll eine Liste durchlaufen, aber wenn Sie den @Modifikator hinzufügen , ist die Liste die verbleibende Liste der Argumente für die Formatfunktion. Es muss mindestens ein Element in der iterierten Liste vorhanden sein (ansonsten beenden wir, ohne V zu berücksichtigen). Aus diesem Grund gibt es ein zusätzliches Argument für format (0).

Da kein Element in der Liste vom Format belegt wird, ist die Schleife unendlich, aber glücklicherweise wird sie auch durch V begrenzt, auch bekannt als die Anzahl der zu druckenden Klammern.

Edit: danke an Michael Vehrs für den Hinweis, dass das numerische Argument nicht gerundet werden muss (die Frage erlaubt das Abschneiden / Abrunden, wie wir wollen, daher funktioniert das Standardverhalten hier).

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 in der Zeichenfolge ist p der Prozentsatz (Ganzzahl).

Probieren Sie es online!

05AB1E , 9 8 Bytes

g*ï')×¹ì

Probieren Sie es online!

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

Funktioniert sowohl für Ganzzahlen als auch für Dezimalzahlen, Argumentreihenfolge: f(String, Double)

Python, 30 Bytes

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

Verwendet die Dezimaleingabe.

Probieren Sie es online!

Pyth, 8 Bytes

*\)s*lpz

Online-Test! Erst das Aufregungsverhältnis, dann die Saite, über die man sich begeistern kann.

Erläuterung:

      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)

Probieren Sie es online!

Unterstützt das Dezimalformat.

R 62 46 42 Bytes

Anonyme Funktion, die Zeichenfolge aund Dezimalzahl verwendet n, druckt die Ausgabe auf stdout.

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

Pyth, 9 Bytes

*s*lpzE")

Nimmt zwei Eingabezeilen auf: String und Ratio (dezimal).

Probieren Sie es auf pyth.herokuapp.com

Erläuterung

Abezeichnet das erste Argument einer Funktion, Bihr zweites 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 Bytes

Übernimmt die Dezimaleingabe.

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

(Zahl ist erstes Argument, Zeichenfolge ist zweites.)

Probieren Sie es online!

CJam , 9 Bytes

l_,ld*')*

Probieren Sie es online!

Geben Sie die Zeichenfolge in der ersten Zeile ein und das Betonungsverhältnis in der zweiten Zeile zwischen 0 und 5.

Erläuterung

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

Diese Lösung verwendet die Dezimalform der zweiten Eingabe

Probieren Sie es online!

Erläuterung

        % 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(\

Erklärt:

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

Klammern werden automatisch geschlossen

Hier ist die Ausgabe des Compilers, wenn Sie interessiert sind:

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

Diese Version des Compilers wurde am 27.01.2017 um 23:12 Uhr geschrieben, möglicherweise ein paar Minuten nachdem diese Frage gestellt wurde. Hier ist eine Version, die mit der ältesten Version des Compilers funktioniert, die eine Stunde früher geschrieben wurde: 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

Einzelheiten

Verwendet das ganzzahlige Eingabeformat.

Dies füllt die Eingabezeichenfolge einfach mit der rechten Maustaste mit Parens auf die Ziellänge aus.

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

Angerufen mit

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

Probieren Sie es online!

Ganzzahleingabe.

Groovy, 27 Bytes

Einfache Lösung

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

Testprogramm :

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

Ziemlich langweilige Lösung:

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

Reduziert einfach die strFunktion in einer Liste schließender Klammern mit einem String als Anfangsparameter.

Sehen Sie es online: https://ideone.com/5jEgWS

Nicht so langweilige Lösung (64 Bytes):

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

Konvertiert die Eingabezeichenfolge in ein Symbol (um Anführungszeichen zu entfernen) und wendet die Funktion wiederholt darauf listan (a (a) ((a)) (((a))) ... ). Takes nthElement konvertiert es in einen String und ersetzt alle öffnenden Klammern durch nichts.

Sehen Sie es online: https://ideone.com/C8JmaU

SimpleTemplate, 92 Byte

Nimmt den String als ersten Parameter und das "Verhältnis" als zweiten.
Das Verhältnis liegt zwischen 0 und 5 mit 2 Dezimalstellen.

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

Wie Sie sehen, ist es nicht optimal.
Die 2 {echo}dort könnte auf 1 reduziert werden.
Aufgrund eines Fehlers im Compiler kann dieser Code nicht weiter reduziert werden.

Ungolfed:

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

Wenn kein Fehler vorhanden wäre, würde der Code wie folgt aussehen: 86 Bytes:

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

C # Interactive, 77 67 Bytes

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

C # interactive ist süß.

SmileBASIC, 29 Bytes

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

Gol> <> (Golf), 17 Bytes

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

Probieren Sie es hier aus .

In der obersten Zeile werden die Zeichen ( i) gelesen, bis eine neue Zeile gefunden wird (ASCII 10, a). Anschließend wird die Zeile nach unten verschoben ( v).

Dann verwerfen wir ein Zeichen (die Newline) mit ~, drücken die Länge des Stapels ( l), lesen ein Float ( I), multiplizieren die beiden und Rdrücken das Zeichen ")" so oft wie nötig . Zum Schluss kehren Sie den Stack um ( r), geben ihn aus und stoppen ihn ( H).

PHP, 50 Bytes

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

Nimmt Zeichenfolge und Dezimalzahl als Befehlszeilenargumente. schneidet Polsterung. Laufen mit -r;

Nervenzusammenbruch

<?=                     // 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)}

Ich benutze Lambdas . Das Testprogramm würde ungefähr so ​​aussehen:

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

Clojure, 68 Bytes

Eine anonyme Funktion, die Dezimaleingaben akzeptiert.

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

Buchstäblich das erste Lisp-Programm, das ich je geschrieben habe! Ich hab schon spaß

C ++ 14, 43 Bytes

Als unbenanntes Lambda, das seine Eingabe modifiziert, wird angenommen, dass ses ähnlich zu std::string(hat .append(int,char)und pvom Fließkommatyp ist:

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

Verwendungszweck:

#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]>>")")

Probieren Sie es online! Verwendungszweck:"codegolf" ! 125

Eine Version, die eine Dezimalzahl annimmt: (41 Bytes)

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

Probieren Sie es online! Verwendungszweck:"codegolf" ! 1.25