किसी सरणी में सबसे लंबा शब्द खोजें

24

आपकी चुनौती स्ट्रिंग की एक सरणी लेना है और सरणी में सबसे लंबे स्ट्रिंग को आउटपुट करना है। के लिए

["tiny", "small", "bigger", "biggest"]

आउटपुट होगा biggest।

यदि सरणी के दो तत्वों की लंबाई समान है, तो आपको उस सरणी का चयन करना चाहिए जो पहले सरणी में दिखाई देता है। इसका मतलब है कि अगर सरणी इस तरह दिखता है:

["one", "two", "no"]

आउटपुट है one, लेकिन अगर सरणी इस तरह दिखता है:

["two", "one", "no"]

उत्पादन होता है two।

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

code-golf  string  array-manipulation  sorting 
— धीरे-धीरे
स्रोत
3
2 नोट: 1यह भारी निराश है अगर सवाल बदल गया है और अमान्य कर मौजूदा जवाब है, और सैंडबॉक्स वास्तव में के लिए मौजूद है कि कारण (सुनिश्चित करें कि चुनौतियों बनाने के पोस्टिंग से पहले अच्छा कर रहे हैं)2
— user202729
4
चूंकि मुझे नहीं लगता कि किसी और ने इसका उल्लेख किया है - हाय, और पीपीसीजी में आपका स्वागत है!
— AdmBorkBork
1
नहीं, आपको उस मामले को संभालना नहीं है जहां सरणी खाली है। लेकिन अगर आप चाहें तो आप कर सकते हैं।
— डॉग्गो
4
2 घंटे? यही कारण है कि अब तक है, अब तक बहुत जल्दी एक जवाब को स्वीकार किया जाना है।
— झबरा
6
आम तौर पर आप एक सप्ताह इंतजार करते हैं
— क्रिस्टोफर

जवाबों:

31

इंपीरियल टैम्पियो , 168 बाइट्स

Listan x on riippuen siitä,onko sen ensimmäisen alkion pituus suurempi tai yhtä suuri kuin sen jokaisen alkion pituus,joko sen ensimmäinen alkio tai sen hännän x.

ऑनलाइन संस्करण

Ungolfed:

Listan पिसिन alkio पर riippuen siitä , Onko सेन ensimmäisenalkion pituus suurempi ताई yhtä suuri kuin सेन jokaisen alkion pituus, खेल

  • सेन ensimmäinenअलकियो ताई
  • सेन ह्नान्नो पिसिन अल्कियो।

ऑनलाइन संस्करण

एकमात्र गोल्फिंग अवसर इसके साथ है pisin alkio(जिसका अर्थ है "सबसे लंबा तत्व") x।

अनुवाद:

किसी सूची में सबसे लंबा आइटम इस बात पर निर्भर करता है कि पहले आइटम की लंबाई सूची में प्रत्येक तत्व की लंबाई से अधिक है या बराबर है, या तो

  • सूची में पहला आइटम, या
  • सूची की पूंछ में सबसे लंबा आइटम।
— fergusq
स्रोत
21
क्या यह एक -... क्या थि -... आप कैसे-क्या करते हैं?
— auhmaan
3
Google अनुवाद फिनिश से: एक्स की सूची इस बात पर निर्भर करती है कि पहले तत्व की लंबाई प्रत्येक तत्व की लंबाई से अधिक है या बराबर है, या तो पहले आइटम या एक्स की पूंछ।
— आदाम
2
@ मुझे लगता है कि एपीएल पढ़ना मुश्किल है। जाहिरा तौर पर आप सभी को हरा करने की आवश्यकता है जो कि खेल के मैदान को एक ऐसी भाषा में स्थानांतरित करना है जहां अंग्रेजी एक दुर्लभ वस्तु है।
— उरईल
3
कौन COBOL, AppleScript या Inform 7 की जरूरत है? किसे अर्नोल्ड शेफ या शेक्सपियर की जरूरत है? आपके पास इंपीरियल टैम्पियो है! ओह मेरे उड़ने वाले स्पेगेटी राक्षस, सभी भाषाओं के फिनिश? मैं यह नहीं सीख रहा हूं कि किसी भी समय जल्द ही ...
— फेडे एस।
1
@fedes। आप कह सकते हैं "ओल्कून सुओमलैनन सुदेलम्मा उस्सी सुदेल्मा।" (फिनिश चुंबन एक नया चुंबन होने दो, यह एक नई चुंबन वस्तु बनाता है)
— fergusq
20

