La tua sfida è prendere una matrice di stringhe e produrre la stringa più lunga nella matrice. Quindi per

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

l'output sarebbe biggest.

Se due elementi dell'array hanno la stessa lunghezza, è necessario scegliere quello che appare per primo nell'array. Ciò significa che se l'array è simile al seguente:

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

l'output è one, ma se l'array fosse simile al seguente:

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

l'uscita è two.

Poiché si tratta di code-golf , vince il codice più breve in byte.

Tampio imperativo , 168 byte

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.

Versione online

Ungolfed:

Listan pisin alkio on riippuen siitä , onko sen ensimmäisenalkion pituus suurempi tai yhtä suuri kuin sen jokaisen alkion pituus, joko

• sen ensimmäinenalkio tai
• sen hännän pisin alkio.

Versione online

L'unica opportunità di golf che ha è quella di sostituire pisin alkio(che significa "l'elemento più lungo") con x.

Traduzione:

L'elemento più lungo in un elenco è, a seconda che la lunghezza del primo elemento sia maggiore o uguale alla lunghezza di ciascun elemento nell'elenco,

• il primo elemento nell'elenco o
• l'elemento più lungo nella coda dell'elenco.

Python , 23 byte

lambda a:max(a,key=len)

Provalo online!

Haskell , 35 byte

-3 byte grazie a Zgarb.

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

Provalo online!

Mi piace questo codice Tu sai perché? Perché Haskell supporta soluzioni molto più eleganti con funzioni di librerie casuali.

maximumBy(compare`on`length).reverse

È leggibile! Tranne che non è valido.

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

Se non fosse stato per le importazioni, questa sarebbe stata una presentazione perfetta per ottenere tutti i voti. : P

(Inoltre, utilizza una punta da golf e una piega.)

R + pryr , 31 byte

[-2 byte grazie a Scrooble]

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

Provalo online!

R , 33 byte

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

Provalo online!

ECCELLERE, 36 42 byte

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

Inserito come una formula di matrice (ctrl-shift-invio). L'array di input deve essere inserito nella colonna A.

La formula restituisce la prima corrispondenza con la lunghezza massima.

A seconda delle impostazioni della propria regione, sostituire ,con ;; la lunghezza del codice rimane invariata. Delle 16 lingue elencate qui , i nomi delle funzioni inglesi sono i più brevi per questa formula.

Spiegazione:

=                                          - 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

APL (Dyalog Unicode) , ^{SBCS da} 9 byte

⊢⊃⍨∘⊃∘⍒≢¨

Provalo online!

⊢ dall'argomento,

⊃⍨ scegli l'elemento con l'indice che è il

⊃ primo dei

⍒ indici in ordine decrescente di

≢¨ lunghezze di ciascuno

Prolog (SWI) , 98 92 72 69 byte

Il predicato di livello superiore è *.

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

Provalo online!

Spiegazione

La prima riga definisce il predicato diadico /come abbreviato per atom_length/2cui è vero se la lunghezza del primo argomento è il secondo argomento. Questo ci fa risparmiare 3 byte oltre usando atom_lengthdue volte.

Il nostro predicato principale è definito come diadico in *cui il primo argomento è un elenco e il secondo argomento l'elemento più lungo di tale elenco.

La seconda riga è il nostro caso base in cui si afferma che l'elemento più lungo di un elenco di un elemento è quell'elemento.

La terza riga afferma che per un elenco con almeno 2 elementi, l'elemento più lungo è:

Se la lunghezza del secondo elemento è più lunga del primo elemento, l'elemento più lungo è nell'elenco senza il primo elemento.

Altrimenti l'elemento più lungo è nell'elenco senza il secondo elemento.

Pyth , 4 byte

h.Ml

Suite di test.

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

PowerShell , 24 byte

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

Provalo online!

Prende input $args[0], reindirizza in Sort-Objectbase a length in -dordine crescente. Quindi prende il [0]suo. Poiché l'ordinamento è stabile, questo prende il primo elemento in caso di pareggio.

Ottava , 33 byte

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

L'input è un array di celle di stringhe.

Provalo online!

Spiegazione

