Biorąc pod uwagę 2 dane wejściowe, ciąg i liczbę dziesiętną, wyprowadza ciąg pomnożony przez tę liczbę.

Połów polega na tym, że liczba może być liczbą zmiennoprzecinkową lub liczbą całkowitą.

Powinieneś wypisać floor(n)czas łańcucha, a następnie floor((n-floor(n))*len(string))ponownie pierwsze litery.

Inne notatki:

• Dane wejściowe nie zawsze będą zmiennoprzecinkowe, może być liczbą całkowitą. Tak więc wszystkie 1,5, 1 i 1,0 są możliwe. Zawsze będzie jednak w bazie 10, a jeśli chcesz wyjątek, prosimy o komentarz.
• Dane wejściowe ciągu mogą zawierać białe znaki, cudzysłowy i inne znaki. Jednak nie ma nowych linii ani znaków kontrolnych.
• Żadne wbudowane funkcje bezpośredniego powtarzania ciągów, nawet mnożenie ciągów, takie jak python, 'a'*5są niedozwolone. Dozwolone jest jednak dodawanie ciągów .

Przypadki testowe:

Przecinek i spacja oddzielają dane wejściowe.

test case, 1 -> test case

case, 2.5 -> casecaseca

(will add more later), 0.3333 -> (will(space)

cats >= dogs, 0.5 -> cats >

Uwaga końcowa:

Widzę wiele odpowiedzi, które wykorzystują wbudowane funkcje mnożenia lub powtarzania ciągów. To jest nie dozwolone. Odpowiedź @ VTC jest jednak ważna, ponieważ nie zwielokrotnia ciągu, a jedynie dane zmiennoprzecinkowe. Ostateczna zasada brzmi: jeśli bezpośrednio zwielokrotnia ciąg, nie możesz tego zrobić.

Galaretka, 5 bajtów

×L}Rị

Nie używa wbudowanego powtarzania. Wypróbuj online!

Jak to działa

×L}Rị  Main link. Left input: n (multiplier). Right input: S (string)

 L}    Yield the length of S.
×      Multiply it with n.
   R   Range; turn n×len(S) into [1, ... floor(n×len(S))].
    ị  Retrieve the elements of S at those indices.
       Indices are 1-based and modular in Jelly, so this begins with the first and
       jump back after reaching the last.

Java 7, 89

void g(char[]a,float b){for(int i=0,l=a.length;i<(int)(l*b);)System.out.print(a[i++%l]);}

pobiera char [] i float i wypisuje do STDOUT. podstawowe zapętlenie.

Pyth 9 8

s@Lz*lzQ

Zaoszczędzono 1 bajt dzięki Pietu1998

Pobiera floor(n * len(string))litery z ciągu, używając cyklicznego indeksowania. Uważam, że zawsze jest to równoważne z podaną formułą.

Pakiet testowy

JavaScript (ES6), 50 bajtów

Edytuj jeszcze 2 bajty, aby uwzględnić definicję funkcji f. 1 bajt mniej przy użyciu końcówki @manatwork. Uwaga: przy użyciu ~mamy więcej iteracji niż to konieczne, ale jest to kod golfowy, a nawet 1 bajt się liczy

f=(s,n,l=s.length*n)=>~n?f(s+s,n-1,l):s.slice(0,l)

TEST

f=(s,n,l=s.length*n)=>~n?f(s+s,n-1,l):s.slice(0,l)

//TEST
console.log=x=>O.textContent+=x+'\n'
;[
 ['test case', 1, 'test case'],
 ['case', 3.5, 'casecasecaseca'],
 ['(will add more later)', 0.3333, '(will '],
 ['cats >= dogs', 0.5, 'cats >']]
.forEach(t=>{
  var s=t[0],n=t[1],x=t[2],r=f(s,n);
  console.log("«"+s+"» "+n+' => «'+r+'» '+(x==r?'OK':'FAIL expected '+x));
 })

<pre id=O></pre>

Vitsy, 9 bajtów

Oczekuje, że słowo to będzie argumentem, a liczba zostanie pomnożona przez STDIN.

