Có một thách thức trước đây về việc nhân chuỗi. Nó cho chúng ta thấy làm thế nào chúng ta có thể nhân không chỉ các số, mà cả các chuỗi. Tuy nhiên, chúng ta vẫn không thể nhân một số với một chuỗi đúng. Đã có một nỗ lực để làm như vậy nhưng điều này rõ ràng là sai. Chúng ta cần sửa nó!

Nhiệm vụ của bạn:

Viết hàm hoặc chương trình nhân hai đầu vào, một chuỗi và một số nguyên. Để (đúng) nhân một chuỗi với một số nguyên, bạn chia chuỗi thành các ký tự, lặp lại mỗi ký tự một số lần bằng số nguyên, sau đó dán các ký tự lại với nhau. Nếu số nguyên âm, chúng tôi sử dụng giá trị tuyệt đối của nó trong bước đầu tiên, và sau đó đảo ngược chuỗi. Nếu đầu vào là 0, đầu ra không có gì (mọi thứ nhân với 0 bằng không có gì).

Đầu vào:

Một chuỗi chỉ bao gồm các ký tự và dòng mới ASCII có thể in và một số nguyên (có thể phủ định).

Đầu ra:

Chuỗi nhân với số nguyên.

Ví dụ:

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

                               WWoorrlldd!!

Ghi điểm:

Đây là mã golf , số byte thấp nhất sẽ thắng!

Thạch , 6 5 4 byte

²Ɠxm

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

²Ɠ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 byte

Đưa đầu vào theo cú pháp currying (s)(n).

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

Các trường hợp thử nghiệm

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 byte

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

Hãy thử trực tuyến!

Python 2 , 59 57 50 46 byte

-2 byte nhờ có Anders Kaseorg. -4 byte nhờ Dennis.

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

Hãy thử trực tuyến!

05AB1E , 10 byte

S²Ä×J²0‹iR

Hãy thử trực tuyến!

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 byte

y|Y"w0<?P

Đầu vào là: số, sau đó là chuỗi.

Chuỗi có dòng mới được nhập bằng char 10như sau : ['first line' 10 'second line'].

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

Xem xét đầu vào -3và '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 byte

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

Hãy thử trực tuyến!

Ví dụ sử dụng: f (-3) "abc"sản lượng "cccbbbaaa".

Chỉnh sửa: -5 byte nhờ xnor!

V , 29, 23, 18 , 17 byte

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

Hãy thử trực tuyến!

Hexdump:

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

Cảm ơn @ nmjcman101 vì đã lưu 6 byte, điều này khuyến khích tôi tiết kiệm thêm 5 byte!

Bản sửa đổi ban đầu khá khủng khiếp, nhưng bây giờ tôi thực sự tự hào về câu trả lời này vì nó xử lý tốt các số âm. (V không có hỗ trợ số và không hỗ trợ số âm)

Giải trình:

æ_          " 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

Tại thời điểm này, bộ đệm trông như thế này:

H
e
l
l
o

w
o
r
l
d
!
<cursor>

Điều quan trọng là không phải là dòng mới, và con trỏ ở trên đó.

À           " 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 byte

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

Chức năng ẩn danh.

Frederic lưu 3 byte, Giuseppe lưu 2 4.

Giải trình:

     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

Các xét nghiệm:

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

0‹FR}ʒ¹Ä×?

Hãy thử trực tuyến!

Giải trình

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 byte

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

PHP Sandbox trực tuyến

Brain-Flak (BrainHack) , 154 152 byte

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

Hãy thử trực tuyến!

Chỉ cần ở đây để cung cấp cho DJMcMayhem một số cuộc thi. ;)

Giải trình

Đây là phiên bản sửa đổi của lời giải thích của 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 byte

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

Hãy thử trực tuyến!

Giải trình

        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

APL Dyalog, 15 byte

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

Chuỗi là một đối số bên trái, số là một đối số bên phải.

Hãy thử trực tuyến!

Làm sao?

⍺/⍨ - lặp lại chuỗi

|⍵ - abs (số) lần

⌽⍣ - đảo ngược nếu

(⍵<0) - số dưới 0

MATLAB, 37 byte

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

Điều này xác định và hàm ẩn danh với đầu vào s: chuỗi và n: số.

Ví dụ chạy:

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

Brain-Flak (Haskell) , 202 192 byte

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

Hãy thử trực tuyến!

Đây có lẽ là ngôn ngữ tồi tệ nhất có thể để làm điều đó, nhưng nó đã được thực hiện. Cảm ơn @Wheatwizard đã cung cấp trình thông dịch Haskell, cho phép các định dạng đầu vào hỗn hợp. Điều này sẽ dài hơn khoảng 150 byte nếu không có nó.

Giải trình:

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

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

Hãy thử trực tuyến!

• -2 byte nhờ @Xanderhall
• -2 byte nhờ @Nevay

Octave , 49 byte

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

Hãy thử trực tuyến!

Tôi sẽ cung cấp một lời giải thích vào ngày mai.

Ruby , 59 +1 = 60 byte

Sử dụng -ncờ.

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

Hãy thử trực tuyến!

Than , 16 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｆθ              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 byte

q~__*@e*%

Hãy thử trực tuyến!

Japt , 12 byte

®pVaìr!+sVg

Hãy thử trực tuyến!

Giải trình

Đầu vào ngầm định của chuỗi Uvà số nguyên V.

®pVaÃ

Ánh xạ ( ®) mỗi chữ cái của U(ngầm) đến chính nó lặp lại ( p) abs(V)( Va) lần.

¬r

Biến chuỗi thành một mảng ký tự ( ¬) và giảm ( r) với ...

!+sVg

"!+".slice(sign(V))- điều này hoặc giảm với +→ a + b, hoặc với !+→ b + a.
Cảm ơn @Arnauld cho ý tưởng giảm ngược!

WendyScript , 46 byte

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

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

Hãy thử trực tuyến!

Giải thích (Ungolfed):

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 byte

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

Tôi đã xem phiên bản của Ben Perlin và tự hỏi liệu bạn không thể ngắn hơn nữa và cũng có một chương trình đầy đủ; chắc chắn, atoi()và putchar()không đắt về mặt byte? Có vẻ như tôi đã đúng!

Bình thường, 13 11 byte

*sm*.aQdz._

Thử nó!

-2 byte nhờ @jacoblaw

giải trình

*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 

cách tiếp cận cũ, 13 byte

_W<Q0sm*.aQdz

Thử nó!

Python 3 , 68 byte

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

Hãy thử trực tuyến!

QBIC , 32 byte

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

Giải trình

            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

Toán học, 89 byte

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

đầu vào

["Xin chào thế giới!", 3]

Braingolf , 22 byte

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

Hãy thử trực tuyến!

Eeh, không tệ.

Lấy đầu vào là một số nguyên và một mảng các ký tự.

Cách khác:

Braingolf , 31 byte

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

Hãy thử trực tuyến!

Lấy đầu vào là một số nguyên và một chuỗi

C, 109 byte

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

Bắt đầu với một khai báo hàm lấy một int và một chuỗi và tạo ra một chuỗi (có vẻ như ngụ ý rằng bộ nhớ không được kích thích và phải được tạo ra) có vẻ như cách tiếp cận đơn giản ngắn hơn bất kỳ nỗ lực nào trong việc tìm kiếm cleaver mà tôi đã thử .

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;

}