चुनौती का वर्णन

मदों की सूची / सरणी को देखते हुए, लगातार दोहराई जाने वाली वस्तुओं के सभी समूहों को प्रदर्शित करें।

इनपुट / आउटपुट विवरण

आपका इनपुट आइटमों की एक सूची / सरणी है (आप मान सकते हैं कि वे सभी एक ही प्रकार के हैं)। आपको हर प्रकार की भाषा का समर्थन करने की आवश्यकता नहीं है, लेकिन कम से कम एक का समर्थन करना है (अधिमानतः int, लेकिन प्रकार boolean, हालांकि बहुत दिलचस्प नहीं हैं, ठीक भी हैं)। नमूना आउटपुट:

[4, 4, 2, 2, 9, 9] -> [[4, 4], [2, 2], [9, 9]]
[1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4] -> [[1, 1, 1], [2, 2], [3, 3, 3], [4, 4, 4, 4]]
[1, 1, 1, 3, 3, 1, 1, 2, 2, 2, 1, 1, 3] -> [[1, 1, 1], [3, 3], [1, 1], [2, 2, 2], [1, 1], [3]]
[9, 7, 8, 6, 5] -> [[9], [7], [8], [6], [5]]
[5, 5, 5] -> [[5, 5, 5]]
['A', 'B', 'B', 'B', 'C', 'D', 'X', 'Y', 'Y', 'Z'] -> [['A'], ['B', 'B', 'B'], ['C'], ['D'], ['X'], ['Y', 'Y'], ['Z']]
[True, True, True, False, False, True, False, False, True, True, True] -> [[True, True, True], [False, False], [True], [False, False], [True, True, True]]
[0] -> [[0]]

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

[1, 1, 1, 2, 2, 3, 3, 3, 4, 9] ->

1 1 1
2 2
3 3 3
4
9

महत्वपूर्ण बात यह है कि समूहों को किसी तरह से अलग रखा जाए।

code-golf array-manipulation

— shooqie
स्रोत

शायद हम एक सूची का उत्पादन करते हैं जिसमें कुछ विशेष विभाजक मूल्य हैं?

— xnor

@ xnor: क्या आप एक उदाहरण प्रदान कर सकते हैं? intउदाहरण के लिए, द्वारा अलग किए गए s की एक सरणी 0एक बुरा विचार होगा क्योंकि 0इनपुट में s हो सकता है ...

— shooqie

उदाहरण के लिए, [4, 4, '', 2, 2, '', 9, 9]या [4, 4, [], 2, 2, [], 9, 9]।

— xnor

दरअसल, हमें किस प्रकार का समर्थन करना है। क्या तत्व स्वयं सूचियाँ हो सकते हैं? मुझे लगता है कि कुछ भाषाओं में अंतर्निहित प्रकार होते हैं जिन्हें मुद्रित नहीं किया जा सकता है या अजीब समानता-जांच हो सकती है।

— xnor

@xnor: हाँ, यही मेरी चिंता थी - यदि आपके इनपुट में इसके अंदर सूचियाँ हैं, तो एक विभाजक के रूप में खाली सूची का उपयोग करना भ्रमित कर सकता है। इसलिए मैंने शामिल किया "आप मान सकते हैं कि सभी आइटम एक ही प्रकार के हैं", ताकि एक विभाजक के रूप में एक अलग प्रकार का उपयोग कर सकें।

— शौकी

15

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

Split

... इसके लिए एक अंतर्निहित है।

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

9

…क्या आश्चर्य है!

— बजे

11

@ भाग्य को वास्तविक आश्चर्य यह है कि यह कितना छोटा है।

— मार्टिन एंडर

8

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

I0;œṗ

सभी संख्यात्मक प्रकारों के लिए काम करता है। इसे ऑनलाइन आज़माएं! या सभी संख्यात्मक परीक्षण मामलों की पुष्टि करें ।

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

I0;œṗ  Main link. Argument: A (array)

I      Increments; compute the differences of consecutive elements.
 0;    Prepend a zero.
   œṗ  Partition; split A at truthy values in the result to the left.

— डेनिस
स्रोत

8

रेटिना , 15 8 बाइट्स

एक सरल I / O प्रारूप सुझाने के लिए लिन का धन्यवाद।

