था एक चुनौती कुछ समय पहले तक तार गुणा के बारे में। इसने हमें दिखाया कि कैसे हम न केवल संख्याओं को गुणा कर सकते हैं, बल्कि तार भी। हालाँकि, हम अभी भी किसी संख्या को एक स्ट्रिंग द्वारा ठीक से गुणा नहीं कर सकते हैं। ऐसा करने का एक प्रयास किया गया है लेकिन यह स्पष्ट रूप से गलत है। हमें इसे ठीक करने की आवश्यकता है!

आपका कार्य:

एक फ़ंक्शन या प्रोग्राम लिखें जो दो इनपुट, एक स्ट्रिंग और एक पूर्णांक को गुणा करता है। (ठीक से) एक स्ट्रिंग को एक पूर्णांक द्वारा गुणा करें, आप स्ट्रिंग को वर्णों में विभाजित करते हैं, प्रत्येक वर्ण को पूर्णांक के बराबर कई बार दोहराते हैं, और फिर वर्णों को एक साथ चिपकाते हैं। यदि पूर्णांक ऋणात्मक है, तो हम पहले चरण में इसके निरपेक्ष मान का उपयोग करते हैं, और फिर स्ट्रिंग को उल्टा करते हैं। यदि इनपुट 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!!

स्कोरिंग:

यह कोड-गोल्फ है , सबसे कम बाइट गिनती जीतता है!

— ग्रीफॉन - मोनिका को बहाल करना
स्रोत

4

क्या हम मान सकते हैं कि स्ट्रिंग मुद्रण योग्य ASCII- ही, प्लस न्यूलाइन्स है?

— mbomb007

क्या हम तार की एक सूची का उत्पादन कर सकते हैं?

— जुबान 11:17

रेटिना में आंशिक समाधान। केवल पूर्णांक के सकारात्मक मूल्यों के लिए काम करता है। अगर कोई चाहता है तो मैं शायद इसे खत्म करने का समय नहीं दूंगा। tio.run/##K0otycxL/P8/…

— mbomb007

@ mbomb007, हाँ, इसके बारे में इतना लंबा समय लेने के लिए खेद है।

— ग्रिफन - मोनिका

@totallyhuman, नहीं, आप नहीं कर सकते।

— ग्रीफॉन -

31

जेली , 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.

— डेनिस
स्रोत

1

ठीक है, अब मैं वास्तव में प्रभावित हूं। मैं लघु में इस विशेष आश्चर्य की व्याख्या प्यार करता हूँ।

— ग्रिफ़ॉन -

ज़रूर। जैसे ही मैंने एक टेस्ट सूट बनाया और मैं गोल्फ कर रहा हूं।

— डेनिस

4

ठीक है, यदि आप इसे किसी भी छोटे कर सकते हैं, तो मैं एक सवाल बनाने की कोशिश करने जा रहा हूं जो आपको ले जाएगा> 10 बाइट्स।

— ग्रिएफॉन -

13

हाँ यह ठीक है। मैं जेली सीख रहा हूं। मैं चाहता हूं कि मैं भी जादू कर सकूं।

— ग्रिएफॉन -

2

हम सभी जानते हैं कि जेली चेन के बारे में एक चर्चा कैसे खत्म हो जाती है ...

— एरिक द आउटग्राफर

9

जावास्क्रिप्ट (ईएस 6), 63 बाइट्स

करी सिंटैक्स में इनपुट लेता है (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))

Expand snippet

— Arnauld
स्रोत

3

+1 के लिए reduce!

— नील

9

पायथन 3 , 44 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत

आधार मामला अंतिम चरित्र की अनदेखी करता है।

— xnor

मुझे यकीन नहीं है कि मैंने ऐसा क्यों किया ... धन्यवाद!

— डेनिस

1

41 बाइट्स । लेकिन idk अगर कोई फ़ंक्शन कॉल f(n,*s)वैध माना जाता है

— फेलिप नारदी बतिस्ता

9

पायथन 2 , 59 57 50 46 बाइट्स

-2 बाइट्स एंडर्स कासेगोर को धन्यवाद। -4 बाइट्स डेनिस की बदौलत।

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

इसे ऑनलाइन आज़माएं!

— totallyhuman
स्रोत

6

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