पायथन , 23 बाइट्स

lambda a:max(a,key=len)

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

— नील
स्रोत
1
मुझे खेद है कि मैंने यह अधिकार परिवर्तित नहीं किया।
— डोगो
1
मैंने कोड स्निपेट को अपडेट किया, लेकिन जैसा कि लिखा गया है, यह पहले से ही इस कार्यक्षमता को प्राप्त करता है।
— नील
1
यह पायथन 3 में अपरिवर्तित भी काम करेगा।
— अनामिका
17

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

-3 बाइट्स जर्बर्ग के लिए धन्यवाद।

foldl1(!)
a!b|(a<$a)<(a<$b)=b|1<2=a

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

मुझे यह कोड पसंद है। तुम जानते हो क्यों? क्योंकि हास्केल यादृच्छिक पुस्तकालयों के कार्यों के साथ बहुत अधिक सुरुचिपूर्ण समाधानों का समर्थन करता है।

maximumBy(compare`on`length).reverse

यह 'friggin पठनीय है! सिवाय इसके, यह मान्य नहीं है।

import Data.List
import Data.Function
maximumBy(compare`on`length).reverse

यदि यह आयात के लिए नहीं थे, तो यह सभी उत्थान प्राप्त करने के लिए एक सही प्रस्तुतिकरण होता। : पी

(इसके अलावा, यह एक गोल्फ टिप का उपयोग करता है और यह एक तह का उपयोग करता है।)

— totallyhuman
स्रोत
2
जोड़े गए "पहले-घटना-के-केस-ऑफ-टाई" -requirement के साथ, यह सुंदरता काम करेगी: snd.maximum.map((,)=<<(0<$)) इसे ऑनलाइन आज़माएं! ।
— लैकोनी
1
बस संदर्भ के लिए: वहाँ उबाऊ 29 बाइट में निर्मित है import Data.Lists;argmax(0<$)।
— नीम
1
वाह, कैसे lनहीं का एक हिस्सा है fold? यह उस और एक नाम के बीच अंतर कैसे करता है foldl?
— 12Me21
1
@ 12Me21 यह फ़ंक्शन नाम का एक हिस्सा है foldl1। मुझे लगा कि स्पष्टीकरण का एक हिस्सा भ्रामक हो सकता है, क्षमा करें ...
— पूरी तरह से
1
लंबोदर के बजाय एक फ़ंक्शन के साथ 35 बाइट्स । दिलचस्प बात यह है कि, आपको या कुछ और के 0साथ प्रतिस्थापित करना होगा a, अन्यथा जीएचसी अस्पष्ट अस्पष्ट प्रकार के बारे में शिकायत करता है।
— 22
9

आर + प्राइर , 31 बाइट्स

[-2 बाइट्स स्क्रूबल के लिए धन्यवाद]

pryr::f(x[order(-nchar(x))][1])

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

आर , 33 बाइट्स

function(x)x[order(-nchar(x))][1]

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

— NofP
स्रोत
3
साथ ही 33 बाइट्स:x[which.max(nchar(x))]
— Giuseppe
आपके लिंक से @Sroroble मैं एक 33 बाइट्स समाधान देखता हूं।
— NofP
1
@ नोफहा हाहा, मुझे मूर्ख। 31 बाइट्स।
— खुल्दरेसथ न'बर्या
8

एक्सेल, 36 42 बाइट्स

=INDEX(A:A,MATCH(MAX(LEN(A:A)),LEN(A:A),))

एक सरणी सूत्र (ctrl-shift-enter) के रूप में दर्ज किया गया। इनपुट एरे को कॉलम ए में दर्ज किया जाना चाहिए।

सूत्र अधिकतम लंबाई के साथ पहला मैच लौटाता है।

आपकी क्षेत्र सेटिंग्स पर निर्भर करता है, के ,साथ स्थानापन्न ;; कोड की लंबाई अपरिवर्तित रहती है। यहां सूचीबद्ध 16 भाषाओं में से , अंग्रेजी सूत्र नाम इस सूत्र के लिए सबसे छोटा है।

स्पष्टीकरण:

