Vor einiger Zeit gab es eine Herausforderung , Strings zu multiplizieren. Es hat uns gezeigt, wie wir nicht nur Zahlen, sondern auch Zeichenketten multiplizieren können. Wir können eine Zahl jedoch immer noch nicht richtig mit einer Zeichenfolge multiplizieren. Es hat einen Versuch gegeben , aber das ist offensichtlich falsch. Wir müssen das beheben!

Deine Aufgabe:

Schreiben Sie eine Funktion oder ein Programm, das zwei Eingaben multipliziert, eine Zeichenfolge und eine Ganzzahl. Um eine Zeichenfolge mit einer Ganzzahl (richtig) zu multiplizieren, teilen Sie die Zeichenfolge in Zeichen auf, wiederholen jedes Zeichen so oft wie die Ganzzahl und kleben die Zeichen dann wieder zusammen. Wenn die Ganzzahl negativ ist, verwenden wir im ersten Schritt ihren absoluten Wert und kehren dann die Zeichenfolge um. Wenn der Eingang 0 ist, wird nichts ausgegeben (alles, was mit 0 multipliziert wird, ist nichts).

Eingang:

Eine Zeichenfolge, die ausschließlich aus druckbaren ASCII-Zeichen und Zeilenumbrüchen sowie einer Ganzzahl (möglicherweise negativ) besteht.

Ausgabe:

Die Zeichenfolge multipliziert mit der Ganzzahl.

Beispiele:

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

                               WWoorrlldd!!

Wertung:

Dies ist Code-Golf , die niedrigste Anzahl an Bytes gewinnt!

Jelly , 6 5 4 Bytes

²Ɠxm

Probieren Sie es online!

Wie es funktioniert

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

Übernimmt Eingaben in der Currying-Syntax (s)(n).

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

Testfälle

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 Bytes

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

Probieren Sie es online!

Python 2 , 59 57 50 46 Bytes

-2 Bytes dank Anders Kaseorg. -4 Bytes dank Dennis.

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

Probieren Sie es online!

05AB1E , 10 Bytes

S²Ä×J²0‹iR

Probieren Sie es online!

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 Bytes

y|Y"w0<?P

Eingaben sind: Zahl, dann Zeichenfolge.

Strings mit Zeilenumbrüche eingegeben werden char 10wie folgt: ['first line' 10 'second line'].

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

Betrachten Sie Eingaben -3und '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 Bytes

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

Probieren Sie es online!

Anwendungsbeispiel: f (-3) "abc"Erträge "cccbbbaaa".

Edit: -5 Bytes dank xnor!

V , 29, 23, 18 , 17 Bytes

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

Probieren Sie es online!

Hexdump:

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

Vielen Dank an @ nmjcman101 für das Speichern von 6 Bytes, was mich dazu ermutigte, weitere 5 Bytes zu speichern!

Die ursprüngliche Revision war ziemlich schrecklich, aber jetzt bin ich wirklich stolz auf diese Antwort, weil sie überraschend gut mit negativen Zahlen umgehen kann. (V hat so gut wie keine numerische Unterstützung und keine Unterstützung für negative Zahlen)

Erläuterung:

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

Zu diesem Zeitpunkt sieht der Puffer folgendermaßen aus:

H
e
l
l
o

w
o
r
l
d
!
<cursor>

Es ist wichtig, dass die nachgestellte Zeile nicht mit dem Cursor markiert wird.

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

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

Anonyme Funktion.

Frederic sparte 3 Bytes, Giuseppe 2 4.

Erläuterung:

     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

Tests:

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

0‹FR}ʒ¹Ä×?

Probieren Sie es online!

Erläuterung

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 Bytes

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

PHP Sandbox Online

Brain-Flak (BrainHack) , 154 152 Bytes

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

Probieren Sie es online!

Nur hier, um DJMcMayhem Konkurrenz zu machen. ;)

Erläuterung

Hier ist eine modifizierte Version der Erklärung von 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 Bytes

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

Probieren Sie es online!

Erläuterung

        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 Bytes

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

Zeichenfolge als linkes Argument, Zahl als rechtes Argument.

Probieren Sie es online!

Wie?

⍺/⍨ - Wiederholen Sie die Zeichenfolge

|⍵ - abs (Anzahl) mal

⌽⍣ - umkehren, wenn

(⍵<0) - Die Zahl liegt unter 0

MATLAB, 37 Bytes

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

Dies definiert und anonymisiert die Funktion mit den Eingaben s: string und n: number.

Beispiel läuft:

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

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

Probieren Sie es online!

Dies ist wahrscheinlich die schlechteste Sprache, in der es möglich ist, aber es ist geschafft. Vielen Dank an @Wheatwizard für die Bereitstellung des Haskell-Interpreters, der gemischte Eingabeformate ermöglicht. Dies wäre ungefähr 150 Bytes länger ohne es.

Erläuterung:

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

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

Probieren Sie es online!

• -2 Bytes dank @Xanderhall
• -2 Bytes dank @Nevay

Oktave , 49 Bytes

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

Probieren Sie es online!

Ich werde morgen eine Erklärung geben.

Ruby , 59 +1 = 60 Bytes

Verwendet -nFlagge.

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

Probieren Sie es online!

Kohle , 16 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

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

q~__*@e*%

Probieren Sie es online!

Japt , 12 Bytes

®pVaìr!+sVg

Probieren Sie es online!

Erläuterung

Implizite Eingabe von Zeichenfolge Uund Ganzzahl V.

®pVaÃ

Ordne ( ®) jeden Buchstaben U(implizit) sich selbst zu und wiederhole ( p) abs(V)( Va) Male.

¬r

Verwandle den String in ein Array von Zeichen ( ¬) und reduziere ( r) das mit ...

!+sVg

"!+".slice(sign(V))- dies verringert sich entweder mit +→ a + boder mit !+→ b + a.
Vielen Dank an @Arnauld für die Rückwärtsreduzierung!

WendyScript , 46 Bytes

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

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

Probieren Sie es online!

Erklärung (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 Bytes

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

Ich habe Ben Perlins Version gesehen und mich gefragt, ob du nicht noch kürzer sein könntest und auch ein volles Programm hast. Sicher, atoi()und putchar()ist das nicht so teuer in Bezug auf Bytes? Scheint, ich hatte recht!

Pyth, 13 11 Bytes

*sm*.aQdz._

Versuch es!

-2 Bytes dank @jacoblaw

Erläuterung

*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 

alter Ansatz, 13 Bytes

_W<Q0sm*.aQdz

Versuch es!

Python 3 , 68 Bytes

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

Probieren Sie es online!

QBIC , 32 Bytes

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

Erläuterung

            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 Bytes

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

Eingang

["Hallo Welt!", 3]

Braingolf , 22 Bytes

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

Probieren Sie es online!

Äh, nicht schlecht.

Nimmt Eingaben als Ganzzahl und als Array von Zeichen an.

Alternative:

Braingolf , 31 Bytes

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

Probieren Sie es online!

Übernimmt die Eingabe als Ganzzahl und als Zeichenfolge

C 109 Bytes

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

Ausgehend von einer Funktionsdeklaration, die ein int und ein string verwendet und einen string erzeugt (es scheint, dass der Speicher nicht vorbelegt ist und erstellt werden muss), scheint der direkte Ansatz kürzer zu sein als alle Versuche, ein Hackmesser zu sein, die ich versucht habe .

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;

}