学校搬出(第一天)


21

挑战经我的大学代码挑战竞赛许可


多年来,我学校的学生人数一直稳定增长。首先,教室增加了学生的数量,但随后有必要为一些团体转换一些空间以便在那里上课,例如健身房看台,或最后一道课程,直到扫帚室。

去年,学术机构获得了建造新建筑并开始工程的预算。终于,他们完成了,新建筑物已经可以使用了,所以我们可以搬家了(旧建筑物将被修复,并将用于其他功能),但是在整个过程中它已经使我们半途而废。导演想知道是否可以在不拆分或不加入小组的情况下搬家,或者某些学生必须更换小组。

挑战

给定当前组和新教室的学生数量(容量),如果可以为每个当前组分配一个具有足够容量的不同教室,则输出真实值,否则输出假值。

测试用例

Input: groups of students => [10, 20, 30], classrooms capacity => [31, 12, 20]
Output: True

Input: groups of students => [10, 20, 30], classrooms capacity => [100, 200]
Output: False

Input: groups of students => [20, 10, 30], classrooms capacity => [20, 20, 50, 40]
Output: True

Input: groups => [30, 10, 30, 5, 100, 99], classrooms => [40, 20, 50, 40, 99, 99]
Output: False

Input: groups => [], classrooms => [10, 10, 10]
Output: True

Input: groups => [10, 10, 10], classrooms => []
Output: False

Input: groups => [], classrooms => []
Output: True

Input: groups => [10, 1], classrooms => [100]
Output: False

Input: groups => [10], classrooms => [100, 100]
Output: True

Input: groups => [1,2,3], classrooms => [1,1,2,3]
Output: True

笔记

  • 您可以采用任何合理的格式输入
  • 您可以输出任何Truthy / Falsey值(1/0True/False,等...)

5
建议的测试用例:g=[1,2,3], c=[1,1,2,3]
TF场

您是否有权在此处发布?
亚当

2
@Adám是的。我问我的老师(谁是比赛的负责人),他说没有问题。唯一的事情是,每天这都是一个挑战
路易斯·菲利佩·德·耶稣·穆诺兹

0团体或教室有效的价值?
NIMI

1
@Shaggy任何虚假/真实的
Luis

Answers:


14

Brachylog,4个字节

看到挑战并知道brachylog会击败所有人总是很高兴。以当前班级为输入,以新教室为输出;如果找到适合学生的方法,它将输出true,否则输出false

p≤ᵐ⊆

说明

该代码分为3部分,顺序实际上无关紧要

≤ᵐ --> projects each value to a value bigger/equal then input
⊆  --> input is a ordered subsequence of output
p  --> permutes the list so it becomes a unordered subsequence

在线尝试!


4

Pyth,11个字节

.AgM.t_DMQ0

将输入作为列表列表,首先是教室人数,然后是小组人数。在此处在线尝试,或在此处一次验证所有测试用例。

.AgM.t_DMQ0   Implicit: Q=eval(input())
      _DMQ    Sort each element of Q in reverse
    .t    0   Transpose, padding the shorter with zeroes
  gM          Element wise test if first number >= second number
.A            Are all elements truthy? Implicit print

4

果冻,9个字节

以教室为第一参数,以组为第二参数。

Œ!~+Ṡ‘ḌẠ¬

在线尝试!

已评论

注意:这Ṡ‘ḌẠ¬太长了。但是我怀疑这不是正确的方法。

Œ!~+Ṡ‘ḌẠ¬  - main link taking the classrooms and the groups e.g. [1,1,2,3], [1,2,3]
Œ!         - computes all permutations of the classrooms    -->  [..., [1,2,3,1], ...]
  ~        - bitwise NOT                                    -->  [..., [-2,-3,-4,-2], ...]
   +       - add the groups to each list; the groups fits   -->  [..., [-1,-1,-1,-2], ...]
             in a given permutation if all resulting values
             are negative
    Ṡ      - take the signs                                 -->  [..., [-1,-1,-1,-1], ...]
     ‘     - increment                                      -->  [..., [0,0,0,0], ...]
      Ḍ    - convert from decimal to integer                -->  [..., 0, ...]
       Ạ   - all truthy?                                    -->  0
        ¬  - logical NOT                                    -->  1

4

Japt,9个字节

ñÍí§Vñn)e

尝试在TIO上运行所有测试用例