=                                          - return
 INDEX(                                  ) - the item of
       A:A                                 - the input
          ,                                - at
           MATCH(                       )  - the position of
                                       ,   - the first exact match of
                 MAX(        )             - the maximum of
                     LEN(   )              - the array of lengths of
                         A:A               - the input
                              ,            - in
                               LEN(   )    - the array of lengths of
                                   A:A     - the input
— pbeentje
स्रोत
,बाद के लिए क्या ? सूत्र अभी भी इसके बिना काम करता है
— अनास्तासिया-रोमानोवा '
अंतिम ,MATCH के लिए एक पैरामीटर है जो पहले (सटीक (संशोधित)) प्रश्न के अनुसार, सटीक मिलान देता है। यदि इसे छोड़ दिया जाता है, तो MATCH को आरोही क्रम में एक सरणी की उम्मीद है, और यदि एक ही लंबाई के साथ कई तत्व हैं, तो पहले के बजाय अंतिम मैच लौटाता है ।
— पबेन्तेज
सुनिश्चित हैं? मैंने उन दो सूत्रों की तुलना की है और दोनों एक ही परिणाम के साथ आते हैं
— अनास्तासिया-रोमानोवा
क्या आप एक इनपुट ऐरे का उपयोग कर रहे हैं जिसमें समान लंबाई के दो (अलग) तार हैं? अल्पविराम (अर्धविराम) छोड़ने से मुझे अधिकतम लंबाई का आखिरी तार मिलता है, जैसा कि अपेक्षित है ... (एक्सेल 2016, 64-बिट)
— pbeentje
दुर्भाग्य से समुदाय ने फैसला किया है कि इस तरह से नामित श्रेणियों का उपयोग करना अमान्य है, इसलिए मेरा सुझाव है कि इस विशेष मामले के लिए आप A:Aइसका उपयोग करने के लिए स्विच करते हैं और इसे एक सरणी के साथ औपचारिक बनाते हैं {...}, अन्यथा महान पोस्ट!
— टेलर स्कॉट
7

प्रोलोग (एसडब्ल्यूआई) , 98 92 72 69 बाइट्स

शीर्ष स्तर विधेय है *।

X/Y:-atom_length(X,Y).
[A]*A.
[A,B|L]*Z:-A/X,B/Y,Y>X,[B|L]*Z;[A|L]*Z.

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

व्याख्या

पहली पंक्ति डाईडिक विधेय /को संक्षिप्त करती है, atom_length/2जिसके लिए पहले तर्क की लंबाई दूसरा तर्क है, तो यह सत्य है। यह atom_lengthदो बार उपयोग करने से हमें 3 बाइट बचाता है ।

हमारे मुख्य विधेय को रंजक के रूप में परिभाषित किया गया है *जहां पहला तर्क एक सूची है और दूसरा तर्क उस सूची का सबसे लंबा तत्व है।

दूसरी पंक्ति हमारा आधार मामला है जो बताता है कि एक तत्व सूची का सबसे लंबा तत्व वह तत्व है।

तीसरी पंक्ति बताती है कि कम से कम 2 तत्वों वाली सूची के लिए, सबसे लंबा तत्व है:

यदि दूसरे तत्व की लंबाई पहले तत्व से अधिक है, तो सबसे लंबा तत्व पहले तत्व के बिना सूची में है।

अन्यथा दूसरा तत्व के बिना सूची में सबसे लंबा तत्व है।

— Emigna
स्रोत
मैं यह कैसे काम करता है पर एक स्पष्टीकरण देखने में दिलचस्पी होगी
— Kritii Lithos
@Cowsquack: मैंने एक छोटा स्पष्टीकरण जोड़ा है।
— एमिग्ना
7

अजगर , 4 बाइट्स

h.Ml

परीक्षण सूट।

व्याख्या 
h.Ml   | Program
h.MlZQ | With implicit variables filled in
-------+--------------------------------------------------------------------
h      | First element of
 .M  Q | The list of elements from the input list with the maximal value for
   lZ  | The length of the element
— मिस्टर एक्सकोडर
स्रोत
अच्छा, तुम 6 बाइट्स के साथ पाइथ के जवाब को हरा देते हो।
— 13
elD_और ho_lउसी लंबाई को प्राप्त करते हैं।
— isaacg
1
@ hakr14 संपादन के लिए बहुत बहुत धन्यवाद!
— मिस्टर एक्सकोडर
6

