Ihre Herausforderung besteht darin, ein Array von Zeichenfolgen zu verwenden und die längste Zeichenfolge im Array auszugeben. So für

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

die Ausgabe wäre biggest.

Wenn zwei Elemente des Arrays dieselbe Länge haben, sollten Sie dasjenige auswählen, das zuerst im Array angezeigt wird. Das heißt, wenn das Array so aussieht:

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

die Ausgabe ist one, aber wenn das Array so aussah:

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

die Ausgabe ist two.

Da es sich um Code-Golf , der kürzeste Code in Bytes gewinnt.

Imperativ Tampio , 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.

Online Version

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.

Online Version

Die einzige Golfmöglichkeit, die dies bietet, ist das Ersetzen pisin alkio(was "das längste Element" bedeutet) durch x.

Übersetzung:

Das längste Element in einer Liste hängt davon ab, ob die Länge des ersten Elements größer oder gleich der Länge jedes Elements in der Liste ist

• das erste Element in der Liste oder
• das längste Element im Ende der Liste.

Python , 23 Bytes

lambda a:max(a,key=len)

Probieren Sie es online!

Haskell , 35 Bytes

-3 Bytes dank Zgarb.

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

Probieren Sie es online!

Ich mag diesen Code. Du weißt, warum? Weil Haskell viel elegantere Lösungen mit Funktionen aus zufälligen Bibliotheken unterstützt.

maximumBy(compare`on`length).reverse

Das ist verdammt lesbar! Außer, es ist nicht gültig.

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

Ohne die Importe wäre dies eine perfekte Vorlage gewesen, um alle positiven Stimmen zu erhalten. : P

(Außerdem wird ein Golf-Tipp und eine Falte verwendet.)

R + Pryr , 31 Bytes

[-2 Bytes dank Scrooble]

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

Probieren Sie es online!

R , 33 Bytes

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

Probieren Sie es online!

EXCEL, 36 42 Bytes

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

Wird als Matrixformel eingegeben (Strg-Umschalt-Eingabe). Das Eingabearray sollte in Spalte A eingegeben werden.

Die Formel gibt die erste Übereinstimmung mit maximaler Länge zurück.

Ersetzen Sie je nach den Einstellungen in Ihrer Region ,durch ;; Die Codelänge bleibt unverändert. Von den 16 hier aufgeführten Sprachen sind englische Funktionsnamen die kürzesten für diese Formel.

Erläuterung:

=                                          - 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 Byte ^SBCS

⊢⊃⍨∘⊃∘⍒≢¨

Probieren Sie es online!

⊢ aus dem argument,

⊃⍨ Wählen Sie das Element mit dem Index, der das ist

⊃ zuerst der

⍒ Indizes in absteigender Reihenfolge der

≢¨ Längen von jedem

Prolog (SWI) , 98 92 72 69 Bytes

Das Prädikat der obersten Ebene ist *.

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

Probieren Sie es online!

Erläuterung

Die erste Zeile definiert das dyadische Prädikat /als eine Abkürzung, für atom_length/2die gilt, wenn die Länge des ersten Arguments das zweite Argument ist. Dies spart uns 3 Bytes bei atom_lengthzweimaliger Verwendung .

Unser Hauptprädikat ist als die Dyade definiert, bei der *das erste Argument eine Liste und das zweite Argument das längste Element dieser Liste ist.

Die zweite Zeile ist unser Basisfall, der besagt, dass das längste Element einer Liste mit einem Element dieses Element ist.

Die dritte Zeile gibt an, dass für eine Liste mit mindestens 2 Elementen das längste Element ist:

Wenn das zweite Element länger als das erste Element ist, befindet sich das längste Element in der Liste ohne das erste Element.

Andernfalls befindet sich das längste Element in der Liste ohne das zweite Element.

Pyth , 4 Bytes

h.Ml

Testsuite.

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]

Probieren Sie es online!

Übernimmt Eingaben $args[0], leitet diese an Sort-Objectdie lLänge in -dabsteigender Reihenfolge an. Dann nimmt man die [0]th davon. Da sort stabil ist, wird im Falle eines Unentschieden das erste Element verwendet.

Oktave , 33 Bytes

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

Die Eingabe ist ein Zellenarray von Zeichenfolgen.