zlW*\[DO{]
z          Grab all string argument input.
 l         Get the length of the stack.
  W        Parse STDIN.
   *       Multiply the top two items (length of string and the number of repetitions)
    \[   ] Do the stuff in the loop.
      DO{  Output one char at a time, making sure to duplicate first.

Wypróbuj online!

CJam, 10 bajtów

l_,l~*,\f=

Ciąg jest dostarczany w pierwszym wierszu STDIN, liczba zmiennoprzecinkowa w drugim.

Sprawdź to tutaj.

Wyjaśnienie

l    e# Read string.
_,   e# Duplicate and get its length.
l~   e# Read second line and evaluate.
*    e# Multiply them. If the result, N, was floored it would give us the number of
     e# characters in the required output.
,    e# Get range [0 1 ... ⌊N⌋-1].
\f=  e# For each character in that range, fetch the corresponding character from the
     e# string using cyclic indexing.

Python 2, 71 bajtów

lambda s,x:"".join(s for i in range(int(x)))+s[:int(len(s)*(x-int(x)))]

Wypróbuj tutaj!

Tworzy nienazwaną lambda, która przyjmuje ciąg jako pierwszy argument, a zmienną jako drugi. Zwraca ciąg znaków.

Może to być 46, jeśli dozwolone są wbudowane powtórzenia ciągów :(

Ruby, 49 48 znaków

->s,n{(0...(n*l=s.size).to_i).map{|i|s[i%l]}*''}

Przykładowy przebieg:

2.1.5 :001 > ->s,n{(0...(n*l=s.size).to_i).map{|i|s[i%l]}*''}['case', 2.5]
 => "casecaseca" 

Perl 6 ,  46 41   39 bajtów

{([~] $^a xx$^b)~$a.substr(0,$a.chars*($b%1))}    # 46 bytes
{substr ([~] $^a xx$^b+1),0,$a.chars*$^b}         # 41 bytes
{substr ([~] $^a xx$^b+1),0,$a.comb*$b}           # 39 bytes

Perl 6 ma zarówno operator powtarzania łańcucha, jak xi operator powtarzania listy xx.

Ponieważ reguły nie zezwalają na powtarzanie ciągów, powtarzamy je tak, jakby to była lista pojedynczych elementów. Następnie lista jest łączona razem i zwracany jest jej podłańcuch.

Stosowanie:

# give it a lexical name
my &code = {substr ([~] $^a xx$^b+1),0,$a.chars*$^b}
#          {substr ($^a x$^b+1),0,$a.chars*$^b}

say code('test case', 1).perl;                  # "test case"
say code('case', 2.5).perl;                     # "casecaseca"
say code('(will add more later)', 0.3333).perl; # "(will "
say code('cats >= dogs', 0.5).perl;             # "cats >"

osascript, 173 bajtów

Och, moje dni, to jest gorsze niż myślałem.

on run a
set x to a's item 1's characters
set y to a's item 2
set o to""
set i to 1
set z to x's items's number
repeat y*z
set o to o&x's item i
set i to i mod z+1
end
o
end

Zwraca wartość ciągu, kolejna odpowiedź przy użyciu cyklicznego indeksowania. Oczekuje danych wejściowych jako"string" "repetitions" .

Haskell, 44 bajty

c x=x++c x
s#n=take(floor$n*sum[1|a<-s])$c s

Przykład użycia: "(will add more later)" # 0.3333 -> "(will ".

Jak to działa: cłączy nieskończone kopie ciągu x. Zachowuje się jak wbudowany cycle. sum[1|a<-s]jest funkcją o niestandardowej długości, która działa z systemem ścisłego typu Haskella, ponieważ zwraca a Double(wbudowane lengthzwraca an, z Intktórym nie można pomnożyć n). #pobiera floor (n * length(s))znaki z cyklicznego ciągu znaków s.

PHP 5, 96 87

9 bajtów zapisanych dzięki @manatwork

<?for($i=$z=0;$i++<floor(strlen($a=$argv[1])*$argv[2]);$z++)echo$a[$z]?:$a[$z=0‌​];

Dość prosta, zapętlona odpowiedź.

Nie golfił

<?
$a=$argv[1];
$z=0;
for($i=0; $i < floor(strlen($a)*$argv[2]); $i++) {
    // if the string offset is not set
    // then reset $z back to 0 so we can
    // echo the beginning of ths string again
    @$a[$z] ?: $z=0;
    echo $a[$z];
    $z++;
}

R, 59 bajtów

function(s,l)cat(rawToChar(array(charToRaw(s),nchar(s)*l)))

Jako funkcja bez nazwy. Używa charToRaw do podzielenia łańcucha na wektor raws. Jest to wypełnione do tablicy o długości * l, przekonwertowanej z powrotem na char i wyjście.
Zamierzałem użyć strsplit, ale skończyło się to na dłuższym czasie.

Test

> f=
+ function(s,l)cat(rawToChar(array(charToRaw(s),nchar(s)*l)))
> f('test case', 1) # -> test case
test case
> f('case', 2.5) # -> casecaseca
casecaseca
> f('(will add more later)', 0.3333) # -> (will(space)
(will 
> f('cats >= dogs', 0.5) # -> cats >
cats >
> 

Perl, 51 + 3 = 54 bajtów

$l=<>*y///c;for$i(1..$l){push@a,/./g}say@a[0..$l-1]

Wymaga: -n, -li -M5.010|-E:

 $ perl -nlE'$l=<>*y///c;for$i(1..$l){push@a,/./g}say@a[0..$l-1]' <<< $'test case\n1'
 test case
 $ perl -nlE'$l=<>*y///c;for$i(1..$l){push@a,/./g}say@a[0..$l-1]' <<< $'case\n2.5'
 casecaseca
 $ perl -nlE'$l=<>*y///c;for$i(1..$l){push@a,/./g}say@a[0..$l-1]' <<< $'(will add more later)\n0.3333'
 (will 
 $ perl -nlE'$l=<>*y///c;for$i(1..$l){push@a,/./g}say@a[0..$l-1]' <<< $'cats >= dogs\n0.5'
 cats >

Wyjaśnienie:

$l=<>*y///c;              # Calculate output length (eg. 2.5 * input length)
for$i(1..$l){push@a,/./g} # Push a lot of chars from input into @a
say@a[0..$l-1]            # Slice @a according to output length

c (makro preprocesora), 71

j,l;
#define f(s,m) l=strlen(s);for(j=0;j<(int)(l*m);)putchar(s[j++%l])

Nie jest to zbyt trudne. Przed porównaniem musisz upewnić się, że l*mzostał on przeniesiony na „an” .intj

Wypróbuj online.

Oracle SQL 11.2, 154 152 bajty

WITH v(s,i)AS(SELECT SUBSTR(:1,1,FLOOR(FLOOR((:2-FLOOR(:2))*LENGTH(:1)))),1 FROM DUAL UNION ALL SELECT :1||s,i+1 FROM v WHERE i<=:2)SELECT MAX(s)FROM v;

Nie grał w golfa

WITH v(s,i) AS
(
  SELECT SUBSTR(:1,1,FLOOR(FLOOR((:2-FLOOR(:2))*LENGTH(:1)))),1 FROM DUAL 
  UNION ALL 
  SELECT :1||s,i+1 FROM v WHERE i<=:2
)
SELECT MAX(s) FROM v;

Poszedłem rekurencyjnie, z wyborem inicjalizacji dbającym o część dziesiętną.

Zaoszczędź 2 bajty dzięki @MickyT

Poważnie, 24 bajty

,╗,mi@≈╜n╜l(*≈r`╜E`MΣ)kΣ

Wypróbuj online!

Wyjaśnienie:

,╗,mi@≈╜n╜l(*≈r`╜E`MΣ)kΣ
,╗                        get first input (string) and push it to register 0
  ,mi@≈                   get input 2 (x), push frac(x) (f), int(x) (n)
       ╜n                 push n copies of the string
         ╜l(*≈            push length of string, multiply by f, floor (substring length) (z)
              r`╜E`MΣ     push s[:z]
                     )kΣ  move fractional part of string to bottom, concat entire stack

Pyth, 9 bajtów

V*Elzp@zN

Zasadniczo po prostu robię

             z = input()
V*Elz        for N in range(evaluatedInput()*len(z)):    # flooring is automatic
     p@zN        print(z[N], end="")                     # modular indexing