문자열을 곱하는 것에 대해 얼마 전에 도전 이있었습니다 . 숫자뿐만 아니라 문자열도 곱할 수있는 방법을 보여주었습니다. 그러나 여전히 숫자에 문자열을 곱할 수는 없습니다. 이 있었다 하나 개의 시도 그렇게 할 수 있지만, 이것은 분명히 잘못된 것입니다. 우리는 그것을 고쳐야합니다!

당신의 작업 :

문자열과 정수의 두 입력을 곱하는 함수 나 프로그램을 작성하십시오. 문자열에 정수를 (적절하게) 곱하려면 문자열을 문자로 나누고 각 문자를 정수와 같은 횟수만큼 반복 한 다음 문자를 다시 붙입니다. 정수가 음수이면 첫 번째 단계에서 절대 값을 사용한 다음 문자열을 반대로 바꿉니다. 입력이 0이면 아무것도 출력하지 않습니다 (0을 곱한 것은 아무것도 없음).

입력:

인쇄 가능한 ASCII 문자와 줄 바꿈 및 정수 (음수 가능)로만 구성된 문자열입니다.

산출:

문자열에 정수를 곱한 값입니다.

예 :

Hello World!, 3            --> HHHeeellllllooo   WWWooorrrlllddd!!!
foo, 12                    --> ffffffffffffoooooooooooooooooooooooo
String, -3                 --> gggnnniiirrrtttSSS
This is a fun challenge, 0 --> 
Hello
World!, 2                  --> HHeelllloo

                               WWoorrlldd!!

채점 :

이것은 code-golf 이며 가장 낮은 바이트 수입니다.

젤리 , 6 5 4 바이트

²Ɠxm

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

작동 원리

²Ɠxm  Main link. Argument: n (integer)

²     Yield n².
 Ɠ    Read and eval one line of input. This yields a string s.
  x   Repeat the characters of s in-place, each one n² times.
   m  Takes each |n|-th character of the result, starting with the first if n > 0, 
      the last if n < 0.

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

카레 구문으로 입력을받습니다. (s)(n) 받습니다.

s=>n=>[...s].reduce((s,c)=>n<0?c.repeat(-n)+s:s+c.repeat(n),'')

테스트 사례

let f =

s=>n=>[...s].reduce((s,c)=>n<0?c.repeat(-n)+s:s+c.repeat(n),'')

console.log(f(`Hello World!`)(3))
console.log(f(`foo`)(12))
console.log(f(`String`)(-3))
console.log(f(`This is a fun challenge`)(0))
console.log(f(`Hello
World!`)(2))

파이썬 3 , 44 바이트

f=lambda s,n:s and s[0]*n+f(s[1:],n)+s[0]*-n

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

파이썬 2 , 59 57 50 46 바이트

Anders Kaseorg 덕분에 -2 바이트. Dennis 덕분에 -4 바이트

lambda s,n:''.join(i*n**2for i in s)[::n or 1]

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

05AB1E , 10 바이트

S²Ä×J²0‹iR

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

S          # Split the string into characters
 ²Ä×       # Repeat each character abs(integer) times
    J      # Join into a string
     ²0‹i  # If the integer is less than 0...
         R #   Reverse the string

MATL , 9 바이트

y|Y"w0<?P

입력은 숫자와 문자열입니다.

줄 바꿈이있는 문자열 10은 다음과 같이 char 을 사용하여 입력됩니다 ['first line' 10 'second line'].

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

설명

입력 -3과를 고려하십시오 'String'.

y      % Implicitly take two inputs. Duplicate from below
       % STACK: -3, 'String', -3
|      % Absolute value
       % STACK: -3, 'String', 3
Y"     % Run-length decoding
       % STACK: -3, 'SSStttrrriiinnnggg'
w      % Swap
       % STACK: 'SSStttrrriiinnnggg', -3
0<     % Less than 0?
       % STACK: 'SSStttrrriiinnnggg', 1
?      % If so
  P    %   Flip
       %   STACK: 'gggnnniiirrrtttSSS'
       % End (implicit). Display (implicit)

하스켈 , 41 36 바이트

