Orada bir meydan okuma bir süre önce yukarı dizeleri çarparak yaklaşık. Bize sadece sayıları değil aynı zamanda dizeleri nasıl çarpabileceğimizi gösterdi. Ancak, hala bir sayıyı bir dizge ile doğru şekilde çarpamıyoruz. Bunu yapmak için bir girişimde bulunuldu , ancak bu açıkça yanlıştır. Bunu düzeltmemiz gerek!

Senin görevin:

Bir dize ve bir tam sayı olan iki girişi çarpan bir fonksiyon veya program yazın. Bir dizgiyi bir tamsayıyla (uygun şekilde) çarpmak için, dizgiyi karakterlere böler, her karakteri tam sayıya eşit sayıda tekrarlar ve sonra karakterleri tekrar birbirine yapıştırırsınız. Tamsayı negatifse, mutlak değerini ilk adımda kullanırız ve sonra dizgiyi tersine çeviririz. Girdi 0 ise, hiçbir şey çıkmaz (0 ile çarpılan herhangi bir şey hiçbir şeye eşittir).

Giriş:

Yalnızca yazdırılabilir ASCII karakterleri ve yeni satırlardan oluşan bir dize ve bir tamsayı (olası negatif).

Çıktı:

Dize tamsayı ile çarpılır.

Örnekler:

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

                               WWoorrlldd!!

puanlama:

Bu kod golf , en düşük bayt sayısı kazanıyor!

Jöle , 6 5 4 bayt

²Ɠxm

Çevrimiçi deneyin!

Nasıl çalışır

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

Körleme sözdiziminde girdi alır (s)(n).

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

Test durumları

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 bayt

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

Çevrimiçi deneyin!

Python 2 , 59 57 50 46 bayt

Anders Kaseorg sayesinde -2 bayt. Dennis sayesinde -4 byte.

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

Çevrimiçi deneyin!

05AB1E , 10 bayt

S²Ä×J²0‹iR

Çevrimiçi deneyin!

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 bayt

y|Y"w0<?P

Girişler: sayı, sonra dize.

Yeni satır ile Yaylı kömürü kullanılarak girilmektedir 10aşağıdaki gibi ['first line' 10 'second line'].

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

açıklama

Girdileri düşünün -3ve '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 bayt

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

Çevrimiçi deneyin!

Örnek kullanım: f (-3) "abc"verim "cccbbbaaa".

Düzenleme: xnor sayesinde -5 bayt!

V , 29, 23, 18 , 17 bayt

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

Çevrimiçi deneyin!

HexDump:

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

6 byte'ı kaydettiği için @ nmjcman101'e teşekkürler, bu da 5 tane daha kurtarmamı sağladı!

Orijinal revizyon oldukça kötüydü, ama şimdi bu cevabımla gerçekten gurur duyuyorum çünkü negatif rakamları şaşırtıcı derecede iyi kullanıyor. (V, sayısal bir desteğin yanında negatif sayılar için desteğin yanında değildir)

Açıklama:

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

Bu noktada, arabellek şuna benzer:

H
e
l
l
o

w
o
r
l
d
!
<cursor>

Sondaki yeni satır değil ve imlecin üzerinde olması önemlidir.

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

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

Anonim işlev

Frederic 3 bayt, Giuseppe 2 4 kurtardı .

Açıklama:

     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

Testler:

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

0‹FR}ʒ¹Ä×?

Çevrimiçi deneyin!

açıklama

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 bayt

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

PHP Sandbox Çevrimiçi

Brain-Flak (BrainHack) , 154 152 bayt

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

Çevrimiçi deneyin!

Sadece DJMcMayhem'e biraz rekabet vermek için buradayım. ;)

açıklama

İşte DJMcMayhem'in açıklamasının değiştirilmiş bir versiyonu.

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

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

Çevrimiçi deneyin!

açıklama

        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 bayt

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

Sol argüman olarak dize, sağ argüman olarak sayı.

Çevrimiçi deneyin!

Nasıl?

⍺/⍨ - dizeyi tekrarla

|⍵ - abs (sayı) kez

⌽⍣ - eğer tersi

(⍵<0) - sayı 0'ın altında

MATLAB, 37 bayt

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

Bu, input'lu anonim fonksiyonu tanımlar ve tanımlar s: string and n: number.

Örnek çalışır:

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

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

Çevrimiçi deneyin!

Muhtemelen bunu yapmak için mümkün olan en kötü dil, ancak bitti. Karma giriş biçimlerini sağlayan Haskell tercümanını sağlamak için @Wheatwizard sayesinde. Bu onsuz yaklaşık 150 bayt olacaktır.

Açıklama:

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

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

Çevrimiçi deneyin!

• @Xanderhall sayesinde -2 bayt
• @Nevay sayesinde -2 bayt

Oktav , 49 bayt

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

Çevrimiçi deneyin!

Yarın bir açıklama yapacağım.

Ruby , 59 +1 = 60 bayt

-nBayrak kullanır .

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

Çevrimiçi deneyin!

Kömür , 16 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

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

q~__*@e*%

Çevrimiçi deneyin!

Japt, 12 bytes

®pVaìr!+sVg

Try it online!

Explanation

Implicit input of string U and integer V.

®pVaÃ

Map (®) each letter of U (implicitly) to itself repeated (p) abs(V) (Va) times.

¬r

Turn the string into an array of chars (¬) and reduce (r) that with...

!+sVg

"!+".slice(sign(V)) - this either reduces with + → a + b, or with !+ → b + a.
Thanks @Arnauld for the backwards-reduce idea!

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

Try it online!

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

I saw Ben Perlin's version and wondered if you couldn't be shorter still and also have a full program; surely, atoi() and putchar() aren't that expensive in terms of bytes? Seems I was right!

Pyth, 13 11 bytes

*sm*.aQdz._

Try it!

-2 bytes thanks to @jacoblaw

explanation

*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 

old approach, 13 bytes

_W<Q0sm*.aQdz

Try it!

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

Try it online!

QBIC, 32 bytes

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

Explanation

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

input

["Hello World!", 3]

Braingolf, 22 bytes

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

Try it online!

Eeh, not bad.

Takes input as an integer and an array of characters.

Alternatively:

Braingolf, 31 bytes

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

Try it online!

Takes input as an integer and a string

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

Starting with a function declaration that takes an int and a string and produces a string (it seems implied that memory is not preallocated and must be created) it seems that the straight-forward approach is shorter than any attempts at being cleaver that I had tried.

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;

}