— रिले
स्रोत

TFW आप 30 मिनट खर्च करने के लिए @Riley साबित करने के लिए कुछ के साथ आने की कोशिश कर रहे हैं ²0‹iजो सबसे अच्छा मार्ग नहीं है और सचमुच 0 विकल्प के साथ आते हैं।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn मैंने पहले की तरह कुछ का उपयोग किया है ²0‹iऔर मुझे हमेशा लगता है कि कुछ बेहतर होना चाहिए।

— रिले

मुझे लगता है कि मैंने अब लगभग 10 बार एक विकल्प खोजने की कोशिश की है ... अपने जीवन के 3 घंटे संचयी बर्बाद कर रहा हूँ ।_। Ä.D)øJ¹0‹iRसबसे अच्छा मैं आपको कॉपी किए बिना कर सकता हूं, मुझे लगता है कि आपका अनुकूलित है।

— मैजिक ऑक्टोपस Urn

यदि आप परवाह करते हैं, तो Emigna ने è यहां उपयोग किया है , हालांकि मुझे इस परिदृश्य में इसे लागू करने का कोई तरीका नहीं मिल रहा है। यदि अधिकतम 1 बाइट बचती है, तो।

— मैजिक ऑक्टोपस Urn

SÂÎ›@²Ä×J, Îयदि आप ऑर्डर बदलते हैं तो 0 और इनपुट काम करता है। 1 बाइट बचाता है! (इसके अलावा अगर, तो इसे बंद करने की आवश्यकता नहीं है) की जगह

— कलसोवरस

5

MATL , 9 बाइट्स

y|Y"w0<?P

इनपुट्स हैं: संख्या, फिर स्ट्रिंग।

Newlines के साथ तार इनपुट का उपयोग कर रहे हैं 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)

— लुइस मेंडो
स्रोत

5

हास्केल , 41 36 बाइट्स

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

इसे ऑनलाइन आज़माएं!

उदाहरण उपयोग: f (-3) "abc"पैदावार "cccbbbaaa"।

संपादित करें: xnor के लिए -5 बाइट्स धन्यवाद!

— Laikoni
स्रोत

1

के (<*[1..n])लिए है ((<$[1..n])=<<)।

— xnor

@xnor धन्यवाद! यह जानकर अच्छा लगा।

— लकोनी

5

वी , 29, 23, 18 , 17 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Hexdump:

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

6 बाइट बचाने के लिए @ nmjcman101 को धन्यवाद, जिसने मुझे एक और 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.

— DJMcMayhem
स्रोत

फिर के लिए कुछ बाइट्स यह ऑनलाइन कोशिश करो! मैं हमेशा नफरत करता हूँ "नकारात्मक संख्या कुछ और मतलब है!" किनारे का मामला भी। यह एक ऐसा मामला है जहां 0V में आपके विशेष मामले सुपर काम में आए।

— nmjcman101

नकारात्मक संख्या विशेष के बारे में क्षमा करें। हालांकि, बहुत सारे उत्तर उनके मुख्य उत्तर में शामिल करने में कामयाब रहे। इस वी एक पर प्रभावशाली हालांकि।

— ग्रीफॉन -

@ nmjcman101 ओह वाह, यह इतना स्पष्ट है, मुझे नहीं पता कि मैंने इसके बारे में कैसे नहीं सोचा। धन्यवाद!

— डीजेमेकमेमे

@Gryphon ओह मुझे पता है। चुनौती ठीक है, मैं अपनी भाषा को इतना बुरा मानने के लिए नापसंद करता हूं जितना अच्छा होना चाहिए। : पी

— DJMcMayhem

5

आर, 83 78 76 बाइट्स

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

अनाम फ़ंक्शन।

फ्रेडरिक ने 3 बाइट्स बचाए, ग्यूसेप ने 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!!

— बीएलटी
स्रोत

2

बहुत बढ़िया ! आप कुछ बाइट्स लिखकर rep(foo,,,3)या rep(foo,e=3)(एक ही तरह से) बचा सकते हैं ;-)

— Frédéric

@ Frédéric तुम मुझे यह करने के लिए हरा, मैं एक ही बात कहने जा रहा था!

— Giuseppe

1