!`(.)\1*

इनपुट को पात्रों की एक सूची के रूप में मानता है (और अलग-अलग समूहों को लाइनफीड का उपयोग करता है)।

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

यह बस समूहों के मिलान और उन सभी को प्रिंट करने के द्वारा काम करता है (जो स्वचालित रूप से लाइनफीड जुदाई का उपयोग करता है)।

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

मैंने पूछा कि abbcccddd→ a bb ccc dddस्वीकार्य I / O प्रारूप है, और OP ने इसे स्वीकृत किया है, इसलिए मुझे लगता !`(.)\1*है कि यह ठीक है?

— लिन

@ लियन ओह, यह वास्तव में बहुत सरल है, धन्यवाद।

— मार्टिन एंडर

4

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

f=
s=>s.replace(/(\w+) (?!\1\b)/g,`$1
`)
;

<input oninput=o.textContent=f(this.value);><pre id=o>

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

किसी भी अंतरिक्ष-अलग शब्द-जैसे टोकन पर काम करता है। @ मार्टिनएंडर ed की बदौलत 2 बाइट्स बचाए। सर्वश्रेष्ठ मैं सरणी इनपुट के लिए कर सकता था और रिटर्न 68 है:

a=>a.reduce((l,r)=>(l==r?c.push(r):b.push(c=[r]),r),b=[c=[a[0]]])&&b

— नील
स्रोत

1

मैंने एक सरणी उत्तर 56 में

— edc65

4

MATL , 9 बाइट्स

Y'v"@Z}Y"

Y'     % Take input. Run-length encoding. Gives two row arrays: values and run lengths
v      % Concatenate vertically   
"      % For each column
  @Z}  %   Push column and split into its two elements
  Y"   %   Run-length decoding
       % End for. Implicitly display

इनपुट संख्याओं की एक पंक्ति सरणी है , जिसमें विभाजक के रूप में रिक्त स्थान या अल्पविराम हैं।

इसे ऑनलाइन आज़माएं! गैर-पूर्णांक संख्याओं के साथ परीक्षण करें ।

MATL, 11 बाइट्स

lidgvYsG7XQ

इनपुट विभाजक के रूप में उपयोग करके संख्या या वर्णों का एक कॉलम सरणी है ;।

इसे ऑनलाइन आज़माएं! मनमानी संख्या के साथ टेस्ट करें । पात्रों के साथ परीक्षण करें ।

l     % Push 1
i     % Take input, say [4;4;2;2;9;9]
d     % Consecutive differences of input: [0;-2;0;7;0]
g     % Convert to logical: gives 1 if consecutive entries were different: [0;1;0;1;0]
v     % Concatenate vertically with the initial 1: [1;0;1;0;1;0]
Ys    % Cumulative sum. Each value is a group label: [1;1;2;2;3;3]
G     % Push input again
7XQ   % Split into horizontal arrays as indicated by group labels: {[4 4];[2 2];[9 9]}
      % Implicitly display

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

3

gs2, 2 बाइट्स

c-

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

cएक समूहबद्ध निर्माण है जो ठीक यही करता है, इसलिए हम इसे STDIN (जो एक स्ट्रिंग है, अर्थात, वर्णों की सूची) कहते हैं और तार की एक सूची प्राप्त करते हैं। दुर्भाग्य से, परिणाम इनपुट से अप्रभेद्य है, इसलिए हमें विभाजकों को जोड़ने की आवश्यकता है! -(रिक्त स्थान से जुड़ें) चाल करता है।

एक वैकल्पिक उत्तर है cα(CP437 के 2 बाइट्स), जो बस cएक अनाम फ़ंक्शन में लपेटता है।

— लिन
स्रोत

2

ब्रेकीलॉग , 13 बाइट्स

:{s.dl1}fs.c?

चेतावनी: यह बेहद अक्षम है, और आप समझेंगे कि स्पष्टीकरण में क्यों।

यह एक सूची (जैसे [1:1:2:2:2]) इनपुट के रूप में उम्मीद करता है। सूची के अंदर के तत्व बहुत ज्यादा कुछ भी हो सकते हैं।

व्याख्या

