Birçoğunuz bir yerden internetten Rusya'dan gelen insanlarla etkileşime girmiş olabilirsiniz ve bir altkümeniz, kendilerini ifade etmeleri gereken garip bir yöntemi fark etmiş olabilirsiniz.

Örneğin удали игру нуб)))

nerede )))önceki ekstresinde vurgu için eklenir, ben oranının bir teorisi üzerine çalışıyor olması )ancak çoğu zaman zor oranını hesaplamak bulmak, dize geri kalanına s' zımni vurgu miktarı ile doğru orantılıdır Bir miktar suistimalle başa çıkmaya çalıştığım için, orjinal verilen% 0 ile% 500 arasındaki bir coşkunun değeri için, ortaya çıkan dizenin ne olacağını hesaplamama yardımcı olacak en kısa kodun olmasını istiyorum. hevessiz bir dize, bu, hipotezimi her test etmek istediğimde hacimli senaryolar yazmam gerekmeyeceğinden araştırmama büyük ölçüde yardımcı olacak.

Yani, meydan okuma:

tam argüman biçiminde (0 ile 500 arasında) veya ondalık biçimde (0 ile 5 arasında, 2 doğruluk noktasıyla) iki argüman, uzunluğu bilinmeyen bir dize ve sayı içeren tam bir program veya işlev yazın.

• İade / bir numarası eklenir orijinal dize, görüntülemek )'s
• sayı, giriş sayısının dize uzunluğuna oranı olarak hesaplanır.
• bu yüzden, 200 veya 2.00 sayısı sağlanmışsa, dizginin% 200'ü, )'
• ondalık durumlarda yuvarlanmış parantezlerin sayısı önemli değildir.
• Yazdırılabilir ASCII karakterlerini desteklemek için komut dosyası gerekir.
• Seçtiğiniz yalnızca bir giriş numarası biçimini desteklemelidir.

Örnekler:

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

Örnek kod (PowerShell) (ondalık girişle):

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

Bu kod golf yani en kısa kod kazanır!

Jöle , 7 bayt

ȮL×Ċ”)x

Çevrimiçi deneyin!

Ondalık formatı kullanır.

Nasıl?

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

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

Ortak Lisp, 59 52 50

Parantez? Ben varım

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

ayrıntılar

(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

Kontrol dizesini biçimlendir

• ~a : pretty print argümanı (burada verilen dize)
• ~v@{...~}: V argümanı olarak (* ...)ifade edilen V ifadesiyle sınırlı olan yineleme bloğu, yani ifade. Yinelemenin bir liste üzerinde yinelenmesi gerekir, ancak @değiştiriciyi eklediğinizde , liste biçim işlevinin argüman listesidir. Yinelenen listede en az bir öğe bulunmalıdır (aksi takdirde V'yi göz ardı ederek çıkarız). Bu yüzden (0) formatına ek bir argüman var.

Listedeki hiçbir öğe format tarafından tüketilmediğinden, döngü sonsuzdur ancak neyse ki, V, yani yazdırılacak parantezlerin sayısı da sınırlıdır.

Düzenleme: Michael Vehrs'a sayısal argümanı yuvarlamanın gerekmediğine dikkat çektiği için teşekkür ederiz (soru istediğimiz gibi kesmeye / yuvarlamaya izin verir, bu nedenle varsayılan davranış burada işe yarar).

JavaScript ES6, 38 31 30 bayt

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

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

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

Python 2,29 bayt

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

Dize s , p yüzdesi (tamsayı).

Çevrimiçi deneyin!

05AB1E , 9 8 bayt

g*ï')×¹ì

Çevrimiçi deneyin!

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

Hem tamsayı hem de ondalık sayı için çalışır, argüman sırası: f(String, Double)

Python, 30 bayt

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

Ondalık girişi kullanır.

Çevrimiçi deneyin!

Pyth, 8 bayt

*\)s*lpz

Çevrimiçi Test! Önce heyecan oranını, ardından merak uyandırılan dizeyi alır.

Açıklama:

      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 bayt

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

Çevrimiçi deneyin!

Ondalık formatı destekler.

R, 62 46 42 bayt

Dize ave ondalık alan adsız işlev, nçıktıyı stdout'a yazdırır.

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

Pyth, 9 bayt

*s*lpzE")

İki satır girdi alır: string ve oran (ondalık).

Pyth.herokuapp.com adresinde deneyin

açıklama

Abir işlevin ilk argümanı, Bikinci argümanı belirtir .

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

Ondalık giriş alır.

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

Perl 5, 29 bayt

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

(Sayı birinci arg, dize ikinci.)

Çevrimiçi deneyin!

CJam , 9 bayt

l_,ld*')*

Çevrimiçi deneyin!

İlk satırdaki girdi dizesi, ikinci sıradaki 0-5 aralığında vurgu oranı.

açıklama

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 bayt

yn*:"41h

Bu çözüm ikinci girişin ondalık biçimini kullanır

Çevrimiçi deneyin!

açıklama

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

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

Açıklaması:

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

Parantezler otomatik olarak kapatılır.

İşte ilgileniyorsanız, derleyicinin çıktısı:

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

Derleyicinin bu sürümü, bu soruyu yayınladıktan birkaç dakika sonra olabilir, 11: 12'de 11: 27'de 17: 17'de yazılmıştır. İşte derleyicinin en eski sürümünde çalışan, bir saat önce yazılmış bir sürüm: iS$,N?S$;')'*(N*l(S$))(22 bayt)

