^{대학 코드 챌린지 컨테스트의 허가를받은 챌린지}

몇 년 동안 우리 학교의 학생 수는 꾸준히 증가하고 있습니다. 먼저 교실 수에 따라 학생들의 수가 늘어 났지만 체육관 스탠드 나 마지막 강의실과 같은 일부 그룹이 교실을 비울 수있는 공간을 마련해야했습니다.

작년에 학계 당국은 새 건물을 짓고 예산을 책정했습니다. 마침내 그들은 끝났고 새로운 건물을 이미 사용할 수 있기 때문에 우리는 움직일 수 있습니다 (오래된 건물은 재건되고 다른 기능에 사용될 것입니다). 감독은 그룹을 나누거나 참여하지 않고 이사 할 수 있는지 또는 일부 학생들이 그룹을 변경해야하는지 알고 싶어합니다.

도전

현재 그룹의 학생 수와 새로운 교실 (용량)을 고려할 때 충분한 능력을 가진 다른 교실을 각 현재 그룹에 할당하거나 그렇지 않으면 잘못된 값을 할당 할 수 있으면 진실한 가치를 산출합니다.

테스트 사례

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/0, True/False, 등 ...)
• 코드 골프

Brachylog , 4 바이트

도전을보고 근친상간이 모든 사람을 이길 것임을 아는 것이 항상 좋습니다. 현재 수업을 입력으로하고 새로운 교실을 출력으로합니다. 학생에게 맞는 방법을 찾으면 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

온라인으로 사용해보십시오!

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

젤리 , 9 바이트

교실을 첫 번째 논쟁으로, 그룹을 두 번째 논쟁으로 삼습니다.

Œ!~+Ṡ‘ḌẠ¬

온라인으로 사용해보십시오!

댓글

NB : Ṡ‘ḌẠ¬너무 깁니다. 그러나 나는 이것이 올바른 접근법이 아니라고 생각합니다.

Œ!~+Ṡ‘ḌẠ¬  - 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

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 , 49 바이트

종료 코드 별 출력, 잘못된 입력에 실패

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

온라인으로 사용해보십시오!

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

하스켈 , 40 바이트

c%l=[1|x<-l,x>=c]
s#g=and[c%s<=c%g|c<-s]

온라인으로 사용해보십시오!

05AB1E , 14 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)

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()

하스켈, 66 바이트

import Data.List
q=sortOn(0-)
x#y=and$zipWith(<=)(q x)$q y++(0<$x)

온라인으로 사용해보십시오!

배쉬 + 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

TIO

줄 바꾸기로 구분 된 문자열 번호로 학생 실을 첫 번째 및 두 번째 인수로 사용하여 종료 상태 1을 true로, false를 0으로 리턴합니다.

펄 5 -pal , 67 62 바이트

@NahuelFouilleul은 재배치와 grep으로 5 바이트를 절약했습니다.

$_=!grep$_>0,map$_-(sort{$b-$a}@F)[$x++],sort{$b-$a}<>=~/\d+/g

온라인으로 사용해보십시오!

67 바이트 버전

첫 줄에 공백으로 구분 된 클래스 크기 목록과 다음 줄에 공백으로 구분 된 공간 크기 목록을 가져옵니다.

공통 리스프, 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. 학생과 방, 그러나 가장 큰 방보다 큰 학생 그룹-return NIL

파이썬 2 , 71 67 64 바이트

lambda g,c:s(g)==s(map(min,zip(s(g)[::-1],s(c)[::-1])))
s=sorted

온라인으로 사용해보십시오!

레티 나 0.8.2 , 50 바이트

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

온라인으로 사용해보십시오! 링크에는 테스트 스위트가 포함되어 있습니다. 그룹과 회의실의 두 목록을 가져옵니다 (테스트 스위트는 ;목록 구분자로 사용). 설명:

\d+
$*

단항으로 변환합니다.

%O^`1+

각 목록을 개별적으로 역 정렬하십시오.

%`$
,

각 목록에 쉼표를 추가하십시오.

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

첫 번째 목록의 각 숫자가 두 번째 목록의 해당 숫자와 일치하는지 확인하십시오. 매번 \3이전에 일치 한 방이 포함되어 \2있으므로 다음 그룹 은 다음 방에 맞출 수 있어야합니다. (?>\3?)핸들 첫 번째 룸의 경우는 때 아직 이전 객실이 없습니다.

숯 , 28 바이트

Ｗ∧⌊講⌈§θ¹⌈§θ⁰ＵＭθΦκ⁻ν⌕κ⌈κ¬⊟θ

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. -회의실이 그룹을 수용 할 수있는 경우 회의실 및 그룹 및 출력 목록을 가져옵니다 . 설명:

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

그룹을 회의실에 할당 할 수있는 동안 반복하십시오.

ＵＭθΦκ⁻ν⌕κ⌈κ

목록에서 가장 큰 방과 그룹을 제거하십시오.

¬⊟θ

할당되지 않은 그룹이 남아 있지 않은지 확인하십시오.

자바 스크립트, 56 바이트

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

시도 해봐

펄 6 , 34 바이트

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

온라인으로 사용해보십시오!

입력을 그룹과 교실의 두 목록으로 가져오고 참 / 거짓으로 부울 수있는 없음 정션을 리턴합니다.

설명:

{                                }   # 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

루비 , 57 바이트

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

온라인으로 사용해보십시오!

소요 c, 클래스 r객실에 대해. 역 정렬은 너무 많은 바이트를 요구하기 때문에 정렬을 사용하는 대신 룸의 모든 순열을 확인합니다. 그래도 여전히 길어 보입니다 ...

C # (Visual C # 대화 형 컴파일러) , 105 93 91 82 81 79 77 76 74 바이트

이제 다나의 점수와 일치합니다!

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

거짓이면 오류를 발생시키고, 참이면 아무것도 발생하지 않습니다.

@Destrogio 덕분에 -12 바이트!

온라인으로 사용해보십시오!

설명

//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;
}

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의 도움이되는 조언 과 코드 자체 를 간단히 살펴보면 영어 단어 3 개만 바꾸면 점수가 9 % 줄어 듭니다!

자바 (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;}

온라인으로 사용해보십시오!

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"
}

R , 65 바이트

function(g,r)isTRUE(all(Map(`-`,sort(-g),sort(-r)[seq(a=g)])>=0))

온라인으로 사용해보십시오!