हां कोई समस्या नहीं! मूल रूप से, मैं ब्रेसिज़ से छुटकारा पाना चाहता था, इसलिए मुझे छुटकारा पाने की आवश्यकता थी a=। इसलिए, मैंने aरिवर्स फ़ंक्शन के लिए एक तर्क के रूप में मूल्य का उपयोग किया है i<0, अगर सशर्त फ़ंक्शन को वापस करके (यही वजह है कि मुझे बैकक्वाट्स की आवश्यकता थी)। लेकिन मुझे i>=0मामले के लिए पहचान समारोह को लागू करने की भी आवश्यकता थी , इसलिए मैंने उपयोग किया (जो कि काफी करीब है। (वास्तव में एक समारोह है। आर अजीब है।

— Giuseppe

1

Btw, Paren के लिए R डॉक्स का कहना है कि (शब्दार्थ पहचान के बराबर हैfunction(x)x

— Giuseppe

1

76 बाइट्स

— ग्यूसेप

4

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

— Emigna
स्रोत

4

PHP> = 7.1, 65 बाइट्स

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

PHP सैंडबॉक्स ऑनलाइन

— जार्ग हुल्सरमन
स्रोत

1

पूर्णांक संदर्भ में, $n<0इसका मान समान है $n<0?:0लेकिन यह 3 बाइट्स छोटा है

— अक्षीय

4

ब्रेन-फ्लैक (ब्रेनहैक) , 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
{}

— गेहूं का जादूगर
स्रोत

4

जे , 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

— Tikkanz
स्रोत

2

(#~|)A.~0-@>]13 बाइट्स के लिए

— मील

बहुत अच्छा @ मीलों!

— तिककंज

कोई बात नहीं। आपको क्रिया को लागू करने के लिए उपयोग किए जाने वाले कोष्ठकों को गिनने की भी आवश्यकता नहीं है।

— मील

1

इसके अलावा 13 बाइट्स:#~ ::(|.@#~|)

— FrownyFrog

3

दिल्लोग एपीएल, 15 बाइट्स

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

बाएं तर्क के रूप में स्ट्रिंग, सही तर्क के रूप में संख्या।

इसे ऑनलाइन आज़माएं!

कैसे?

⍺/⍨ - स्ट्रिंग दोहराएं

|⍵ - एब्स (संख्या) बार

⌽⍣ - अगर रिवर्स

(⍵<0) - संख्या 0 से नीचे है

— Uriel
स्रोत

उम्म, यह अच्छा होगा अगर टीआईओ जैसे काम करता है?

— ग्रिएफॉन -

@Gryphon और यहाँ बाइट जाता है ...

— Uriel

हां, मुझे यह एहसास हुआ कि मैं आपको बताने के लिए अपनी टिप्पणी टाइप कर रहा हूं।

— ग्रिफ़ॉन -

3

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

— लुइस मेंडो
स्रोत

जिस आयाम के साथ फ्लिप करना था उसे चुनना उस गड़बड़ से बेहतर था जिसे मैंने flip +1 लिखा था। और मैं हमेशा repelemमौजूद हूं ।

— स्टेवि ग्रिफिन

@StewieGriffin खैर, आप इसे अपने उत्तर में भी शामिल कर सकते हैं :-) (+1 पहले ही)। मुझे लगता है कि repelemऑक्टेव में कोई नहीं है, अब के लिए

— लुइस मेन्डो

3

ब्रेन-फ्लैक (हास्केल) , 202 192 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह ऐसा करने के लिए शायद सबसे खराब संभव भाषा है, लेकिन यह किया जाता है। Haskell दुभाषिया प्रदान करने के लिए @Wheatwizard को धन्यवाद, जो मिश्रित इनपुट स्वरूपों की अनुमति देता है। यह इसके बिना लगभग 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
{}

— DJMcMayhem
स्रोत

आप 2 बाइट्स को बचाने के लिए मेरे 52 बाइट एब्स का उपयोग कर सकते हैं, आप 6 बाइट्स को बचाने के लिए 50 बाइट्स-लैब्स का उपयोग कर सकते हैं जो मैंने आपको और वेतन वृद्धि के बजाय घटाया है।

— गेहूं जादूगर

1

कुछ दोस्ताना प्रतियोगिता।

— गेहूं जादूगर

3

जावा (ओपनजेडके 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 बाइट्स @ नवीन को धन्यवाद

— ओलिवियर ग्रेजायर
स्रोत

ऐसे विचार जो काम नहीं करते (अब लंबे समय तक): पहले स्ट्रिंग को उल्टा करें, एक धारा का उपयोग करें,

— ओलिवियर ग्रेजायर

1

2 बाइट्स के साथ सहेजेंs[(n<0?-l-~i:i)/n]

— Xanderhall

@Xanderhall धन्यवाद! मैं देख रहा हूँ कि इतनी देर तक मेरी आँखों से खून बह रहा है। मुझे पता था कि यह संभव है, मैंने इसे लागू करते समय सब कुछ गड़बड़ कर दिया।

— ओलिवियर ग्रेजायर

1

@ user902383 हाँ, यह अनिवार्य है । यदि वे वैकल्पिक होते, तो बहुत सारी चीजें अपठनीय होतीं। इसके अलावा, मेरा कार्य एक "एकल कथन" नहीं है, बल्कि एक लूप है, जिसमें कई कथन शामिल हैं।

— ओलिवियर ग्रेजायर

1

आप iहालत में वृद्धि करके 1 बाइट बचा सकते हैं s->n->{for(int l=s.length*(n<0?-n:n),i=0;i++<l;)System.out.print(s[(n<0?i-l:i-1)/n]);}। एक और बाइट को -l से 0 ( 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

ऑक्टेव , 49 बाइट्स

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

इसे ऑनलाइन आज़माएं!

मैं कल एक स्पष्टीकरण प्रदान करूंगा।

— स्टीवी ग्रिफिन
स्रोत

2

माणिक , 59 +1 = 60 बाइट्स

-nध्वज का उपयोग करता है ।

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

इसे ऑनलाइन आज़माएं!

— पावेल
स्रोत

1

eval$_$_.to_i1 बाइट से छोटा है । String#charsएक ब्लॉक को भी उसी तरह स्वीकार String#each_charकर सकता है। अंत में, प्रत्येक वर्ण को संसाधित करने से पहले इनपुट को उल्टा करें ताकि आप इसे सीधे प्रिंट कर सकें (अपने झंडे को स्विच कर रहे हैं -n)। यह सब मिलकर 55 + 1 = 56 बाइट्स बन जाता है।

— मूल्य स्याही

2

चारकोल , 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

— नील
स्रोत

2

CJam , 9 बाइट्स

q~__*@e*%

इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत

2

जाप , 12 बाइट्स

®pVaÃ¬r!+sVg

इसे ऑनलाइन आज़माएं!

व्याख्या

स्ट्रिंग Uऔर पूर्णांक का निहित इनपुट V।

®pVaÃ

( दोहराया ) ( ) ( ) ( बार ®) के प्रत्येक अक्षर का नक्शा ( ) ।Upabs(V)Va

¬r

स्ट्रिंग को वर्णों की एक सरणी में बदल दें ( ¬) और कम करें ( r) के साथ ...

!+sVg

"!+".slice(sign(V))- यह या तो साथ कम कर देता है +→ a + b, या के साथ !+→ b + a।
थैंक्स @Arnauld बैकवर्ड-कम विचार के लिए!

— जस्टिन मेरिनर
स्रोत

मुझे ऐसा लगता है कि मुझे £gY*Vg)pVaछोटे समाधान की ओर अग्रसर होना चाहिए, लेकिन मेरा दिमाग छुट्टियों के लिए बंद हो गया है, इसलिए मैं इसका पता नहीं लगा सकता। आप इसके साथ कुछ करने में सक्षम हो सकते हैं, हालांकि।

— झबरा

2

वेंडीस्क्रिप्ट , 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
}

— फेलिक्स गुओ
स्रोत

2

C89 बाइट्स

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

मैंने बेन पेरलिन के संस्करण को देखा और सोचा कि क्या आप अभी भी कम नहीं हो सकते हैं और एक पूर्ण कार्यक्रम भी कर सकते हैं; निश्चित रूप से, atoi()और putchar()बाइट्स के संदर्भ में यह महंगा नहीं है? लगता है मैं सही था!

— एंड्रिया
स्रोत

2

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

कोशिश करो!

— KarlKastor
स्रोत

आप इस उलट-पलट वाले तर्क के साथ दो बाइट बचा सकते हैं

— जकोब्लाव जूल

2

पायथन 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

इसे ऑनलाइन आज़माएं!

— कवि
स्रोत

नमस्कार, और साइट पर आपका स्वागत है! दुर्भाग्य से, यह उत्तर अभी अमान्य है, क्योंकि यह ऋणात्मक संख्याओं का समर्थन नहीं करता है । चुनौती का कहना है:If the integer is negative, we use its absolute value in the first step, and then reverse the string.

— DJMcMayhem

इसे ठीक करने के लिए धन्यवाद! BTW, आप दो बाइट्स बंद कोष्टक के बाद रिक्त स्थानों को हटाकर ले सकता है)

— DJMcMayhem

संपादित, योगदान के लिए धन्यवाद

— कावी

n<0 else=>n<0else

— जकार्ही

1

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

— steenbergh
स्रोत

1

मैथेमेटिका, 89 बाइट्स

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

इनपुट

["हैलो वर्ल्ड!", 3]

— J42161217
स्रोत

1

ब्रिंगोल्फ , 22 बाइट्स

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

इसे ऑनलाइन आज़माएं!

एह, बुरा नहीं है।

एक पूर्णांक और वर्णों के एक सरणी के रूप में इनपुट लेता है।

वैकल्पिक रूप से:

ब्रिंगोल्फ , 31 बाइट्स

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

इसे ऑनलाइन आज़माएं!

एक पूर्णांक और एक स्ट्रिंग के रूप में इनपुट लेता है

— Skidsdev
स्रोत

1

सी, 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;}

एक फ़ंक्शन घोषणा के साथ शुरू करना जो एक इंट और स्ट्रिंग लेता है और एक स्ट्रिंग पैदा करता है (ऐसा लगता है कि मेमोरी उपदेशित नहीं है और इसे बनाया जाना चाहिए) ऐसा लगता है कि सीधे-आगे का दृष्टिकोण क्लीवर होने के किसी भी प्रयास से कम है जिसे मैंने कोशिश की थी ।

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;

}