f n|n<0=reverse.f(-n)|1<3=(<*[1..n])

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

사용법 예 : f (-3) "abc"yields "cccbbbaaa".

편집 : xnor 덕분에 -5 바이트!

V , 29, 23, 18 , 17 바이트

æ_ñÀuñÓ./&ò
ÀäëÍî

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

16 진 덤프 :

00000000: e65f f1c0 75f1 d32e 2f26 f20a c0e4 ebcd  ._..u.../&......
00000010: ee                                       .

6 바이트를 절약 해 준 @ nmjcman101에게 감사의 말씀을 전합니다.

원래 개정판은 꽤 끔찍했지만 이제는이 답변이 음수를 놀랍게 잘 처리하기 때문에 정말 자랑스럽게 생각합니다. (V는 숫자 지원이없고 음수를 지원하지 않습니다)

설명:

æ_          " Reverse the input
  ñ  ñ      " In a macro:
   À        "   Run the arg input. If it's positive it'll give a count. If it's negative
            "   running the '-' will cause V to go up a line which will fail since we're
            "   on the first line, which will break out of this macro
    u       "   (if arg is positive) Undo the last command (un-reverse the line)
      Ó./&ò " Put every character on it's own line

이 시점에서 버퍼는 다음과 같습니다.

H
e
l
l
o

w
o
r
l
d
!
<cursor>

후행 줄 바꿈이 없어야하며 커서가 그 위에 있어야합니다.

À           " Run arg again. If it's negative, we will move up a line, and then give the 
            " absolute value of the count. If it's positive (or 0) it'll just give the
            " count directly (staying on the last line)
 ä          " Duplicate... (count times)
  ë         "   This column. 
   Íî       " Remove all newlines.

R, 83 78 76 바이트

function(s,i)cat('if'(i<0,rev,`(`)(rep(el(strsplit(s,'')),e=abs(i))),sep='')

익명의 기능.

프레 더릭은 3 바이트를, 주세페는 2 4를 절약했습니다 .

설명:

     el(strsplit(s,''))                      # split string into list characters
 rep(                  ,e=abs(i)))           # repeat each character abs(i) times


    'if'(i<0,rev,   ){...}                 # if i>0, reverse character list
                 `(`                       # otherwise leave it alone: `(` is the identity function
cat(                      ,sep='')         # print the result

테스트 :

> f('Hello World!', 3 )
HHHeeellllllooo   WWWooorrrlllddd!!!
> f('foo', 12)
ffffffffffffoooooooooooooooooooooooo
> f('String', -3)
gggnnniiirrrtttSSS
> f('This is a fun challenge', 0)
> f('Hello
+ World!', 2)
HHeelllloo

WWoorrlldd!!

05AB1E , 10 바이트

0‹FR}ʒ¹Ä×?

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

설명

0‹F         # input_1 < 0 times do:
   R        # reverse input_2
    }       # end loop
     ʒ      # filter
      ¹Ä×   # repeat current char abs(input_1) times
         ?  # print without newline

PHP> = 7.1, 65 바이트

for([,$s,$n]=$argv;$i<strlen($s)*abs($n);)echo$s[$i++/$n-($n<0)];

PHP 샌드 박스 온라인

브레인-플락 (BrainHack) , 154 (152) 바이트

([(({})(<()>))]<>)<>{({}()<([{}]()<([{}])>)<>({}<>)<>>)<>}{}<>{}<>({}<([][()]){{}({<({}<(({}<>)<>)>())>[()]}<{}{}>)([][()])}{}{}<>>){{}{({}<>)<>}(<>)}{}

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

여기 DJMcMayhem에게 경쟁을주기 위해 여기에. ;)

설명

다음은 DJMcMayhem의 수정 된 버전입니다.

#Compute the sign and negative absolute value 
([(({})<(())>)]<>)<>{({}()<([{}]()<([{}])>)<>({}<>)<>>)<>}{}<>{}<>

#Keep track of the sign
({}<

    #For each char in the input string:
    ([][()])
    {
        {}

        #Push n copies to the alternate stack
        ({<({}<(({}<>)<>)>())>[()]}<{}{}>)

        #Endwhile
        ([][()])
    }{}{}<>

#Push the sign back on
>)

