^{Herausforderung Mit freundlicher Genehmigung von meinem University Code Challenge Contest}

Seit einigen Jahren wächst die Anzahl der Schüler an meiner Schule stetig. Zuerst wurde die Anzahl der Schüler durch das Klassenzimmer erhöht, aber dann mussten einige Räume für einige Gruppen umgebaut werden, um dort Unterricht zu erteilen, wie zum Beispiel die Turnhallenstände oder, in diesem letzten Kurs, bis zum Besenraum.

Letztes Jahr erhielten die akademischen Behörden das Budget für den Bau eines neuen Gebäudes und begannen mit den Arbeiten. Endlich sind sie fertig und das neue Gebäude kann bereits genutzt werden, sodass wir umziehen können (das alte Gebäude wird saniert und für eine andere Funktion genutzt), aber es hat uns auf halber Strecke erwischt. Der Direktor möchte wissen, ob der Umzug ohne Aufteilung oder Beitritt zu Gruppen möglich ist oder ob einige Schüler die Gruppe wechseln müssen.

Herausforderung

Geben Sie unter Berücksichtigung der Anzahl der Schüler der aktuellen Gruppen und der neuen Klassenräume (Kapazität) einen Wahrheitswert aus, wenn es möglich ist, jeder der aktuellen Gruppen einen anderen Klassenraum mit ausreichender Kapazität zuzuweisen, oder andernfalls einen Falschwert.

Testfälle

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

Anmerkungen

• Sie können die Eingabe in jedem vernünftigen Format vornehmen
• Sie können die Ausgabe jeder truthy / Falsey Wert ( 1/0, True/False, etc ...)
• Code-Golf

Brachylog , 4 Bytes

Es ist immer schön, eine Herausforderung zu sehen und zu wissen, dass Brachylog jeden schlagen wird. Verwendet aktuelle Klassen als Eingabe und neue Klassenräume als Ausgabe. Es wird true ausgegeben, wenn es einen Weg findet, den Schülern zu entsprechen, andernfalls false

p≤ᵐ⊆

Erläuterung

Der Code besteht aus 3 Teilen, von denen die Reihenfolge eigentlich keine Rolle spielt

≤ᵐ --> 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

Probieren Sie es online!

Pyth, 11 Bytes

.AgM.t_DMQ0

Nimmt die Eingabe als Liste von Listen vor, wobei die Klassengröße an erster Stelle und die Gruppengröße an zweiter Stelle steht. Versuchen Sie es online hier oder überprüfen alle Testfälle auf einmal hier .

.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

Gelee , 9 Bytes

Nimmt die Klassenräume als erstes Argument und die Gruppen als zweites Argument.

Œ!~+Ṡ‘ḌẠ¬

Probieren Sie es online!

Kommentiert

NB: Das Ṡ‘ḌẠ¬ist viel zu lang. Aber ich vermute, dass dies sowieso nicht der richtige Ansatz ist.

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

ñÍí§Vñn)e

Probieren Sie es aus oder führen Sie alle Testfälle unter TIO aus

ñÍí§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

Probieren Sie es aus oder führen Sie alle Testfälle unter TIO aus

ñÍ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 Bytes

Ausgabe per Exit-Code, Fehler bei falscher Eingabe.

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

Probieren Sie es online!

MATL , 10 Bytes

yn&Y@>~!Aa

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

Betrachten Eingänge [20, 10, 30], [20, 20, 50, 40]als Beispiel. Der Stapel wird von unten nach oben angezeigt.

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 Bytes

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

Probieren Sie es online!

05AB1E , 14 12 8 Bytes

