L'obiettivo

Il compito è molto semplice. Dato un array che contiene solo numeri interi e stringhe , genera il numero più grande e il numero più piccolo.

Casi test

Input: [1, 2, 3, 4, 5, 6, 7, 8]
Output: 1, 8

Input: [5, 4, 2, 9, 1, 10, 5]
Output: 1, 10

Input: [7, 8, 10, "Hello", 5, 5]
Output: 5, 10

I numeri nelle stringhe non sono considerati numeri interi:

Input: [1, 2, 3, 4, "5"]
Output: 1, 4

Se esiste un solo numero intero, è il numero intero più grande e più piccolo:

Input: [1]
Output: 1, 1

Input: ["1", "2", "3", "4", 5]
Output: 5, 5

Regole

• Si può presumere che un array contenga sempre almeno un numero intero.
• Tutti i numeri interi sono positivi (maggiore di 0)
• L'ordine dell'output non ha importanza.
• Questo è code-golf , quindi vince l'invio con il minor numero di byte!
• Le stringhe possono contenere tutti i caratteri ASCII stampabili ( 32 - 126) e non sono vuote.

Scherzi a parte, 9 6 byte

,ì;M@m

Provalo online

Come funziona

,                              Read list input
 ì                             Remove everything but numbers from it
  ;                            Make a copy
   m                           Extract its min value
    @M                         Extract the other one's max value
                               Implicit output (max then min)

JavaScript (ES6), 54 56

Modifica 2 byte salvati grazie a @Neil

Nota: x===+xè vero se e solo se xè un numero

a=>[Math.max(...a=a.filter(x=>x===+x)),Math.min(...a)]

Pyth, 14 11 10 byte

hM_BS^I#1Q

Provalo online. Suite di test.

Spiegazione

• Q: input valutato
• #: filtralo su:
  • I: il valore è lo stesso dopo:
    • ^…1 elevandolo al potere 1
• S: ordina quello
• _B: crea array [previous, reversed(previous)]
• hM: prendi il primo oggetto di ciascun oggetto

La parte più difficile è golf la rimozione delle stringhe, che attualmente richiede 4 byte. L'approccio attuale funziona a causa ^<str>1del primo potere cartesiano della sequenza (fondamentalmente, l'elenco dei caratteri della stringa), ma ^<int>1è solo la funzione identità.

Python 2, 42 byte

In Python 2, i numeri interi sono sempre meno delle stringhe durante i confronti, quindi un semplice min(s)troverà il numero intero più piccolo. Nel trovare il massimo, però, dobbiamo prima filtrare le stringhe. La funzione anonima accetta una sequenza e restituisce una tupla con il minimo e il massimo.

lambda s:(min(s),max(x for x in s if''>x))

Esempio:

[1,'77', 6, '', 4] -> (1, 6)

Gelatina, 8 byte

|f¹Ṣ0,1ị

Provalo online!

sfondo

In un mondo perfetto, basterebbe intersecare l'elenco con una versione appiattita di se stesso. Le stringhe sono semplicemente elenchi di caratteri in Jelly, quindi mentre l'elenco originale conterrebbe numeri interi e stringhe, la versione appiattita conterrebbe numeri interi e caratteri, lasciando solo gli interi nell'intersezione.

Nel mondo reale, entrambi i parser di entrambi i letterali di input e string generano caratteri anziché stringhe di lunghezza 1. L'unico modo per passare una stringa singleton a una funzione sarebbe codificarla "manualmente" come, ad esempio [”a], che è un personaggio avvolto in un array.

Ciò consentirebbe di risparmiare un byte, per un totale di 7 byte ( Provalo online! ).

fFṢ0,1ị

Dato che probabilmente non è accettabile, abbiamo anche bisogno di un modo per differenziare i caratteri dagli interi.

Gli atomi bitarici di Jelly cercano disperatamente di convertire i loro argomenti in numeri interi. Iniziano vettorializzando fino a quando incontrano tipi di profondità 0 (numeri o caratteri), quindi tentano di convertirli in numeri interi. Per un personaggio che rappresenta un numero intero, ciò avrà esito positivo. Per altri, un atomo diadico bit a bit si arrenderà e restituirà 0 .

Ad esempio, l'OR bit a bit dell'elenco [1, "2", "34", "-5", "a", "bc"]con se stesso produrrà

[1, 2, [3, 4], [0, 5], 0, [0, 0]]

Incrociando il risultato con l'elenco originale, ci sbarazziamo degli array e degli interi che non erano presenti nell'elenco originale.

Come funziona

|f¹Ṣ0,1ị  Main link. Input: A (list)

