Étant donné 2 entrées, une chaîne et un nombre décimal, sortez la chaîne multipliée par ce nombre.

Le hic, c'est que le nombre peut être un flottant ou un entier.

Vous devez sortir l' floor(n)heure de la chaîne , puis à nouveau les premières floor((n-floor(n))*len(string))lettres.

Autres notes:

• L'entrée ne sera pas toujours un flottant, elle peut être un entier. Donc, 1.5, 1 et 1.0 sont tous possibles. Cependant, il sera toujours en base 10, et si vous souhaitez une exception, veuillez commenter.
• L'entrée de chaîne peut contenir des espaces, des guillemets et d'autres caractères. Pas de nouvelles lignes ni de caractères de contrôle.
• Aucune fonction intégrée pour la répétition directe de chaînes, même la multiplication de chaînes comme le python 'a'*5n'est autorisée. Cependant, l' ajout de chaînes est autorisé.

Cas de test:

La virgule et l'espace séparent les entrées.

test case, 1 -> test case

case, 2.5 -> casecaseca

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

cats >= dogs, 0.5 -> cats >

Note finale:

Je vois beaucoup de réponses qui utilisent des fonctions de multiplication ou de répétition de chaînes intégrées. Ce n'est pas permis. La réponse de @ VTC est cependant valide, car elle ne multiplie pas la chaîne, seule l'entrée flottante. La règle définitive est donc la suivante: s'il multiplie directement la chaîne, vous ne pouvez pas le faire.

Gelée, 5 octets

×L}Rị

N'utilise pas de répétition intégrée. Essayez-le en ligne!

Comment ça fonctionne

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

prend char [] et flotte et sort vers STDOUT. boucle de base.

Pyth, 9 8

s@Lz*lzQ

1 octet enregistré grâce à Pietu1998

Cela prend des floor(n * len(string))lettres de la chaîne, en utilisant l'indexation cyclique. Je crois que cela équivaut toujours à la formule donnée.

Suite de tests

JavaScript (ES6), 50 octets

Modifiez 2 octets de plus pour inclure la définition de la fonction f. 1 octet de moins en utilisant la pointe de @manatwork. Remarque: en utilisant, ~nous avons plus d'itérations que nécessaire, mais c'est le code golf et même 1 octet.

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

TESTER

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 octets

Attend le mot comme argument et le nombre à multiplier par 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.

Essayez-le en ligne!

CJam, 10 octets

l_,l~*,\f=

La chaîne est fournie sur la première ligne de STDIN, le flotteur sur la seconde.

Testez-le ici.

Explication

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 octets

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

Essayez-le ici!

Crée un lambda sans nom qui prend la chaîne comme premier argument et le flottant comme deuxième. Renvoie la chaîne répétée.

Cela pourrait être 46 si les commandes de répétition de chaîne étaient autorisées :(

Ruby, 49 48 caractères

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

Exemple d'exécution:

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 octets

{([~] $^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 possède à la fois un opérateur de répétition de chaîne xet un opérateur de répétition de liste xx.

Étant donné que les règles interdisent la répétition de chaînes, nous la répétons comme s'il s'agissait d'une seule liste d'éléments à la place. Ensuite, la liste est concaténée ensemble, et une sous-chaîne de celle-ci est renvoyée.

Usage:

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

Oh mes jours, c'est pire que ce que je pensais.

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

Renvoie la valeur de la chaîne, une autre réponse utilisant l'indexation cyclique. Attend l'entrée en tant que "string" "repetitions".

Haskell, 44 octets

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

Exemple d'utilisation: "(will add more later)" # 0.3333-> "(will ".

Comment ça marche: cconcatène des copies infinies de la chaîne x. Il se comporte comme le intégré cycle. sum[1|a<-s]est une fonction de longueur personnalisée qui fonctionne avec le système de type strict de Haskell car elle renvoie un Double(le intégré lengthrenvoie un Intqui ne peut pas être multiplié avec n). #prend des floor (n * length(s))caractères de la chaîne cyclée s.

PHP 5, 96 87

9 octets économisés grâce à @manatwork

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

Réponse en boucle assez simple.

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

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

En tant que fonction sans nom. Ceci utilise charToRaw pour diviser la chaîne en un vecteur de raws. Ceci est rempli dans un tableau de longueur * l, reconverti en char et en sortie.
J'allais utiliser strsplit, mais cela a fini par être plus long.

Tester

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

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

Nécessite: -n, -let -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 >

Explication:

$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 préprocesseur), 71

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

Pas très compliqué ici. Il suffit de s'assurer que le contenu l*mest converti en un intavant de le comparer j.

Essayez-le en ligne.

Oracle SQL 11.2, 154 152 octets

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;

Non 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;

J'ai choisi la voie récursive, la sélection d'initialisation prenant en charge la partie décimale.

Sauvegardé 2 octets grâce à @MickyT

Sérieusement, 24 octets

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

Essayez-le en ligne!

Explication:

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

V*Elzp@zN

Fondamentalement, juste faire

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