definizioni

• Una sottosequenza potrebbe non essere contigua, ad esempio [1, 1, 1]una sottosequenza di [1, 2, 1, 2, 1].
• Una sottosequenza uguale è una sottosequenza in cui ogni elemento è uguale.
• La sottosequenza uguale più lunga potrebbe non essere unica, ad es. [1, 1]E [2, 2]sono entrambe le sottosequenze uguali più lunghe di [2, 1, 1, 2].

Ingresso

Un elenco non vuoto di numeri interi positivi in ​​uno dei formati seguenti:

• come l'implementazione nativa di una matrice di numeri interi positivi nella tua lingua
• come una stringa di numeri interi separati da nuova riga in decimale
• come una stringa di numeri interi separati da nuova riga in unario
• qualsiasi altro formato ragionevole

Produzione

Tutte le sottosequenze uguali più lunghe in qualsiasi ordine in uno dei formati seguenti:

• come un array nidificato 2D nella tua lingua (se l'input è un array)
• come un array appiattito con gli stessi elementi contigui
• qualsiasi altro formato ragionevole

punteggio

Anche se stiamo cercando qualcosa di lungo, il codice utilizzato dovrebbe essere il più breve possibile in termini di numero di byte, poiché questo è code-golf

Casi test

ingressi:

[1, 2, 3]
[1, 2, 2, 1]
[1, 2, 3, 2, 1]
[1, 2, 1, 2, 3, 4, 1]

Uscite:

[[1], [2], [3]]
[[1, 1], [2, 2]]
[[1, 1], [2, 2]]
[[1, 1, 1]]

Si noti che per le uscite sopra, qualsiasi ordine è valido.

È valido anche un array appiattito, purché gli elementi uguali siano contigui.

Gelatina , 5 byte

ĠLÐṀị

Provalo online!

Come funziona

ĠLÐṀị  Main link. Argument: A (array)

Ġ      Group; partition the indices of A by their corresponding values.
 LÐṀ   Select all index arrays with maximal length.
    ị  Unindex; retrieve the items of A at the specified indices.

Brachylog , 7 byte

⊇ᶠ=ˢlᵍh

Provalo online!

Spiegazione

⊇ᶠ=ˢlᵍh
⊇ᶠ        Find all subsequences
  =ˢ      Keeping only those for which all elements are equal
    lᵍ    Group by length
      h   Take the first group

⊇L 'ordine naturale genera prima le sottosequenze più lunghe, quindi quelle che finiscono nel primo gruppo.

Pyth, 5 byte

S.M/Q

Suite di test

Spiegazione:

Questo è implicitamente S.M/QZQ. .Mè la funzione massima, quindi .M/QZQseleziona tutti gli elementi in cui il valore di /QZ, conta il numero di occorrenze dell'elemento nell'input, è massimo. Squindi ordina l'elenco in modo che elementi identici siano contigui.

bash, 66 byte

sort|uniq -c|sort -rn|awk 'NR==1{a=$1}$1==a{for(i=a;i--;)print$2}'

Sembra che dovrebbe essere molto più breve, ma non riesco a capire come.

sort                  # sort the input
|uniq -c              # group runs of identical lines and prefix with count
|sort -rn             # sort by count, with largest at top
|awk '                # pipe to awk...
  NR==1{a=$1}         # on the first line, set the variable "a" to field 1
  $1==a{              # on any line, if first field is a (max count)...
    for(i=a;i--;)     # a times...
    print$2           # print the second field
  }
'

Provalo online!

Grazie a Leaky Nun per 3 byte!

Python 2 , 68 63 byte

lambda x:sorted(n for n in x if x.count(n)/max(map(x.count,x)))

Provalo online!

Mathematica, 42 31 25 byte

Grazie @GregMartin per 5 byte e @MartinEnder per un altro byte!

MaximalBy[Length]@*Gather

Spiegazione

MaximalBy[Length]@*Gather  (*                       {1, 2, 3, 2, 1}       *)
                   Gather  (* Gather same numbers:  {{1, 1}, {2, 2}, {3}} *)
                 @*        (* Function composition                        *)
MaximalBy[Length]          (* Find longest:         {{1, 1}, {2, 2}}      *)

Impilato , 55 52 43 byte

sorted rle toarr:[1#]map MAX@K[1#K=]YES rld

Provalo online!

Funziona in base alla lunghezza della corsa codificando l'input, ordinando per occorrenze, mantenendo le occorrenze per le quali il numero di occorrenze è massimo e decodificando la lunghezza della corsa. Output attraverso un elenco semplice, come è accettabile dalla sfida.

In realtà , 23 byte

;╗⌠;╜ck⌡M;♂NM╗⌠N╜=⌡░♂FS

Provalo online o esegui tutti i casi di test !

Grazie a Leaky Nun per aver sottolineato un miglioramento di un byte che avrebbe dovuto essere ovvio per me

-3 byte dal formato di output semplificato

Spiegazione:

;╗⌠;╜ck⌡M;♂NM╗⌠N╜=⌡░♂FS
;╗                        save a copy of the input to register 0
  ⌠;╜ck⌡M                 for each value in the input list:
   ;                        make a copy on the stack
    ╜c                      count the occurrences in the input list (from register 0)
      k                     make a list: [value, count]
         ;♂N             make a copy, take last value of each list in the 2D list
            M╗           store the maximum count in register 0
              ⌠N╜=⌡░     filter the other copy of the list of [value, count] lists:
               N╜=         take items where the count equals the maximum count
                    ♂FS  take first items (values) and sort them

Python 2, 138 byte

lambda l:[[x[0]]*x[1] for x in next(__import__('itertools').groupby(__import__('collections').Counter(l).most_common(),lambda x:x[1]))[1]]

MATL , 10 byte

3#XMg1bX"&

Provalo online!

Spiegazione

Simile alla mia risposta Octave. Considera l'input [10, 20, 30, 20, 10]come esempio.

3#XM   % Three-output version of mode function. Gives the first mode, the
       % number of repetitions, and a cell array with all modes
       % STACK: 10, 2, {10; 20}
g      % Convert from cell array to matrix
       % STACK: 10, 2, [10; 20]
1      % Push 1
       % STACK: 10, 2, [10; 20], 1
b      % Bubble up in the stack
       % STACK: 10, [10; 20], 1, 2
X"     % Repeat those number of times vertically and horizontally
       % STACK: 10, [10, 10; 20, 20]
&      % Specify that implicit display will show only the top of the stack.
       % Since this is singleton cell array that contains a matrix, that 
       % matrix is directly displayed

Ottava , 47 byte

[~,b,c]=mode(input(0));disp([repmat(c,1,b){:}])

Provalo online!

Spiegazione

La seconda e la terza uscita di mode(ottenuto come [~,b,c]=mode(...)) danno rispettivamente il numero di ripetizioni ( b) e una matrice di celle di colonna ( c) degli elementi più ripetuti nell'input ( input(0)). L'array di celle cviene quindi ripetuto orizzontalmente bvolte ( repmat(c,1,b)), convertito in un elenco separato da virgole ( {:}) e contatenato orizzontalmente ( [...]) per dare una matrice numerica, che viene visualizzata ( disp(...)).

05AB1E , 8 5 byte

Emette un elenco piatto in ordine

.M¹Ã{

Utilizza la codifica 05AB1E . Provalo online!

CJam , 22 byte

{$e`z~\__:e>f=.*\]ze~}

Questo è un blocco (funzione) anonimo che accetta l'input dalla parte superiore dello stack e lo sostituisce con l'output. L'output è un array appiattito con elementi contigui.

Provalo online!

Spiegazione

Considera l'input [10 20 30 20 10 ]come esempio.

{      e# Begin block
       e#   STACK: [10 20 30 20 10]
  $    e#   Sort
       e#   STACK: [10 10 20 20 30]
  e`   e#   Run-length encoding
       e#   STACK: [[2 10] [2 20] [1 30]]
  z    e#   Zip
       e#   STACK: [[2 2 1] [10 20 30]]
  ~    e#   Dump array contents onto the stack
       e#   STACK: [2 2 1] [10 20 30]
  \    e#   Swap
       e#   STACK: [10 20 30] [2 2 1]
  __   e#   Duplicate twice
       e#   STACK: [10 20 30] [2 2 1] [2 2 1] [2 2 1]
  :e>  e#   Fold maximum over array. Gives the maximum of the array
       e#   STACK: [10 20 30] [2 2 1] [2 2 1] 2
  f=   e#   Map "is equal" with number (2) over the array ([2 2 1])
       e#   STACK: [10 20 30] [2 2 1] [1 1 0]
  .*   e#   Vectorized multiplication
       e#   STACK: [10 20 30] [2 2 0]
  \    e#   Swap
       e#   STACK: [2 2 0] [10 20 30]
  ]    e#   Pack into array
       e#   STACK: [[2 2 0] [10 20 30]]
  z    e#   Zip
       e#   STACK: [[2 10] [2 20] [0 30]]
  e~   e#   Run-length decoding
       e#   STACK: [10 10 20 20]
}      e# End block

Perl 5, 58 byte

sub{sort grep$x{$_}>$m,grep{$/=$x{$_}++;$m=$/if$m<$/;1}@_}

APL (Dyalog) , 22 byte

Richiede il ⎕ML←3valore predefinito su molti sistemi.

Programma: s/⍨(⌈/=⊢)≢¨s←⊂⍨(⍋⊃¨⊂)⎕

⎕ ottenere input numerici (valutati)

(... ) tacita funzione
 ⍋ gli indici degli elementi ascendenti
 ⊃¨ ogni prelievo
 ⊂ dall'intero array

⊂⍨ partizione tagliando ai suoi aumenti

s← conservare come s

≢¨ conta ciascuno

(... la ) funzione tacita
 ⌈/ il massimo (conteggio) è
 = uguale
 ⊢ all'argomento (i conteggi )

s/⍨ filtro s con quella

Funzione: {s/⍨(⌈/=⊢)≢¨s←⊂⍨⍵[⍋⍵]}

{... } funzione anonima in cui si trova l'argomento⍵

⍵[⍋⍵] ordina (lit. indice con indici di articoli ascendenti)

⊂⍨ partizione tagliando ai suoi aumenti

s← conservare come s

≢¨ conta ciascuno

(... la ) funzione tacita
 ⌈/ il massimo (conteggio) è
 = uguale
 ⊢ all'argomento (i conteggi )

s/⍨ Filtro s con quella Provalo in rete!

PHP, 69 byte

<?print_r(preg_grep("#".max($r=array_count_values($_GET))."#",$r));

Versione online

Formato di output

chiave = valore, valore = conteggio

Array
(
    [1] => 2
    [2] => 2
)

PHP, 96 byte

<?foreach($_GET as$v)$r[$m[]=count($l=preg_grep("#^{$v}$#",$_GET))][$v]=$l;print_r($r[max($m)]);

Versione online

Formato di output

Chiave 1D = valore

Chiave 2D = posizione nella matrice di input per ciascun valore

Array
(
    [1] => Array
        (
            [0] => 1
            [4] => 1
        )

    [2] => Array
        (
            [1] => 2
            [3] => 2
        )

)

PHP, 97 byte

<?foreach($_GET as$v)$r[count($l=preg_grep("#^{$v}$#",$_GET))][$v]=$l;ksort($r);print_r(end($r));

JavaScript (ES6), 84 83 byte

Restituisce un array appiattito ordinato.

a=>a.sort().filter((_,i)=>b[i]==Math.min(...b),b=a.map(i=>a.filter(j=>i-j).length))

Casi test

let f =

a=>a.sort().filter((_,i)=>b[i]==Math.min(...b),b=a.map(i=>a.filter(j=>i-j).length))

console.log(JSON.stringify(f([1, 2, 3])))
console.log(JSON.stringify(f([1, 2, 2, 1])))
console.log(JSON.stringify(f([1, 2, 3, 2, 1])))
console.log(JSON.stringify(f([1, 2, 1, 2, 3, 4, 1])))

CJam, 24 byte

{$e`_$W=0=\{0=1$=},e~\;}

Volevo farlo in 05ab1e, ma ho rinunciato: P

Questo è un blocco Input e output sono array nello stack.

Provalo online!

Spiegazione:

{                      e# Stack:                | [1 2 3 2 1]
 $                     e# Sort:                 | [1 1 2 2 3]
  e`                   e# RLE encode:           | [[2 1] [2 2] [1 3]]
    _$W=               e# Copy elements:        | [[2 1] [2 2] [1 3]] [2 1]
       0=              e# First element:        | [[2 1] [2 2] [1 3]] 2
         \             e# Swap:                 | 2 [[2 1] [2 2] [1 3]]
          {0=1$=},     e# Filter where x[0]==2: | 2 [[2 1] [2 2]]
                  e~   e# RLE decode:           | 2 [1 1 2 2]
                    \; e# Delete back:          | [1 1 2 2]
                      }

Clojure, 65 byte

#(let[P partition-by C count](last(P C(sort-by C(P +(sort %))))))

Ungolfed:

(def f #(->> %
             (sort-by      identity)   ; sort so that identical values are one after another, same as sort
             (partition-by identity)   ; partition by identity (duh!)
             (sort-by      count)      ; sort by item count
             (partition-by count)      ; partition by item count
             last))                    ; get the last partition

C #, 145 byte

l=>{var t=Enumerable.Range(0,l.Max()+1).Select(i=>l.Count(a=>a==i));return t.Select((a,i)=>Enumerable.Repeat(i,a)).Where(d=>d.Count()==t.Max());}

Anche questo deve essere possibile, ma sono un po 'bloccato.

Spiegazione

l =>                                                   //Takes the list
{                                                      //...
    var t = Enumerable.Range(0, l.Max() + 1)           //Makes a range till the count, so that the items together with their indices are double defined (i.e. the items are 0,1,2,3... and the indices are the same)
                      .Select(i =>                     //Takes the items
                          l.Count(a => a == i));       //And replaces them with the count of themselves in the list (so the item has the index with its old value and the count as it's actual value)
    return t.Select((a, i) =>                          //Then it takes this list and selects the items together with the indices
        Enumerable.Repeat(i, a))                       //Repeats them as often as they appeared in the list
                  .Where(d => d.Count() == t.Max());   //And just keeps those which appear the maximum amount of times
};                                                     //...

Probabilmente un approccio completamente diverso sarebbe molto più breve, quindi la sfida C # è ancora aperta :)

Rubino , 57 byte

->a{a.reject{|i|a.map{|j|a.count j}.max>a.count(i)}.sort}

Provalo online!