:{     }f       Find all ordered subsets of the Input with a unique element in them
  s.                Output is a subset of the input
    dl1             Output minus all duplicates has a length of 1 (i.e. one unique value)
         s.     Output is an ordered subset of those subsets
           c?   The concatenation of those subsets is the Input

यह s - Subsetएकीकृत होने के तरीके के कारण ही काम करता है: सबसे छोटे सेट अंत में हैं। इसलिए पहली बात यह है कि इनपुट के लिए सबसे लंबे रन होते हैं, उदाहरण के लिए [[1:1]:[2:2:2]]और उदाहरण के लिए नहीं [[1:1]:[2:2]:[2]]।

— Fatalize
स्रोत

2

जे , 13 बाइट्स

<;.1~1,2~:/\]

चूँकि J, ragged सरणियों का समर्थन नहीं करता है, इसलिए समान तत्वों के प्रत्येक रन को बॉक्स किया जाता है। इनपुट मूल्यों की एक सरणी है और आउटपुट बॉक्सिंग ऐरे का सरणी है।

प्रयोग

   f =: <;.1~1,2~:/\]
   f 4 4 2 2 9 9
┌───┬───┬───┐
│4 4│2 2│9 9│
└───┴───┴───┘
   f 1 1 1 3 3 1 1 2 2 2 1 1 3
┌─────┬───┬───┬─────┬───┬─┐
│1 1 1│3 3│1 1│2 2 2│1 1│3│
└─────┴───┴───┴─────┴───┴─┘
   f 'ABBBCDXYYZ'
┌─┬───┬─┬─┬─┬──┬─┐
│A│BBB│C│D│X│YY│Z│
└─┴───┴─┴─┴─┴──┴─┘
   f 0
┌─┐
│0│
└─┘

व्याख्या

<;.1~1,2~:/\]  Input: s
            ]  Identify function to get s
       2       The constant 2
           \   Operate on each overlapping sublist of size 2
        ~:/      Are the two values unequal, 1 if true else 0
     1,        Prepend a 1 to it
<;.1~          Using the list just made, chop s at each index equal to 1 and box it
               Return this as the result

— मील की दूरी पर
स्रोत

2

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

⊢⊂⍨1,2≠/⊢

⊢तर्क को पहले तत्व में
⊂⍨विभाजित किया
1गया
,और फिर
2≠/बाद के जोड़े जहां
⊢तर्क में भिन्न हैं

— एडम
स्रोत

2

पायथन 2, 43 बाइट्स

p=-1
for x in input():print"|"[:x^p],x,;p=x

मल की सूची पर काम करता है। उदाहरण:

>> [True,True,False,False,False,True,False,True,False]
 True  True | False  False  False | True | False | True | False

अंतिम देखी गई तत्व को संग्रहीत करते हुए, इनपुट सूची के माध्यम से Iterates। प्रत्येक तत्व से पहले एक विभाजक पट्टी मुद्रित की जाती है, जो कि पिछले से भिन्न होती है, जिसे बिटवाइस एक्सआर ^के रूप में जांचा p=-1जाता है। शुरुआती में पहले तत्व से पहले एक विभाजक से बचा जाता है।

— XNOR
स्रोत

बहुत बुरा groupbyहोता है ऐसा दर्द ...

— Sp3000

2

CJam, 9 बाइट्स

दो समाधान:

