<< Precedente Successivo >>

Grazie alla comunità PPCG, Babbo Natale è riuscito a rigenerare tutti i suoi regali e dopo la catena di montaggio, i regali sono ora pronti per essere spostati nei moli di trasporto!

Ciascuna delle banchine di trasporto di Babbo Natale contiene solo una gamma di dimensioni attuali perché le slitte di trasporto sono specializzate per una dimensione specifica (qualsiasi più leggera e sarebbe dispendiosa, qualsiasi più pesante e la slitta non sarebbe in grado di gestire il carico). Pertanto, ha bisogno che tu lo aiuti a prendere i suoi regali e ordinarli nei moli di trasporto corretti.

Sfida

Dato un elenco e gli intervalli delle banchine di trasporto, organizzare stabilmente i regali nell'ordine corretto.

Prendiamo ad esempio questo: i regali sono [5, 3, 8, 6, 2, 7]e le gamme di dock sono [[1, 5] and [6, 10]].

I regali 5, 3e 2vanno nella prima dock e i regali 8, 6e 7vanno nella seconda dock. Questo può essere mostrato come [[5, 3, 2], [8, 6, 7]]. Questo elenco sarà più vicino all'ordinamento dell'input, ma stablysignifica che all'interno di ciascun dock, l'ordine dei presenti deve essere uguale all'ordine dell'input (altrimenti potresti semplicemente ordinare l'intero elenco).

Il tuo output finale per questo caso sarebbe [5, 3, 2, 8, 6, 7](come una lista piatta).

Specifiche di formattazione

Vi sarà dato ingresso come una semplice lista di numeri interi e un elenco di intervalli in qualsiasi formato ragionevole (per esempio, l'intervallo per il caso di cui sopra potrebbe essere dato come [[1, 5], [6, 10]], [1, 5, 6, 10]o [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]). L'output dovrebbe essere un elenco semplice di numeri interi in qualsiasi formato ragionevole.

L'input può contenere valori duplicati; in questo caso, è necessario restituire tutte le loro istanze. Tutte le dimensioni attuali saranno esattamente in un intervallo di dimensioni e si può presumere che gli intervalli non si sovrapporranno mai. Possono esserci spazi vuoti nelle gamme purché siano coperte tutte le dimensioni attuali.

Regole

• Si applicano scappatoie standard
• Questo è code-golf , quindi vince la risposta più breve in byte
• Nessuna risposta sarà accettata
• Puoi presumere che non ci saranno intervalli vuoti ( [7, 4]sarebbe non valido perché gli intervalli salgono)

Casi test

[1, 2, 3, 4, 5, 6, 7] ; [[1, 3], [4, 7]] => [1, 2, 3, 4, 5, 6, 7]
[1, 2, 3, 4, 5, 6, 7] ; [[4, 7], [1, 3]] => [4, 5, 6, 7, 1, 2, 3]
[7, 3, 5, 4, 6, 1, 2] ; [[1, 3], [4, 5], [6, 7]] => [3, 1, 2, 5, 4, 7, 6]
[4, 7, 6, 3, 5, 2, 1] ; [[1, 4], [5, 7]] => [4, 3, 2, 1, 7, 6, 5]
[1, 1, 3, 3, 6, 4, 7] ; [[1, 4], [6, 7]] => [1, 1, 3, 3, 4, 6, 7]

^{Nota: ho tratto ispirazione per questa serie di sfide da Advent Of Code . Non ho affiliazione con questo sito}

Puoi vedere un elenco di tutte le sfide della serie guardando la sezione "Linked" della prima sfida qui .

Haskell , 26 byte

a#s=[x|r<-s,x<-a,elem x r]

Provalo online! Esempio di utilizzo: [1,2,3,4,5,6,7] # [[1,2,3],[4,5,6,7]]rese [1,2,3,4,5,6,7].

Gelatina , 4 byte

fЀẎ

Provalo online!

Accetta input come elenco attuale, intervalli completi.

Mathematica, 39 byte

x##&@@Cases[x,#|##&@@Range@##]&@@@#&

-22 byte da JungHwan Min
-4 byte da Martin

Provalo online!

Pyth , 5 byte

s@Rvz

Provalo qui!

Pyth , 10 byte

s.gx}LkQ1E

Provalo qui!

Come funzionano

s @ Rvz | Programma completo.

  R | Mappa a destra ...
 @ | ... Utilizzando l'intersezione.
   vz | Del primo input con il secondo.
s | Appiattire di un livello.

s.gx} LkQ1E | Programma completo.

 .g E | Raggruppa gli elementi nel secondo input per ...
    } LkQ | Mappa sopra il primo input e controlla se l'elemento corrente è nell'elenco.
   x 1 | Prendi l'indice del primo elemento di verità.
