95

एक बार जब मैंने एक जावास्क्रिप्ट प्रोग्राम लिखा जो इनपुट स्ट्रिंग एंड कैरेक्टर के रूप में लेगा और पहले वर्ण और इनपुट के रूप में दिए गए चरित्र को छोड़कर सभी वर्णों को हटा देगा।

उदाहरण के लिए, इनपुट के साथ codegolf.stackexchange.comऔर eचरित्र पैदावार के लिए यह गणना :

codegolf.stackexchange.com
cdegolf.stackexchange.com
cegolf.stackexchange.com
ceolf.stackexchange.com
celf.stackexchange.com
cef.stackexchange.com
ce.stackexchange.com
cestackexchange.com
cetackexchange.com
ceackexchange.com
ceckexchange.com
cekexchange.com
ceexchange.com
ceechange.com
ceehange.com
ceeange.com
ceenge.com
ceege.com
ceee.com
ceeecom
ceeeom
ceeem
ceee

यह पहला चरित्र और सभी को रखता है e। अन्य सभी पात्रों को एक-एक करके हटा दिया जाता है।

आपका कार्य एक प्रोग्राम (या फ़ंक्शन) लिखना है जो दो इनपुट और आउटपुट (या रिटर्न) लेता है एक स्ट्रिंग जो इस प्रभाव को पूरा करती है।

विशेष विवरण

आप यह मान सकते हैं कि स्ट्रिंग में कोई नया अंक नहीं होगा।
दूसरा इनपुट हमेशा एक वर्ण का होगा।
यदि उत्तर एक फ़ंक्शन के रूप में है, तो आप आउटपुट में प्रत्येक पंक्ति वाले स्ट्रिंग की एक सरणी वापस कर सकते हैं।
आउटपुट में एक अनुगामी न्यूलाइन हो सकती है।

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

Test Cases, s:

Test Cases
Tst Cases
Ts Cases
TsCases
Tsases
Tsses
Tsss

Make a "Ceeeeeeee" program, e:

Make a "Ceeeeeeee" program
Mke a "Ceeeeeeee" program
Me a "Ceeeeeeee" program
Mea "Ceeeeeeee" program
Me "Ceeeeeeee" program
Me"Ceeeeeeee" program
MeCeeeeeeee" program
Meeeeeeeee" program
Meeeeeeeee program
Meeeeeeeeeprogram
Meeeeeeeeerogram
Meeeeeeeeeogram
Meeeeeeeeegram
Meeeeeeeeeram
Meeeeeeeeeam
Meeeeeeeeem
Meeeeeeeee

Hello World!, !:

Hello World!
Hllo World!
Hlo World!
Ho World!
H World!
HWorld!
Horld!
Hrld!
Hld!
Hd!
H!

Hello World!, z:

Hello World!
Hllo World!
Hlo World!
Ho World!
H World!
HWorld!
Horld!
Hrld!
Hld!
Hd!
H!
H

alphabet, a:

alphabet
aphabet
ahabet
aabet
aaet
aat
aa

upperCASE, e:

upperCASE
uperCASE
uerCASE
ueCASE
ueASE
ueSE
ueE
ue

यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड (बाइट्स में) जीतता है।

code-golf string

— फल तोड़ना
स्रोत

27

किंडा यादृच्छिक, लेकिन +1

— TuxCrafting

25

+1 के लिएMeeeeeeeeegram

— FlipTack

इस मामले में कि यह एक सरणी देता है, क्या प्रत्येक तत्व को एक अनुगामी न्यूलाइन शामिल करना है?

— ब्रैड गिल्बर्ट b2gills

@ ब्रैडगिल्बर्ब २गिल्स नं।

— फलों का संग्रह

4

Meeeeeeeeeeeeem

— गणित 7

5

वी , 12 बाइट्स

òYpó.“„a]òd

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

Hexdump:

00000000: f259 70f3 2e93 8412 615d f264            .Yp.....a].d

मैंने चुनौती से पहले उपलब्ध वी के नवीनतम संस्करण के साथ इसका परीक्षण किया है , और सब कुछ सही ढंग से चलता है, जिससे यह उत्तर प्रतिस्पर्धा में आता है।

स्पष्टीकरण:

ò         ò    " Recursively:
 Yp            "   Duplicate this line
   ó           "   Remove:
    .a]      "     A compressed regex
            d  " Delete our extra line

संपीडित रेगेक्स का अनुवाद होता है

.\zs[^e]

जिसका मतलब है

.           " Any character
 \zs        " Leave the previous character out of the selection
    [^e]    " Any character except for 'e' (Or whatever is given for input)

गैर-प्रतिस्पर्धात्मक संस्करण (11 बाइट्स)

Ypजब यह चुनौती पोस्ट की गई थी तो यह संस्करण उस शॉर्टकट का उपयोग करता है जो उपलब्ध नहीं था।

— DJMcMayhem
स्रोत

@ चैलेंजर 5 बहुत बढ़िया! मैं एक पुराने संस्करण को देखूंगा और सत्यापित करूंगा कि यह सही ढंग से काम करता है। मुझे इसे थोड़ा संशोधित करना पड़ सकता है। अपडेट होने के बाद मैं आपको पिंग करूंगा।

— DJMcMayhem

@ चैलेंजर 5 मैंने जवाब संपादित किया है, और सत्यापित किया है कि जब चुनौती पोस्ट की गई थी तब इस संस्करण ने काम किया था।

— DJMcMayhem

मैं लिनक्स सिस्टम पर फ़ाइल में संग्रहीत विम आदेशों के एक समूह को कैसे निष्पादित करूंगा? क्या मैं cat filename | vimया मैं कुछ और करता?

— cjjbgames

31

विम, 27, 26 , 25 बाइट्स

DJqqYp:s/.\zs[^<C-r>-]<CR>@qq@qD

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

इनपुट इस प्रारूप में आता है:

e
codegolf.stackexchange.com

मेरा भोला पहला दृष्टिकोण तीन बाइट्स लंबा है:

i:s/.\zs[^<Right>]<Esc>"addqqYp@a@qq@qdd

मैं इस जवाब से भी खुश हूं क्योंकि यह मेरे नाम के साथ शुरू होता है।