|         Bitwise OR the list A with itself.
 f¹       Filter the result by presence in A.
   Ṣ      Sort the resulting list of integers.
    0,1ị  Retrieve the elements at those indexes.
          Indices are 1-based and modular in Jelly, so 0 is the last (maximum),
          and 1 is the first (minimum).

Mathematica, 20 byte

MinMax@*Select[#>0&]

Casi test

MinMax@*Select[#>0&]@{1,2,3,4,"5"}
(* {1,4} *)

Rubino, 57 36 29 byte

Principiante qui, quindi non so se esiste un posto / modo standard o universalmente accettato per calcolare i byte utilizzati, qualsiasi aiuto sarebbe molto apprezzato!

A cura di manatwork e commento di Doorknob!

->n{(n.map(&:to_i)&n).minmax}

Test

2.3.0 :076 > f=->n{[(n.map(&:to_i) & n).min, (n.map(&:to_i) & n).max]}
 => #<Proc:0x007ff7650ee868@(irb):76 (lambda)>
2.3.0 :077 > f[[7, 8, 10, "Hello", 5, 5]]
 => [5, 10]

CJam, 15 13 byte

{_:z&$2*_,(%}

Un blocco senza nome (funzione) che prevede l'array di input nello stack e lascia l'array di output al suo posto.

Esegui tutti i casi di test.

Spiegazione

_     e# Duplicate.
:z    e# Map over list: a) take abs() of integer elements (a no-op) or b) wrap strings
      e# in an array.
&     e# Set intersection: only the integers will appear in both arrays.
$     e# Sort.
2*    e# Repeat array twice (to make the code work with single-integer input).
_,    e# Duplicate, get length N.
(%    e# Decrement, get every (N-1)th element, i.e. the first and the last.

Haskell, 41 39 byte

f x=[minimum,maximum]<*>[[i|Left i<-x]]

In Haskell tutti gli elementi di un elenco devono essere dello stesso tipo, quindi non posso mescolare Integere String. Tuttavia, esiste il Eithertipo per combinare due tipi in uno solo. L'elenco di input è quindi di tipo Either Integer String¹ . ffiltra gli Integer, rimuove il Eitherwrapper, inserisce l'elenco come singolo elemento in un nuovo elenco (ad es. [[1,2,3]]), in modo che <*>possa applicare ad esso le funzioni fornite nel primo argomento.

Esempio di utilizzo: f [Left 1, Left 3, Right "Hello", Left 2]-> [1,3].

Modifica: @xnor è stato messo <*>in gioco e salvato 2 byte. Grazie!

^{1 in} realtà è completamente polimorfico nel secondo tipo in quanto la Stringproprietà non viene mai utilizzata.

jq, 21 caratteri

[.[]|numbers]|min,max

Esecuzione di esempio:

bash-4.3$ bin/jq '[.[]|numbers]|min,max' <<< '[7, 8, 10, "Hello", 5, 5]'
5
10

Test online:

• [7, 8, 10, "Ciao", 5, 5]
• ["1", "2", "3", "4", 5]

Mathematica, 28 byte

MinMax[#/._String->Nothing]&

PHP, 50 48 byte

<?=min($a=array_filter($a,is_int)).', '.max($a);

Retina , 71

Grazie (come sempre) a @ MartinBüttner per l'aiuto del golf.

Non competitivo dal punto di vista del golf, ma è interessante implementare lo smistamento di bolle intere in Retina.

Presuppone che tutte le stringhe nell'input "abbiano virgolette doppie e non contengano virgolette doppie con escape\" .

A`"
¶

\d+
$&$*a $&$*a
+`\b(a+) +\1(a+)\b
$1$2 $1
 +[a ]+ +

(a)+
$#1

L'input è separato da una nuova riga.

Provalo online.

Mathematica , 14

#&@@@MinMax@#&

Esempio:

tests = {
   {1, 2, 3, 4, 5, 6, 7, 8},
   {5, 4, 2, 9, 1, 10, 5},
   {7, 8, 10, "Hello", 5, 5},
   {1, 2, 3, 4, "5"},
   {1},
   {"1", "2", "3", "4", 5}
 };

# & @@@ MinMax@# & /@ tests

{{1, 8}, {1, 10}, {5, 10}, {1, 4}, {1, 1}, {5, 5}}

Spiegazione:

Quando MinMaxottiene un input non numerico, riduce il problema il più possibile, quindi lascia i termini racchiusi Mine Max:

MinMax @ {7, 8, 10, "Hello", 5, 5}

{Min[5, "Hello"], Max[10, "Hello"]}

A causa dell'ordine automatico che ha luogo le stringhe seguono numeri interi.

Applyat levelspec {1}, la scorciatoia @@@, viene quindi utilizzata per estrarre il primo argomento di elementi non atomici. Si noti che 5non è toccato qui:

foo @@@ {5, Max[10, "Hello"]}

{5, foo[10, "Hello"]}

Oracle SQL 11.2, 189 byte

SELECT MIN(TO_NUMBER(i)),MAX(TO_NUMBER(i))FROM(SELECT REGEXP_SUBSTR(:1,'[^,]+',1,LEVEL)i FROM DUAL CONNECT BY LEVEL<REGEXP_COUNT(:1,',')+2)WHERE TRIM(TRANSLATE(i,' 0123456789',' '))IS NULL;

Un-golfed

SELECT MIN(TO_NUMBER(i)),MAX(TO_NUMBER(i)) 
FROM  (
        SELECT REGEXP_SUBSTR(:1,'[^,]+',1,LEVEL)i 
        FROM   DUAL 
        CONNECT BY LEVEL<REGEXP_COUNT(:1,',')+2
      )
WHERE TRIM(TRANSLATE(i,' 0123456789',' '))IS NULL;

La query secondaria analizza l'array e lo divide per popolare una vista con un elemento per riga. Quindi gli elementi non numerici vengono filtrati.

Vorrei poter trovare un modo per farlo con LEAST e GREATEST, ma non ho avuto fortuna con come gestire l'array come parametro.

vimscript, 25 byte

g/"/d
sort n
t.
t.
2,$-1d

Sì, esatto, vimscript.

Prevede input nel modulo

1
2
3
4
"5"

E output nella forma

1
4

Spiegazione:

g/"/d    delete all lines that contain quotes
sort n   sort numerically
t.       duplicate the first line
t.       duplicate it again
2,$-1d   delete from line 2 to line (END-1)

La prima riga deve essere duplicata due volte per gestire il caso limite di un input di un singolo numero. Questo perché l'ultimo comando si lamenterà se ci sono solo due righe quando viene raggiunto, poiché finisce per essere 2,1dun intervallo all'indietro.

Perl 44 39 + 3 = 41 byte

@a=sort{$a-$b}grep!/"/,@F;$_="@a[0,-1]"

Richiede -pabandiere:

$ perl -pae'@a=sort{$a-$b}grep!/"/,@F;$_="@a[0,-1]"' <<< '1 2 3 5 4'
1 5
$ perl -pae'@a=sort{$a-$b}grep!/"/,@F;$_="@a[0,-1]"' <<< '1 2 3 4 "5"'
1 4

Grazie a @manatwork per la rasatura di pochi byte

Julia, 35 byte

x->extrema(filter(i->isa(i,Int),x))

Questa è una funzione lambda che accetta un array e restituisce una tupla di numeri interi. Per chiamarlo, assegnarlo a una variabile.

Julia ha una funzione integrata extremaper ottenere gli elementi minimo e massimo di un array come tupla. Tuttavia, poiché l'array può contenere anche stringhe, dobbiamo prima filtrarle. Possiamo farlo testando se ogni elemento è un numero intero usando isa.

Japt, 23 byte

[V=Uf_bZÃn@X-Y})g Vw g]

Provalo online!

Come funziona

[V=Uf_  bZÃ n@  X-Y})g Vw g]
[V=UfZ{ZbZ} nXY{X-Y})g Vw g]

