您面临的挑战是获取一个字符串数组并输出该数组中最长的字符串。因此对于

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

输出将是biggest。

如果数组的两个元素的长度相同，则应选择在数组中最先出现的元素。这意味着如果数组看起来像这样：

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

输出为one，但如果数组如下所示：

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

输出是two。

因为这是code-golf，所以以字节为单位的最短代码获胜。

命令式坦皮奥，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.

在线版

取消高尔夫：

Listan pisin alkio 上 riippuen siitä，onko仙ensimmäisenalkion身体高度suurempi 泰 yhtä suuri kuin仙jokaisen alkion身体高度，佐戈

• 森ensimmäinenalkio 泰
• 森·汉纳·皮辛·奥尔基奥。

在线版

唯一的高尔夫机会是将替换为pisin alkio（表示“最长的元素”）x。

翻译：

列表中最长的项取决于第一项的长度是大于还是等于列表中每个元素的长度，或者

• 列表中的第一项，或者
• 列表尾部最长的项目。

Python，23个字节

lambda a:max(a,key=len)

在线尝试！

Haskell，35个字节

-3个字节感谢Zgarb。

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

在线尝试！

我喜欢这个代码。你知道为什么？因为Haskell使用随机库中的函数支持更优雅的解决方案。

maximumBy(compare`on`length).reverse

这是弗里金的可读性！除了，这是无效的。

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

如果不是进口的话，这将是获得所有支持的完美选择。：P

（此外，它使用一个高尔夫球头，并且使用了折叠。）

R + pryr，31个字节

[-2个字节，感谢Scrooble]

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

在线尝试！

R，33个字节

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

在线尝试！

极好 36 42字节

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

输入为数组公式（ctrl-shift-enter）。输入数组应在A列中输入。

该公式返回最大长度的第一个匹配项。

根据您的区域设置，替代,用;; 代码长度保持不变。在此处列出的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

APL（Dyalog Unicode），9字节^SBCS

⊢⊃⍨∘⊃∘⍒≢¨

在线尝试！

⊢ 从论点来看，

⊃⍨ 选择具有索引的元素是

⊃ 首先

⍒ 索引按降序排列

≢¨ 每个的长度

Prolog（SWI），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.

在线尝试！

说明

第一行将二元谓词定义/为short，atom_length/2如果第一个参数的长度为第二个参数，则为true。这样比使用atom_length两次可节省3个字节。

我们的主要谓词定义为二进位*，其中第一个参数是列表，第二个参数是该列表的最长元素。

第二行是我们的基本情况，它指出一个元素列表中最长的元素是该元素。

第三行指出，对于包含至少2个元素的列表，最长的元素为：

如果第二个元素的长度大于第一个元素的长度，则最长的元素在列表中，而没有第一个元素。

否则，最长的元素将在列表中，而没有第二个元素。

Pyth，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

PowerShell，24字节

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

在线尝试！

以升序接受输入$args[0]，Sort-Object基于强度的管道。然后采取其中之一。由于排序是稳定的，因此在平局的情况下这是第一个要素。l-d[0]

八度，33字节

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

输入是字符串的单元格数组。

在线尝试！

说明

cellfun(@nnz,x)将nnz函数（非零数）应用于输入数组中的每个字符串x。对于ASCII字符串，nnz等效于numel（元素数），但更短。结果是带有字符串长度的数字数组。

然后，[~,]=max(...)给出字符串长度数组中第一个最大值的索引。结果用作花括号索引，x以获取相应的字符串。

JavaScript（Node.js），38字节

在线尝试！

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

J，19，11，10 8字节

0{>\:#@>

在线尝试！

感谢streetster的提示！

-1个字节感谢FrownyFrog！

-2个字节，感谢Conor O'Brien

怎么运行的：

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

在线尝试！

C＃，43 + 18 = 61字节

在线尝试！

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

Perl 6的， 14  13个字节

*.max(*.chars)

试试吧

*.max(&chars)

试试吧

PHP，72字节

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

Japt -h，5 3字节

ÔñÊ

试试吧

反向，按长度排序并输出最后一个元素。

迅捷，54字节

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

在线尝试！

K（oK），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}）。

Java（OpenJDK 8），67字节

我最喜欢的语言的另一个提交！（阅读：我认识的唯一一位）。
这不适用于空数组，但是很好。

打高尔夫球

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

不打高尔夫球

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.

在线尝试！

球拍，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)))

不打高尔夫球

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

根据反馈更新了解决方案

Bash，45个字节

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

在线尝试！

刮擦 27 17 170 160

它期望一个称为的字符串的全局列表（更确切地说，附加到所有sprite）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

根据此元计数。

Röda，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]]}

在线尝试！

APL- 23 16字节

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

感谢大家的宝贵建议和鼓励！

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

用法：

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

说明：

获取每个字符向量（字符串）的长度，然后使用最大值作为索引。我刚刚在20分钟前启动APL，所以如果这样做是愚蠢的做法，我感到抱歉。

在线尝试！

（为清楚起见进行了编辑）

标准ML（MLton），55字节

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

在线尝试！用法示例：& ["abc","de","fgh"]yields "abc"。

取消高尔夫：

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

在线尝试！

朱莉娅0.6，24字节

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

在线尝试！

时髦的，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.

在线尝试！

红宝石，21 20字节

->s{s.max_by &:size}

在线尝试！

简单的解决方案，感谢Snack提供的-1个字节

SNOBOL4（CSNOBOL4），63 57字节

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

在线尝试！

输入在stdin上，输出在stdout上。

大致翻译为以下伪代码：

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

Bash，44个字节

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

在线尝试！