ñÍí§Vñn)e     :Implicit input of arrays U=students, V=classrooms
ñ             :Sort U by
 Í            :  Subtracting each integer from 2
  í           :Interleave with
    Vñn       :  V sorted by negating each integer
   §          :  Reduce each pair by checking if the first is <= the second
       )      :End interleaving
        e     :All true?

ñÍeȧVn o

尝试在TIO上运行所有测试用例

ñÍeȧVn o     :Implicit input of arrays U=students, V=classrooms
ñ             :Sort U by
 Í            :  Subtracting each integer from 2
  e           :Does every element return true
   È          :When passed through the following function
    §         :  Less than or equal to
     Vn       :  Sort V
        o     :  Pop the last element

出于好奇,为什么要为2 - nIn Japt 内置一个单字节?它必须证明什么样的用例是内置的1字节?
凯文·克鲁伊森

1
好问题,@ KevinCruijssen。Ín2<space>字符串的快捷方式,它是为与字符串一起使用而创建的,将字符串从2到10的数字进行转换(这是相当普遍的需求)。但是,该n方法应用于数字时,将从方法的参数中减去该数字(default = 0)。所以在这里,尽管从中减去0就足以以相反的顺序对数组进行排序,但是使用快捷方式可以节省一个字节ñn<space>。我还可以在排序时使用它,V但是它不会保存任何字节,因为我仍然需要一个空格而不是)来关闭该í方法。
毛茸茸的

3

Python 2,49个字节

通过退出代码输出,对于伪造的输入失败。

g,r=map(sorted,input())
while g:g.pop()>r.pop()>y

在线尝试!


3

MATL,10字节

yn&Y@>~!Aa

在线尝试!验证所有测试用例

说明

考虑输入[20, 10, 30][20, 20, 50, 40]作为一个例子。堆栈从下至上显示。

y     % Implicit inputs. Duplicate from below
      % STACK: [20 10 30]
               [20 20 50 40]
               [20 10 30]
n     % Number of elements
      % STACK: [20 10 30]
               [20 20 50 40]
               3
&Y@   % Variations. Gives a matrix, each row is a variation
      % STACK: [20 10 30]
               [20 10 30
                20 20 40
                20 20 40
                ···
                50 40 20]
>~    % Less than? Element-wise with broadcast
      % STACK: [1 1 1
                1 1 1
                1 1 1
                ···
                1 1 0]
!     % Transpose
      % STACK: [1 1 1 ··· 0
                1 1 1 ··· 1
                1 1 1 ··· 1]
A     % All. True for columns that only contain nonzeros
      % STACK: [1 1 1 ··· 0]
a     % Any. True if the row vector contains at least a nonzero. Implicit display
      % STACK: 1


3

05AB1E14 12 8 字节

