<<上一页 下一页>>

多亏了PPCG社区，Santa设法重新制造了他所有的礼物，并且在装配线之后，现在就可以将这些礼物搬到运输码头了！

圣诞老人的每个运输码头都只能容纳一定范围的当前尺寸，因为运输雪橇是专门针对特定尺寸的（任何较轻的雪橇都会很浪费，更重的雪橇将无法承受负荷）。因此，他需要您帮助他拿礼物并将其分类到正确的运输码头中。

挑战

根据清单和运输码头范围，将礼物稳定地组织成正确的顺序。

让我们以这个为例：礼物是[5, 3, 8, 6, 2, 7]，码头范围是[[1, 5] and [6, 10]]。

礼物5，3以及2进入第一对接和礼物8，6和7进入第二平台。可以显示为[[5, 3, 2], [8, 6, 7]]。此列表将比输入更接近排序，但stably意味着在每个扩展坞中，礼物的顺序必须与输入的顺序相同（否则，您可以对整个列表进行排序）。

在这种情况下，您的最终输出将是[5, 3, 2, 8, 6, 7]（作为固定列表）。

格式化规格

你将被给定输入作为整数的平面列表，并且在任何合理的格式范围的列表（例如，用于上述情况的范围内，可以给定为[[1, 5], [6, 10]]，[1, 5, 6, 10]，或[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]）。您的输出应该是任何合理格式的整数整数列表。

输入可以包含重复值；在这种情况下，您需要返回它们的所有实例。当前所有尺寸均在一个尺寸范围内，并且您可以假定这些范围永远不会重叠。只要覆盖所有当前尺寸，范围就可能存在差距。

规则

• 适用标准漏洞
• 这是 代码高尔夫球，因此以字节为单位的最短答案会获胜
• 没有答案将被接受
• 您可以假设没有空范围（[7, 4]由于范围增加，该范围无效）

测试用例

[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]

^{注意：我从Advent Of Code汲取灵感来挑战这个系列。我没有与此网站的隶属关系}

通过查看此处第一个挑战的“链接”部分，您可以查看该系列中所有挑战的列表。

Haskell，26个字节

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

在线尝试！用法示例：[1,2,3,4,5,6,7] # [[1,2,3],[4,5,6,7]]yields [1,2,3,4,5,6,7]。

果冻，4字节

fЀẎ

在线尝试！

将输入作为当前列表，完整范围。

Mathematica，39个字节

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

JungHwan Min -22个
字节，Martin -4个字节

在线尝试！

Pyth，5个字节

s@Rvz

在这里尝试！

Pyth，10个字节

s.gx}LkQ1E

在这里尝试！

他们如何工作

s @ Rvz | 完整程序。

  R | 右图...
 @ | ...使用交集。
   vz | 第一个输入与第二个。
s | 展平一级。

s.gx} LkQ1E | 完整程序。

 .g E | 通过...将第二个输入中的项目分组
    } LkQ | 映射第一个输入，并检查当前项是否在列表中。
   x 1 | 取得第一个真实元素的索引。
s | 展平。

首先使用停靠点，所有整数都在范围内，然后以新行出现。

Python 2中，49 46个字节

感谢@HyperNeutrino -3个字节

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

在线尝试！

不打高尔夫球

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

在线尝试！

05AB1E，3个字节

δØ

在线尝试！（感谢Adnan通知我δ存在，-1字节）

怎么运行的

δÃ| 完整程序。

δ| 对下一个命令进行双重向量化（类似于外部产品）。
 Ã| 列出交集。由于这是一个二元组，因此第一个输入将自动
     | 用于填充丢失的参数（据我所知）。
  〜| 展平。

视网膜，37 36字节

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

