前一阵子关于将字符串相乘存在一个挑战。它向我们展示了如何不仅可以将数字相乘，而且还可以将字符串相乘。但是，我们仍然无法正确地将数字乘以字符串。已经尝试过这样做，但这显然是错误的。我们需要解决这个问题！

你的任务：

编写一个将两个输入（一个字符串和一个整数）相乘的函数或程序。要将字符串乘以整数（适当），请将字符串拆分为字符，将每个字符重复等于整数的次数，然后将字符重新粘在一起。如果整数为负数，则在第一步中使用其绝对值，然后反转字符串。如果输入为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!!

得分：

这是代码高尔夫球，最低字节数获胜！

果冻，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.

JavaScript（ES6），63个字节

以currying语法接受输入(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))

Python 3，44字节

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

在线尝试！

Python 2中，59个 57 50 46字节

-2个字节感谢Anders Kaseorg。-4个字节感谢Dennis。

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

输入是：数字，然后是字符串。

带有换行符的字符串使用char输入10，如下所示：['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)

Haskell，41 36字节

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

在线尝试！

用法示例：f (-3) "abc"yields "cccbbbaaa"。

编辑： -5字节感谢xnor！

V，29，23，18，17字节

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

在线尝试！

十六进制转储：

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

感谢@ nmjcman101保存了6个字节，这鼓励我再保存5个字节！

最初的修订版本非常糟糕，但是现在我真的为这个答案感到骄傲，因为它可以很好地处理负数。（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='')

匿名函数。

弗雷德里克（Frederic）保存了3个字节，朱塞佩（Giuseppe）保存了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)⊢⍺/⍨|⍵}

字符串作为左参数，数字作为右参数。

在线尝试！

怎么样？

⍺/⍨ -重复字符串

|⍵ -绝对次数

⌽⍣ -如果相反

(⍵<0) -数字低于0

MATLAB，37个字节

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

这使用输入s：字符串和n：数字来定义和匿名函数。

示例运行：

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

脑高射炮（Haskell中），202个 192字节

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

在线尝试！

这可能是最糟糕的语言了，但是已经做到了。感谢@Wheatwizard提供了Haskell解释器，该解释器允许混合输入格式。如果没有它，则长度将增加约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
{}

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

在线尝试！

• -2个字节，感谢@Xanderhall
• -2个字节，感谢@Nevay

八度，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

将字符串转换为chars（¬）数组，并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._

试试吧！

-2个字节，感谢@jacoblaw

说明

*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

试试吧！

Python 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

Mathematica，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&@

在线尝试！

嗯，还不错。

将输入作为整数和字符数组。

或者：

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和一个字符串并产生一个字符串的函数声明开始（似乎暗示内存没有被预先分配，必须创建），似乎直截了当的方法比我尝试过的任何切刀都短。

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;

}