€{í0ζÆdP

@Sok的Pyth答案的端口,因此请确保也对他进行投票

将输入作为列表列表,其中教室列表作为第一项,组列表作为第二项。

在线尝试验证所有测试用例

说明:

€{         # Sort each inner list
  í        # Reverse each inner list
   0ζ      # Zip/transpose; swapping rows/columns, with 0 as filler
     Æ     # For each pair: subtract the group from the classroom
      d    # Check if its non-negative (1 if truthy; 0 if falsey)
       P   # Check if all are truthy by taking the product
           # (and output implicitly)

旧的12个字节的答案:

æε{I{0ζÆdP}à

首先获取教室列表,然后获取小组列表。

在线尝试验证所有测试用例

说明:

æ             # Take the powerset of the (implicit) classroom-list,
              # resulting in a list of all possible sublists of the classrooms
 ε            # Map each classroom sublist to:
  {           #  Sort the sublist
   I{         #  Take the group-list input, and sort it as well
     0ζ       #  Transpose/zip; swapping rows/columns, with 0 as filler
       Æ      #  For each pair: subtract the group from the classroom
        d     #  Check for everything if it's non-negative (1 if truthy; 0 if falsey)
         P    #  Check if all are truthy by taking the product
            # After the map: check if any are truthy by getting the maximum
              # (and output the result implicitly)

1
嘿嘿,我很惊讶Pyth击败了05AB1E进行了更改,但事实证明它毕竟是算法:oP
Sok

1
@Sok抱歉让您失望。; p但是感谢-4个字节。:D
凯文·克鲁伊森

3

C#(Visual C#交互式编译器)77 74字节

a=>b=>a.Count==a.OrderBy(x=>-x).Zip(b.OrderBy(x=>-x),(x,y)=>x>y?0:1).Sum()

在线尝试!

注释代码:

// a: student group counts
// b: classroom capacities
a=>b=>
  // compare the number of student
  // groups to...
  a.Count==
  // sort student groups descending
  a.OrderBy(x=>-x)
     // combine with classroom
     // capacities sorted descending
     .Zip(
        b.OrderBy(x=>-x),
        // the result selector 1 when
        // the classroom has enough
        // capacity, 0 when it doesn't
        (x,y)=>x<y?0:1
     )
     // add up the 1's to get the number
     // of student groups who can fit
     // in a classroom
     .Sum()

1
我无法为其找到一个合理的班轮。不错的工作!
无知的体现


2

Bash + GNU工具,68个字节

(sort -nr<<<$2|paste -d- - <(sort -nr<<<$1)|bc|grep -- -)&>/dev/null

69个字节

(paste -d- <(sort -nr<<<$2) <(sort -nr<<<$1)|bc|grep -- -)&>/dev/null

蒂奥

将学生房间作为第一个和第二个参数,用换行符分隔的字符串号返回退出状态1为true或0为false



2

Common Lisp,74个字节

(defun c(s r)(or(not(sort s'>))(and(sort r'>)(<=(pop s)(pop r))(c s r))))

未缩小

(defun can-students-relocate (students rooms)
  (or (not (sort students #'>))
      (and (sort rooms #'>)
           (<= (pop students)
               (pop rooms))
           (can-students-relocate students rooms))))

测试一下

请注意,sort会永久更改列表,然后pop将变量重新绑定到下一个元素。

实际上,这只是递归检查最大的学生群体是否可以容纳最大的房间。有3种基本情况:

  1. 没有学生-返回T
  2. 学生,但没有房间-返回NIL
  3. 学生和房间,但最大的学生组大于最大的房间-返回NIL


1

视网膜0.8.2,50字节

\d+
$*
%O^`1+
%`$
,
^((1*,)(?=.*¶((?>\3?)1*\2)))*¶

在线尝试!链接包括测试套件。获取组和房间的两个列表(测试套件;用作列表分隔符)。说明:

\d+
$*

转换为一元。

%O^`1+

对每个列表分别进行反向排序。

%`$
,

给每个列表添加一个逗号。

^((1*,)(?=.*¶((?>\3?)1*\2)))*¶

检查第一个列表中的每个数字是否可以匹配第二个列表中的适当数字。每次\3包含先前匹配的房间,因此下一组\2需要适应下一个房间。(?>\3?)当没有以前的房间时,将处理第一个房间的情况。


1

木炭,28字节

W∧⌊講⌈§θ¹⌈§θ⁰UMθΦκ⁻ν⌕κ⌈κ¬⊟θ

在线尝试!链接是详细版本的代码。获取房间和组列表的列表,-如果房间可以容纳组,则输出。说明:

W∧⌊講⌈§θ¹⌈§θ⁰

可以重复将群组分配到房间。

UMθΦκ⁻ν⌕κ⌈κ

从他们的列表中删除最大的房间和组。

¬⊟θ

检查是否没有剩余的未分配组。


1

JavaScript,56个字节

s=>c=>s.sort(g=(x,y)=>y-x).every((x,y)=>c.sort(g)[y]>=x)

试试吧


79的班级8和班级失败10
尼尔

感谢您指出@Neil。我想知道裸露的表情是否不会再咬我屁股!我将不得不退回到原来的解决方案,直到我有时间再试一次。
毛茸茸的

1

Perl 6,34个字节

{none [Z>] $_>>.sort(-*)>>[^.[0]]}

在线尝试!

将输入作为两个列表(组和教室)的列表,并返回可以被设置为true / false的None结。

说明:

{                                }   # Anonymous code block
           $_>>.sort(-*)             # Sort both lists from largest to smallest
                        >>[^.[0]]    # Pad both lists to the length of the first list
 none                                # Are none of
      [Z>]                           # The groups larger than the assigned classroom

1

红宝石,57个字节

->c,r{r.permutation.any?{|p|c.zip(p).all?{|a,b|b&&a<=b}}}

在线尝试!

需要c上课,r为客房。检查房间的所有排列而不使用排序,因为反向排序会占用太多字节。虽然看起来还是很长...


1

C#(Visual C#交互式编译器)105 93 91 82 81 79 77 76 74字节

现在符合dana的分数!

n=>m=>{n.Sort();m.Sort();int i=m.Count-n.Count;i/=n.Any(b=>m[i++]<b)?0:1;}

如果为false,则引发错误;如果为true,则不引发错误。

-12个字节感谢@Destrogio!

在线尝试!

说明

//Function taking in a list, and returning another function
//that takes in a list and doesn't return
n=>m=>{
  //Sort the student groups from smallest to largest
  n.Sort();
  //Sort the classrooms fom smallest capacity to largest
  m.Sort();
  //Initialize a variable that will function as a sort of index
  int i=m.Count-n.Count;
  //And divide that by...
  i/=
    //0 if any of the student groups...
    n.Any(b=>
      //Don't fit into the corresponding classroom and incrementing i in the process
      /*(In the case that a the amount of classrooms are less than the amount of
      student groups, an IndexOutOfRangeException is thrown)*/
      m[i++]<b)?0
    //Else divide by 1
    :1;
}

93个字节- 在线尝试!
Destroigo

1
@Destrogio谢谢!
的无知的体现

0

Java(OpenJDK 8),183字节

a->{int b=a[0].length;Arrays.sort(a[0]);Arrays.sort(a[1]);if(b>a[1].length){return false;}for(int i=0;i<b;i++){if(a[0][i]>a[1][i]){return false;}}return true;}

在线尝试!

凯文·克鲁伊森Kevin Cruijssen)的一些有用建议以及我自己对代码的一瞥,我只需替换三个英语单词就可以将我的分数降低整整9%!

Java(OpenJDK 8),166字节

a->{int b=a[0].length;Arrays.sort(a[0]);Arrays.sort(a[1]);if(b>a[1].length){return 0;}for(int i=0;i<b;){if(a[0][i]>a[1][i++]){return 0;}}return 1;}

在线尝试!


您必须import java.util.*;在您的字节数中包含。不过,您可以将Java替换为,在Java 8中将其压缩144个字节,在Java 10中为140 个字节booleanvar
Kevin Cruijssen

PS:如果您确实需要true/ false在您的代码中1>0/ 0>1是更短的选择。:)
凯文·克鲁伊森

实际上,我确实记得将额外的24个字节包括在内!(我相信是XD几个月前告知您有关该规则的信息),但谢谢您的提示!生病吧!
X1M4L

3
这使最后一个测试用例失败。
毛茸茸的

关于您的166字节版本:尽管您可以返回问题状态,1/0并且我认为在这种情况下还可以,但是请注意,在Java中,与Python不同,JavaScript,C等1/0通常不被视为有效的true / falsey输出。在我的第一个评论中,我提到了一个144字节的版本。:)虽然,它现在也无效,因为它不适用于最后一个测试用例,如@Shaggy所述
Kevin Cruijssen

0

PowerShell,80字节

param($s,$c)!($s|sort -d|?{$_-gt($r=$c|?{$_-notin$o}|sort|select -l 1);$o+=,$r})

在线尝试!

少打高尔夫的测试脚本:

$f = {

param($students,$classrooms)
$x=$students|sort -Descending|where{          
    $freeRoomWithMaxCapacity = $classrooms|where{$_ -notin $occupied}|sort|select -Last 1
    $occupied += ,$freeRoomWithMaxCapacity    # append to the array
    $_ -gt $freeRoomWithMaxCapacity           # -gt means 'greater than'. It's a predicate for the 'where'
}                                             # $x contains student groups not assigned to a relevant classroom
!$x                                           # this function returns a true if $x is empty

}

@(
    ,(@(10, 20, 30), @(31, 12, 20), $true)
    ,(@(10, 20, 30), @(100, 200), $False)
    ,(@(20, 10, 30), @(20, 20, 50, 40), $True)
    ,(@(30, 10, 30, 5, 100, 99), @(40, 20, 50, 40, 99, 99), $False)
    ,(@(), @(10, 10, 10), $True)
    ,(@(10, 10, 10), @(), $False)
    ,(@(), @(), $True)
    ,(@(10, 1), @(100), $False)
    ,(@(10), @(100, 100), $True)
    ,(@(1,2,3), @(1,1,2,3), $True)
) | % {
    $students, $classrooms, $expected = $_
    $result = &$f $students $classrooms
    "$($result-eq$expected): $result"
}

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.