^{Виклик, прийнятий з дозволу на моєму університетському конкурсі Code Challenge}

Вже кілька років кількість учнів моєї школи постійно зростає. Спочатку кількість учнів збільшувалась на заняттях, але потім потрібно було перетворити простір для деяких груп, щоб провести там заняття, наприклад, гімнастичні стенди або, останній курс, до кімнати мітла.

Минулого року академічна влада отримала бюджет на будівництво нового корпусу та розпочала роботи. Нарешті вони закінчились, і нову будівлю вже можна використовувати, тож ми можемо переїхати (стара будівля буде відремонтована і буде використана для іншої функції), але це нас застало на півдорозі курсу. Директор хоче знати, чи можливий переїзд без розбивки або приєднання до груп, чи що деякі студенти повинні змінити групи.

Виклик

Враховуючи кількість учнів нинішніх груп та нових аудиторій (місткість), виведіть триєдине значення, якщо можна призначити інший класний клас із достатньою потужністю для кожної з поточних груп або значення фальси в іншому випадку.

Випробування

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і т.д. ...)
• код-гольф

Брахілог , 4 байти

Завжди приємно бачити виклик і знати, що брахілог переможе всіх. Приймає поточні класи як вхідні та нові аудиторії як вихідні; Це вийде правдою, якщо він знайде спосіб підходити до учнів, помилково в іншому випадку

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

Python 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

Haskell , 40 байт

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

Спробуйте в Інтернеті!

05AB1E , 14 12 8 байт

€{í0ζÆdP

Порт відповіді Pyth @Sok , тому не забудьте також підтримати його!

Приймає введення як список списків, а список класів як перший елемент, а список груп як другий.

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Пояснення:

€{         # 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 # Interactive Compiler) , 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()

Haskell, 66 байт

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

Спробуйте в Інтернеті!

Інструменти 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 для істинного або 0 для помилкового

Perl 5 -pal , 67 62 байт

@NahuelFouilleul врятував 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))))

Перевірте це

Зауважте, що сортування постійно мутує список, а поп відновлює змінну до наступного елемента.

Насправді це просто рекурсивно перевіряє, чи може найбільша студентська група вміститися у найбільшій кімнаті. Є 3 базових випадки:

1. Студентів немає - поверніть T
2. Студенти, але немає номерів - поверніть NIL
3. Студенти та кімнати, але найбільша студентська група, більша, ніж найбільша кімната - повертають NIL

Python 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 байт

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

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Складає список списків кімнат та груп та виходить, -якщо кімнати можуть вмістити групи. Пояснення:

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

Повторіть, поки групу можна присвоїти кімнаті.

ＵＭθΦκ⁻ν⌕κ⌈κ

Видаліть найбільшу кімнату та групу зі своїх списків.

¬⊟θ

Перевірте, чи не залишилося нерозподілених груп.

JavaScript, 56 байт

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

Спробуй це

Perl 6 , 34 байти

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

Спробуйте в Інтернеті!

Приймає дані як список двох списків, груп та аудиторій та повертає None Junction, який може бути збільшений до true / false.

Пояснення:

{                                }   # 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 # Interactive Compiler) , 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;}

Якщо помилка, помилка, нічого, якщо істина.

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

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

Спробуйте в Інтернеті!

З невеликою корисною порадою Кевіна Круїссена і просто ще одним поглядом на свій код я можу знизити свою оцінку на цілих 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;}

Спробуйте в Інтернеті!

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

Спробуйте в Інтернеті!