s | Appiattire.

Prende prima i dock, con tutti gli interi negli intervalli, quindi i regali su una nuova riga.

Python 2 , 49 46 byte

grazie a @HyperNeutrino per -3 byte

lambda p,b:[x for l in b for x in p if x in l]

Provalo online!

Ungolfed

def f(presents, groups):
  result = []
  for group in groups:
    for present in presents:
      if present in group:
        result.append(present)
  return result

Provalo online!

05AB1E , 3 byte

δØ

Provalo online! (grazie ad Adnan per avermi fatto sapere che δesiste, -1 byte)

Come funziona

δØ | Programma completo.

δ | Doppio vettorializzare il comando successivo (qualcosa come un prodotto esterno).
 Ã | Elenca intersezione. Poiché questa è una diade, il primo input è automaticamente
     | usato per riempire l'argomento mancante (per quanto ne so).
  ˜ | Appiattire.

Retina , 37 36 byte

O$`(\d+)(?=.*¶(.*)\[.*\b\1\b)
$2
G1`

Provalo online! Accetta input come un elenco di regali sulla prima riga e un elenco di intervalli sulla seconda riga; il collegamento include un'intestazione per dividere i casi di test nel formato desiderato. Modifica: salvato 1 byte grazie a @MartinEnder. Spiegazione: Il primo stadio corrisponde ai regali e trova il dock corrispondente. I regali sono ordinati in base alla sottostringa dall'inizio della linea a [, raggruppando così i regali per dock. Il secondo stadio quindi elimina i dock.

Enlist , 3 byte

f₱Ẏ

Provalo online!

Come funziona

f ₹ Ẏ | Programma completo.

 ₱ | Mappa su argomento corretto.
f | Utilizzo dell'intersezione dell'elenco, conteggio delle molteplicità.
  Ẏ | Stringere (appiattire di 1 livello).

APL + WIN, 29 byte

(,⍉<\p←n∘.≤∊¯1↑¨⎕)/(×/⍴p)⍴n←⎕

Richiede l'immissione dello schermo sia per gli interi che per gli intervalli. I numeri interi come elenco piatto e gli intervalli come vettore nidificato, ad esempio il caso 3:

(1 3) (4 5) (6 7)

Spiegazione:

(×/⍴p)⍴n←⎕ prompt for screen input of integers and replicate by the number of ranges 

∊¯1↑¨⎕ prompt for screen input of ranges and select the top of each

p←n∘.≤ create a boolean matrix using outer product with less than the top of each range

,⍉<\ identify the first range which each element fits in and ravel into a partition vector

(.....)/.... use the partition vector to select the elements in each range in order

C ++, 127 byte

Prendi l'input come due matrici rappresentate da coppie di puntatori [start, end).

#import<algorithm>
[](int*A,int*x,int*B,int*y){for(;B!=y;B+=2)A=std::stable_partition(A,x,[&](int a){return a>=*B&&a<=B[1];});}

Provalo online!

J, 15 byte

[/:[:I.e.&>"0 1

Prende l'input come argomento sinistro e gli intervalli come argomento destro . Gli intervalli sono elenchi in box degli intervalli completi.

ad es. per la prima gamma:

   NB. This produces the range
   (1 2 3 ; 4 5 6 7)
┌─────┬───────┐
│1 2 3│4 5 6 7│
└─────┴───────┘

Provalo online!

Spiegazione

[/:[:I.e.&>”0 1
          >”0 1  Pair each element on the left with each range on the right
       e.        Is the element in the range?
     I.          Indices of ones
[/:              Sort the elements by this array

J , 26 24 byte

2 byte grazie a Cole

[:;]<@#~1=-&1 0"1@[I."1]

Come funziona:

L'argomento sinistro contiene gli intervalli.

-&1 0"1@[ riduce il limite inferiore di ciascun intervallo di 1

I."1] controlla in quale intervallo si adatta a ciascun regalo

1= è nell'intervallo corretto

]<@#~ copia e confeziona i regali che si trovano nell'intervallo corrente

; - raze (unboxing)

Provalo online!

R , 113 48 55 41 byte

Una versione precedente non ordinava correttamente gli oggetti quando i dock non erano in ordine crescente.

function(P,D)for(d in D)cat(P[P%in%d],"")

Provalo online!

Prende Dcome un elenco di vettori di intervalli, vale a dire, list(4:7,1:3)sarebbe [[4, 7], [1, 3]].

Probabilmente la risposta ingenua avrei dovuto arrivare a secoli fa; stampa su stdout.

Japt , 6 byte

ñ@VbøX

Provalo

Spiegazione

Input implicito di array U(presenta) e 2d-array V(intervalli completi). Ordina ( ñ) i regali passandoli attraverso una funzione ( @) che ottiene l'indice del primo elemento ( b) in Vcui contiene ( ø) il presente presente ( X).

Python 2, 97 85 byte

l,d=input()
k=lambda i,j=0:-~j*(d[j][0]<=i<=d[j][1])or k(i,j+1)
print sorted(l,key=k)

-11 byte dagli ovs

-1 byte da Mr. Xcoder

Provalo online!

Ordina l'elenco usando una lambda ricorsiva come chiave. Spiegazione in arrivo ™ di seguito.

Spiegazione:

l,d=input()             # l is the lsit of presents, d is the list of ranges
k=lambda i,j=0:-~j*(d[j][0]<=i<=d[j][1])or k(i,j+1)# recursive lambda to sort with
k=lambda i,j=0:                                    # i is the present
                                                   # j is the index in the list of ranges
               -~j*(d[j][0]<=i<=d[j][1])           # return the index of the list of
                                                   # ranges(plus one) if the present is
                                                   # in the range
                                        or k(i,j+1)# if the present is not in the range,
                                                   # try the next range
print sorted(i,key=k)   # print the list of presents sorted by the lambda

Javascript ES6, 53 47 45 byte

p=>l=>l.map(d=>p.filter(a=>d.includes(a)))+''

Provalo online!

PowerShell , 37 byte

param($a,$b)$b|%{$i=$_;$a|?{$_-in$i}}

Provalo online!

Prende $acome una matrice letterale dei presenti e $bcome una matrice di array, ciascuno dei quali rappresenta l'intera gamma (ad esempio, @(1,2,3,4,5)anziché @(1,5)). Quindi eseguiamo il ciclo su ogni elemento in $bcon |%{...}. All'interno, dobbiamo impostare un helper $iin modo che sia l'elemento corrente, quindi usare una Where-Objectclausola contro $aper estrarre solo quegli elementi che sono -inl' $barray corrente .

Questi vengono lasciati in cantiere e l'output è implicito. Poiché il comportamento predefinito Write-Outputinserisce una nuova riga tra gli elementi dell'array, ecco cosa otteniamo. Ecco una versione leggermente ottimizzata che viene -joinedita insieme tramite virgole anziché una nuova riga, solo per mostrare le differenze.

Rosso , 73 byte

f: func[b r][n: copy[]foreach p r[foreach a b[if find p a[append n a]]]n]

Provalo online!

C # (.NET Core) , 50 + 18 byte

a=>b=>b.SelectMany(x=>a.Where(y=>y>=x[0]&y<=x[1]))

+18 byte da

using System.Linq;

Prende una raccolta di regali e una raccolta di array per i dock.

Provalo online!

Windows Batch (CMD), 90 79 byte

set/pX=||exit
set/pY=
for %%n in (%*)do if %X% LEQ %%n if %%n LEQ %Y% %%n
%0 %*

Utilizza il formato di fine riga LF. Ogni carattere di fine riga può essere conteggiato come 1 byte.

Nessun TIO (perché TIO utilizza Linux)

Prendi l'elenco dagli argomenti della riga di comando e va da stdin.

Ad esempio, se il programma viene eseguito (supponiamo che il file sia denominato r1.cmd)

r1 7 3 5 4 6 1 2

e con stdininput

1
3
4
5
6
7

, il programma verrà emesso stderrcon il formato

'3' is not recognized as an internal or external command,
operable program or batch file.
'1' is not recognized as an internal or external command,
operable program or batch file.
'2' is not recognized as an internal or external command,
operable program or batch file.
'5' is not recognized as an internal or external command,
operable program or batch file.
'4' is not recognized as an internal or external command,
operable program or batch file.
'7' is not recognized as an internal or external command,
operable program or batch file.
'6' is not recognized as an internal or external command,
operable program or batch file.

(corrisponde alla sequenza di output 3 1 2 5 4 7 6)

Spiegazione:

set /p X=       Prompt for variable X (min range)
   ||exit       If failed (end of file), exit - similar to short-circuit of logical OR
set /p Y=       Prompt for variable Y
for %%n in (%*)do     For each number %%n in all command-line arguments
   if %X% LEQ %%n     If X <= n
      if %%n LEQ %Y%  and n <= Y
         %%n          run command named "n", which lead to an error.

%0 %*           Call itself, process other ranges

Codice non golfato (con interazione abilitata se trueviene passato come argomento 1; richiesta di elenco da stdin, utilizzare gotoper evitare lo overflow dello stack - in realtà ho appena provato a eseguire uno script che si chiama da solo oltre 70000 volte senza vedere alcun problema, quindi immagino dovrebbe essere abbastanza sicuro):

@echo off

set INTERACTIVE=%1

if "%INTERACTIVE%" == "true" (
    set rangeMinPrompt=Enter range min: 
    set rangeMaxPrompt=Enter range max: 
    set listPrompt=Enter list: 
) else (
    set rangeMinPrompt=
    set rangeMaxPrompt=
    set listPrompt=
)


set /p list=%listPrompt%

:loop_label

set /p rangeMin=%rangeMinPrompt%&& set /p rangeMax=%rangeMaxPrompt%|| exit /b

for %%n in (%list%) do (
    if %rangeMin% LEQ %%n (
        if %%n LEQ %rangeMax% (
            echo %%n
        )
    )
)

goto :loop_label

Pulito , 59 byte

import StdEnv;f p l=flatten[[n\\n<-p|a<=n&&n<=b]\\[a,b]<-l]

Provalo online!

Accetta due elenchi, restituisce un elenco.

Wolfram Language (Mathematica) , 34 byte

r#~SortBy~{#&@@@r~Position~#&}&

Provalo online!

è l' Functionoperatore.

Questa è una funzione curry senza nome che dovrebbe essere chiamata prima con l'elenco di intervalli di dock (espansi) e poi con l'elenco dei regali. Ad esempio, se si assegna la funzione a f:

f[ {{4,5,6,7},{1,2,3}} ][ {1,2,3,4,5,6,7} ]

L'elenco dei regali è semplicemente ordinato in base alla posizione di primo livello del valore nell'elenco degli intervalli di dock. Dobbiamo racchiudere la SortByfunzione in un elenco per rendere stabile l'ordinamento.

Julia 0.6 , 31 30 byte

p%d=vcat((∩(p,x)for x=d)...)

Provalo online!

Ridefinisce l' %operatore e mappa l'intersezione impostata ∩()sui dock dmantenendo l'ordine e la molteplicità del primo imput, l'elenco dei regali p. vcatcon l'input espanso in più argomenti tramite ...appiattisce l'array nidificato risultante.

Modifica, -1Byte: comprensione della lista anziché map().