DJqq:t$|s/.\zs[^<C-r>"]<CR>@qq@qD
DJMcMayhem

समानता देखें? एह?

कम सफल दृष्टिकोण:

i:s/.\zs[^<Right>]<Esc>"addqqYp@a@qq@qdd
i:s/.\zs[^<Right>]<CR>@q<Esc>"adkqqYp@aq@qdd
DJ:s/.\zs[^<C-r>"]<CR>uqqYp@:@qq@qdd
DJqq:t.|$s/.\zs[^<C-r>"]<CR>@qq@qdd

स्पष्टीकरण:

D                                   " Delete everything on this first line
 J                                  " Remove this empty line
  qq                                " Start recording into register 'q'
    Y                               " Yank this line
     p                              " And paste it
      :s/                           " Run a substitute command on the last line in the buffer. Remove:
         .                          "   Any character
          \zs                       "   Move the selection forward (so we don't delete the first one)
             [^<C-r>-]              "   Followed by anything *except* for the character we deleted
                      <CR>          " Run the command
                          @q        " Call register 'q'
                            q       " Stop recording
                             @q     " Run the recursive macro
                               D    " Delete our extra line

— DJMcMayhem
स्रोत

1

मुझे लगता है कि आपको वहां एक टाइपो मिला है जहां इनपुट दिया गया है kबहुत ज्यादा है :)

— geisterfurz007

@ geisterfurz007 मुझे यकीन नहीं है कि अगर मुझे मिलता है तो आपका क्या मतलब है?

— DJMcMayhem

यह (...)comkवर्तमान में 5 लाइन में कहते हैं ।

— जियोस्टरफ़रज़ 007

:tयहाँ उपयोग करने का कोई कारण नहीं है। सामान्य Ypबाइट को बचा लेगा। आपको निश्चित रूप से स्विच करना होगा <C-R>-। ठेठ पीपीसीजी नियम निराशाजनक हैं, क्योंकि किसी भी उचित परीक्षण के मामले के लिए, :t.|sसाथ ही सही 99@:भी 999@:होगा, लेकिन उस तरह से एक अनंत दोहराने के लिए कोई अच्छा तरीका नहीं है । आप कम दिलचस्प स्ट्रेट्स का उपयोग करने के लिए मजबूर हैं।

— udioica

22

MATL , 20 16 बाइट्स

y-f1X-"t[]@X@q-(

इसे ऑनलाइन आज़माएं! या परीक्षण मामलों को सत्यापित करें: 1 , 2 , 3 , 4 , 5 ।

बोनस

स्ट्रिंग को धीरे-धीरे सिकुड़ते हुए देखने के लिए संशोधित कोड (ऑफ़लाइन संकलक):

y-f1X-"tt.3Y.XxD[]@X@q-(].3Y.XxDvx

या इसे MATL ऑनलाइन पर आज़माएं!

व्याख्या

y        % Implicitly input string and char. Duplicate string onto top
-        % Subtract. Gives nonzero for chars in the input string that are
         % different from the input char
f        % Array of indices of nonzero values
1X-      % Remove 1 from that array. This gives an array of the indices of 
         % chars to be removed from the string
"        % For each
  t      %   Duplicate previous string
  []     %   Push empty array
  @      %   Push index of char to be removed. But this index needs to be 
         %   corrected to account for the fact that previous chars have
         %   already been removed...
  X@q-   %   ... So we correct by subtracting the 0-based iteration index
  (      %   Assign empty array to that position, to remove that char
         % Implicitly end for each
         % Implicitly display

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

3

GIFS! gifs शांत हैं!

— ब्रेन गाइडर

20

हास्केल, 50 बाइट्स

w@(a:x)%c|(d,_:y)<-span(==c)x=w:(a:d++y)%c|0<1=[w]

एक फ़ंक्शन को परिभाषित करता है (%)जो स्ट्रिंग्स की एक सूची लौटाता है।

व्याख्या

(%)के रूप में कहा जाता है w%c, wइनपुट स्ट्रिंग होने के साथ , और cचरित्र रखने के लिए। संक्षेप में, यह परिभाषा wपहले चरित्र ( a) और शेष ( x) को अलग करते हुए काम करती है, इसके xअलावा किसी अन्य चरित्र की पहली घटना को विभाजित करती है c, और पुन: अपने आप को उस एक चरित्र के साथ बुलाती है।

w@(a:x)%c              -- define (%) with w separated into a and x.
 |(d,_:y)<-span(==c)x  -- split x; bind the string of `c` to d, and the rest
                       -- to _:y, dropping first character and calling the rest y.
  =w:(a:d++y)%c        -- if there was a character to drop, cons w onto the
                       -- sequence gained by recursively calling (%) with that
                       -- character removed (i.e. call with a:d++y).
 |0<1=[w]              -- if nothing needed to be dropped, the result sequence is
                       -- simply the one-element list [w]

— डायने
स्रोत

3

क्या आप कोड समझा सकते हैं?

— bli

1

@ बिल्ली हो गया! उम्मीद है कि यह मदद करता है?

— dianne

14

रेटिना , 28 27 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

;{G*1`
R1r`(?!^|.*¶?\1$)(.)

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

व्याख्या

;{G*1`

यहाँ बहुत विन्यास है। मंच ही वास्तव में सिर्फ है G1`, जो केवल पहली पंक्ति रखता है, इनपुट चरित्र को त्याग देता है। *इसे सूखे रन में बदल देता है, जिसका अर्थ है कि परिणाम (यानी स्ट्रिंग की पहली पंक्ति) वास्तव में स्ट्रिंग को बदले बिना मुद्रित किया जाता है। {रेटिना को लूप में दोनों चरणों को चलाने के लिए कहता है जब तक कि स्ट्रिंग बदलना बंद न हो जाए और ;प्रोग्राम के अंत में आउटपुट को रोकता है।

R1r`(?!^|.*¶?\1$)(.)

यह पहला वर्ण देता है जो a) इनपुट की शुरुआत में नहीं है, b) अलग इनपुट चरित्र के बराबर नहीं है।

— मार्टिन एंडर
स्रोत

10

पिप , 22 26 24 22 बाइट्स

Lv+#Paa@oQb?++oPaRA:ox

पहले कमांड-लाइन तर्क के रूप में स्ट्रिंग, दूसरा के रूप में चरित्र। इसे ऑनलाइन आज़माएं!

व्याख्या

इनपुट के पात्रों पर लूप; यदि चरित्र विशेष वर्ण के बराबर है, तो अगले पर जाएं; यदि नहीं, तो इसे हटा दें और स्ट्रिंग प्रिंट करें।

एक ungolfed संस्करण ( a, bcmdline आर्ग मिलता है, oके एक मूल्य के साथ शुरू होता है 1, xहै ""):

P a         Print a
L #a-1      Loop len(a)-1 times:
 I a@o Q b   If a[o] string-eQuals b:
  ++o         Increment o
 E {         Else:
  a RA: o x   In-place in a, Replace char At index o with x (i.e. delete it)
  P a         Print a
 }

गोल्फ चाल:

के लिए लूप हैडर Lका केवल एक बार मूल्यांकन किया जाता है, इसलिए हम प्रारंभिक प्रिंट को वहां से हटा सकते हैं। निम्न-पूर्वता के #Pa-1कारण काम नहीं करेगा P(यह इस तरह से पार्स करेगा #P(a-1)), लेकिन हम इसे पहले से तैयार किए v+#Paगए vचर का उपयोग करके पुनर्व्यवस्थित कर सकते हैं -1।
RA:ऑपरेटर के नए मान देता है a, तो हम बजाय कि अभिव्यक्ति मुद्रित कर सकते हैं एक अलग होने का Paबयान।
अब यदि कथन की दोनों शाखाएँ एक ही भाव हैं, तो हम ?इसके बजाय टर्नरी ऑपरेटर का उपयोग कर सकते हैं ।

— DLosc
स्रोत

10

पर्ल 5, 29 बाइट्स

स्ट्रॉबेरी पर्ल का उपयोग करके मुझे 35 बाइट्स मिले: 31 बाइट्स, प्लस 1 फॉर की -nEजगह -e, प्लस 3 फॉर स्पेस + -i(सिंगल-लेटर इनपुट के लिए उपयोग किया जाता है; लंबा स्ट्रिंग एसटीडीआईएन से है)।

chomp;say;s/(.)[^$^I]/$1/&&redo

हालाँकि, मुझे इसमें कोई संदेह नहीं है कि यह chomp;उपयोग किए बिना संभव है <<<, जो कि 29 बाइट्स है, भले ही मैं इसे स्ट्राबेरी का उपयोग करके स्वयं परीक्षण नहीं कर सकता।

say;s/(.)[^$^I]/$1/&&redo

इस प्रकार:

perl -im -nE'say;s/(.)[^$^I]/$1/&&redo' <<< "example"

— msh210
स्रोत

आप बस "इनपुट में कोई नई पंक्ति नहीं" निर्दिष्ट कर सकते हैं (जो कि दूसरा प्रोग्राम कैसे काम करता है)। यदि आपको इनपुट में नई खामियों को दूर करने की आवश्यकता है, तो -lविकल्प पर गौर करें , जो एक स्वचालित न्यूलाइन हैंडलिंग मोड को चालू करता है जिसमें printएक अतिरिक्त न्यूलाइन (यहां अप्रासंगिक) प्रिंट करता है और -p/ -nइनपुट न्यूलाइन (बहुत प्रासंगिक) को हटा देता है। इसके अलावा, यह पदावनत है, लेकिन मुझे लगता है कि आप ^Iबचत के अतिरिक्त बाइट के लिए शाब्दिक नियंत्रण- I से बदल सकते हैं । अंत में, मुझे लगता है s/.\K[^$^I]/redo/eकि एक चरित्र छोटा होगा, हालांकि मैं 100% निश्चित नहीं हूं कि यह एक कानूनी जगह हैredo ।

@ ais523, newline सलाह के लिए धन्यवाद, लेकिन मुझे लगता है कि मैंने इस मुद्दे को पहले से ही अच्छी तरह से संभाला है। पुनः शाब्दिक ^I, यह अधिकांश नियंत्रण-पत्र चर के लिए सच है, लेकिन यह एक नहीं, IIRC है। री \Kऔर redoरिप्लेसमेंट में /e, धन्यवाद! जब मुझे मौका मिलेगा…

— msh210

... और यह काम नहीं करता है। @ ais523

— msh210

8

पर्ल 6 , 47 40 38 बाइट्स

->\a,\b{a,{S/^(."{b}"*:)./$0/}...^{$^a eq $^b}}

->\a,\b{a,{S/^(."{b}"*:)./$0/}...^&[eq]}

{$^b;$^a,{S/^(."$b"*:)./$0/}...^&[eq]}

विस्तारित:

{       # lambda with two placeholder parameters ｢$a｣ and ｢$b｣

  $^b;    # declare second parameter

  $^a,    # declare first parameter, and use it to seed the sequence

  {       # bare block lambda with implicit parameter ｢$_｣
    S/      # string replace and return
      ^       # beginning of string
      (       # capture into ｢$0｣
        .       # the first character
        "$b"*   # as many ｢$b｣ as possible
        :       # don't allow backtracking
      )
      .       # any character ( the one to be removed )

    /$0/      # put the captured values back into place
  }

  ...^      # repeat that until: ( and throw away the last value )

  &[eq]     # the infix string equivalence operator/subroutine

}

इसके ...^बजाय इसका उपयोग किया गया था ..., जो कि अंतिम मूल्य दोहराए &[eq]जाने Trueतक वापस नहीं आएगा ।

— ब्रैड गिल्बर्ट b2gills
स्रोत

7

05AB1E ,26 25 बाइट्स

¬ˆ[¦Ðg_#¬²k0Qi²ˆë¯J?,]¯J?

¬ˆ                         Put the first character into an array
  [                        While true
   ¦                       Remove the first character
    Ð                      Triplicate
     g_#                   if the string is empty, break
        ¬²k0Qi             if the first character is equal to the one specified in the input
              ²ˆ           Add it to the array
                ë          Else
                 ¯J?       Display the array
                    ,      Display the remaining string
                     ]     End while
                      ¯J?  Display the last string

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

कृपया ध्यान दें कि ¬²k0Q फिर से लिखा जा सकता है ¬²Q, लेकिन किसी कारण से यह काम नहीं करता है जब वर्तमान चरित्र एक उद्धरण चिह्न है: क्यू एक बूलियन के बजाय वास्तविक स्ट्रिंग देता है और यह एक अनंत लूप का कारण बनता है।

¯J?डुप्लिकेट होने के बाद से इस कोड को आगे बढ़ाया जा सकता है। इस भाग को लूप में ले जाने से दोहराव दूर होगा और यह क्लोजिंग स्क्वायर ब्रैकेट को छोड़ने की अनुमति देगा।

— Osable
स्रोत

DˆćUΔD²KRнõ.;DXìˆ}¯¨»21 के लिए, लेकिन वह नई कमांड का उपयोग करता है।

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

7

पायथन 2, 71 66 बाइट्स:

f,m=input();k=f[0]
while f:a=f[0]==m;k+=f[0]*a;f=f[1+a:];print k+f

एक पूरा कार्यक्रम। प्रारूप में STDIN के माध्यम से 2 इनपुट लेता है'<String>','<Char>' ।

इसके अलावा, यहाँ एक पुनरावर्ती समाधान वर्तमान में 140 बाइट्स पर है :

Q=lambda c,p,k='',j=1,l=[]:c and Q(c[1:],p,k+c[0]*(j<2)+c[0]*(c[0]==p),j+1,l+[k+c])or'\n'.join(sorted({*l},key=l.index))+('\n'+k)*(k not in l)

इसे प्रारूप में कहा जाना चाहिए print(Q('<String>','<Char>'))।

— आर। कप
स्रोत

मैं कोई अजगर नहीं हूँ, लेकिन क्या यह केवल एक लाइन नहीं छापना चाहिए?

— कॉनर ओ'ब्रायन

@ ConorO'Brien हाँ, मैंने पोस्ट को पहले गलत बताया है। यह अब तय हो गया है।

— आर। काप

7

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

def e(i,k):
 for r in i:
  if r!=k:i=i[0]+i[1:].replace(r,'',1);print(i)

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

e('😋🥕🍎🥓🥑🥓🥑🥒🍆🥔🍆🥓🍅🥜🥓🥔🍅🍄🍆','🥓')

आहार पर जाएं:

😋🥕🍎🥓🥑🥓🥑🥒🍆🥔🍆🥓🍅🥜🥓🥔🍅🍄🍆
😋🍎🥓🥑🥓🥑🥒🍆🥔🍆🥓🍅🥜🥓🥔🍅🍄🍆
😋🥓🥑🥓🥑🥒🍆🥔🍆🥓🍅🥜🥓🥔🍅🍄🍆
😋🥓🥓🥑🥒🍆🥔🍆🥓🍅🥜🥓🥔🍅🍄🍆
😋🥓🥓🥒🍆🥔🍆🥓🍅🥜🥓🥔🍅🍄🍆
😋🥓🥓🍆🥔🍆🥓🍅🥜🥓🥔🍅🍄🍆
😋🥓🥓🥔🍆🥓🍅🥜🥓🥔🍅🍄🍆
😋🥓🥓🍆🥓🍅🥜🥓🥔🍅🍄🍆
😋🥓🥓🥓🍅🥜🥓🥔🍅🍄🍆
😋🥓🥓🥓🥜🥓🥔🍅🍄🍆
😋🥓🥓🥓🥓🥔🍅🍄🍆
😋🥓🥓🥓🥓🍅🍄🍆
😋🥓🥓🥓🥓🍄🍆
😋🥓🥓🥓🥓🍆
😋🥓🥓🥓🥓

— गौयांग किन
स्रोत

6

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

(s,c)=>[...t=s.slice(1)].map(d=>c!=d?s+=`
`+s[0]+(t=t.replace(d,``)):s)&&s

— नील
स्रोत

मुझे लगता है कि यह f('test cases', 's')(के stssबजाय, के साथ समाप्त tsss) के लिए गलत आउटपुट पैदा करता है । मुझे लगता है कि ऐसा इसलिए है क्योंकि replaceयह पहला पॉश्चरेंस हटाता है, इसलिए यह लूप के चौथे पुनरावृत्ति में tदूसरे के बजाय पहले को हटा देता है । tmap

— 14

@ लिमिस ने यह इंगित करने के लिए धन्यवाद, मुझे लगता है कि मैं अपने संस्करणों में से एक "केवल" के लिए 7 बाइट का जुर्माना तय करने में सक्षम था।

— नील

5

रूबी, 148 139 97 90 83 77 62 बाइट्स

a,c=$*;p s=""+a;i=1;while d=s[i];(d!=c)?(s[i]="";p s):i+=1;end

यह निश्चित नहीं है कि क्या इस कोड पर शौकिया कोड स्वीकार किया जाता है, लेकिन मैं गोल्फ को सीखने में दिलचस्पी रखता हूं, हालांकि मैं इस पर भयानक हूं, किसी भी तरह की मदद से मैं इस कार्यक्रम को दूसरों के रूप में छोटा लग रहा हूं?

संपादित करें:

P के साथ बदला हुआ पुट

व्हाट्सएप के एक टन को हटा दिया और गेहूं के जादूगर को सही ढंग से धन्यवाद बाइट्स गिना

Challenger5 के लिए धन्यवाद से चला गया s=gets.chop;c=gets.chop;करने के लिएs,c=gets.chop,gets.chop;

के thenसाथ ;और धन्यवाद Mhutter के gets.chopसाथ बदल दिया gets[0]!

अब कमांड लाइन चर के रूप में इनपुट लेना, जैसे। prog.rb helloworld l

जगह jeroenvisser101 द्वारा कई सुधार के लिए धन्यवाद a=s.dupके साथ s=""+aऔर अगर बयान पिछले if s[i]!=c;s[i]="";p s;else i+=1;endके साथ (d!=c)?(s[i]="";p s):i+=1;बहुत बड़ा सुधार!

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

साइट पर आपका स्वागत है! मैं रूबी गोल्फिंग में विशेषज्ञ नहीं हूं लेकिन ऐसा लगता है कि आपके पास अतिरिक्त व्हाट्सएप है। विशेष रूप से =एस के आसपास । अधिक व्यापक सुझावों के लिए आप हमारे सुझावों पृष्ठ पर जा सकते हैं ।

— श्रीओटचिलिज्म ओ'ज़ैविक

उदाहरण के लिए, बाइट्स को हटाने का सबसे आसान तरीका अतिरिक्त व्हाट्सएप को खत्म करना है s=gets.chomp। मुझे यकीन नहीं है कि अगर आप रूबी में ऐसा कर सकते हैं, लेकिन पायथन जैसी कुछ भाषाओं में आप एक से अधिक असाइनमेंट को एक स्टेटमेंट में जोड़ सकते हैं, जैसे a,b,c=0,1,2।

— फल

अरे व्हॉट्सएप के बारे में टिप के लिए धन्यवाद माणिक प्रलेखन पढ़ें और महसूस किया कि अर्धविराम बयानों को समाप्त करने के लिए उन्हें प्रतिस्थापित कर सकते हैं: ') के रूप में बनाने के लिए s = get.chop और c = get.chop मैं खिचड़ी भाषा दे सकता है, c = get.chop या कुछ भी। कि दुर्भाग्य से वे निश्चित रूप से कोड का सबसे बड़ा हिस्सा हैं और मैं उस लंबे बयान को दूर करना चाहूंगा ..

— बेन हिली

तुम अब भी विशेष रूप से कीवर्ड से पहले कुछ अतिरिक्त रिक्त स्थान है ( do, thenऔर end) और चौथा चारों ओर =।

— श्रीओटीचिलिज्म ओजैविक

ऐसा लगता है कि आप बाइट काउंट पर खुद को बदल रहे हैं। मैं केवल 90 बाइट्स खुद गिनता हूं।

— श्रीओटीचिलिज्म ओ'ज़ैविक

4

c90, 129 125 बाइट्स

व्हॉट्सएप के साथ:

main(q, x)
{
    for (char **v = x, *a = v[1], *b = a, *c;*b++;)
        for (c = a; c == a | *c == *v[2] && *b != *v[2] && putchar(*c),
            ++c != b || *b != *v[2] && !puts(b););
}

बिना व्हाट्सएप के:

main(q,x){for(char**v=x,*a=v[1],*b=a,*c;*b++;)for(c=a;c==a|*c==*v[2]&&*b!=*v[2]&&putchar(*c),++c!=b||*b!=*v[2]&&!puts(b););}

ungolfed:

#include <stdio.h>
int main(int argc, char **argv)
{
    char *a = argv[1];
    for (char *b = a + 1; *b; b++) {
        if (*b == *argv[2]) {
            continue;
        }
        putchar(*a);
        for (char *c = a + 1; c != b; c++) {
            if (*c == *argv[2]) {
                putchar(*c);
            }
        }
        puts(b);
    }
}

यह स्ट्रिंग की शुरुआत के लिए एक पॉइंटर लेता है, और लूप्स, इस पॉइंटर को पुनरावृत्त करता है जब तक कि यह स्ट्रिंग के अंत तक नहीं पहुंचता। लूप के भीतर, यह पहले वर्ण को प्रिंट करता है, फिर दूसरे तर्क के किसी भी उदाहरण को स्ट्रिंग और पॉइंटर की शुरुआत के बीच पाता है। इसके बाद, यह पॉइंटर पर पुकारता है, बाकी स्ट्रिंग को प्रिंट करता है।

इसे एक ऐसे सिस्टम पर संकलित किया जाना चाहिए जहाँ sizeof (int) == sizeof (char *) हो। +3 बाइट्स अन्यथा।

यह पहली बार है जब मैंने यहां कोड गोल्फिंग की कोशिश की है, इसलिए मुझे यकीन है कि कुछ अनुकूलन किए जाने हैं।

— बॉबी सैकमानो
स्रोत

3

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

{×i←⊃1+⍸⍺≠1↓⎕←⍵:⍺∇⍵/⍨i≠⍳≢⍵}

⍺बहिष्कृत वर्ण ⍵है, प्रारंभिक स्ट्रिंग है

प्रिंट तर्क; iपहले गैर के सूचकांक को खोजें - ⍺पहले चार के बाद; यदि मिला, iहटाए गए के साथ पुनरावर्ती कॉल करें

— NGN
स्रोत

3

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

Most@FixedPointList[StringReplace[#,b_~~Except@a:>b,1]&,a=#2;#]&

अनाम फ़ंक्शन। इनपुट के रूप में दो स्ट्रिंग्स लेता है, और आउटपुट के रूप में स्ट्रिंग्स की एक सूची देता है। चरित्र के पहले गैर-उदाहरण को बार-बार हटाकर काम करता है।

— LegionMammal978
स्रोत

मैं निश्चित रूप से उपयोग शुरू करने जा रहा हूं FixedPointList।

— ngenisis

3

PHP, 88 84 86 85 82 81 78 बाइट्स

1 बाइट ने @ImamaelMiguel को धन्यवाद दिया, 3 बाइट के लिए धन्यवाद @ user59178, 3 बाइट से प्रेरित होकर @ user59178

while($b=substr("$argv[1]\n",$i++))$a>""&$b[0]!=$argv[2]?print$a.$b:$a.=$b[0];

कमांड लाइन तर्कों से इनपुट लेता है; साथ दौड़ोphp -r <code> '<string>' <character>

एक अंतर्निहित अंतिम प्रिंट के लिए इनपुट के लिए एक नई लाइन जोड़ता है।
यह कोड के 5 4 बाइट्स जोड़ता है , लेकिन आउटपुट और एक अतिरिक्त पर बचाता है echo$a;।

— टाइटस
स्रोत

1

$argv[1]."\n"के रूप में लिखा जा सकता है"$argv[1]\n"

— इस्माइल मिगुएल

1

जब तक $bइसमें एक नई पंक्ति जुड़ जाती है, तब तक यह हमेशा सत्य होगा जब तक कि इसकी लंबाई है = = 1. जैसा कि ""<यह अनावश्यक है।

— user59178

आप substr()असाइन करने के बजाए टर्नरी का उपयोग करके एक और बाइट बचा सकते हैं $b।

— 14:59 पर user59178

@ user59178 मैंने वास्तव में आपको वहां नहीं पकड़ा: मुझे substrशर्त और परिणाम दोनों के लिए परिणाम चाहिए print; इसलिए मुझे इसे कहीं सौंप देना चाहिए। लेकिन आपने मुझे प्रेरित किया।

— टाइटस

मेरा मतलब था for(;$b=substr($b?:".$argv[1]\n",1);)लेकिन आपके पास अब और भी बेहतर है।

— user59178

3

05AB1E, 26 24 23 बाइट्स

धन्यवाद @ बाइट 2 बाइट्स के लिए!
धन्यवाद @Emigna 1 बाइट के लिए!

¬UDvy²k0Êiy¡¬s¦yý«Xs«=¦

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

y²k0Êy²Êलेकिन हो सकता है" इसे गड़बड़ कर देता है।

यह शायद अधिक गोल्फ हो सकता है क्योंकि «दो बार दोहराया जाता है। यदि आपके पास कोई सुझाव या तरीका है तो कृपया उसे नीचे छोड़ दें।

— ओलिवर नी
स्रोत

3

जावा 10, 155 140 139 124 बाइट्स

c->s->{var r=s+"\n";for(int i=0;++i<s.length();)if(s.charAt(i)!=c)r+=(s=s.substring(0,i)+s.substring(i--+1))+"\n";return r;}

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

स्पष्टीकरण:

c->s->{          // Method with character and String parameters and String return-type
  var r=s+"\n";  //  Result-String, starting at the input-String with trailing new-line
  for(int i=0;++i<s.length();)
                 //  Loop over the characters of the String, skipping the first
    if(s.charAt(i)!=c)
                 //   If the current character and the input-character are equal
      r+=(s=s.substring(0,i)+s.substring(i--+1))
                 //     Remove this character from the String `s`
         +"\n";  //     And append the new `s` with trailing new-line to the result-String
  return r;}     //  Return the result-String

पुराने 139 बाइट्स पुनरावर्ती उत्तर:

void c(String s,int c){System.out.println(s);for(int i=1;i<s.length();)if(s.charAt(i++)!=c){c(s.substring(0,i-1)+s.substring(i),c);break;}}

-1 बाइट्स @ यूजीन को धन्यवाद । (अगली बार किसी और के पोस्ट को संपादित करने के बजाय एक टिप्पणी करें।)

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

स्पष्टीकरण:

void c(String s,int c){     // Method with String and integer parameters and no return-type
  System.out.println(s);    //  Print the input-String with trailing new-line
  for(int i=1;i<s.length();)//  Loop over the characters of the String, skipping the first
    if(s.charAt(i++)!=c){   //   If the current character and the input-character are equal
      c(s.substring(0,i-1)+s.substring(i),c); 
                            //    Remove this character, and do a recursive call
      break;}}              //    And stop the loop

— केविन क्रूज़सेन
स्रोत

क्या यह चार [], और सिर्फ s.charAt () का उपयोग करने से परेशान नहीं होगा?

— dpa97

@ dpa97 आह, आप पूरी तरह से सही हैं। मैंने पहली बार एक फॉरेस्ट लूप का इस्तेमाल किया, लेकिन इसे एक नियमित फॉर-लूप में बदल दिया। चार-सरणी को हटाना भूल गए। धन्यवाद।

— केविन क्रूजेसेन

2

सी #, 122 117 112 बाइट्स

IEnumerable F(string s,char c){for(int i=0;i<s.Length;++i)if(i<1||s[i]!=c)yield return i>0?s=s.Remove(i--,1):s;}

अधूरा:

public IEnumerable F(string s, char c) {
    for (int i = 0; i < s.Length; ++i) {
        if (i < 1 || s[i] != c)
            yield return i > 0 ? s = s.Remove(i--, 1) : s;
    }
}

स्ट्रिंग्स का एक संग्रह देता है।

— मानसिक
स्रोत

1

सामान्य संग्रह का उपयोग नहीं करने के साथ अच्छी चाल। लेकिन यह काम नहीं करेगा, अगर पिछले चार विशेष चार नहीं है c। उस मामले में लूप हमेशा के लिए काम करने की कोशिश करेगा।

— पाल्दीर

1

@ पाल्दिर वाह, आप सही कह रहे हैं! इस समय मेरे दिमाग को चालू करते हुए, एक बेहतर (और छोटा!) तरीका मिला।

— साइको

आप 2 बाइट्स को बचाने के लिए लूप के कोष्ठक को हटा सकते हैं।

— पमनएस

@PmanAce क्षमा करें, आपका क्या मतलब है? कौन सा कोष्ठक?

— साइको

सार्वजनिक IEnumerable F (string s, char c) {के लिए (int i = 0; मैं <s। लेज़र? ++ i) अगर (i <1 || s [i]! = c) यील्ड रिटर्न i> 0? s = s.Remove (i--, 1): एस; }

— 19

2

TSQL, 127 बाइट्स (परिवर्तनीय परिभाषाओं को छोड़कर)

DECLARE @1 VARCHAR(100)='codegolf.stackexchange.com'
DECLARE @2 CHAR(1) = 'o'

DECLARE @ char=LEFT(@1,1)WHILE patindex('%[^'+@2+']%',@1)>0BEGIN SET @1=STUFF(@1,patindex('%[^'+@2+']%',@1),1,'')PRINT @+@1 END

प्रारूपित:

DECLARE @1 VARCHAR(100) = 'codegolf.stackexchange.com'
DECLARE @2 CHAR(1) = 'o'
DECLARE @ CHAR = LEFT(@1, 1)

WHILE patindex('%[^' + @2 + ']%', @1) > 0
BEGIN
    SET @1 = STUFF(@1, patindex('%[^' + @2 + ']%', @1), 1, '')

    PRINT @ + @1
END

— dfundako
स्रोत

का अच्छा उपयोग patindex, लेकिन alphabetउदाहरण बिल्कुल सही नहीं लगता, यह aaphabetनीचे प्रदर्शित करता है aaa। यह भी उल्लेख के लायक है कि एक केस-संवेदी टकराव के साथ एक सर्वर या डेटाबेस पर चलना चाहिए, अन्यथा upperCASEउदाहरण भी विफल हो जाता है, ueEअपनी अंतिम पंक्ति पर प्रदर्शित होता है।

— ब्रैडेक

2

सी #, 135 138 :( 137 बाइट्स

golfed:

IEnumerable<string>F(string s,char c){int i=1,l;for(;;){yield return s;l=s.Length;while(i<l&&s[i]==c)i++;if(i==l)break;s=s.Remove(i,1);}}

Ungolfed:

    IEnumerable<string> F(string s, char c)
    {
        int i = 1, l;

        for (;;)
        {
            yield return s;

            l = s.Length;

            while (i < l && s[i] == c)
                i++;

            if (i == l)
                break;

            s = s.Remove(i, 1);
        }
    }

फ़ंक्शन स्ट्रिंग्स का संग्रह देता है।

EDIT1: @psycho ने देखा कि एल्गोरिथ्म को ठीक से लागू नहीं किया गया था।

EDIT2: के लिए बनाया गया चर s.Length। एक बाइट ने @TheLethalCoder को धन्यवाद दिया।

— paldir
स्रोत

1

इनपुट चार एक से अधिक बार मौजूद होने पर काम नहीं करेगा। Ex: के बजाय codeegolf eदेना होगा । cecee

— साइको

@psycho मैं के ifसाथ बदली whileऔर यह काम करता है।

— पाल्दीर

बेहतर है! लेकिन यह कम हो सकता है। मैं अपनी खुद की पोस्ट करूँगा!

— साइको

1

s.Lengthएक बाइट को बचाने के लिए एक वैरिएबल बनाएं :int i=1,l;for(;;){yield return s;l=s.Length;while(i<l&&s[i]==c)i++;if(i>=l)break;s=s.Remove(i,1);}}

— TheLethalCoder

2

पायथन 2 - 65 73 बाइट्स

lambda s,c:[s[0]+c*s[1:i].count(c)+s[i+1:]for i in range(len(s))]

और एक 76 बाइट्स पुनरावर्ती समाधान, क्योंकि फ़र्ट वन की तुलना में अधिक लंबा होने के बावजूद, मैं इसे बेहतर तरीके से पसंद करता हूं:

f=lambda s,c,i=1:s[i:]and[[s]+f(s[:i]+s[i+1:],c,i),f(s,c,i+1)][s[i]==c]or[s]

— Lulhum
स्रोत

2

रैकेट 194 बाइट्स

(let p((s s)(n 1)(t substring)(a string-append))(displayln s)(cond[(>= n(string-length s))""]
[(equal? c(string-ref s n))(p(a(t s 0 n)(t s n))(+ 1 n)t a)][else(p(a(t s 0 n)(t s(+ 1 n)))n t a)]))

Ungolfed:

(define (f s c)
  (let loop ((s s)
             (n 1))
    (displayln s)
    (cond
      [(>= n (string-length s))""]
      [(equal? c (string-ref s n))
       (loop (string-append (substring s 0 n) (substring s n))
             (add1 n))]
      [else
       (loop (string-append (substring s 0 n) (substring s (add1 n)))
             n)])))

परिक्षण:

(f "Test cases" #\s)
(f "codegolf.stackexchange.com" #\e)

आउटपुट:

Test cases
Tst cases
Tst cases
Ts cases
Tscases
Tsases
Tsses
Tsses
Tsss
Tsss
""
codegolf.stackexchange.com
cdegolf.stackexchange.com
cegolf.stackexchange.com
cegolf.stackexchange.com
ceolf.stackexchange.com
celf.stackexchange.com
cef.stackexchange.com
ce.stackexchange.com
cestackexchange.com
cetackexchange.com
ceackexchange.com
ceckexchange.com
cekexchange.com
ceexchange.com
ceexchange.com
ceechange.com
ceehange.com
ceeange.com
ceenge.com
ceege.com
ceee.com
ceee.com
ceeecom
ceeeom
ceeem
ceee
""

— rnso
स्रोत

2

जावास्क्रिप्ट (ईएस 6), 64 69

नई कड़ियों के साथ एक एकल स्ट्रिंग लौटना

s=>c=>[...s].map((x,i,z)=>i&&x!=c&&(z[i]='',s+=`
`+z.join``))&&s

F=
s=>c=>[...s].map((x,i,z)=>i&&x!=c&&(z[i]='',s+=`
`+z.join``))&&s
  

function update() {
  var s=S.value,c=C.value[0]
  O.textContent=F(s)(c)
}

update()

<input id=S value='Hello world!' oninput='update()'>
<input id=C value='!' oninput='update()'>
<pre id=O></pre>

स्निपेट का विस्तार करें

— edc65
स्रोत

इसमें थोड़ा अजीब है कि यह दो तर्क नहीं लेता है लेकिन एक तर्क है और फिर एक और फ़ंक्शन देता है जहां आपको दूसरा तर्क देने की आवश्यकता होती है। मुझे यकीन नहीं है कि यह अपेक्षित व्यवहार था।

— MT0

@ MT0 मैं अजीब है लेकिन इसे 2 तर्कों के साथ एक फ़ंक्शन के लिए स्वीकार किया जाता है, क्योंकि यह 1 बाइट बचाता है। मैं आपको एक संदर्भ देता हूँ जब मैं खोजता हूँ। यहाँ यह meta.codegolf.stackexchange.com/a/8427/21348

— edc65

महान तकनीक, मुझे पता नहीं था कि तीसरे तर्क को संशोधित करना .mapसंचयी था। मैंने देखा .map().filter()और सोचा "यह एक महान सरणी समझ बना देगा!", लेकिन सरणी समझ में सूचकांक की कमी ने इसे मार दिया और यह एक ही लंबाई में समाप्त हो गया: s=>c=>[for(x of(i=0,z=[...s]))if(--i&&x!=c)(z[~i]=~i?'':x,z.join``)](btw, मैं इन सभी के लिए 68 बाइट्स गिनता हूं।)

— Eproproductions।

1

वास्तव में, ([...z],c,i=0)=>[for(x of z)if(--i&&x!=c)(z[~i]=~i?'':x,z.join``)]

— परमों

@ETHproductions विश्वास नहीं कर सकता कि मैं फिर से बाइट की गिनती में गलत था । वैसे भी, मुझे फिर से इसके बारे में सोचने के लिए धन्यवाद, इसलिए मुझे मानक ES6 के साथ 64 मिला

— edc65

2

स्विफ्ट 3 - 151 147 बाइट्स

स्विफ्ट गोल्फिंग के लिए आदर्श भाषा नहीं है, खासकर जब यह स्ट्रिंग अनुक्रमण से संबंधित है। यह सबसे अच्छा मैं कर सकता है:

func c(a:String,b:String){print(a);var q=Array(a.characters),i=1;while i<q.count{if "\(q[i])" != b{q.remove(at:i);c(a:String(q),b:b);break};i=i+1}}

दुर्भाग्य से, स्विफ्ट को आसपास !=(लेकिन नहीं ==) के लिए रिक्त स्थान की आवश्यकता होती है , और स्विफ्ट 3 ने ++ऑपरेटर को गिरा दिया । इन दोनों के लिए चाल को एक वर्ण सरणी में परिवर्तित करना है जो पूर्णांक अनुक्रमण की अनुमति देता है, और वापस वर्ण में परिवर्तित करने के लिए एक वर्ण के स्ट्रिंग प्रक्षेप का उपयोग करता है String( "\(c)")।

Ungolfed:

func c(a:String, b:String) {
    print(a)
    var q = Array(a.characters)
    var i = 1
    while i < q.count {
        if "\(q[i])" != b {
            q.remove(at:i)
            c(a: String(q), b: b)
            break
        }
        i=i+1
    }
}

पिछला, गैर-पुनरावर्ती समाधान

func c(a:String,b:String){var q=Array(a.characters),e={q.removeFirst()},z="\(e())";print(a);while !q.isEmpty{"\(e())"==b ? z=z+b : print(z+String(q))}}

func c(a:String, b:String) {
    var q = Array(a.characters)
    var z = "\(q.removeFirst())"
    print(a)
    while !q.isEmpty {
        if "\(q.removeFirst())" == b {
            z = z + b
        }else{
            print(z + String(q))
        }
    }
}

— rabidaudio
स्रोत

PPCG में आपका स्वागत है! क्या कोड के अंत की ओर कुछ व्हाट्सएप को हटाया जा सकता है?

— ETHproductions 3

@ETHproductions दुर्भाग्य से नहीं, टर्नरी ऑपरेटर और whileसंकलन के लिए आवश्यक स्थान। मैं भी टाइप करने के साथ खेला Stringऔर printएक बंद करने के लिए सेट करने के लिए कोशिश कर रहा है , लेकिन वे किसी भी जगह को बचाने नहीं किया।

— रबीदाडियो

2

पाइके, 26 19 17 बाइट्स

jljjhF3<Q/Q*jih>s

यहाँ यह कोशिश करो!

                  - Q = input
j                 - j = input_2
 ljjhF3           - for (i, j, j[0]) for i in range(len(j))
       <          -     j[:i]
        Q/        -    ^.count(Q)
          Q*      -   ^*Q
                s -  sum(j[0], ^, V)
            jih>  -   j[i+1:]

— नीला
स्रोत

क्या आप एक स्पष्टीकरण जोड़ सकते हैं?

— फल

@ चैलेंजर 5 किया गया और 2 बाइट्स लगाए गए!

— ब्लू

1

गणितज्ञ, 78 बाइट्स

लानत है आप मार्टिन एंडर, मैं लगभग पहले था: पी

(i=2;a={c=#};While[i<=Length@c,If[c[[i]]==#2,i++,c=c~Drop~{i};a=a~Append~c]];a)&

बेनाम:; एक Whileलूप और कुछ अस्थायी चर के साथ सीधा कार्यान्वयन ।

— ग्रेग मार्टिन
स्रोत

ओह, चलो, हम दोनों जानते हैं कि गणितज्ञ अनिवार्य नहीं है

— LegionMammal978

1

<एक सफ़ेद झंडा>

— ग्रेग मार्टिन

1

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

मैंने सोचा कि यह एक आसान चुनौती होगी, लेकिन मुझे पूरा यकीन है कि मैं यहां कुछ याद कर रहा हूं।

पुनरावृत्ति का उपयोग करता है और स्ट्रिंग्स की एक सरणी देता है

(c,i=1,r)=>f=a=>a[i]?a[i++]==c?f(a):f(g=a.slice(0,i-1)+a.slice(i--),(r=r||[a]).push(g)):r

F=
  (c,i=1,r)=>f=a=>a[i]?a[i++]==c?f(a):f(g=a.slice(0,i-1)+a.slice(i--),(r=r||[a]).push(g)):r

G=_=>A.value.length>1 && (O.innerHTML = F(E.value)(A.value).join`
`)

G()

<input id=A oninput='G()' value='alphabet'>
<input id=E oninput='G()' value='a'>
<pre id=O>

स्निपेट का विस्तार करें

— बैसड्रॉब कंबरवुबवबब
स्रोत

1

ग्रूवी, 34 बाइट्स

{a,b->a.inject{i,r->i+=r==b?b:""}}

— जादू ऑक्टोपस Urn
स्रोत

1

एक पुराना जवाब पाने के लिए इतना अजीब है ...

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

एक "Ceeeeeeee" कार्यक्रम बनाओ

विशेष विवरण

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

वी , 12 बाइट्स

विम, 27, 26 , 25 बाइट्स

MATL , 20 16 बाइट्स

बोनस

व्याख्या

हास्केल, 50 बाइट्स

व्याख्या

रेटिना , 28 27 बाइट्स

व्याख्या

पिप , 22 26 24 22 बाइट्स

व्याख्या

पर्ल 5, 29 बाइट्स

पर्ल 6 , 47 40 38 बाइट्स

विस्तारित:

05AB1E ,26 25 बाइट्स

पायथन 2, 71 66 बाइट्स:

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

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

रूबी, 148 139 97 90 83 77 62 बाइट्स

c90, 129 125 बाइट्स

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

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

PHP, 88 84 86 85 82 81 78 बाइट्स

05AB1E, 26 24 23 बाइट्स

जावा 10, 155 140 139 124 बाइट्स

सी #, 122 117 112 बाइट्स

सी #, 135 138 :( 137 बाइट्स

पायथन 2 - 65 73 बाइट्स

रैकेट 194 बाइट्स

जावास्क्रिप्ट (ईएस 6), 64 69

स्विफ्ट 3 - 151 147 बाइट्स

पिछला, गैर-पुनरावर्ती समाधान

पाइके, 26 19 17 बाइट्स

गणितज्ञ, 78 बाइट्स

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

ग्रूवी, 34 बाइट्स