परिदृश्य

मैं अपनी कार से सड़क पर चलता हूं और बारिश शुरू हो जाती है। रेनड्रॉप मेरी खिड़की पर बेतरतीब ढंग से गिर रहे हैं और अब मैं खुद से पूछता हूं कि सबसे बड़ा जुड़ा गीला क्षेत्र कहां है?

काम

इसे आसान बनाने के लिए, खिड़की को 10 * 10 वर्गों के मैट्रिक्स में विभाजित किया गया है। आपका काम खिड़की पर सबसे बड़ा जुड़ा हुआ पानी-बूंद-क्षेत्र ढूंढना है।

इनपुट

दो संभावित इनपुट हैं, आप 2-आयामी सरणी या 1-आयामी एक का उपयोग कर सकते हैं। आप स्टड, आदि जैसे किसी भी इनपुट के बीच चयन कर सकते हैं ...
उदाहरण:

// 2-dimensional:
[[0,1,0,0,0,0,1,0,0,0],
 [0,1,1,0,0,0,0,1,1,0],
 [0,1,1,0,0,0,0,1,0,0],
 [0,1,0,0,0,0,0,0,0,0],
 [0,0,0,0,0,0,0,0,1,0],
 [0,0,0,1,1,0,0,0,1,0],
 [0,0,0,1,1,0,0,0,1,0],
 [0,0,0,0,0,1,1,0,1,0],
 [0,0,0,0,0,1,1,0,1,0],
 [0,0,0,0,0,0,0,0,0,0]]

// 1-dimensional
[0,1,0,0,0,0,1,0,0,0,
 0,1,1,0,0,0,0,1,1,0,
 0,1,1,0,0,0,0,1,0,0,
 0,1,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,1,0,
 0,0,0,1,1,0,0,0,1,0,
 0,0,0,1,1,0,0,0,1,0,
 0,0,0,0,0,1,1,0,1,0,
 0,0,0,0,0,1,1,0,1,0,
 0,0,0,0,0,0,0,0,0,0]

उत्पादन

आपके कोड को सबसे बड़े जुड़े क्षेत्र के आकार और x- और y- निर्देशांकों को वाटरड्रॉप से जोड़ना है जो इस क्षेत्र से संबंधित हैं
" प्रारूप : Z निर्देशांक: (X1, Y1) (X2, Y2) ।। "
पिछले इनपुट के लिए उदाहरण:

Size: 6 Coordinates: (1,0) (1,1) (2,1) (1,2) (2,2) (1,3)

निर्देशांक का क्रम मायने नहीं रखता है।

नियम

वॉटरड्रॉप्स जुड़े हुए हैं, अगर वे एक-दूसरे को स्पर्श करते हैं
विकर्ण कनेक्शन की गणना नहीं है
कई क्षेत्र हो सकते हैं और आपके कोड को सबसे बड़ा खोजना होगा
एक खाली फ़ील्ड को "0" और एक गीले क्षेत्र को "1" के रूप में दर्शाया जाता है।
एक संक्षिप्त विवरण और पिछले इनपुट के आउटपुट के साथ अपना समाधान पोस्ट करें
अगले 7 दिनों के भीतर सबसे छोटा कोड जीत जाएगा
यदि एक ही आकार के दो क्षेत्र हैं, तो आप एक चुन सकते हैं

विजेता: 171 के साथ वेंटरो - रूबी

code-golf

— izlin
स्रोत

2

@Doorknob एक टाइपो के बारे में शिकायत? ओपी जर्मन है।

— edc65

1

@Doorknob मैंने इसे बदल दिया, धन्यवाद। समय सीमा केवल यह कहती है, जब मैं विजेता का निर्धारण करूंगा लेकिन आप अभी भी उत्तर पोस्ट कर सकते हैं।

— izlin

6

मैं कहूंगा कि यह एक कोडगॉल्फ.स्टैकएक्सचेंज . com/questions/32015/… का डुप्लिकेट है ।

— हावर्ड

1

@TeunPronk: ओपी का मतलब होता है ऑरिजनल पोस्टर। इसे Google में देखें :)

— छलनी

2