€{í0ζÆdP

Port of @Soks Pyth-Antwort , also stelle sicher, dass du ihn auch positiv bewertest!

Nimmt die Eingabe als Liste von Listen auf, wobei die Klassenzimmerliste als erstes Element und die Gruppenliste als zweites Element dient.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

€{         # 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)

Alte 12-Byte-Antwort:

æε{I{0ζÆdP}à

Nimmt zuerst die Klassenliste und dann die Gruppenliste.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

æ             # 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 bis 74 Byte

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

Probieren Sie es online!

Kommentierter Code:

// 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 Bytes

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

Probieren Sie es online!

Bash + GNU-Tools, 68 Bytes

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

69 Bytes

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

TIO

Nimmt Studentenzimmer als erstes und zweites Argument als durch Newline begrenzte Zeichenfolgenummern und gibt den Beendigungsstatus 1 für true oder 0 für false zurück

Perl 5 -pal , 67 62 Bytes

@NahuelFouilleul sparte 5 Bytes mit einer Neuanordnung und einem Grep

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

Probieren Sie es online!

67-Byte-Version

Nimmt die durch Leerzeichen getrennte Liste der Klassengrößen in der ersten Zeile und die durch Leerzeichen getrennte Liste der Raumgrößen in der nächsten Zeile.

Common Lisp, 74 Bytes

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

Nicht minimiert

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

Probier es aus

Beachten Sie, dass sort die Liste permanent verändert und pop die Variable erneut an das nächste Element bindet.

Tatsächlich wird nur rekursiv überprüft, ob die größte Studentengruppe in den größten Raum passt. Es gibt 3 Basisfälle:

1. Keine Schüler - Rückgabe T
2. Studenten, aber keine Zimmer - Rückkehr NIL
3. Studenten und Zimmer, aber größte Studentengruppe größer als der größte Raum - Rückgabe NIL

Python 2 , 71 67 64 Bytes

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

Probieren Sie es online!

Retina 0,8,2 , 50 Bytes

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

Probieren Sie es online! Link enthält Testsuite. Nimmt zwei Listen von Gruppen und Räumen auf (Testsuite wird ;als Listentrennzeichen verwendet). Erläuterung:

\d+
$*

In Unary konvertieren.

%O^`1+

Sortieren Sie jede Liste einzeln um.

%`$
,

Fügen Sie jeder Liste ein Komma hinzu.

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

Stellen Sie sicher, dass jede der Nummern in der ersten Liste mit der entsprechenden Nummer in der zweiten Liste übereinstimmt. Jedes Mal \3enthält die zuvor übereinstimmenden Räume und die nächste Gruppe muss \2daher in der Lage sein, in den nächsten Raum zu passen. Der (?>\3?)behandelt den Fall des ersten Raums, wenn noch keine vorherigen Räume vorhanden sind.

Kohle , 28 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erstellt eine Liste mit Listen von Räumen und Gruppen und gibt aus, -ob die Räume die Gruppen aufnehmen können. Erläuterung:

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

Wiederholen Sie diesen Vorgang, während eine Gruppe einem Raum zugewiesen werden kann.

ＵＭθΦκ⁻ν⌕κ⌈κ

Entfernen Sie den größten Raum und die größte Gruppe von ihren Listen.

¬⊟θ

Stellen Sie sicher, dass keine nicht zugewiesenen Gruppen mehr vorhanden sind.

JavaScript, 56 Bytes

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

Versuch es

Perl 6 , 34 Bytes

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

Probieren Sie es online!

Nimmt Eingaben als Liste von zwei Listen, den Gruppen und den Klassenzimmern, und gibt eine None Junction zurück, die auf true / false gesetzt werden kann.

Erläuterung:

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

Ruby , 57 Bytes

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

Probieren Sie es online!

Nimmt cfür Klassen, rfür Räume. Überprüft alle Permutationen von Räumen, anstatt sort zu verwenden, da die umgekehrte Sortierung zu viele Bytes kostet. Sieht aber trotzdem ziemlich lang aus ...

C # (Visual C # Interactive Compiler) , 105 93 91 82 81 79 77 76 74 Byte

Jetzt entspricht die Punktzahl von Dana!

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

Wirft einen Fehler, wenn er falsch ist, nichts, wenn er wahr ist.

-12 Bytes dank @Destrogio!

Probieren Sie es online!

Erläuterung

//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 Byte

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

Probieren Sie es online!

Mit einem kleinen hilfreichen Rat von Kevin Cruijssen und einem weiteren Blick auf meinen Code kann ich meine Punktzahl um ganze 9% senken, indem ich nur drei englische Wörter ersetze!

Java (OpenJDK 8) , 166 Byte

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

Probieren Sie es online!

PowerShell , 80 Byte

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

Probieren Sie es online!

Weniger Golf-Testskript:

$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 Bytes

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

Probieren Sie es online!