문자열과 10 진수 두 개의 입력이 주어지면 문자열에 해당 숫자를 곱한 값이 출력됩니다.

catch는 숫자가 부동 소수점이거나 정수일 수 있다는 것입니다.

문자열 floor(n)시간을 출력 한 다음 첫 floor((n-floor(n))*len(string))글자를 다시 출력해야 합니다.

기타 참고 사항 :

• 입력은 항상 float가 아니며 int 일 수 있습니다. 따라서 1.5, 1 및 1.0이 모두 가능합니다. 그래도 항상 기본 10에 있으며 예외를 원하면 의견을 말하십시오.
• 문자열 입력에는 공백, 따옴표 및 기타 문자가 포함될 수 있습니다. 줄 바꿈이나 제어 문자는 없습니다.
• 직접 문자열 반복을위한 내장 기능이 없으며 파이썬과 같은 문자열 곱셈 'a'*5도 허용됩니다. 그러나 문자열 추가 는 허용됩니다.

테스트 사례 :

쉼표 및 공백은 입력을 구분합니다.

test case, 1 -> test case

case, 2.5 -> casecaseca

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

cats >= dogs, 0.5 -> cats >

최종 메모 :

내장 문자열 곱셈 또는 반복 함수를 사용하는 많은 답변을보고 있습니다. 이것은 허용 되지 않습니다. @VTC의 대답 은 문자열을 곱하지 않고 부동 입력 만하 기 때문에 유효합니다. 따라서 결정적인 규칙은 다음과 같습니다. 직접 문자열을 곱하면 할 수 없습니다.

젤리, 5 바이트

×L}Rị

반복 내장 기능을 사용하지 않습니다. 온라인으로 사용해보십시오!

작동 원리

×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.

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

char []를 가져 와서 부동 소수점으로 출력합니다. 기본 반복.

피스, 9 8

s@Lz*lzQ

Pietu1998 덕분에 1 바이트 절약

floor(n * len(string))순환 색인을 사용하여 문자열에서 문자를 가져옵니다 . 나는 이것이 항상 주어진 공식과 동일하다고 생각합니다.

테스트 스위트

자바 스크립트 (ES6), 50 바이트

함수의 정의를 포함하도록 2 바이트를 더 편집하십시오f . @manatwork의 팁을 사용하면 1 바이트가 줄어 듭니다. 참고 : 사용하면 ~필요한 것보다 많은 반복이 있지만 이것은 코드 골프이며 1 바이트 수입니다.

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

테스트

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 바이트

단어가 인수이고 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.

온라인으로 사용해보십시오!

CJam, 10 바이트

l_,l~*,\f=

스트링은 STDIN의 첫 번째 행에 제공되며 두 번째 행에는 부동이 제공됩니다.

여기에서 테스트하십시오.

설명

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.

파이썬 2, 71 바이트

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

여기 사용해보십시오!

문자열을 첫 번째 인수로 사용하고 float를 두 번째로 사용하는 명명되지 않은 람다를 만듭니다. 반복되는 문자열을 반환합니다.

문자열 반복 내장이 허용 된 경우 46이 될 수 있습니다. (

루비, 49 48 자

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

샘플 실행 :

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

펄 6 ,  46 41   39 바이트

{([~] $^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에는 문자열 반복 연산자 x와 목록 반복 연산자 가 모두 xx있습니다.

규칙은 문자열 반복을 허용하지 않기 때문에 단일 요소 목록 인 것처럼 반복합니다. 그런 다음 목록이 함께 연결되고 하위 문자열이 반환됩니다.

용법:

# 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 바이트

오, 내 생각보다 나빠

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

주기적 인덱싱을 사용하는 다른 응답 인 문자열 값을 반환합니다. 로 입력이 예상됩니다 "string" "repetitions".

하스켈, 44 바이트

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

사용 예 : "(will add more later)" # 0.3333-> "(will ".

작동 방식 : c문자열의 무한 복사본을 연결합니다 x. 내장처럼 동작합니다 cycle. sum[1|a<-s]이 반환로 하스켈의 엄격한 타입 시스템과 함께 작동하는 사용자 정의 길이 기능이있는 Double(내장 length다시 표시 Int와 곱 수없는 n). 순환 문자열에서 문자를 #가져옵니다 .floor (n * length(s))s

PHP 5, 96 87

@manatwork 덕분에 9 바이트 절약

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

매우 빠른 정답입니다.

언 골프

<?
$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 바이트

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

명명되지 않은 함수로. charToRaw를 사용하여 문자열을 raw 벡터로 분할합니다. 이것은 길이 * l의 배열로 채워져 char로 다시 변환되어 출력됩니다.
strsplit을 사용하려고했지만 더 길어졌습니다.

테스트

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

펄, 51 + 3 = 54 바이트

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

요구 사항 : -n, -l및 -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 >

설명:

$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 (전 처리기 매크로), 71

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

여기서 까다 롭지 않습니다. 그냥 확인해야 l*m로 캐스팅 된 경우 int에 비교하기 전에 j.

온라인으로 사용해보십시오.

Oracle SQL 11.2, 154 152 바이트

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;

언 골프

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;

나는 초기화가 소수 부분을 돌보는 선택과 함께 재귀 적 인 길을 갔다.

@MickyT 덕분에 2 바이트 절약

진심으로, 24 바이트

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

온라인으로 사용해보십시오!

설명:

,╗,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 바이트

V*Elzp@zN

기본적으로 그냥

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