Seu desafio é pegar uma matriz de seqüências de caracteres e produzir a sequência mais longa da matriz. Então para

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

a saída seria biggest.

Se dois elementos da matriz tiverem o mesmo comprimento, escolha o que aparecer primeiro na matriz. Isso significa que se a matriz estiver assim:

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

a saída é one, mas se a matriz estiver assim:

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

a saída é two.

Como esse é o código-golfe , o código mais curto em bytes vence.

Tampio imperativo , 168 bytes

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.

Versão online

Ungolfed:

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

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

Versão online

A única oportunidade de golfe disponível é substituí-la pisin alkio(significando "o elemento mais longo") por x.

Tradução:

O item mais longo de uma lista é, dependendo se o comprimento do primeiro item é maior ou igual ao comprimento de cada elemento da lista, seja

• o primeiro item da lista ou
• o item mais longo no final da lista.

Python , 23 bytes

lambda a:max(a,key=len)

Experimente online!

Haskell , 35 bytes

-3 bytes graças ao Zgarb.

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

Experimente online!

Eu gosto deste código. Você sabe porque? Porque o Haskell suporta soluções muito mais elegantes com funções de bibliotecas aleatórias.

maximumBy(compare`on`length).reverse

Isso é legível! Exceto, não é válido.

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

Se não fosse pelas importações, esse seria um envio perfeito para obter todos os votos positivos. : P

(Além disso, ele usa uma dica de golfe e uma dobra.)

R + pryr , 31 bytes

[-2 bytes graças ao Scrooble]

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

Experimente online!

R , 33 bytes

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

Experimente online!

EXCEL, 36. 42 bytes

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

Introduzido como uma fórmula de matriz (ctrl-shift-enter). A matriz de entrada deve ser inserida na coluna A.

A fórmula retorna a primeira correspondência com o comprimento máximo.

Dependendo das configurações da sua região, substitua ,por ;; o comprimento do código permanece inalterado. Dos 16 idiomas listados aqui , os nomes das funções em inglês são os mais curtos para esta fórmula.

Explicação:

=                                          - 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 de} 9 bytes

⊢⊃⍨∘⊃∘⍒≢¨

Experimente online!

⊢ do argumento,

⊃⍨ escolha o elemento com o índice que é o

⊃ primeiro do

⍒ índices em ordem decrescente do

≢¨ comprimentos de cada

Prolog (SWI) , 98 92 72 69 bytes

O predicado de nível superior é *.

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

Experimente online!

Explicação

A primeira linha define o predicado diádico /como um curto, o atom_length/2que é verdadeiro se o comprimento do primeiro argumento for o segundo argumento. Isso nos economiza 3 bytes usando atom_lengthduas vezes.

Nosso predicado principal é definido como o diádico, *onde o primeiro argumento é uma lista e o segundo argumento, o elemento mais longo dessa lista.

A segunda linha é o nosso caso base, que afirma que o elemento mais longo de uma lista de um elemento é esse elemento.

A terceira linha afirma que, para uma lista com pelo menos 2 elementos, o elemento mais longo é:

Se o comprimento do segundo elemento for maior que o primeiro, o elemento mais longo estará na lista sem o primeiro elemento.

Caso contrário, o elemento mais longo estará na lista sem o segundo elemento.

Pitão , 4 bytes

h.Ml

Suíte de teste.

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 bytes

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

Experimente online!

Recebe entrada $args[0], tubos que, com Sort-Objectbase no length, em -dordem de tendência. Em seguida, leva o [0]th dela. Como a classificação é estável, isso leva o primeiro elemento em caso de empate.

Oitava , 33 bytes

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

Entrada é uma matriz de células de cadeias.

Experimente online!

Explicação

cellfun(@nnz,x)aplica a nnzfunção (número de nonzeros) a cada string na matriz de entrada x. Para cadeias ASCII, nnzé equivalente a numel(número de elementos), mas menor. O resultado é uma matriz numérica com os comprimentos de sequência.

Em seguida, [~,]=max(...)fornece o índice do primeiro máximo na matriz de comprimentos de sequência. O resultado é usado como um índice de chaves xpara obter a sequência correspondente.

JavaScript (Node.js) , 38 bytes

Experimente online!

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

J , 19, 11, 10 8 bytes

0{>\:#@>

Experimente online!

Obrigado ao streetster pela dica!

-1 byte graças a FrownyFrog!

-2 bytes graças a Conor O'Brien

Como funciona:

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

Experimente online!

C #, 43 + 18 = 61 bytes

Experimente online!

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

Perl 6 ,  14  13 bytes

*.max(*.chars)

Tente

*.max(&chars)

Tente

PHP, 72 bytes

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

Japonês -h, 5 3 bytes

ÔñÊ

Tente

Inverta, classifique por comprimento e produza o último elemento.

Rápido , 54 bytes

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

Experimente online!

K (oK) , 9 bytes

*x@>#:'x:

Experimente online!

Exemplo:

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

Explicação

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

Notas:

Com exclusão de exclusão, isso é classificado como não trivial, apesar de ter basicamente 5 etapas (seria escrito como a função {*x@>#:'x}).

Java (OpenJDK 8) , 67 bytes

Outra submissão no meu idioma favorito! (leia: o único que eu conheço).
Isso não funciona com uma matriz vazia, mas tudo bem.

Golfe

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.

Experimente online!

Raquete , 160 bytes 110 bytes

Experimente online! Primeira contribuição, conselhos apreciados!

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

Solução atualizada com base no 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!