Introduzione:

Dopo aver pubblicato due sfide legate all'arcobaleno : Codegolf Rainbow: Fun with Integer-Arrays ¹ e Codegolf Rainbow: Draw in Black-and-White ² , il seguente commento è stato fatto da @ChrisM nell'ASCII ( Draw in Black-and-White ) sfida :

Forse lo sai ed è di progettazione (so che anche gli arcobaleni non sono rombi o ascii e le posizioni degli ordini superiori diventano più complicate), ma i colori non sono invertiti nel 2 ° arcobaleno?

E ha davvero ragione. Quando vedi un doppio arcobaleno, il secondo è in realtà un riflesso del primo, quindi i colori sono invertiti. Con tre arcobaleni, è un vero doppio arcobaleno, con il terzo riflesso di uno degli altri due. E con quattro, ci sono due arcobaleni e due riflessi di quelli.

Quindi, facciamo una terza sfida correlata usando quel fatto.

Sfida:

Input: un numero intero positivo nche è >=2e un elenco di numeri interi di dimensioni >= n+1.
Output: lo stesso elenco ordinato come segue:

1. Dividi innanzitutto gli elenchi di input in elenchi secondari di dimensioni n(in cui l'elenco secondario finale potrebbe essere di qualsiasi dimensione nell'intervallo [1,n]).
2. Quindi eseguiamo le seguenti operazioni in base alla quantità di elenchi secondari m:
   • Ordina il primo m - m//2numero di sotto-elenchi dal più basso al più alto (dove //è la divisione intera). (Vale a dire con 6 elenchi secondari, i primi tre verranno ordinati dal più basso al più alto; con 5 elenchi secondari il pugno tre verrà ordinato dal più basso al più alto.)
   • Ordina l'ultimo m//2numero di sotto-elenchi dal più alto al più basso (dove //è la divisione intera). (Vale a dire con 6 elenchi secondari, gli ultimi tre verranno ordinati dal più alto al più basso; con 5 elenchi secondari gli ultimi due verranno ordinati dal più alto al più basso.)
3. Unisci tutti gli elenchi secondari per formare nuovamente un unico elenco

Esempi:

Ingressi: n=7e [3,2,1,-4,5,6,17,2,0,3,5,4,66,-7,7,6,-5,2,10]
Passaggio 1: [[3,2,1,-4,5,6,17],[2,0,3,5,4,66,-7],[7,6,-5,2,10]]
Passaggio 2: [[-4,1,2,3,5,6,17],[-7,0,2,3,4,5,66],[10,7,6,2,-5]]
Passaggio 3 / Uscita:[-4,1,2,3,5,6,17,-7,0,2,3,4,5,66,10,7,6,2,-5]

Ingressi: n=4e [7,4,-8,9,3,19,0,-23,-13,13]
Passaggio 1: [[7,4,-8,9],[3,19,0,-23],[-13,13]]
Passaggio 2: [[-8,4,7,9],[-23,0,3,19],[13,-13]]
Passaggio 3 / Uscita:[-8,4,7,9,-23,0,3,19,13,-13]

Regole della sfida:

• L'ingresso intero nè garantito per essere maggiore di 1.
• La dimensione dell'elenco intero è garantita come maggiore di n.
• L'elenco secondario finale può essere più piccolo di n(come si può vedere negli esempi e nei casi di test).
• Il formato I / O è flessibile in qualsiasi formato ragionevole. Può essere un elenco / matrice di numeri interi o decimali, una stringa delimitata da virgola / spazio / newline, flusso di numeri interi, ecc. (L'output potrebbe non essere un elenco 2D di elenchi come il passaggio 2. Passaggio 3 per appiattirlo in un unico elenco è richiesto per questa sfida.)

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si consiglia vivamente di aggiungere una spiegazione per la risposta.

Casi test:

Inputs: n=7 and [3,2,1,-4,5,6,17,2,0,3,5,4,66,-7,7,6,-5,2,10]
Output: [-4,1,2,3,5,6,17,-7,0,2,3,4,5,66,10,7,6,2,-5]

Inputs: n=4 and [7,4,-8,9,3,19,0,-23,-13,13]
Output: [-8,4,7,9,-23,0,3,19,13,-13]

Inputs: n=2 and [7,-3,1]
Output: [-3,7,1]

Inputs: n=3 and [1,6,99,4,2]
Output: [1,6,99,4,2]

Inputs: n=2 and [5,2,9,3,-5,-5,11,-5,4,12,9,-2,0,4,1,10,11]
Output: [2,5,3,9,-5,-5,-5,11,4,12,9,-2,4,0,10,1,11]

Inputs: n=3 and [5,2,9,3,-5,-5,11,-5,4,12,9,-2,0,4,1,10,11]
Output: [2,5,9,-5,-5,3,-5,4,11,12,9,-2,4,1,0,11,10]

Brachylog , 18 17 16 byte

ġ₎↔ḍ↔{izo₎ᵐ↔}ᶠcc

Provalo online!

-1 byte grazie a @sundar

Si aspetta input come [<integer list>, n]. Si noti che gli interi negativi sono rappresentati con _il "meno meno" di Brachylog. La variabile di output è R.

Tentativo di Brachylog per la prima volta, quindi immagino sia subottimale e maturo per la riduzione dei byte.

Spiegazione

Partizione, biforcata, ordinamento in base all'indice (0: asc, 1: desc), appiattimento.

ġ₎               | split head of input into groups of length n (last of list)
  ↔              | reverse so that...
   ḍ             | dichotomize splits in two, attaching any additional element to the second list
    ↔            | reverse so first half of partitions corresponds to the 0 index
     {      }    | apply
      i          | : append index
       z         | : zip each sublist with the index of its parent
        o₎ᵐ      | : map over sublists, ordering by the zipped index
           ↔     | : undo earlier reverse
             ᶠ   | find all outputs
              cc | flatten two levels

Gelatina , 9 byte

sṢ€ŒHUÐeF

Provalo online!

Python 2 , 82 byte

lambda n,l:sum([sorted(l[i:i+n],reverse=i>len(l)/2)for i in range(0,len(l),n)],[])

Provalo online!

Japt , 10 byte

òV ®nÃÇwÃc

Also 10 bytes
òV mn ow c

Provalo online!

05AB1E (legacy) , 9 byte

ô€{2ä`í«˜

Provalo online!

Provalo online! in 05AB1E (riscrittura elisir) - si aspetta che l'input sia nello stack, un metodo I / O predefinito.

Kevin ha inventato il suo 11-byte che ero solito raggiungere a 10. Poi ho trovato qualcos'altro per 9 byte.

JavaScript (ES6), 82 81 byte

Salvato 1 byte grazie a @redundancy

Accetta input come (list)(n).

a=>n=>(g=z=>a+a?[...a.splice(0,n).sort((x,y)=>1/z?x-y:y-x),...g(a[i+=n])]:a)(i=0)

Provalo online!