Probieren Sie es online!

Erläuterung

cellfun(@nnz,x)nnzWendet die Funktion (Anzahl der Nichtzeros) auf jede Zeichenfolge im Eingabearray an x. nnzEntspricht für ASCII-Zeichenfolgen numel(Anzahl der Elemente), ist jedoch kürzer. Das Ergebnis ist ein numerisches Array mit den Zeichenfolgenlängen.

Dann [~,]=max(...)gibt den Index des ersten Maximums in der Anordnung der Saitenlängen. Das Ergebnis wird als Index xfür geschweifte Klammern verwendet , um die entsprechende Zeichenfolge zu erhalten.

JavaScript (Node.js) , 38 Byte

Probieren Sie es online!

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

J , 19, 11, 10 8 Bytes

0{>\:#@>

Probieren Sie es online!

Danke an streetster für den Hinweis!

-1 Byte dank FrownyFrog!

-2 Bytes dank Conor O'Brien

Wie es funktioniert:

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

Probieren Sie es online!

C #, 43 + 18 = 61 Bytes

Probieren Sie es online!

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

Perl 6 ,  14  13 Bytes

*.max(*.chars)

Versuch es

*.max(&chars)

Versuch es

PHP, 72 Bytes

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

Japt -h, 5 3 Bytes

ÔñÊ

Versuch es

Kehren Sie um, sortieren Sie nach Länge und geben Sie das letzte Element aus.

Schnell , 54 Bytes

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

Probieren Sie es online!

K (oK) , 9 Bytes

*x@>#:'x:

Probieren Sie es online!

Beispiel:

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

Erläuterung

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

Anmerkungen:

Nicht gelöscht, da dies als nicht trivial eingestuft wird, obwohl es im Grunde genommen 5 Schritte sind (wäre, wenn es als Funktion geschrieben würde {*x@>#:'x}).

Java (OpenJDK 8) , 67 Byte

Noch ein Beitrag in meiner Lieblingssprache! (gelesen: das einzige, das ich kenne).
Dies funktioniert nicht mit einem leeren Array, aber das ist in Ordnung.

Golf gespielt

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.

Probieren Sie es online!

Schläger , 160 Bytes 110 Bytes

Probieren Sie es online! Zum ersten Mal mitarbeiten, Ratschläge erwünscht!

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

Aktualisierte Lösung basierend auf Feedback

Bash , 45 Bytes

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

Probieren Sie es online!

Scratch 27 17 170 160

Es wird eine globale (genauer gesagt an alle Sprites angehängte) Liste von Strings erwartet, die aufgerufen werden mylist. Nach dem Klicken auf die grüne Flagge verbleibt das längste Wort in der Variablen w.

Ich denke das ist der 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

Zählen nach diesem Meta.

Röda , 30 Bytes

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

Probieren Sie es online!

Erläuterung:

{
 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]]}

Probieren Sie es online!

APL - 23 16 Bytes

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

Vielen Dank an alle für all Ihre tollen Vorschläge und Ermutigungen!

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

Verwendung:

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

Erläuterung:

Ruft die Länge jedes Zeichenvektors (Zeichenkette) ab und verwendet dann Maximum als Index. Ich habe gerade vor 20 Minuten mit APL angefangen. Es tut mir leid, wenn dies ein dummer Weg ist, es zu tun.

Probieren Sie es online!

(aus Gründen der Übersichtlichkeit bearbeitet)

Standard ML (MLton) , 55 Bytes

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

Probieren Sie es online! Anwendungsbeispiel: & ["abc","de","fgh"]Erträge "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

Probieren Sie es online!

Julia 0,6 , 24 Bytes

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

Probieren Sie es online!

Funky , 38 Bytes

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

Erklärt

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.

Probieren Sie es online!

Ruby , 21 bis 20 Bytes

->s{s.max_by &:size}

Probieren Sie es online!

Triviale Lösung, danke Snack für -1 Byte

SNOBOL4 (CSNOBOL4) , 63 57 Bytes

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

Probieren Sie es online!

Der Eingang ist auf stdin und der Ausgang auf stdout.

Grob übersetzt in den folgenden 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<<<"$*"`}<<<"$*"

Probieren Sie es online!