{e`:a:e~}
{e`{(*}%}

इसका परीक्षण यहां करें।

व्याख्या

e`   e# Run-length encode (gives a list of pairs [run-length value]).
:a   e# Wrap each pair in a singleton list.
:e~  e# Run-length decode each list.

या

e`   e# Run-length encode.
{    e# Map this block over each pair...
  (  e#   Pull out the run length.
  *  e#   Repeat the list containing only the value that many times.
}%

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

2

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

import Data.List
group

इसमें बिल्ट-इन है। किसी भी प्रकार पर काम करता है जो समानता का समर्थन करता है।

— XNOR
स्रोत

2

किसी भी कारण से यह सामुदायिक विकि है?

— 11

@ किसी को भी, जो हास्केल जानता है, उसे पोस्ट कर सकता था।

— xnor

1

यह अच्छा है लेकिन चूंकि कोई और ऐसा नहीं कर रहा है, आप मेटा के बारे में क्यों नहीं पूछते?

— बजे

2

MATL, 8 7 बाइट्स

@Suever के लिए 1 बाइट धन्यवाद निकाला गया

ly&Y'Y{

पूर्णांक / फ़्लोट्स / चार्ट / बुलियन / यूनिकॉर्न पॉइंट / अन्य काल्पनिक इनपुट के साथ काम करता है।
बूलियन के लिए, इनपुट हैं T/F, आउटपुट हैं 1/0।

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

समूहीकृत और दोहराया गया

ly&Y'Y{
l          % push 1 onto the stack
 y         % duplicate the input
  &Y'      % run-length encoding (secondary output only)
     Y{    % break up array into cell array of subarrays

— बीकर
स्रोत

1

सी #, 117 बाइट्स

void f(List<String>m){Console.Write(m[0]+String.Join("",m.GetRange(1,m.Count()-1).Select((i,j)=>i==m[j]?i:"\n"+i)));}

अनगढ़ (वास्तव में नहीं)

    public static void f(List<String>m)
    {
        Console.Write(m[0]+String.Join("",m.GetRange(1,m.Count()-1).Select((i,j)=>i==m[j]?i:"\n"+i)));
    }

— downrep_nation
स्रोत

1

अजगर, ९ by बाइट्स

mr9]dr8

2 बाइट के लिए @LeakyNun को श्रेय!

स्पष्टीकरण:

             input
     r8      run-length decode
m            for each...
   ]d        ...treat each run as standalone encoded form...
 r9          ...decode 
             print

पुराना उत्तर, 12 बाइट्स

hf.Am!t{dT./

अंतर्निहित लंबाई के बारे में भूल गए, लेकिन मुझे लगता है कि यह एक ठीक तरीका है, इसलिए मैंने इसे रखा।

स्पष्टीकरण:

                input
          ./    all possible partitions
 f       T      filter by...
  .A            ...whether all groups of integers...
    m!t{d       ...have length one after deduplication
h               get the first element (first one has no adjacent [1,1] and [1])
                print

— busukxuan
स्रोत

यह 7 बाइट्स है

— लीक

@LeakyNun ओह ठीक है! यह अच्छा है।

— बसुकक्सुआन

1

मेरा मानना है कि यह 6 के लिए काम करता है

— FryAmTheEggman

@FryAmTheEggman का अच्छा दुरुपयोग m।

— लीकी नून

@FryAmTheEggman वाह, मुझे समझ में नहीं आ रहा है

— बुसुकुआन जुआन

1

पायथ , 36 35 बाइट्स

VQIqNk=hZ).?=+Y]*]kZ=Z1=kN;t+Y]*]kZ

परीक्षण लिंक

संपादित करें: स्पष्टीकरण:

                                      standard variables: Y=[], Z=0, k='', Q=input
VQ                                    iterate over input
  IqNk                                if the current entity is equal to k:
      =hZ)                            increase Z.
          .?                          else:
               ]*]kZ                  list of length Z filled with k
            =+Y                       add it to Y
                    =Z1               set Z to 1
                       =kN            set k to the current entity
                          ;           end loop
                              ]*]kZ   list of length Z filled with k
                            +Y        add it to Y
                           t          implicitly print the tail of Y (removing the first element)

— Arfie
स्रोत

1

रेटिना , 24 22 बाइट्स

मार्टिन एंडर को 2 बाइट्स धन्यवाद।

एक 15-बाइट उत्तर पहले से मौजूद है, इसलिए यह सिर्फ एक और दृष्टिकोण है जिसकी लागत अधिक बाइट्स है।

