Dadas 2 entradas, una cadena y un número decimal, genera la cadena multiplicada por ese número.

El problema es que el número puede ser flotante o entero.

Debería mostrar el floor(n)tiempo de cadena y luego las primeras floor((n-floor(n))*len(string))letras nuevamente.

Otras notas:

• La entrada no siempre será flotante, puede ser un int. Entonces 1.5, 1 y 1.0 son todos posibles. Sin embargo, siempre estará en la base 10, y si desea una excepción, por favor comente.
• La entrada de cadena puede contener espacios en blanco, comillas y otros caracteres. Sin embargo, no hay líneas nuevas ni caracteres de control.
• No hay incorporados para la repetición directa de cadenas, incluso 'a'*5se permite la multiplicación de cadenas como la pitón . Sin embargo, se permite la adición de cadenas .

Casos de prueba:

La coma y el espacio separan las entradas.

test case, 1 -> test case

case, 2.5 -> casecaseca

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

cats >= dogs, 0.5 -> cats >

Nota final:

Estoy viendo muchas respuestas que usan funciones de multiplicación o repetición de cadenas incorporadas. Esto no esta permitido. Sin embargo, la respuesta de @ VTC es válida, ya que no multiplica la cadena, solo la entrada flotante. Entonces, la regla definitiva es: si multiplica directamente la cadena, no puede hacerlo.

Jalea, 5 bytes

×L}Rị

No utiliza una repetición incorporada. Pruébalo en línea!

Cómo funciona

×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]);}

toma char [] y float y sale a STDOUT. bucle básico.

Pyth 9 9 8

s@Lz*lzQ

Guardado 1 byte gracias a Pietu1998

Esto toma floor(n * len(string))letras de la cadena, usando indexación cíclica. Creo que esto siempre es equivalente a la fórmula dada.

Banco de pruebas

JavaScript (ES6), 50 bytes

Edite 2 bytes más para incluir la definición de la función f. 1 byte menos con la punta de @manatwork. Nota: usando ~tenemos más iteraciones de las necesarias, pero esto es código de golf e incluso recuentos de 1 byte

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

PRUEBA

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 bytes

Espera que la palabra sea un argumento y que el número se multiplique por 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.

Pruébalo en línea!

CJam, 10 bytes

l_,l~*,\f=

La cadena se suministra en la primera línea de STDIN, el flotante en la segunda.

Pruébalo aquí.

Explicación

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 bytes

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

Pruébalo aquí!

Crea una lambda sin nombre que toma la cadena como primer argumento y el flotante como segundo. Devuelve la cadena repetida.

Esto podría ser 46 si se permitieran las repeticiones de cadenas integradas :(

Ruby, 49 48 caracteres

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

Ejecución de muestra:

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 bytes

{([~] $^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 tiene un operador de repetición de cadena xy un operador de repetición de lista xx.

Como las reglas no permiten la repetición de cadenas, la repetimos como si fuera una lista de un solo elemento. Luego, la lista se concatena y se devuelve una subcadena.

Uso:

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

Oh, mis días, esto es peor de lo que pensaba.

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

Devuelve el valor de la cadena, otra respuesta usando indexación cíclica. Espera entrada como "string" "repetitions".

Haskell, 44 bytes

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

Ejemplo de uso: "(will add more later)" # 0.3333-> "(will ".

Cómo funciona: cconcatena infinitas copias de la cadena x. Se comporta como el incorporado cycle. sum[1|a<-s]es una función de longitud personalizada que funciona con el sistema de tipo estricto de Haskell, ya que devuelve un Double(el incorporado lengthdevuelve un Intque no se puede multiplicar n). #toma floor (n * length(s))caracteres de la cadena cíclica s.

PHP 5, 96 87

9 bytes guardados gracias a @manatwork

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

Respuesta en bucle bastante directa.

Sin golf

<?
$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 bytes

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

Como una función sin nombre. Esto usa charToRaw para dividir la cadena en un vector de raws. Esto se llena en una matriz de longitud * l, convertida de nuevo a char y salida.
Iba a usar strsplit, pero terminó siendo más largo.

Prueba

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

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

Se requiere: -n, -ly -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 >

Explicación:

$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 (macro preprocesador), 71

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

No es muy complicado aquí. Solo necesito asegurarmel*m esté emitido intantes de comparar j.

Pruébalo en línea.

Oracle SQL 11.2, 154 152 bytes

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;

Sin golf

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;

Seguí el camino recursivo, con la selección de inicialización cuidando la parte decimal.

Guardado 2 bytes gracias a @MickyT

En serio, 24 bytes

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

Pruébalo en línea!

Explicación:

,╗,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 bytes

V*Elzp@zN

Básicamente solo haciendo

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