#If so...
{{}

    #Reverse the whole stack
    {({}<>)<>}

    #And toggle over, ending the loop
    (<>)
}

#Pop the counter off
{}

J , 19 15 13 바이트

(#~|)A.~0-@>]

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

설명

        0-@>]      NB. first or last index depending on sign of right arg
     A.~           NB. get first or last Anagram of left arg
(#~|)              NB. copy left arg, absolute-value-of-right-arg times

Dyalog APL, 15 바이트

{⌽⍣(⍵<0)⊢⍺/⍨|⍵}

왼쪽 인수 인 문자열, 오른쪽 인수 인 숫자

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

어떻게?

⍺/⍨ -문자열을 반복

|⍵ -abs (수) 회

⌽⍣ -반대의 경우

(⍵<0) -숫자가 0 미만입니다

MATLAB, 37 바이트

@(s,n)flip(repelem(s,abs(n)),(n<0)+1)

이것은 입력과 함께 익명 함수를 정의하고 s: string 및 n: number.

예제 실행 :

>> @(s,n)flip(repelem(s,abs(n)),(n<0)+1)
ans = 
    @(s,n)flip(repelem(s,abs(n)),(n<0)+1)

>> f = ans;

>> f('String', 3)
ans =
SSStttrrriiinnnggg

>> f('String', -3)
ans =
gggnnniiirrrtttSSS

>> f('String', 0)
ans =
   Empty matrix: 1-by-0

뇌 플랙 (하스켈) , 202 (192) 바이트

(({})<(([({})]<>)){({}()<([{}])<>({}<>)<>>)<>}{}([{}]<><{}>)([][()]){{}({<({}<(({}<>)<>)>[()])>()}<{}{}>)([][()])}{}{}<>>)([({}<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}{{}{({}<>)<>}(<>)}{}

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

이것은 아마도 최악의 언어 일 것입니다. 그러나 끝났습니다. 혼합 입력 형식을 허용하는 Haskell 인터프리터를 제공 한 @Wheatwizard에게 감사합니다. 이것이 없으면 약 150 바이트 더 길어집니다.

설명:

#Keep track of the first input (n)
(({})<

    #Push abs(n) (thanks WheatWizard!)
    (([({})]<>)){({}()<([{}])<>({}<>)<>>)<>}{}([{}]<><{}>)

    #For each char in the input string:
    ([][()])
    {
        {}

        #Push n copies to the alternate stack
        ({<({}<(({}<>)<>)>[()])>()}<{}{}>)

        #Endwhile
        ([][()])
    }{}{}<>

#Push the original n back on
>)

#Push n >= 0
([({}<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}

#If so...
{{}

    #Reverse the whole stack
    {({}<>)<>}

    #And toggle over, ending the loop
    (<>)
}

#Pop the counter off
{}

자바 (OpenJDK 8) , 99 98 89 87 85 바이트

s->n->{for(int i=s.length*(n<0?n:-n),r=n<0?0:~i;i++<0;)System.out.print(s[(i+r)/n]);}

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

• @Xanderhall 덕분에 -2 바이트
• @Nevay 덕분에 -2 바이트

옥타브 , 49 바이트

@(s,n){t=repmat(s,abs(n),1)(:)',flip(t)}{2-(n>0)}

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

내일 설명을 드리겠습니다.

루비 , 59 +1 = 60 바이트

-n플래그를 사용합니다 .

n=eval$_
a=$<.read
a.reverse!if n<0
a.chars{|i|$><<i*n.abs}

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

숯 , 16 바이트

Ｆθ¿‹η0Ｆ±Ｉη←ιＦＩηι

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

Ｆθ              For each character in the input string
  ¿‹η0          If the input number is less than zero
      Ｆ±Ｉη      Repeat the negation of the input number times
          ←ι    Print the character leftwards (i.e. reversed)
      ＦＩη       Otherwise repeat the input number times
         ι      Print the character

CJam , 9 바이트

q~__*@e*%

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

Japt , 12 바이트

®pVaìr!+sVg

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

설명

문자열의 암시 적 입력 U및 정수 V.

®pVaÃ

(암시 적으로 ®) 각 문자를 U반복 ( p) abs(V)( Va) 횟수로 매핑 합니다.

¬r

문자열을 문자 배열 ( ¬) 로 바꾸고 줄이십시오 ( r).

!+sVg

"!+".slice(sign(V))-이 중 하나와 함께 감소 +→ a + b또는과 !+→ b + a.
거꾸로 줄어든 아이디어에 대해 @Arnauld에게 감사드립니다!

WendyScript , 46 바이트

<<f=>(s,x){<<n=""#i:s#j:0->x?x>0n+=i:n=i+n/>n}

f("Hello World", -2) // returns ddllrrooWW  oolllleeHH

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

설명 (비 골프) :

let f => (s, x) {
  let n = ""
  for i : s
    for j : 0->x
      if x > 0 n += i
      else n = i + n
  ret n
}

C89 바이트

main(int c,char**v){for(;*v[1];v[1]++)for(c=atoi(v[2]+(*v[2]=='-'));c--;)putchar(*v[1]);}

Ben Perlin의 버전을 보았고 아직 짧을 수없고 전체 프로그램을 가질 수 있을지 궁금했습니다. 확실히, atoi()그리고 putchar()바이트의 측면에서 비싼하지? 내가 옳은 것 같아!

Pyth, 13 11 바이트

*sm*.aQdz._

시도 해봐!

@jacoblaw 덕분에 -2 바이트

설명

*sm*.aQdz._   
  m     z     # map onto the input string (lambda var: d)
   *.aQd      # repeat the char d as often as the absolute value of the input number 
 s            # sum the list of strings into a single string
*        ._Q   # Multiply with the sign of the implicit input value: reverse for negative Q 

기존 접근 방식, 13 바이트

_W<Q0sm*.aQdz

시도 해봐!

파이썬 3 , 68 바이트

h=lambda s,n:h(s[::-1],-n)if n<0 else s[0]*n+h(s[1:],n)if s else s*n

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

QBIC , 32 바이트

g=sgn(c)[_l;||[:*g|?_sA,b*g,1|';

설명

            Takes inputs A$ ('Hello'), and c (-3) from the cmd line
g=sgn(c)    Save the sign of c          -1
[_l;||      FOR each char in A$
[:*g|       FOR the number of repetitions wanted    (ie: -3 * -1)
            Note that : reads a number from the cmd line, and c is the first 
            available variable to save it in after a and b got used as FOR counters.
            Also note that a negative value times the sign becomes positive.
?_s         PRINT a substring
  A         of A$
 ,b*g       startng at char n, where n is the first FOR loop counter times the sign
                That means that when c is negative, so is this. A negative starting index
                on Substring instructs QBIC to take from the right.
 ,1|        taking 1 char.
';          This bit injects a literal ; in the output QBasic, to suppress newlines om PRINT

수학, 89 바이트

(T=Table;t=""<>T[s[[i]]~T~Abs@#2,{i,Length[s=Characters@#]}];If[#2>0,t,StringReverse@t])&

입력

[ "Hello World!", 3]

Braingolf , 22 바이트

1-v{R.[v.R]v}R[v>R]v&@

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

Eeh, 나쁘지 않습니다.

정수 및 문자 배열로 입력을받습니다.

또는

Braingolf , 31 바이트

l1->[M]1-v&,{R.[v.R]v}R[v>R]v&@

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

입력을 정수와 문자열로 취합니다

C, 109 바이트

char *f(int n, char *s){char *o=calloc(n,strlen(s)+1),*t=o;while(*s){for(int i=n;i--;)*t++=*s;s++;}return o;}

int와 문자열을 가져 와서 문자열을 생성하는 함수 선언으로 시작하면 (메모리가 사전 할당되지 않았고 생성되어야 함을 암시하는 것처럼 보입니다.) 직접적인 접근 방식은 시도한 cleaver 시도보다 짧습니다. .

char *f(int n, char *s){
  char *o=calloc(n, strlen(s)+1),
    *t=o;

  while (*s) {
    for(int i=n; i--; )
      *t++=*s;
    s++;
  }

 return o;

}