इनपुट विधियों की अनुमति देने पर कुछ स्पष्टीकरण, वास्तव में, बहुत अच्छा होगा।

— वेंटरो

3

रूबी, 171 वर्ण

r=eval *$*
u=(0..99).map(&v=->p{-~p*r[p]>0?" (#{r[p]=0;u=p%c=10},#{p/c})"+v[p+c]+v[p-c]+v[u>0?p-1:p]+v[u<9?p+1:p]:""}).max_by &:size
puts"Size: #{u.size/6} Coordinates:"+u

एक-आयामी सरणी के रूप में कमांड लाइन पैरामीटर के माध्यम से इनपुट।

नमूना इनपुट के लिए आउटपुट: Size: 6 Coordinates: (1,0) (1,1) (1,2) (1,3) (2,2) (2,1)

यह उत्तर एक साधारण बाढ़-भराव दृष्टिकोण का उपयोग करता है, प्रत्येक रेनड्रॉप क्लस्टर के लिए निर्देशांक की एक सूची का निर्माण करता है। अधिकांश कोड का उपयोग वास्तव में सीमा जाँच और I / O के लिए किया जाता है।

— Ventero
स्रोत

5

अजगर - 192

a=10;g+=[0]*a
def f(k):
 if g[k]:g[k]=0;return" (%d,%d)"%(k/a,k%a)+f(k+a)+f(k-a)+f(k+(k%a<9))+f(k-(k%a>0))
 return''
m=max(map(f,range(100)),key=len)
print"Size: "+`len(m)/6`+" Coordinates:"+m

इनपुट (कोड से पहले पेस्ट करें):

g=[0,1,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,1,0,0,1,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,1,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0]

सुझाए गए संपादन के लिए केल्विन के शौक को धन्यवाद!

— vectorized
स्रोत

आप 8 वर्णों को सहेजने के map(f,range(100))बजाय उपयोग कर सकते हैं [f(i)for i in range(100)]। इसके अलावा, मेरा मानना है कि आपके निर्देशांक (y, x) नहीं (x, y) हैं।

— केल्विन के

3

सी # - 548 523 522 511 503 476

(500 से कम ... yey)

मुझे यकीन है कि सुधार के लिए बहुत जगह है।

