Su desafío es tomar una matriz de cadenas y generar la cadena más larga de la matriz. Entonces para

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

la salida sería biggest.

Si dos elementos de la matriz tienen la misma longitud, debe elegir el que aparece primero en la matriz. Eso significa que si la matriz se ve así:

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

la salida es one, pero si la matriz se ve así:

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

la salida es two.

Como se trata de código golf , gana el código más corto en bytes.

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.

Versión en línea

Sin golf:

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

Versión en línea

La única oportunidad de golf que tiene es reemplazar pisin alkio(que significa "el elemento más largo") con x.

Traducción:

El elemento más largo de una lista es, dependiendo de si la longitud del primer elemento es mayor o igual a la longitud de cada elemento de la lista, ya sea

• el primer elemento de la lista, o
• El elemento más largo en la cola de la lista.

Pitón , 23 bytes

lambda a:max(a,key=len)

Pruébalo en línea!

Haskell , 35 bytes

-3 bytes gracias a Zgarb.

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

Pruébalo en línea!

Me gusta este codigo ¿Sabes por qué? Porque Haskell admite soluciones mucho más elegantes con funciones de bibliotecas aleatorias.

maximumBy(compare`on`length).reverse

¡Eso es legible! Excepto que no es válido.

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

Si no fuera por las importaciones, esta hubiera sido una presentación perfecta para obtener todos los votos positivos. :PAGS

(Además, esto usa una punta de golf y usa un pliegue).

R + pryr , 31 bytes

[-2 bytes gracias a Scrooble]

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

Pruébalo en línea!

R , 33 bytes

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

Pruébalo en línea!

SOBRESALIR, 36 42 bytes

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

Ingresado como una fórmula de matriz (ctrl-shift-enter). La matriz de entrada debe ingresarse en la columna A.

La fórmula devuelve la primera coincidencia con longitud máxima.

Dependiendo de la configuración de su región, sustituya ,con ;; la longitud del código permanece sin cambios. De los 16 idiomas enumerados aquí , los nombres de funciones en inglés son los más cortos para esta fórmula.

Explicación:

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

⊢⊃⍨∘⊃∘⍒≢¨

Pruébalo en línea!

⊢ del argumento

⊃⍨ elija el elemento con el índice que es el

⊃ primero de los

⍒ índices en orden descendente de la

≢¨ longitudes de cada

Prólogo (SWI) , 98 92 72 69 bytes

El predicado de nivel superior es *.

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

Pruébalo en línea!

Explicación

La primera fila define el predicado diádico /como un corto para el atom_length/2cual es verdadero si la longitud del primer argumento es el segundo argumento. Esto nos ahorra 3 bytes al usaratom_length dos veces.

Nuestro predicado principal se define como la diádica * donde el primer argumento es una lista y el segundo argumento el elemento más largo de esa lista.

La segunda fila es nuestro caso base que establece que el elemento más largo de una lista de un elemento es ese elemento.

La tercera fila indica que para una lista con al menos 2 elementos, el elemento más largo es:

Si la longitud del segundo elemento es más larga que el primer elemento, el elemento más largo está en la lista sin el primer elemento.

De lo contrario, el elemento más largo está en la lista sin el segundo elemento.

Pyth , 4 bytes

h.Ml

Banco de pruebas.

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]

Pruébalo en línea!

Toma entradas $args[0], canalizaciones Sort-Objectbasadas en la lprofundidad en -dorden ascendente. Luego toma el [0]th del mismo. Como sort es estable, esto toma el primer elemento en caso de empate.

Octava , 33 bytes

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

La entrada es una matriz de celdas de cadenas.

Pruébalo en línea!

Explicación

cellfun(@nnz,x)aplica la nnzfunción (número de nonzeros) a cada cadena en la matriz de entrada x. Para cadenas ASCII, nnzes equivalente a numel(número de elementos), pero más corto. El resultado es una matriz numérica con las longitudes de cadena.

Luego, [~,]=max(...)da el índice del primer máximo en la matriz de longitudes de cadena. El resultado se utiliza como un índice de llaves xpara obtener la cadena correspondiente.

JavaScript (Node.js) , 38 bytes

Pruébalo en línea!

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

J , 19, 11, 10 8 bytes

0{>\:#@>

Pruébalo en línea!

Gracias a streetter por la pista!

-1 byte gracias a FrownyFrog!

-2 bytes gracias a Conor O'Brien

Cómo 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

Pruébalo en línea!

C #, 43 + 18 = 61 bytes

Pruébalo en línea!

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

Perl 6 ,  14  13 bytes

*.max(*.chars)

Intentalo

*.max(&chars)

Intentalo

PHP, 72 bytes

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

Japt -h, 5 3 bytes

ÔñÊ

Intentalo

Invertir, ordenar por longitud y generar el último elemento.

Rápido , 54 bytes

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

Pruébalo en línea!

K (oK) , 9 bytes

*x@>#:'x:

Pruébalo en línea!

Ejemplo:

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

Explicación

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

Notas:

Sin eliminar, ya que se clasifica como no trivial, a pesar de ser básicamente 5 pasos (se escribiría como la función {*x@>#:'x}).

Java (OpenJDK 8) , 67 bytes

¡Otra presentación en mi idioma favorito! (léase: el único que conozco).
Esto no funciona con una matriz vacía, pero está bien.

Golfed

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

Sin golf

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.

Pruébalo en línea!

Raqueta , 160 bytes 110 bytes

Pruébalo en línea! Contribución por primera vez, apreciado consejo!

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

Sin golf

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

Solución actualizada basada en comentarios

Bash , 45 bytes

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

Pruébalo en línea!

Scratch 27 17 170 160

Espera una lista global de cadenas (unidas a todos los sprites, para ser más precisos) llamadas mylist. Después de hacer clic en la bandera verde, la palabra más larga quedará en la variablew .

Creo que este es el enlace

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

Contando según este meta.

Röda , 30 bytes

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

Pruébalo en línea!

Explicación:

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

Alternativa de 30 bytes:

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

Pruébalo en línea!

APL - 23 16 bytes

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

¡Gracias a todos por todas sus excelentes sugerencias y aliento!

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

Uso:

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

Explicación:

obtiene la longitud de cada vector de caracteres (cadena) y luego usa el máximo como índice. Acabo de comenzar APL hace 20 minutos, así que lamento si esta es una forma estúpida de hacerlo.

Pruébalo en línea!

(editado para mayor claridad)

ML estándar (MLton) , 55 bytes

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

Pruébalo en línea! Ejemplo de uso: & ["abc","de","fgh"]rendimientos"abc" .

Sin golf:

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

Pruébalo en línea!

Julia 0.6 , 24 bytes

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

Pruébalo en línea!

Funky , 38 bytes

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

Explicado

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.

Pruébalo en línea!

Ruby , 21 20 bytes

->s{s.max_by &:size}

Pruébalo en línea!

Solución trivial, gracias Snack por -1 byte

SNOBOL4 (CSNOBOL4) , 63 57 bytes

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

Pruébalo en línea!

La entrada está en stdin y la salida en stdout.

Se traduce aproximadamente al siguiente pseudocódigo:

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

Bash , 44 bytes

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

Pruébalo en línea!