— बेन पेरलिन
स्रोत

यह नकारात्मक n के लिए काम नहीं करता है।

— गैस्ट्रोपनर

एक संख्या से एक स्ट्रिंग गुणा करें!

आपका कार्य:

इनपुट:

आउटपुट:

उदाहरण:

स्कोरिंग:

जेली , 6 5 4 बाइट्स

यह काम किस प्रकार करता है

जावास्क्रिप्ट (ईएस 6), 63 बाइट्स

परीक्षण के मामलों

पायथन 3 , 44 बाइट्स

पायथन 2 , 59 57 50 46 बाइट्स

05AB1E , 10 बाइट्स

MATL , 9 बाइट्स

व्याख्या

हास्केल , 41 36 बाइट्स

वी , 29, 23, 18 , 17 बाइट्स

आर, 83 78 76 बाइट्स

05AB1E , 10 बाइट्स

PHP> = 7.1, 65 बाइट्स

ब्रेन-फ्लैक (ब्रेनहैक) , 154 152 बाइट्स

व्याख्या

जे , 19 15 13 बाइट्स

दिल्लोग एपीएल, 15 बाइट्स

MATLAB, 37 बाइट्स

ब्रेन-फ्लैक (हास्केल) , 202 192 बाइट्स

जावा (ओपनजेडके 8) , 99 98 89 87 85 बाइट्स

ऑक्टेव , 49 बाइट्स

माणिक , 59 +1 = 60 बाइट्स

चारकोल , 16 बाइट्स

CJam , 9 बाइट्स

जाप , 12 बाइट्स

व्याख्या

वेंडीस्क्रिप्ट , 46 बाइट्स

स्पष्टीकरण (अनप्लग्ड):

C89 बाइट्स

Pyth, 13 11 बाइट्स

व्याख्या

पुराने दृष्टिकोण, 13 बाइट्स

पायथन 3 , 68 बाइट्स

QBIC , 32 बाइट्स

व्याख्या

मैथेमेटिका, 89 बाइट्स

ब्रिंगोल्फ , 22 बाइट्स

ब्रिंगोल्फ , 31 बाइट्स

सी, 109 बाइट्स