जिस तरह से मैंने डेटा इनपुट किया था वह किसी ऐरे को इनिशियलाइज़ करना था। मैंने उस सरणी को स्कोर में शामिल नहीं किया (यदि आपको लगता है कि यह धोखा है तो मैं कोड बदल सकता हूं, लेकिन यह अपेक्षाकृत अधिक कोड जोड़ देगा क्योंकि C # पार्सिंग सरणियों में महान नहीं है)

using o=System.Console;using l=System.Collections.Generic.List<int[]>;class P{
static int[,] a ={{0,1,0,0,0,0,1,0,0,0},{0,1,1,0,0,0,0,1,1,0},{0,1,1,0,0,0,0,1,0,0},{0,1,0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0,1,0},{0,0,0,1,1,0,0,0,1,0},{0,0,0,1,1,0,0,0,1,0},{0,0,0,0,0,1,1,0,1,0},{0,0,0,0,0,1,1,0,1,0},{0,0,0,0,0,0,0,0,0,0}};
static int w=10,h=w,x=0,y;static l t=new l(),m=new l();static void f(int r,int c){if(a[r,c]==1){a[r,c]=0;if(r<h)f(c,r+1);if(r>0)f(c,r-1);if(c<w)f(c+1,r);if(c>0)f(c-1,r);t.Add(new[]{c,r});}}static void Main(){for(;++x<w;)for(y=0;++y<h;){if(a[x,y]==1)f(x,y);if(t.Count>m.Count)m=t.FindAll(r=>true);t.Clear();}o.Write("Size: "+m.Count+" Coordinates: ");m.ForEach(c=>o.Write("({0},{1}) ",c[0],c[1]));}}

इसका परीक्षण http://ideone.com/UCVCPM पर करें

नोट: वर्तमान संस्करण ideone में काम नहीं करता है क्योंकि यह पसंद नहीं करता है using l=System.Collections..., इसलिए विचारधारा संस्करण थोड़ा पुराना (और लंबा) है

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

यह मूल रूप से जाँच करता है कि क्या कोई है 1। यदि यह एक को पाता है, तो यह फ्लड फिल एल्गोरिथ्म का उपयोग करता है कि सभी आसन्न 1के साथ 0एक अस्थायी सूची में प्रतिस्थापित निर्देशांक जोड़ता है। बाद में यह शीर्ष सूची ( m) से अस्थायी सूची ( t) की तुलना करता है और सेट करता mहै tकि क्या tअधिक तत्व शामिल हैं।

— क्रिस्टोफ़ बोहमलडर
स्रोत

3

गणितज्ञ - 180 बाइट्स

यह फ़ंक्शन 2-आयामी सरणी लेता है।

golfed

f@x_:=(c=MorphologicalComponents[x,CornerNeighbors->False];m=Last@SortBy[ComponentMeasurements[c,"Count"],Last];Print["Size: ",Last@m," Coordinates: ",Reverse/@Position[c,m[[1]]]])

सुंदर हे

f@x_ := (
   c = MorphologicalComponents[x, CornerNeighbors -> False];
   m = Last@SortBy[ComponentMeasurements[c, "Count"], Last];
   Print["Size: ", Last@m, " Coordinates: ", Reverse/@Position[c, m[[1]]]]
   );

उदाहरण

{0,1,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,1,0,0,1,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,1,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0};
w=Partition[%,10];
f@w

आकार: 6 निर्देशांक: {{1,2}, {2,2}, {2,3}, {3,2}, {3,3}, {4,2}}

आउटपुट थोड़ा विषम है। गणितज्ञ 0 के बजाय 1 पर अनुक्रमित करना शुरू कर देता है, और {}स्थिति को इंगित करने के लिए उपयोग करता है। 2 बाइट्स ( -1) जोड़ें यदि पदों को 0-अनुक्रमित करने की आवश्यकता है। यदि उन्हें ()इसके बजाय उपयोग करने की आवश्यकता हो तो बहुत सारे बाइट्स जोड़ें {}:(

व्याख्या

fका एक कार्य है x। यह cएक परिवर्तन के रूप में परिभाषित होता है x, जहां प्रत्येक (i, j) अब एक पूर्णांक के बराबर होता है, जो संबंधित घटक से संबंधित होता है। इसमें मुख्य कार्य शामिल है:

MorphologicalComponents[w, CornerNeighbors -> False] // Colorize

यहाँ छवि विवरण दर्ज करें

फिर mगणना करता है कि प्रत्येक घटक में कितने तत्व हैं, उन्हें उस संख्या के अनुसार क्रमबद्ध करें, और अंतिम परिणाम (अर्थ, अधिकांश तत्वों के साथ) लेता है। अंतिम पंक्ति गिनती में cनिहित है , और सूचकांक में मौजूद पदों को प्रिंट करती है m।

— mfvonh
स्रोत

2

हास्केल, 246

r=[0..9]
q=[(i,j)|i<-r,j<-r]
t v p@(i,j)|elem p v||notElem p q||g!!j!!i==0=v|1<2=foldr(\(k,l)v->t v(i+k,j+l))(p:v)$zip[-1,0,1,0][0,-1,0,1]
(?)=map
a=t[]?q;(b,c)=maximum$zip(length?a)a
main=putStrLn.unwords$["Size:",show b,"Coordinates:"]++show?c

इनपुट

gउदाहरण के लिए, कोड से पहले दो आयाम और पेस्ट :

g = [[0, 1, 1, ......, 0], [......], ....]

Ungolfed

field = [
 [0,1,0,0,0,0,1,0,0,0],
 [0,1,1,0,0,0,0,1,1,0],
 [0,1,1,0,0,0,0,1,0,0],
 [0,1,0,0,0,0,0,0,0,0],
 [0,0,0,0,0,0,0,0,1,0],
 [0,0,0,1,1,0,0,0,1,0],
 [0,0,0,1,1,0,0,0,1,0],
 [0,0,0,0,0,1,1,0,1,0],
 [0,0,0,0,0,1,1,0,1,0],
 [0,0,0,0,0,0,0,0,0,0]
 ]
range = [0..9]
positions = [(i, j) | i <- range, j <- range]
directions = zip [-1, 0, 1, 0] [0, -1, 0, 1]
traverse visited pos@(i, j)
  | pos `elem` visited || pos `notElem` positions || field!!j!!i == 0 = visited
  | otherwise = foldr folder (pos:visited) directions
  where folder = (\(di, dj) visited -> traverse visited (i + di, j + dj))
blocks = map (traverse []) positions
(maxCount, maxBlock) = maximum $ zip (map length blocks) blocks
main = putStrLn.unwords $ ["Size:", show maxCount, "Coordinates:"] ++ map show maxBlock

— रे
स्रोत

2

C # 374byte फ़ंक्शन

यह मेरे उत्तर का सबसे बड़ा संशोधित संस्करण है, क्या आप सबसे बड़े कमरे में हैं? । यह एक-आयामी सरणी के ints लेता है, और आवश्यक शैली में एक स्ट्रिंग लौटाता है। यह इनपुट (पहले लूप) से असंबद्ध सेट के निर्माण, प्रत्येक सेट के आकार को टैली करने और सबसे बड़ा सेट (दूसरा लूप) खोजने और फिर उस सेट में किसी भी सेल को आउटपुट स्ट्रिंग (तीसरे लूप) में जोड़ने का काम करता है, जो तब वापस आ जाता है ।

static string F(int[]g){int s=10,e=0,d=s*s,a=0,b=d+1;int[]t=new int[b],r=new int[b];t[d]=d;System.Func<int,int>T=null,k=v=>t[T(v)]=t[v]<d?a:d;T=v=>t[v]!=v?T(t[v]):v;for(;a<d;a++)if(g[a]>0){e=t[a]=a;if(a>s)k(a-s);if(a%s>0)k(a-1);}else t[a]=d;for(;a-->0;)e=r[e]<++r[b=T(a)]&&b<d?b:e;var p="Size: "+r[e]+" Coordinates:";for(;d-->1;)p+=T(d)==e?" ("+d%s+","+d/s+")":"";return p;}

कम गोल्फ वाले (और परीक्षण कोड के साथ):

class P
{
    static int[] z = {0,1,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,1,0,0,1,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,1,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0};

    static string F(int[]g)
    {
        int s=10,e=0,d=s*s,a=0,b=d+1;

        int[]t=new int[b],r=new int[b];
        t[d]=d;
        System.Func<int,int>T=null,k=v=>t[T(v)]=t[v]<d?a:d;
        T=v=>t[v]!=v?T(t[v]):v;

        for(;a<d;a++)
            if(g[a]>0)
            {
                e=t[a]=a;
                if(a>s)k(a-s);
                if(a%s>0)k(a-1);
            }
            else
                t[a]=d;
        for(;a-->0;)
            e=r[e]<++r[b=T(a)]&&b<d?b:e;

        var p="Size: "+r[e]+" Coordinates:";
        for(;d-->1;)
            p+=T(d)==e?" ("+d%s+","+d/s+")":"";

        return p;
    }

    static void Main()
    {
        System.Console.WriteLine(F(z));
    }
}

— VisualMelon को पुनर्जीवित करता है
स्रोत

इससे मुझे अपने 476 बाइट्स समाधान के बारे में बुरा लग रहा है :( +1 तुम्हारे लिए, अच्छा साहब।

— क्रिस्टोफ बोह्मवेल्डर

1

जावास्क्रिप्ट (एक्मास्क्रिप्ट 6) 183 189

सरणी इनपुट और स्ट्रिंग वापसी मान के साथ एक फ़ंक्शन। यदि वास्तविक आउटपुट की आवश्यकता है (मेरे लिए स्पष्ट नहीं है) 'अलर्ट ()' के लिए 7 बाइट्स जोड़ें।

W=(a,n=10,x=0)=>(F=p=>a[p]|0&&(a[p]=0,o+=' ('+p%n+','+(p/n|0)+')',1+F(p-n)+F(p+n)+F(p-(p%n>0))+F(p+((p+1)%n>0))),a.map((e,p)=>(t=F(p,o=''))>x&&(x=t,k=o)),'Size: '+x+' Coordinates:'+k)

टेस्ट आउटपुट

Size: 6 Coordinates: (1,0) (1,1) (1,2) (1,3) (2,2) (2,1)

अधिक पठनीय

W=(a,n=10,x=0)=>
(
  F=p=>
    a[p]|0&&(  
      a[p]=0,o+=' ('+p%n+','+(p/n|0)+')',
      1+F(p-n)+F(p+n)+F(p-(p%n>0))+F(p+((p+1)%n>0)) // modulo takes care of not overflowing out of a row
    ),
  a.map((e,p)=>(t=F(p,o=''))>x&&(x=t,k=o)), 
  'Size: '+x+' Coordinates:'+k
)

व्याख्या

एक एकल आयाम सरणी और एक पंक्ति के आकार के साथ एक वैकल्पिक पैरामीटर प्राप्त करें। फ़ंक्शन विभिन्न सरणी आयामों के साथ भी काम करता है, यहां तक कि x! = Y।

छद्म कोड:

 For each element, 
   try to fill. 
   During the fill operation build a string with the coordiinates. 
   Remember the longest fill and the corresponding string and 
 output that at the end.

— edc65
स्रोत

1

जावास्क्रिप्ट, 273

फ़ंक्शन सरणी लेता है और स्ट्रिंग लौटाता है। मेरा पहला प्रयास ~ 500 वर्णों का था और फ्लड फिल का उपयोग नहीं किया। यह एक करता है। मैं जावास्क्रिप्ट सीख रहा हूँ इसलिए किसी भी सुझाव की सराहना की जाएगी।

यह फ़ंक्शन इनपुट ऐरे के माध्यम से लूप करता है और प्रत्येक 1 के लिए यह वहां शुरू होता है और भरण फ़ंक्शन का उपयोग करके सभी को 1s से 0 से जोड़ा जाता है। ऐसा करते समय यह सबसे 1 एस के साथ बूँद को याद करता है। भरण फ़ंक्शन वर्तमान स्थिति को 0 में बदलता है और फिर ऊपर, दाईं ओर, नीचे और बाईं ओर स्थित स्थिति में खुद को कॉल करता है।

function G(m){var B="",b=0;for(var p=0;p<m.length;p++)if(m[p]){var T="",t=0;
Z(p);if(t>b){b=t;B=T;}}return"Size: "+b+" Coordinates:"+B;function Z(p){if(m[p])
{m[p]=0;t++;T+=" ("+p%10+","+Math.floor(p/10)+")";if(p>9)Z(p-10);if(p%10)Z(p-
1);if(p<90)Z(p+10);if(p%10!=9)Z(p+1);}}}

यहाँ परीक्षण करें: http://goo.gl/9Hz5OH

पठनीय संहिता

var map = [0, 1, 0, 0, 0, 0, 1, 0, 0, 0,
           ...
           0, 0, 0, 0, 0, 0, 0, 0, 0, 0];

function F(map) {

    var bestBlob = "", bestLen=0;
    for (var p = 0; p < map.length; p++)
        if (map[p]) {
            var thisBlob = "", thisLen=0;
            Fill(p);
            if (thisLen > bestLen){
                bestLen=thisLen ; bestBlob = thisBlob;
            }
        }
    return "Size: " + bestLen + " Coordinates:" + bestBlob;

    function Fill(p) {
        if (map[p]) {
            map[p] = 0; thisLen++;
            thisBlob += " (" + p % 10 + "," + Math.floor(p / 10) + ")";
            if (p > 9) Fill(p - 10);
            if (p % 10) Fill(p - 1);
            if (p < 90) Fill(p + 10);
            if (p % 10 != 9) Fill(p + 1);
        }
    }
}

— JeffSB
स्रोत

1

स्काला, 420

नमस्ते, मेरी प्रविष्टि के रूप में एक 2d सरणी लेता है List[List[Int]], एक देता हैString

val o=for{(r, y)<-w.zipWithIndex;(v,x)<-r.zipWithIndex;if(v == 1)}yield(x,y);val a=o.flatMap(c=>o.collect{case(x,y)if{(x==c._1+1||x==c._1-1)&&y==c._2^(y==c._2+1||y==c._2-1)&&x==c._1}=>c->(x,y)}).groupBy(_._1).map(n => (n._1->n._2.map(t=>t._2)));val b=a.values.flatMap(v=>v.map(c=>a(c)++v));val l=b.collect{case x if (x.length==b.map(_.length).max)=>x}.head;println(s\"Size: ${l.length} Coordinates: ${l.mkString(" ")}\")

व्याख्या

एक के रूप में एक खिड़की को देखते हुए List[List[Int]], पहले हम प्रत्येक "1" को ढूंढते हैं और एक सूची में निर्देशांक को बचाते हैं। इसके बाद हम उस सूची को Mapप्रत्येक "1" के समन्वय में सूची में बदल देते हैं और प्रत्येक आसन्न "1" के निर्देशांक को सूचीबद्ध करते हैं। इसके बाद आसन्न मानचित्र का उपयोग करके उप-बूँदें को blobs में लिंक करें, और अंत में हम सबसे बड़ी बूँद लौटाते हैं (और डुप्लिकेट blobs को अनदेखा करते हैं क्योंकि लौटे निर्देशांक का कोई फर्क नहीं पड़ता)।

अधिक पठनीय

 val w = {
  List(//0,1,2,3,4,5,6,7,8,9
    List(0,1,0,0,0,0,1,0,0,0), //0
    List(0,1,1,0,0,0,0,1,1,0), //1
    List(0,1,1,0,0,0,0,1,0,0), //2
    List(0,1,0,0,0,0,0,0,0,0), //3
    List(0,0,0,0,0,0,0,0,1,0), //4
    List(0,0,0,1,1,0,0,0,1,0), //5
    List(0,0,0,1,1,0,0,0,1,0), //6
    List(0,0,0,0,0,1,1,0,1,0), //7
    List(0,0,0,0,0,1,1,0,1,0), //8
    List(0,0,0,0,0,0,0,0,0,0)) //9
}

case class Coord(x: Int, y: Int)

val ones: List[Coord] = for{
  (row, y)   <- w.zipWithIndex
  (value, x) <- row.zipWithIndex
  if (value == 1)        
} yield Coord(x,y)

val adjacencyMap: Map[Coord, List[Coord]] = ones.flatMap(keyCoord => ones.collect{
case Coord(adjacentX, adjacentY) if {
    (adjacentX == keyCoord.x + 1 || adjacentX == keyCoord.x - 1) && adjacentY == keyCoord.y ^ 
    (adjacentY == keyCoord.y + 1 || adjacentY == keyCoord.y - 1) && adjacentX == keyCoord.x
  }  => keyCoord->Coord(adjacentX,adjacentY)
}).groupBy(_._1).map(n => (n._1->n._2.map(t=>t._2) ))

val blobs: Iterable[List[Coord]] = adjacencyMap.values.flatMap(v => v.map(coord => adjacencyMap(coord)++v))

val largestBlob: List[Coord] = blobs.collect{case x if (x.length == blobs.map(b=> b.length).max) => x}.head

println(s"""Size: ${largestBlob.length} Coordinates: ${largestBlob.collect{case Coord(x,y) => (x,y)}.mkString(" ")}""")

आलोचना को बहुत सराहा जाता है।

— जूलियन पीटर्स
स्रोत

मेरी खिड़की पर पानी है

परिदृश्य

काम

इनपुट

उत्पादन

नियम

विजेता: 171 के साथ वेंटरो - रूबी

रूबी, 171 वर्ण

अजगर - 192

सी # - 548 523 522 511 503 476

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

गणितज्ञ - 180 बाइट्स

golfed

सुंदर हे

उदाहरण

व्याख्या

हास्केल, 246

इनपुट

Ungolfed

C # 374byte फ़ंक्शन

जावास्क्रिप्ट (एक्मास्क्रिप्ट 6) 183 189

जावास्क्रिप्ट, 273

स्काला, 420

व्याख्या

अधिक पठनीय