Hubo un desafío hace un tiempo sobre la multiplicación de cadenas. Nos mostró cómo podemos multiplicar no solo números, sino también cadenas. Sin embargo, todavía no podemos multiplicar un número por una cadena correctamente. Ha habido un intento de hacerlo, pero esto obviamente está mal. ¡Necesitamos arreglar eso!

Tu tarea:

Escriba una función o programa que multiplique dos entradas, una cadena y un número entero. Para (correctamente) multiplicar una cadena por un entero, divida la cadena en caracteres, repita cada carácter varias veces igual al entero y luego vuelva a unir los caracteres. Si el número entero es negativo, usamos su valor absoluto en el primer paso y luego invertimos la cadena. Si la entrada es 0, no genera nada (cualquier cosa multiplicada por 0 es igual a nada)

Entrada:

Una cadena que consiste únicamente en caracteres ASCII imprimibles y líneas nuevas, y un número entero (posiblemente negativo).

Salida:

La cadena multiplicada por el entero.

Ejemplos:

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

                               WWoorrlldd!!

Tanteo:

Este es el código de golf , ¡el conteo de bytes más bajo gana!

Gelatina , 6 5 4 bytes

²Ɠxm

Pruébalo en línea!

Cómo funciona

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

Toma entrada en la sintaxis de curry (s)(n).

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

Casos de prueba

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

Pruébalo en línea!

Python 2 , 59 57 50 46 bytes

-2 bytes gracias a Anders Kaseorg. -4 bytes gracias a Dennis.

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

Pruébalo en línea!

05AB1E , 10 bytes

S²Ä×J²0‹iR

Pruébalo en línea!

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

Las entradas son: número, luego cadena.

Cuerdas con saltos de línea son de entrada utilizando carbón 10como sigue: ['first line' 10 'second line'].

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

Considere las entradas -3y '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])

Pruébalo en línea!

Ejemplo de uso: f (-3) "abc"rendimientos "cccbbbaaa".

Editar: -5 bytes gracias a xnor!

V , 29, 23, 18 , 17 bytes

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

Pruébalo en línea!

Hexdump:

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

¡Gracias a @ nmjcman101 por guardar 6 bytes, lo que me animó a guardar otros 5!

La revisión original fue bastante terrible, pero ahora estoy realmente orgulloso de esta respuesta porque maneja los números negativos sorprendentemente bien. (V casi no tiene soporte numérico ni soporte para números negativos)

Explicación:

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

En este punto, el búfer se ve así:

H
e
l
l
o

w
o
r
l
d
!
<cursor>

Es importante no la nueva línea final y que el cursor esté sobre ella.

À           " 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='')

Función anónima.

Frederic salvó 3 bytes, Giuseppe salvó 2 4.

Explicación:

     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

Pruebas:

> 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}ʒ¹Ä×?

Pruébalo en línea!

Explicación

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 en línea

Brain-Flak (BrainHack) , 154 152 bytes

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

Pruébalo en línea!

Solo aquí para darle competencia a DJMcMayhem. ;)

Explicación

Aquí hay una versión modificada de la explicación de 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-@>]

Pruébalo en línea!

Explicación

        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)⊢⍺/⍨|⍵}

Cadena como argumento izquierdo, número como argumento derecho.

Pruébalo en línea!

¿Cómo?

⍺/⍨ - repite la cuerda

|⍵ - abs (número) veces

⌽⍣ - invertir si

(⍵<0) - el número está por debajo de 0

MATLAB, 37 bytes

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

Esto define una función anónima con entradas s: cadena y n: número.

Ejecuciones de ejemplo:

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

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

Pruébalo en línea!

Este es probablemente el peor lenguaje posible para hacerlo, pero está hecho. Gracias a @Wheatwizard por proporcionar el intérprete Haskell, que permite formatos de entrada mixtos. Esto sería aproximadamente 150 bytes más sin él.

Explicación:

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

Pruébalo en línea!

• -2 bytes gracias a @Xanderhall
• -2 bytes gracias a @Nevay

Octava , 49 bytes

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

Pruébalo en línea!

Proporcionaré una explicación mañana.

Ruby , 59 +1 = 60 bytes

Utiliza -nbandera.

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

Pruébalo en línea!

Carbón , 16 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｆθ              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*%

Pruébalo en línea!

Japt , 12 bytes

®pVaìr!+sVg

Pruébalo en línea!

Explicación

Entrada implícita de cadena Uy entero V.

®pVaÃ

Asigne ( ®) cada letra de U(implícitamente) a sí misma repetida ( p) abs(V)( Va) veces.

¬r

Convierta la cadena en una matriz de caracteres ( ¬) y reduzca ( r) eso con ...

!+sVg

"!+".slice(sign(V))- esto se reduce con +→ a + bo con !+→ b + a.
¡Gracias @Arnauld por la idea de reducir hacia atrás!

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

Pruébalo en línea!

Explicación (sin golf):

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

Vi la versión de Ben Perlin y me pregunté si aún no podía ser más corto y tener un programa completo; seguramente, atoi()yputchar() no son tan caros en términos de bytes? Parece que tenía razón!

Pyth, 13 11 bytes

*sm*.aQdz._

¡Intentalo!

-2 bytes gracias a @jacoblaw

explicación

*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 

enfoque antiguo, 13 bytes

_W<Q0sm*.aQdz

¡Intentalo!

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

Pruébalo en línea!

QBIC , 32 bytes

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

Explicación

            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])&

entrada

["Hola mundo!", 3]

Braingolf , 22 bytes

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

Pruébalo en línea!

Eeh, no está mal.

Toma la entrada como un entero y una matriz de caracteres.

Alternativamente:

Braingolf , 31 bytes

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

Pruébalo en línea!

Toma la entrada como un entero y una cadena

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

Comenzando con una declaración de función que toma un int y una cadena y produce una cadena (parece implicado que la memoria no está preasignada y debe crearse) parece que el enfoque directo es más corto que cualquier intento de ser más inteligente que había intentado .

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;

}