UfZ{ZbZ}   // Filter out the items Z in U where Z.b(Z) is falsy.
           // For numbers, this the original number, which is always non-0 (non-falsy).
           // For strings, this returns Z.indexOf(Z), which is always 0 (falsy).
nXY{X-Y}   // Sort by subtraction. Small items move to the front, large to the back.
V=         // Set variable V to the resulting array.
)g Vw g    // Take the first item in V, and the first in V.reverse().
[       ]  // Wrap them in an array so both are sent to output.

Bash, 40 31 30 byte

sort -n|sed /\"/d|sed '1p;$p;d'

Richiede un elenco separato da righe:

$ echo $'5\n4\n2\n9\n1\n"10"\n5' | sort -n|sed /\"/d|sed '1p;$p;d'
1
9

Grazie a @manatwork per radere qualche byte

PowerShell, 53 36 byte

@($args[0]|?{$_-is[int]}|sort)[0,-1]

_{Risparmiato 17 byte grazie a @goric}

ooof ... PowerShell di solito gioca abbastanza velocemente e sciolto con il lancio, che è normalmente una buona cosa per il golf, ma fa male qui.

Prende il nostro input $args[0]e lo inserisce in Where-Objectun'istruzione (the ?) che selezionerà solo numeri interi e li passerà lungo la pipeline, scartando qualsiasi altra cosa. Poiché il re-casting dinamico avviene al volo in background per te (ad esempio, il 1+"5"ritorno 6è PowerShell perfettamente valido), è necessario utilizzare l' -isoperatore per differenziare i tipi di dati.