PostgreSQL, 102 bayt

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

ayrıntılar

Tamsayı giriş biçimini kullanır.

Bu, giriş dizesini hedef uzunluğa kadar parensli olarak sağa doldurur.

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

Denilen

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

Bash + coreutils, 45 bayt

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

Çevrimiçi deneyin!

Tamsayı girişi.

Groovy, 27 bayt

Basit çözüm

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

Test programı :

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

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

Rebol, 39 bayt

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

Clojure, 40 bayt

Oldukça sıkıcı çözüm:

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

Sadece strbaşlangıç ​​parametresi olarak bir dizge ile parantez kapatma listesindeki işlevi azaltır .

Çevrimiçi görün: https://ideone.com/5jEgWS

Çok sıkıcı olmayan bir çözüm (64 bayt):

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

(Tırnak kurtulmak için) bir sembol giriş dizesini dönüştürür ve defalarca fonksiyonunu uygular listböyle sonsuz dizisini üreten üzerine: (a (a) ((a)) (((a))) ... ). Takes nthelemanı onu string'e dönüştürür ve tüm açılış parantezlerini hiçbir şey ile değiştirir.

Çevrimiçi görün: https://ideone.com/C8JmaU

SimpleTemplate, 92 bayt

Dizeyi ilk parametre olarak alır ve "oran" ı ikinci olarak alır.
Oran, 0 ile 5 arasındadır ve 2 ondalık basamağa sahiptir.

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

Gördüğünüz gibi, optimal değil.
Buradaki 2 {echo}, 1'e düşürülebilir.
Derleyicideki bir hata nedeniyle bu kod daha fazla azaltılamaz.

Ungolfed:

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

Hata yoksa, kod şöyle görünür, 86 bayt:

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

C # Etkileşimli, 77 67 bayt

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

C # etkileşimli tatlıdır.

SmileBASIC, 29 bayt

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

Gol> <> (Golfish), 17 bayt

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

Burada dene .

Üst satır i, yeni bir satır bulana dek karakterleri ( ) okur (ASCII 10, a), sonra da gider ( v).

Sonra bir karakteri (yeni satırı) atıyoruz ~, yığının uzunluğunu ( l) itiyoruz, bir float ( I) okuyoruz , ikisini çarpıyoruz ve tekrar tekrar ( R) ")" karakterini defalarca basıyoruz. Son olarak, yığını ( r) tersten çevirin, çıkarıp durdurun ( H).

PHP, 50 bayt

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

dize ve ondalık sayıyı komut satırı argümanları olarak alır; dolgu keser. Çalıştır -r;

Yıkmak

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

Yakut, 25 bayt

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

Lambda kullanıyorum . Test programı şöyle bir şey olurdu:

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

Clojure, 68 bayt

Ondalık girişi kabul eden adsız bir işlev.

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

Kelimenin tam anlamıyla, şimdiye kadar yazdığım ilk Lisp programı! Ben zaten eğleniyorum.

C ++ 14,43 bayt

Adlandırılmamış lambda girdisini değiştirdiği için, varsayımın sbenzer olduğunu std::string( kayan nokta türüne sahip olduğunu .append(int,char)varsayarsak) p:

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

Kullanımı:

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

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

Çevrimiçi deneyin! Kullanımı:"codegolf" ! 125

Ondalık sayı alan bir sürüm: (41 bayt)

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

Çevrimiçi deneyin! Kullanımı:"codegolf" ! 1.25