पॉवरशेल , 24 बाइट्स

($args[0]|sort l* -d)[0]

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

इनपुट ले जाता है $args[0], पाइप जो कि बढ़ते क्रम में ength Sort-Objectपर आधारित है । इसके बाद वें को लेता है। चूंकि सॉर्ट स्थिर है, इसलिए टाई के मामले में यह पहला तत्व है।l-d[0]

— AdmBorkBork
स्रोत
1
नाइस नाम वफ़ वफ़: डी
— डोगो
6

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

@(x)x{[~,p]=max(cellfun(@nnz,x))}

इनपुट स्ट्रिंग्स का एक सेल ऐरे है।

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

व्याख्या

cellfun(@nnz,x)nnzइनपुट ऐरे में प्रत्येक स्ट्रिंग के फंक्शन (नॉनजेरोस की संख्या) को लागू करता है x। ASCII स्ट्रिंग्स के लिए, nnzके बराबर हैnumel (तत्वों की संख्या) के , लेकिन कम है। परिणाम स्ट्रिंग लंबाई के साथ एक संख्यात्मक सरणी है।

फिर, [~,]=max(...)स्ट्रिंग लंबाई के सरणी में पहले अधिकतम का सूचकांक देता है। परिणाम xसंगत स्ट्रिंग प्राप्त करने के लिए एक घुंघराले ब्रेस सूचकांक के रूप में प्रयोग किया जाता है ।

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

जावास्क्रिप्ट (Node.js) , 38 बाइट्स

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

a=>a.sort((a,b)=>a.length<b.length)[0]
— LiefdeWen
स्रोत
@ डोगो यह एक टाई के मामले में पहला तत्व वापस करता है।
— LiefdeWen
1
सॉर्ट () कॉलबैक में हस्ताक्षर किए गए नंबर के बजाय एक बूलियन लौटना सभी जेएस इंजनों में काम नहीं करता है (जैसे यह एज में काम नहीं करता है)। एक और तरीका कुछ ऐसा होगा , जो 1 बाइट से छोटा हो। फिर भी, इस बात की कोई गारंटी नहीं है कि टाई के मामले में पहला आइटम ब्राउज़र में लगातार चुना जाएगा।
— अरनुलद
लेकिन अगर यह यह TIO पर Node.js में लगातार चुनता है कि अच्छा पर्याप्त नहीं है \?
— LiefdeWen
1
आपको तुलनित्र फ़ंक्शन के -बजाय उपयोग करना चाहिए <।
— kamoroso94
1
@LiefdeWen हाँ, लेकिन यह टिप्पणियों में समस्याओं को संबोधित करता है।
— सेबस्टियन साइमन
5

जे , 19, 11, 10 8 बाइट्स