Da lì, convogliamo quella raccolta in Sort-Object, che ordinerà gli interi dal più piccolo al più grande. L'esterno ()è necessario in modo che possiamo fare riferimento al primo e all'ultimo elemento con [0,-1](cioè il più piccolo e il più grande), ma nota che abbiamo anche bisogno dell'esterno @per forzare il cast dell'output sortcome array se c'è un solo oggetto (come risultato di è ?stato inserito solo un oggetto).

MATL , 23 byte

"@Y:tX%1)2\?x]N$htX<wX>

Provalo online!

"       % implicitly input cell array. For loop that iterates on each cell
  @     %   push each cell
  Y:    %   cell's contents (either a number or a string)
  tX%   %   duplicate and push class. This will produce 'char'  or 'double'
  1)    %   get first letter: either 'c' or 'd'
  2\    %   is its ASCII code odd?
  ?     %   if so...
    x   %     delete (it's a string)
  ]     %   end if
  N$h   %   concatenate all stack into an array. This array will contain up to
        %   three numbers: minimum up to now, maximum up to now, new value (if any)
  tX<   %   duplicate. Push minimum
  wX>   %   swap. Push maximum.
        % implicitly end for
        % implicitly display stack contents

JavaScript (ES5), 105 byte

function a(b){m=Math;b=b.filter(function(c){return c===+c});alert(m.min.apply(m,b)+','+m.max.apply(m,b))}

Uso: a([1,2,3,'4'])

Sto solo provando :)

"Ungolfed":

function a(b){
  m=Math;
  b=b.filter(function(c){
    return c===+c
  });
  alert(m.min.apply(m,b) + ',' + m.max.apply(m,b))
}

Pyth, 11 byte

hJSf!>TkQeJ

Spiegazione:

   f    Q   - filter([V for T in >], Q)
    !>Tk    - not(T>"")
  S         - sorted(^)
hJ       eJ - print first and last element

Provalo qui!

Perl 6 , 25 byte

La risposta ovvia sarebbe questa Lambda di qualunque codice

*.grep(Int).minmax.bounds

Se deve essere un programma completo

put get.words».&val.grep(Int).minmax.bounds

L'input per questo programma completo è un elenco di valori separati da spazi

uso

# give it a lexical name
my &code = *.grep(Int).minmax.bounds;

say code [1, 2, 3, 4, 5, 6, 7, 8];  # (1 8)
say code [5, 4, 2, 9, 1, 10, 5];    # (1 10)
say code [7, 8, 10, "Hello", 5, 5]; # (5 10)
say code [1, 2, 3, 4, "5"];         # (1 4)
say code [1];                       # (1 1)
say code ["1", "2", "3", "4", 5];   # (5 5)

say code []; # (Inf -Inf)

𝔼𝕊𝕄𝕚𝕟, 16 caratteri / 20 byte

[МƲ(ï⇔⒡≔=+$⸩,МƵï

Try it here (Firefox only).

Non male non male...

Spiegazione

Ciò genera un array contenente sia il massimo che il minimo. (ï⇔⒡≔=+$⸩,fondamentalmente filtra tutte le stringhe nell'input, МƲottiene il massimo nell'input eМƵ ottiene il minimo.

Solo una nota: questa è la prima sfida in cui posso usare ⇔, che sostanzialmente si trasforma ï⇔in ï=ï.

Python 3, 56 byte

lambda x:[m(t for t in x if str(t)!=t)for m in(min,max)]

Provalo online su Ideone .

APL (Dyalog) , 13 byte

(⌊/,⌈/)⎕AV~⍨∊

Provalo online!

∊ enlist (flatten - questo trasforma tutte le stringhe in caratteri nella grande lista)

⎕AV~⍨ rimuovi tutti i personaggi in A tomic V (il set di caratteri - lascia i numeri)

(... ) applica la seguente funzione tacita:

 ⌊/ il minimo attraverso

 , aggiunto a

 ⌈/ il massimo attraverso

Java (OpenJDK 8) , 124 byte

a->{int s[]={0,0},t;for(Object i:a)try{t=(int)i;s[0]=s[0]<1|t<s[0]?t:s[0];s[1]=s[1]<t?t:s[1];}catch(Exception e){}return s;}

Provalo online!

Funzione lambda Java 8, accetta array come input e distribuisce array {min, max} . Non in competizione, perché l'input deve essere un array intero.

Risolto e -1 byte grazie a Kevin Cruijssen

Jolf, 20 byte

Probabilmente posso giocare a golf ... Devo implementare soluzioni più brevi di verifica del tipo.

γ fxd='nF~tH0ͺZkγZKγ
 _fx                 filter the input
    d='nF~tH0        checking for number type
γ                    call that "γ"
             ͺ       pair
              ZkγZKγ  the min and max of the array