Bei 2 Eingaben, einer Zeichenfolge und einer Dezimalzahl, wird die mit dieser Zahl multiplizierte Zeichenfolge ausgegeben.

Der Haken ist, dass die Zahl ein Float oder eine Ganzzahl sein kann.

Sie sollten die Zeichenfolge floor(n)Zeit und dann die ersten floor((n-floor(n))*len(string))Buchstaben erneut ausgeben .

Weitere Hinweise:

• Die Eingabe ist nicht immer ein Float, sondern möglicherweise ein Int. 1,5, 1 und 1,0 sind also alle möglich. Es wird jedoch immer in der Basis 10 sein, und wenn Sie eine Ausnahme wünschen, kommentieren Sie dies bitte.
• Die Zeichenfolge kann Leerzeichen, Anführungszeichen und andere Zeichen enthalten. Keine Zeilenumbrüche oder Steuerzeichen.
• Es gibt keine eingebauten Funktionen für die direkte Wiederholung von Strings. Auch die Multiplikation von Strings wie Python 'a'*5ist nicht erlaubt. Das Hinzufügen von Zeichenfolgen ist jedoch zulässig.

Testfälle:

Das Komma und das Leerzeichen trennen die Eingaben.

test case, 1 -> test case

case, 2.5 -> casecaseca

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

cats >= dogs, 0.5 -> cats >

Schlussbemerkung:

Ich sehe viele Antworten, die eingebaute Zeichenkettenmultiplikations- oder Wiederholungsfunktionen verwenden. Das ist nicht erlaubt. Die Antwort von @ VTC ist jedoch gültig, da sie nicht den String, sondern nur die Float-Eingabe multipliziert. Die endgültige Regel lautet also: Wenn die Zeichenfolge direkt multipliziert wird, können Sie dies nicht tun.

Gelee, 5 Bytes

×L}Rị

Verwendet keine eingebaute Wiederholung. Probieren Sie es online!

Wie es funktioniert

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

Nimmt char [] und float und gibt sie an STDOUT aus. Grundschleifen.

Pyth, 9 8

s@Lz*lzQ

1 Byte dank Pietu1998 gespeichert

Dies nimmt floor(n * len(string))Buchstaben aus dem String unter Verwendung einer zyklischen Indizierung. Ich glaube, das entspricht immer der angegebenen Formel.

Test Suite

JavaScript (ES6), 50 Byte

Bearbeiten Sie 2 Bytes mehr, um die Definition der Funktion aufzunehmen f. 1 Byte weniger mit dem Tipp von @manatwork. Hinweis: Bei Verwendung von haben ~wir mehr Iterationen als erforderlich, dies ist jedoch Codegolf und es werden sogar 1 Byte gezählt

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

PRÜFUNG

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

Erwartet, dass das Wort ein Argument ist und die Zahl mit STDIN multipliziert wird.

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.

Probieren Sie es online!

CJam, 10 Bytes

l_,l~*,\f=

Der String wird in der ersten Zeile von STDIN angegeben, der Float in der zweiten.

Teste es hier.

Erläuterung

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

Probieren Sie es hier aus!

Erstellt ein unbenanntes Lambda, das den String als erstes Argument und den Gleitkomma als zweites Argument verwendet. Gibt die wiederholte Zeichenfolge zurück.

Dies könnte 46 sein, wenn die eingebauten Zeichenfolgenwiederholungen zulässig sind :(

Ruby, 49 48 Zeichen

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

Probelauf:

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 verfügt sowohl über einen String-Wiederholungsoperator xals auch über einen Listen-Wiederholungsoperator xx.

Da die Regeln die Wiederholung von Zeichenfolgen nicht zulassen, wiederholen wir sie, als ob es sich stattdessen um eine einzelne Elementliste handeln würde. Dann wird die Liste zusammengefügt und ein Teil davon wird zurückgegeben.

Verwendung:

# 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 meine Tage, das ist schlimmer als ich dachte.

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

Gibt den Wert des Strings zurück, eine weitere Antwort unter Verwendung der zyklischen Indizierung. Erwartet Eingabe als "string" "repetitions".

Haskell, 44 Bytes

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

Anwendungsbeispiel: "(will add more later)" # 0.3333 -> "(will ".

So funktioniert es: cVerkettet unendliche Kopien des Strings x. Es verhält sich wie das eingebaute cycle. sum[1|a<-s]ist eine benutzerdefinierte Längenfunktion, die mit dem strengen Typsystem von Haskell arbeitet, da es ein zurückgibt Double(das eingebaute lengthgibt ein zurück, Intdas nicht mit multipliziert werden kann n). #nimmtfloor (n * length(s)) Zeichen aus der zyklischen Zeichenfolge s.

PHP 5, 96 87

9 Bytes gespart dank @manatwork

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

Ziemlich geradlinige Antwort in einer Schleife.

Ungolfed

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

Als unbenannte Funktion. Dies verwendet charToRaw, um den String in einen Vektor von Raws aufzuteilen. Dies wird in ein Array der Länge * l gefüllt, zurück in char konvertiert und ausgegeben.
Ich wollte Strsplit verwenden, aber es wurde länger.

Prüfung

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

Benötigt: -n, -lund -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 >

Erläuterung:

$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 (Präprozessor-Makro), 71

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

Hier ist es nicht viel schwierig. Ich muss nur sicherstellen, dass vor dem Vergleich mit "" auf "" l*mgeworfen wird .intj

Probieren Sie es online aus.

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;

Nicht golfen

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;

Ich bin den rekursiven Weg gegangen, wobei die Initialisierung select den Dezimalteil berücksichtigt hat.

2 Bytes gespart dank @MickyT

Im Ernst, 24 Bytes

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

Probieren Sie es online!

Erläuterung:

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

Im Grunde nur zu tun

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