S-`(?<=(\d+)) (?!\1\b)

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

यह उन स्थानों पर विभाजित होता है जिनकी पूर्ववर्ती संख्या कार्यवाही से भिन्न होती है।

यह दिखावे का प्रदर्शन है।

— लीक नन
स्रोत

1

05AB1E, 13 बाइट्स

¬svyÊi¶}yðJ?y

व्याख्या की

¬s             # push first element of list to stack and swap with input
  v            # for each X in input
   yÊi¶}       # if X is different from last iteration, push a newline
        yðJ?   # push X followed by a space to stack and join stack to string
            y  # push X to stack for next iterations comparison

किसी भी सूची के लिए काम करना चाहिए।
इंट और चार पर परीक्षण किया गया।

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

— Emigna
स्रोत

1

स्विफ्ट, 43 बाइट्स

var p=0;i.map{print($0==p ?"":",",$0);p=$0}

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

Prettier, ungolfed संस्करण:

var prev = Int.max // unlikely to be the first element, but not the end of the world if it happens to be.
i.map { n in
    print(n == prev ? " " : "\n•", n, terminator: "")
    prev = n
}

यह संस्करण प्रत्येक समूह को अधिक कोड की कीमत पर एक नई लाइन पर प्रिंट करता है।

सुधार के लिए विचार

i.reduce(0){print($0==$1 ?"":"•",$1);return $1}

इस संस्करण में 47 बाइट्स हैं, लेकिन यह एक अलग दृष्टिकोण है, इसलिए हो सकता है कि वहाँ कुछ का अनुकूलन हो? सबसे बड़ी समस्या रिटर्न स्टेटमेंट की है।

— juliand665
स्रोत

1

सी, 88 77 बाइट्स

बचत 11 बाइट्स के strmcmp अंदर ले जाया गयाprintf

f(char**a){*a++;char*x;for(;*a;x=*a++)printf(strcmp(*a,x)?"\n%s ":"%s ",*a);}

उपयोग:

f(char**a){*a++;char*x;for(;*a;x=*a++)printf(strcmp(*a,x)?"\n%s ":"%s ",*a);}
main(c,v)char**v;{f(v);}

नमूना इनपुट:

(कमांड लाइन पैरामीटर)

1 1 1 1 2 2 2 2 3 3 3 3 4 5 6 7777

नमूना आउटपुट:

पर परीक्षण किया गया:

gcc 4.4.7 (Red Hat 4.4.7-16)  - OK
gcc 5.3.0 (Cygwin)            - Segmetation Fault
gcc 4.8.1 (Windows)           - OK

मैं 5.3.0 सेग्मेटेशन फाल्ट को ठीक करने की कोशिश कर रहा हूं।

88 संस्करण

f(char**a){*a++;char*x;for(;*a;x=*a++)strcmp(*a,x)?printf("\n%s ",*a):printf("%s ",*a);}

— जियाकोमो गारबेलो
स्रोत

1

जावा 134 बाइट्स

void a(String[]a){int i=0,l=a.length;for(;i<l-1;i++)System.out.print(a[i]+((a[i].equals(a[i+1]))?" ":"\n"));System.out.print(a[l-1]);}

के माध्यम से पुनरावृति करता है, और यह तय करता है कि एक नई रेखा या स्थान के साथ अलग होना है या नहीं।

— रोहन झुनझुनवाला
स्रोत

स्टार्टर के लिए आप को दूर कर सकता है publicऔर staticखोजशब्दों। इसके अलावा आप लूप के लिए घुंघराले कोष्ठक को हटा सकते हैं

— user902383

हो गया @ user902383

— रोहन झुनझुनवाला

1

लिस्टशेयर , 134 बाइट्स

STRG l = READ[<here>+"\\l.txt"]
[FOREACH NUMB IN 1 TO l LENGTH-1 AS i]
{
[IF l[i] ISNOT l[i-1]]
STRG o=o+"\n"
STRG o=o+l[i]
}
SHOW = o

ListSharp doesnt समर्थन फ़ंक्शंस इसलिए सरणी नामक एक स्थानीय फ़ाइल में सहेजा गया है l.txt

— downrep_nation
स्रोत

1

रूबी , 24 बाइट्स

रूबी Arrayउदाहरणों में अंतर्निहित विधि हैgroup_by

तो समाधान होगा:

a.group_by{|x| x}.values

— फरहत मचलको
स्रोत

0

TSQL, 132 बाइट्स

यह अन्य उत्तरों से थोड़ा अलग है - sql में सरणियाँ नहीं हैं, sql के लिए स्पष्ट इनपुट एक तालिका है।

golfed:

DECLARE @ table(i int identity, v varchar(20))
INSERT @ values(1),(1),(1),(3),(3),(1),(1),(2),(2),(2),(1),(1),(3)

SELECT REPLICATE(v+' ',COUNT(*))FROM(SELECT i,i-row_number()over(partition
by v order by i)x,v FROM @)z GROUP BY x,v ORDER BY max(i)

Ungolfed:

DECLARE @ table(i int identity, v varchar(20))
INSERT @ values(1),(1),(1),(3),(3),(1),(1),(2),(2),(2),(1),(1),(3)

SELECT
  REPLICATE(v+' ',COUNT(*))
FROM 
  (
     SELECT
       i,
       i-row_number()over(partition by v order by i)x,
       v
     FROM @
  )z
GROUP BY
  x,v
ORDER BY
  max(i)

बेला

— t-clausen.dk
स्रोत

0

पर्ल 5 - 39 बाइट्स

print$_.($/)[$_ eq@a[++$-]]for@a=sort@a

— Kaundur
स्रोत

0

पाइके, 2 बाइट्स (गैर प्रतिस्पर्धी)

केवल पूर्णांकों का समर्थन करता है

$f

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

split_at(input, delta(input))

जोड़ा गया है, जब नोड 2 वें आरजीआई सत्य है, विभाजन को विभाजित करें

— नीला
स्रोत

0

सीड, 33 23 + 1 = 24 बाइट्स

s/([^ ]+)( \1)* */&\n/g

इसका -rविकल्प चाहिए।

उपयोग उदाहरण:

$ echo '1 1 1 2 2 3 3 3 4 9 9' | sed -r 's/([^ ]+)( \1)* */&\n/g'
1 1 1 
2 2 
3 3 3 
4 
9 9

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

0

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

इनपुट: संख्या या स्ट्रिंग्स की सरणी

आउटपुट: ऐरे की सरणी

गोल्फ कोड में पहली बार सटीक तुलना का उपयोग करना

a=>a.map(x=>x!==p?o.push(g=[p=x]):g.push(x),p=o=g=[])&&o

— edc65
स्रोत

0

क्लोजर, 19 बाइट्स

#(partition-by + %)

यह बिल्ट-इन है, लेकिन यह मैपिंग फंक्शन लेता है। इस मामले में, +एक पहचान समारोह के रूप में कार्य करता है।

— MattPutnam
स्रोत

0

जावास्क्रिप्ट (बाहरी पुस्तकालय का उपयोग करके) (178 बाइट्स)

(s)=>_.From(s).Aggregate((t,e)=>{if(0===t.Items.length)return t.Items.push([e]),t;var s=t.Items[t.Items.length-1];return s[0]===e?(s.push(e),t):(t.Items.push([e]),t)},{Items:[]})

अस्वीकरण: मैं एक पुस्तकालय का उपयोग कर रहा हूँ जिसे मैंने LINQ को JS में LINQ लागू करने के लिए लिखा था। यह वास्तव में मुझे जीतने में मदद नहीं करता था, लेकिन अच्छी तरह से ओह

— applejacks01
स्रोत

दोहराई जाने वाली वस्तुओं का समूह

चुनौती का वर्णन

इनपुट / आउटपुट विवरण

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

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

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

रेटिना , 15 8 बाइट्स

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

MATL , 9 बाइट्स

MATL, 11 बाइट्स

gs2, 2 बाइट्स

ब्रेकीलॉग , 13 बाइट्स

व्याख्या

जे , 13 बाइट्स

प्रयोग

व्याख्या

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

पायथन 2, 43 बाइट्स

CJam, 9 बाइट्स

व्याख्या

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

MATL, 8 7 बाइट्स

सी #, 117 बाइट्स

अजगर, ९ by बाइट्स

पुराना उत्तर, 12 बाइट्स

पायथ , 36 35 बाइट्स

रेटिना , 24 22 बाइट्स

05AB1E, 13 बाइट्स

स्विफ्ट, 43 बाइट्स

सुधार के लिए विचार

सी, 88 77 बाइट्स

उपयोग:

नमूना इनपुट:

नमूना आउटपुट:

जावा 134 बाइट्स

लिस्टशेयर , 134 बाइट्स

रूबी , 24 बाइट्स

TSQL, 132 बाइट्स

पर्ल 5 - 39 बाइट्स

पाइके, 2 बाइट्स (गैर प्रतिस्पर्धी)

सीड, 33 23 + 1 = 24 बाइट्स

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

क्लोजर, 19 बाइट्स

जावास्क्रिप्ट (बाहरी पुस्तकालय का उपयोग करके) (178 बाइट्स)