Votre défi consiste à prendre un tableau de chaînes et à générer la chaîne la plus longue du tableau. Donc pour

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

la sortie serait biggest.

Si deux éléments du tableau ont la même longueur, vous devez choisir celui qui apparaît en premier dans le tableau. Cela signifie que si le tableau ressemble à ceci:

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

la sortie est one, mais si le tableau ressemblait à ceci:

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

la sortie est two.

Comme il s'agit de code-golf , le code le plus court en octets l'emporte.

Tampio impératif , 168 octets

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.

Version en ligne

Non golfé:

Listan pisin alkio sur 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.

Version en ligne

La seule opportunité de jouer au golf est de remplacer pisin alkio(signifiant "l'élément le plus long") par x.

Traduction:

L'élément le plus long d'une liste est, selon que la longueur du premier élément est supérieure ou égale à la longueur de chaque élément de la liste, soit

• le premier élément de la liste, ou
• l'élément le plus long dans la queue de la liste.

Python , 23 octets

lambda a:max(a,key=len)

Essayez-le en ligne!

Haskell , 35 octets

-3 octets grâce à Zgarb.

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

Essayez-le en ligne!

J'aime ce code. Tu sais pourquoi? Parce que Haskell prend en charge des solutions beaucoup plus élégantes avec des fonctions provenant de bibliothèques aléatoires.

maximumBy(compare`on`length).reverse

C'est facile à lire! Sauf que ce n'est pas valable.

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

S'il n'y avait pas eu les importations, cela aurait été une soumission parfaite pour obtenir tous les votes positifs. : P

(En outre, cela utilise une pointe de golf et un pli.)

R + pryr , 31 octets

[-2 octets grâce à Scrooble]

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

Essayez-le en ligne!

R , 33 octets

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

Essayez-le en ligne!

EXCELLER, 36 42 octets

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

Entré sous forme de formule matricielle (ctrl-shift-enter). Le tableau d'entrée doit être entré dans la colonne A.

La formule renvoie la première correspondance avec une longueur maximale.

Selon les paramètres de votre région, remplacez ,par ;; la longueur du code reste inchangée. Sur les 16 langues répertoriées ici , les noms de fonction anglais sont les plus courts pour cette formule.

Explication:

=                                          - 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) , 9 octets ^SBCS

⊢⊃⍨∘⊃∘⍒≢¨

Essayez-le en ligne!

⊢ de l'argument,

⊃⍨ choisissez l'élément avec l'indice qui est le

⊃ premier des

⍒ indices dans l'ordre décroissant de la

≢¨ longueurs de chacun

Prolog (SWI) , 98 92 72 69 octets

Le prédicat de niveau supérieur est *.

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

Essayez-le en ligne!

Explication

La première ligne définit le prédicat dyadique /comme un court pour atom_length/2lequel est vrai si la longueur du premier argument est le deuxième argument. Cela nous permet d'économiser 3 octets sur l'utilisationatom_length deux fois.

Notre prédicat principal est défini comme le dyadique * où le premier argument est une liste et le deuxième argument l'élément le plus long de cette liste.

La deuxième ligne est notre scénario de base qui indique que l'élément le plus long d'une liste à un élément est cet élément.

La troisième ligne indique que pour une liste avec au moins 2 éléments, l'élément le plus long est:

Si la longueur du deuxième élément est plus longue que le premier élément, l'élément le plus long est dans la liste sans le premier élément.

Sinon, l'élément le plus long se trouve dans la liste sans le deuxième élément.

Pyth , 4 octets

h.Ml

Suite de tests.

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 octets

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

Essayez-le en ligne!

Prend l'entrée $args[0], les tuyaux qui à Sort-Objectbasé sur length dans l' -dordre croissant. Prend ensuite le [0]th de celui-ci. Le tri étant stable, cela prend le premier élément en cas d'égalité.

Octave , 33 octets

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

L'entrée est un tableau de cellules de chaînes.

Essayez-le en ligne!

Explication

cellfun(@nnz,x)applique la nnzfonction (nombre de non-zéros) à chaque chaîne du tableau d'entrée x. Pour les chaînes ASCII, nnzest équivalent à numel(nombre d'éléments), mais plus court. Le résultat est un tableau numérique avec les longueurs de chaîne.

Ensuite, [~,]=max(...)donne l'index du premier maximum dans le tableau des longueurs de chaîne. Le résultat est utilisé comme index d'accolade xpour obtenir la chaîne correspondante.

JavaScript (Node.js) , 38 octets

Essayez-le en ligne!

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

J , 19, 11, 10 8 octets

0{>\:#@>

Essayez-le en ligne!

Merci au streetster pour l'astuce!

-1 octet grâce à FrownyFrog!

-2 octets grâce à Conor O'Brien

Comment ça marche:

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

Essayez-le en ligne!

C#, 43 + 18 = 61 bytes

Try it online!

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

Perl 6,  14  13 bytes

*.max(*.chars)

Try it

*.max(&chars)

Try it

PHP, 72 bytes

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

Japt -h, 5 3 bytes

ÔñÊ

Try it

Reverse, sort by length and output the last element.

Swift, 54 bytes

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

Try it online!

K (oK), 9 bytes

*x@>#:'x:

Try it online!

Example:

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

Explanation

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

Notes:

Undeleted as this is classed as non-trivial, despite being basically 5 steps (would be if written as the function {*x@>#:'x}).

Java (OpenJDK 8), 67 bytes

Another submission in my favourite language! (read: the only one I know).
This doesn't work with an empty array, but that's fine.

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.

Try it online!

Racket, 160 bytes 110 bytes

Try it online! First time contributing, advice appreciated!

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

Updated solution based on feedback

Bash, 45 bytes

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

Try it online!

Scratch 27 17 170 160

It expects a global (attached to all sprites, to be more precise) list of strings called mylist. After clicking the green flag, the longest word will be left in the variable w.

I think this is the link

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

Counting as per this meta.

Röda, 30 bytes

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

Try it online!

Explanation:

{
 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 */
}

Alternative 30 bytes:

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

Try it online!

APL -- 23 16 bytes

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

Thanks to everyone for all of your great suggestions and encouragement!

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

Usage:

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

Explanation:

gets length of each vector of characters (string) then uses maximum as an index. I just started APL 20 min ago so I am sorry if this is a stupid way to do it.

Try it Online!

(edited for clarity)

Standard ML (MLton), 55 bytes

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

Try it online! Example usage: & ["abc","de","fgh"] yields "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

Try it online!

Julia 0.6, 24 bytes

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

Try it online!

Funky, 38 bytes

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

Explained

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.

Try it online!

Ruby, 21 20 bytes

->s{s.max_by &:size}

Try it online!

Trivial solution, thanks Snack for -1 byte

SNOBOL4 (CSNOBOL4), 63 57 bytes

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

Try it 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!