^{Défi relevé avec la permission de mon concours University Code Challenge}

Depuis quelques années, le nombre d'élèves de mon école augmente régulièrement. D'abord, le nombre d'élèves a été augmenté par classe, mais il a ensuite fallu convertir des espaces pour que certains groupes y donnent des cours, comme les tribunes du gymnase ou, ce dernier cours, jusqu'à la salle des balais.

L'année dernière, les autorités académiques ont obtenu le budget pour construire un nouveau bâtiment et ont commencé les travaux. Enfin, ils ont terminé et le nouveau bâtiment peut déjà être utilisé, nous pouvons donc déménager (l'ancien bâtiment sera réhabilité et sera utilisé pour une autre fonction), mais il nous a rattrapés à mi-parcours. Le directeur veut savoir si le déménagement sera possible sans scinder ou rejoindre des groupes, ou que certains élèves doivent changer de groupe.

Défi

Compte tenu du nombre d'élèves des groupes actuels et des nouvelles salles de classe (capacité), affichez une valeur vraie s'il est possible d'affecter une classe différente, avec une capacité suffisante, à chacun des groupes actuels, ou une valeur de falsey sinon.

Cas de test

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

Remarques

• Vous pouvez prendre l'entrée dans n'importe quel format raisonnable
• Vous pouvez produire une valeur Truthy / Falsey ( 1/0, True/False, etc ...)
• code-golf

Brachylog , 4 octets

C'est toujours agréable de voir un défi et de savoir que le brachylog va battre tout le monde. Prend les classes actuelles en entrée et les nouvelles salles de classe en sortie; Il affichera vrai s'il trouve un moyen de s'adapter aux étudiants, faux sinon

p≤ᵐ⊆

Explication

Le code comporte 3 parties dont la commande n'a en fait aucune importance

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

Essayez-le en ligne!

Pyth, 11 octets

.AgM.t_DMQ0

Prend la contribution sous forme de liste de listes, la taille des classes d'abord, la taille des groupes ensuite. Essayez-le en ligne ici ou vérifiez tous les cas de test en même temps ici .

.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

Gelée , 9 octets

Prend les salles de classe comme premier argument et les groupes comme deuxième argument.

Œ!~+Ṡ‘ḌẠ¬

Essayez-le en ligne!

Commenté

NB: C'est Ṡ‘ḌẠ¬beaucoup trop long. Mais je soupçonne que ce n'est pas la bonne approche de toute façon.

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

ñÍí§Vñn)e

Essayez-le ou exécutez tous les cas de test sur 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

Essayez-le ou exécutez tous les cas de test sur 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 octets

Sorties par code de sortie, échoue pour une entrée fausse.

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

Essayez-le en ligne!

MATL , 10 octets

yn&Y@>~!Aa

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

Tenez compte des entrées [20, 10, 30], à [20, 20, 50, 40]titre d'exemple. La pile est représentée de bas en haut.

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 octets

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

Essayez-le en ligne!

05AB1E , 14 12 8 octets

€{í0ζÆdP

Port de @Sok réponse Pyth s » , alors assurez - vous de lui Upvote aussi bien!

Prend l'entrée comme une liste de listes, avec la liste de classe comme premier élément et la liste de groupe comme deuxième élément.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

Ancienne réponse de 12 octets:

æε{I{0ζÆdP}à

Prend d'abord la liste des classes, puis la liste des groupes.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

æ             # 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 octets

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

Essayez-le en ligne!

Code commenté:

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

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

Essayez-le en ligne!

Outils Bash + GNU, 68 octets

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

69 octets

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

TIO

prend les chambres d'étudiant comme premier et deuxième argument sous forme de numéros de chaîne délimités par un retour à la ligne renvoie l'état de sortie 1 pour vrai ou 0 pour faux

Perl 5 -pal , 67 62 octets

@NahuelFouilleul a économisé 5 octets avec un réarrangement et un grep

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

Essayez-le en ligne!

Version 67 octets

Prend la liste des tailles de classe séparées par des espaces sur la première ligne et la liste des tailles des salles séparées par des espaces sur la suivante.

Lisp commun, 74 octets

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

Non minifié

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

Essaye-le

Notez que le tri mute définitivement la liste et pop redéfinit la variable sur l'élément suivant.

En effet, cela vérifie simplement récursivement que le plus grand groupe d'étudiants peut tenir dans la plus grande salle. Il existe 3 cas de base:

1. Aucun élève - retour T
2. Étudiants, mais pas de chambres - retour nul
3. Étudiants et chambres, mais le plus grand groupe d'étudiants est plus grand que la plus grande salle - retour NÉANT

Python 2 , 71 67 64 octets

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

Essayez-le en ligne!

Rétine 0.8.2 , 50 octets

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

Essayez-le en ligne!Le lien inclut une suite de tests. Prend deux listes de groupes et de salles (la suite de tests utilise ;comme séparateur de liste). Explication:

\d+
$*

Convertissez en unaire.

%O^`1+

Tri inversé de chaque liste séparément.

%`$
,

Ajoutez une virgule à chaque liste.

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

Vérifiez que chacun des numéros de la première liste peut correspondre au numéro approprié de la deuxième liste. Chaque fois \3contient les pièces précédemment appariées et le groupe suivant \2doit donc pouvoir s'insérer dans la pièce suivante. Le (?>\3?)gère le boîtier de la première chambre lorsqu'il n'y a pas encore de chambres précédentes.

charbon , 28 octets

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

Essayez-le en ligne!Le lien est vers la version détaillée du code. Prend une liste de listes de salles et de groupes et de sorties -si les salles peuvent accueillir les groupes. Explication:

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

Répétez pendant qu'un groupe peut être affecté à une pièce.

ＵＭθΦκ⁻ν⌕κ⌈κ

Supprimez la plus grande salle et le plus grand groupe de leurs listes.

¬⊟θ

Vérifiez qu'il ne reste aucun groupe non alloué.

JavaScript, 56 octets

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

Essayez-le

Perl 6 , 34 octets

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

Essayez-le en ligne!

Prend l'entrée sous la forme d'une liste de deux listes, les groupes et les salles de classe, et renvoie une jonction None qui peut être booléifiée à true / false.

Explication:

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

Rubis , 57 octets

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

Essayez-le en ligne!

Prend cpour les cours, rpour les chambres. Vérifie toutes les permutations des pièces au lieu d'utiliser le tri, car le tri inverse coûte trop d'octets. Cela semble quand même assez long ...

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

Correspond maintenant au score de dana!

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

Lance une erreur si faux, rien si vrai.

-12 octets grâce à @Destrogio!

Essayez-le en ligne!

Explication

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

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

Essayez-le en ligne!

Avec un petit conseil utile de Kevin Cruijssen et simplement un autre coup d'œil sur mon code moi-même, je peux diminuer mon score de 9% en remplaçant simplement trois mots anglais!

Java (OpenJDK 8) , 166 octets

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

Essayez-le en ligne!

PowerShell , 80 octets

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

Essayez-le en ligne!

Script de test moins golfé:

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

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

Essayez-le en ligne!