cellfun(@nnz,x)applica la nnzfunzione (numero di nonzeros) a ciascuna stringa nella matrice di input x. Per le stringhe ASCII, nnzè equivalente anumel (numero di elementi), ma più breve. Il risultato è una matrice numerica con le lunghezze delle stringhe.

Quindi, [~,]=max(...)fornisce l'indice del primo massimo nella matrice di lunghezze di stringa. Il risultato viene utilizzato come indice parentesi graffa in xper ottenere la stringa corrispondente.

JavaScript (Node.js) , 38 byte

Provalo online!

a=>a.sort((a,b)=>a.length<b.length)[0]

J , 19, 11, 10 8 byte

0{>\:#@>

Provalo online!

Grazie a streetster per il suggerimento!

-1 byte grazie a FrownyFrog!

-2 byte grazie a Conor O'Brien

Come funziona:

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

Provalo online!

C #, 43 + 18 = 61 byte

Provalo online!

a=>a.OrderByDescending(x=>x.Length).First()

Perl 6 ,  14  13 byte

*.max(*.chars)

Provalo

*.max(&chars)

Provalo

PHP, 72 byte

array_reduce($a,function($c,$i){return (strlen($i)>strlen($c))?$i:$c;});

Japt -h, 5 3 byte

ÔñÊ

Provalo

Inverti, ordina per lunghezza e genera l'ultimo elemento.

Rapido , 54 byte

{($0 as[String]).reduce(""){$1.count>$0.count ?$1:$0}}

Provalo online!

K (oK) , 9 byte

*x@>#:'x:

Provalo online!

Esempio:

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

Spiegazione

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

Gli appunti:

Non eliminato in quanto questo è classificato come non banale, nonostante sia sostanzialmente 5 passaggi (sarebbe se scritto come la funzione {*x@>#:'x}).

Java (OpenJDK 8) , 67 byte

Un'altra presentazione nella mia lingua preferita! (leggi: l'unico che conosco).
Questo non funziona con un array vuoto, ma va bene.

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.

Provalo online!

Racchetta , 160 byte 110 byte

Provalo online! La prima volta che hai contribuito, il consiglio è stato apprezzato!

(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)
    )
)

Soluzione aggiornata basata sul feedback

Bash , 45 byte

a=;for b;do((${#b}>${#a}))&&a=$b;done;echo $a

Provalo online!

Graffio 27 17 170 160

Si aspetta un elenco globale (allegato a tutti gli sprite, per essere più precisi) di stringhe chiamate mylist. Dopo aver fatto clic sulla bandiera verde, la parola più lunga verrà lasciata nella variabile w.

Penso che questo sia il collegamento

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

Conteggio secondo questa meta.

Röda , 30 byte

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

Provalo online!

Spiegazione:

{
 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 byte alternativi:

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

Provalo online!

APL - 23 16 byte

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

Grazie a tutti per tutti i vostri fantastici suggerimenti e incoraggiamento!

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

Uso:

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

Spiegazione:

ottiene la lunghezza di ogni vettore di caratteri (stringa) quindi utilizza il massimo come indice. Ho appena iniziato APL 20 minuti fa, quindi mi dispiace se questo è un modo stupido per farlo.

Provalo online!

(modificato per chiarezza)

ML standard (MLton) , 55 byte

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

Provalo online! Esempio di utilizzo: & ["abc","de","fgh"]rese "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

Provalo online!

Julia 0.6 , 24 byte

!s=s[indmax(length.(s))]

Provalo online!

Funky , 38 byte

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

spiegato

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.

Provalo online!

Rubino , 21 20 byte

->s{s.max_by &:size}

Provalo online!

Soluzione di prova, grazie Snack per -1 byte

SNOBOL4 (CSNOBOL4) , 63 57 byte

I	M =LT(SIZE(M),SIZE(X)) X
	X =INPUT	:S(I)
	OUTPUT =M
END

Provalo online!

Input is on stdin and output on stdout.

Roughly translates to the following pseudocode:

while input exists
 x = input
 if length(m) < length(x)
  m = x
end
return m

Bash, 44 bytes

IFS=$'\n';egrep -m1 .{`wc -L<<<"$*"`}<<<"$*"

Try it online!