0{>\:#@>

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

संकेत के लिए स्ट्रीटस्टर के लिए धन्यवाद!

-1 बाइट फ्रोवेफ्रॉग के लिए धन्यवाद!

कॉनर ओ'ब्रायन को -2 बाइट्स धन्यवाद

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

    (  #@>) - unbox each string and find its length
     \:     - sort down the list of strings according to the lengths
0{::        - take and unbox the first string

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

— गैलेन इवानोव
स्रोत
1
यह K में मेरा प्रारंभिक दृष्टिकोण था, लेकिन फिर मुझे एहसास हुआ कि मैं सूची को केवल क्रम से क्रमबद्ध कर सकता हूं, नीचे उतर सकता हूं और पहला आइटम ले सकता हूं ... क्या आप जम्मू में एक ही काम कर सकते हैं?
— स्ट्रीटस्टर
@streetster - धन्यवाद! मुझे बस एहसास हुआ। मैं इसे अभी आज़माने जा रहा हूँ, यह बहुत छोटा हो गया है।
— गैलेन इवानोव
1
इस बिंदु से परे कोई कोष्ठक नहीं:0{::]\:#@>
— FrownyFrog
काम के {.@बदले होगा 0{::?
— क्रिकटी लिथोस
1
8 बाइट्स:0{>\:#@>
— कॉनर ओ'ब्रायन
4

सी #, 43 + 18 = 61 बाइट्स

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

a=>a.OrderByDescending(x=>x.Length).First()
— LiefdeWen
स्रोत
@ डोगो यह एक टाई के मामले में पहला तत्व वापस करता है।
— LiefdeWen
@ LiefdeWen OrderBy स्थिर है इसलिए यह वास्तव में एक टाई के मामले में अंतिम तत्व लौटाएगा। उदाहरण: tio.run/##TY7BCsIwDIbvfYqwUwvaF5jbQcHTRMGDB/…
— Grzegorz Puławski 20'17
1
@ GrzegorzPuławski ओह, मैं देख रहा हूँ, तय की।
— लिफडेविन
मैं कुछ है कि शायद किसी को छोटा मदद कर सकते हैं मिल गया है a=>a.Aggregate((x,y)=>y.Length>x.Length?y:x)44 बाइट आधार, a=>a.First(x=>x.Length==a.Max(y=>y.Length))43 बाइट आधार
— Monso
1
@ मायलोर मेरा पहला समाधान था लेकिन फिर एक टाई में यह आखिरी रिटर्न देता है, क्योंकि ऑर्डर अप्रभावित है।
— लाईफ़डेवेन
3

के (ओके) , 9 बाइट्स

*x@>#:'x:

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

उदाहरण:

*x@>#:'x:("edur";"oot";"taht")
"edur"

व्याख्या

*x@>#:'x: / solution
       x: / store input in variable x
    #:'   / count (#:) each (')
   >      / sort descending
 x@       / apply indices to x
*         / take the first one

टिप्पणियाँ:

मूल रूप से 5 चरणों के होने के बावजूद इसे गैर-तुच्छ के रूप में वर्गीकृत किया गया है (यदि यह फ़ंक्शन के रूप में लिखा जाए {*x@>#:'x})।

— streetster
स्रोत
3

जावा (ओपनजेडके 8) , 67 बाइट्स

मेरी पसंदीदा भाषा में एक और सबमिशन! (पढ़ें: केवल एक ही मुझे पता है)।
यह खाली सरणी के साथ काम नहीं करता है, लेकिन यह ठीक है।

golfed

w->{for(String y:w)if(y.length()>w[0].length())w[0]=y;return w[0];}

Ungolfed

for(String y:w)                           // Loops through all Strings
    if(y.length()>w[0].length())          // If the String is longer than the first String 
                                w[0]=y;   // Store it as the first string.
return w[0];                              // Return the first String.

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

— ल्यूक स्टीवंस
स्रोत
3

रैकेट , 160 बाइट्स 110 बाइट्स

इसे ऑनलाइन आज़माएं! पहली बार योगदान, सलाह की सराहना की!

(define(m a)(if(>(length a)1)(if(>=(string-length(car a))(string-length(m(cdr a))))(car a)(m(cdr a)))(car a)))

Ungolfed

(define (m a)
    (if (> (length a) 1)
        (if (>= (string-length (car a)) (string-length (m (cdr a))))
            (car a)
            (m (cdr a))
        )
        (car a)
    )
)

प्रतिक्रिया के आधार पर अद्यतन समाधान

— डैनियल लैम्बर्ट
स्रोत
4
मैं समुदाय की ओर से PPCG में आपका स्वागत करना चाहता हूं! मैंने देखा कि आपका समाधान उन सूचियों के लिए स्पष्ट रूप से विफल हो जाता है जहां सबसे लंबी स्ट्रिंग अंत में है। यहाँ उदाहरण है । मुझे रैकेट अच्छी तरह से याद नहीं है, लेकिन अगर आप मुझे अपने एल्गोरिथ्म को एक- foldrआधारित दृष्टिकोण में बदलने की सलाह देंगे , तो अधिकतम लंबाई लेकर और उस पार ले जाना।
— कोल
ओह हुह। उसे इंगित करने के लिए धन्यवाद। मुझे विश्वास नहीं हो रहा है कि मैंने इसका परीक्षण नहीं किया है।
— डैनियल लैंबर्ट
तुम भी बदल सकते हैं define(m a)करने के लिएλ(a)
— कृपया फ़ीड रों।
1
यदि आप नहीं भी सुझावों की जाँच करें !
— फेड एस।
3

स्क्रैच 27 17 170 160

कोड चित्र

यह एक वैश्विक (सभी स्प्राइट्स से जुड़ी, अधिक सटीक होने के लिए) नामक तार की सूची की अपेक्षा करता है mylist । हरे झंडे पर क्लिक करने के बाद, सबसे लंबा शब्द चर में छोड़ दिया जाएगाw ।

मुझे लगता है कि यह कड़ी है

when gf clicked
set[w]to(item[1]of[mylist
set[i]to[0
repeat(length of[mylist
change[i]by(1
set[m]to(item(i)of[mylist
if<(m)>(w)>then
set[w]to(m
end
end
stop[all

इस मेटा के अनुसार गिनती ।

— फ़ेडर एस।
स्रोत
क्या stop[allयहां होना जरूरी है?
— गोरगलेन
3

रोदा , 30 बाइट्स

{enum|[[#_,-_,_1]]|max|_|tail}

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

स्पष्टीकरण:

{
 enum|         /* For each element, push its index to the stream */
 [[#_,-_,_1]]| /* For each element and index, push [length, -index, element] */
 max|          /* Find the greatest element */
 _|            /* Flat the list in the stream */
 tail          /* Return the last item in the stream */
}

वैकल्पिक 30 बाइट्स:

{enum|[[#_,-_,_1]]|max|[_[2]]}

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

— fergusq
स्रोत
मेरे jq उत्तर को लिखने से मुझे एहसास हुआ कि enumइसे गिराया जा सकता है, और इसके बजाय से [[-#_,_1]]चयनित किया जा सकता है, tio.run/…
— Krikii Lithos
@Cowsquack इसलिए काम नहीं करता क्योंकि तब minतार की तुलना दूसरी वर्णमाला से होती है (क्योंकि सरणियों की तुलना उनके दूसरे आइटम से की जाती है)। उदाहरण के लिए इनपुट आउटपुट के रूप में ["b", "a"]देगा "a"। मुझे संभवतः minbyरोदा या कुछ इसी तरह के एक फंक्शन को जोड़ना चाहिए ...
— fergusq
3

एपीएल - २३ 16 बाइट्स

a←{((⍴¨⍵)⍳(⌈/(⍴¨⍵)))⌷⍵}

आपके सभी महान सुझावों और प्रोत्साहन के लिए सभी को धन्यवाद!

a←{⍵⌷⍨(⍴¨⍵)⍳⌈/⍴¨⍵}

उपयोग:

a 'duck' 'duck' 'goose'
  'goose'

स्पष्टीकरण:

वर्णों के प्रत्येक वेक्टर की लंबाई (स्ट्रिंग) प्राप्त होती है, फिर एक सूचकांक के रूप में अधिकतम उपयोग करता है। मैंने एपीएल 20 मिनट पहले शुरू किया था इसलिए मुझे खेद है कि अगर यह करना बेवकूफी भरा तरीका है।

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

(स्पष्टता के लिए संपादित)

— rmoro
स्रोत
1
PPCG में आपका स्वागत है!
— स्टीडायबॉक्स
यह a←आपके बाइटकाउंट की ओर नहीं गिना जाता है।
— कृति लिथोस
कभी न भूलें एपीएल का मूल्यांकन दाएं-बाएं: (⌈/(⍴¨⍵))=> है ⌈/⍴¨⍵। इसके अलावा, (...)⌷⍵=> ⍵⌷⍨...एक बाइट बचाने के लिए
— Zacharý
कोष्ठक के अलावा, यह वास्तव में बहुत अच्छा लगता है!
— जकार्इ
2

मानक एमएल (एमएलटन) , 55 बाइट्स

fun&(s::r)=foldl(fn(%,$)=>if size% >size$then%else$)s r

इसे ऑनलाइन आज़माएं! उदाहरण का उपयोग:& ["abc","de","fgh"] पैदावार "abc"।

Ungolfed:

fun step (current, longest) = 
    if size current > size longest 
    then current 
    else longest

fun longestString (start :: list) = foldl step start list
  | longestString nil = raise Empty

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

— Laikoni
स्रोत
2

फंकी , 38 बाइट्स

a=>a[(v=a::map@#)::find(math.max...v)]

व्याख्या की

a=>a[(v=a::map@#)::find(math.max...v)]
        a::map@#                        $ Create a list of the lengths of the input's strings.
      v=                                $ And assign it to v.
     (          )::find(            )   $ Find the first index in this list that equals...
                        math.max...v    $ The largest value of v, eg. the length of the longest string.
   a[                                ]  $ Get the value at that position.

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

— Ataco
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.