在线尝试！在第一行将输入作为礼物列表，在第二行将其作为范围列表；该链接包含一个标题，用于将测试用例拆分为所需的格式。编辑：感谢@MartinEnder，节省了1个字节。说明：第一阶段匹配礼物并找到匹配的底座。从行的开始到为止，礼物均按子字符串排序[，因此按码头将礼物分组。然后，第二阶段删除坞站。

征募，3个字节

f₱Ẏ

在线尝试！

怎么运行的

f₱Ẏ| 完整程序。

 ₱| 映射正确的参数。
f | 使用列表交集，计算重复数。
  Ẏ| 拧紧（拉平1级）。

APL + WIN，29个字节

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

提示输入整数和范围的屏幕输入。整数作为平面列表，范围作为嵌套向量，例如，情况3：

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

说明：

(×/⍴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个字节

将输入作为由成对的指针表示的两个数组[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];});}

在线尝试！

J，15个字节

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

将输入作为左参数，将范围作为右参数。范围是完整范围的列表框。

例如对于第一个范围：

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

在线尝试！

说明

[/:[: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字节

2个字节由于科尔

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

怎么运行的：

左参数保存范围。

-&1 0"1@[ 将每个范围的下边界减小1

I."1] 检查哪个范围适合每个礼物

1= 是否在正确的范围内

]<@#~ 复制并装箱当前范围内的礼物

; -拉兹（拆箱）

在线尝试！

R，113 48 55 41字节

当扩展坞未按升序排列时，以前的版本无法正确对对象进行排序。

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

在线尝试！

需要D为范围的向量列表，即list(4:7,1:3)会[[4, 7], [1, 3]]。

我可能早就应该得出天真的答案；打印到标准输出。

Japt，6个字节

ñ@VbøX

尝试一下

说明

数组U（表示）和二维数组V（完整范围）的隐式输入。ñ通过将礼物传递给函数（@）来对礼物进行排序（），该函数获取包含（）当前礼物（）的第一个元素（b）的索引。VøX

Python 2，97 85字节

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)

ovs -11个字节

Xcoder先生的 -1个字节

在线尝试！

使用递归lambda作为键对列表进行排序。解释即将推出™。

说明：

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字节

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

在线尝试！

PowerShell，37个字节

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

在线尝试！

注意到$a作为礼物的字面阵列和$b作为数组的数组，其中每一个是完整的范围（例如，@(1,2,3,4,5)而不是@(1,5)）。然后，我们遍历每个项目$b有|%{...}。在内部，我们需要将一个辅助对象设置为$i当前项，然后使用Where-Object反对子句$a来仅提取那些是-in当前$b数组的项。

这些留在管道上，输出是隐式的。由于默认的行为是Write-Output在数组元素之间插入换行符，因此我们可以得到。这是一个经过稍微调整的版本，-join使用逗号代替了换行符，以显示差异。

红色，73字节

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

在线尝试！

C＃（.NET Core），50 + 18字节

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

从+18个字节

using System.Linq;

它需要礼物的集合和码头的阵列的集合。

在线尝试！

Windows Batch（CMD），90 79字节

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

使用LF行尾格式。每个行尾字符可计为1个字节。

没有TIO（因为TIO使用Linux）

从命令行参数中获取列表，范围为stdin。

例如，如果程序正在运行（假设文件名为r1.cmd）

r1 7 3 5 4 6 1 2

和stdin输入

1
3
4
5
6
7

，程序将输出为stderr格式

'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.

（对应于输出顺序3 1 2 5 4 7 6）

说明：

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

Ungolfed代码（如果true作为参数1传递则启用交互；从提示输入列表stdin，用于goto避免堆栈溢出-实际上，我刚刚尝试运行一个脚本，该脚本调用了70000次而没有任何问题，所以我猜是应该很安全）：

@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

干净，59字节

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

在线尝试！

取两个列表，返回一个列表。

Wolfram语言（Mathematica），34个字节

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

在线尝试！

是Function运算符。

这是一个未命名的咖喱函数，应首先使用（扩展的）停靠范围列表，然后使用礼物列表进行调用。例如，如果您将功能分配给f：

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

礼物列表仅按码头范围列表中值的第一级位置排序。我们需要将SortBy函数包装在列表中以使排序稳定。

朱0.6，31 30个字节

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

在线尝试！

重新定义%运算符，并∩()在码头上映射设置的交集，以d保持第一个输入项（礼物列表）的顺序和多样性p。vcat通过展...平嵌套数组将输入扩展为多个参数。

编辑，-1Byte：列表解析，而不是map()。