^{La sfida è stata presa con il permesso del mio concorso per la sfida del codice universitario}

Da alcuni anni, il numero di studenti nella mia scuola è cresciuto costantemente. Innanzitutto il numero di studenti è stato aumentato in classe, ma poi è stato necessario convertire alcuni spazi per alcuni gruppi per tenere lezioni lì, come i supporti della palestra o, quest'ultimo corso, fino alla stanza della scopa.

L'anno scorso le autorità accademiche hanno ottenuto il budget per costruire un nuovo edificio e hanno iniziato i lavori. Finalmente hanno terminato e il nuovo edificio può essere già utilizzato, così possiamo spostarci (il vecchio edificio verrà riabilitato e verrà utilizzato per un'altra funzione), ma ci ha sorpreso a metà del percorso. Il regista vuole sapere se la mossa sarà possibile senza dividere o unire i gruppi o che alcuni studenti devono cambiare gruppo.

Sfida

Data la quantità di studenti dei gruppi attuali e delle nuove classi (capacità), genera un valore di verità se è possibile assegnare una classe diversa, con capacità sufficiente, a ciascuno dei gruppi attuali o un valore di falsa in caso contrario.

Casi 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

Gli appunti

• Puoi prendere l'input in qualsiasi formato ragionevole
• È possibile inviare qualsiasi valore Truthy / Falsey ( 1/0, True/False, ecc ...)
• code-golf

Brachylog , 4 byte

È sempre bello vedere una sfida e sapere che brachylog batterà tutti. Prende le classi correnti come input e le nuove aule come output; Produrrà vero se trova un modo per adattarsi agli studenti, falso altrimenti

p≤ᵐ⊆

Spiegazione

Il codice ha 3 parti delle quali l'ordine non ha importanza

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

Provalo online!

Pyth, 11 byte

.AgM.t_DMQ0

Prende l'input come un elenco di elenchi, prima le dimensioni dell'aula e le seconde del gruppo. Provalo online qui o verifica tutti i casi di test contemporaneamente qui .

.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

Gelatina , 9 byte

Prende le aule come primo argomento e i gruppi come secondo argomento.

Œ!~+Ṡ‘ḌẠ¬

Provalo online!

Commentate

NB: Ṡ‘ḌẠ¬è troppo lungo. Ma sospetto che questo non sia comunque l'approccio giusto.

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

ñÍí§Vñn)e

Provalo o esegui tutti i casi di test su 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

Provalo o esegui tutti i casi di test su 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 byte

Uscite per codice di uscita, errore per input errato.

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

Provalo online!

MATL , 10 byte

yn&Y@>~!Aa

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

Considera gli input [20, 10, 30], [20, 20, 50, 40]come esempio. Stack è mostrato dal basso verso l'alto.

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 byte

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

Provalo online!

05AB1E , 14 12 8 byte

€{í0ζÆdP

Porto di @Sok Pyth risposta s' , quindi assicuratevi di lui upvote, come pure!

Prende l'input come un elenco di elenchi, con l'elenco delle classi come primo elemento e l'elenco dei gruppi come secondo elemento.

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Vecchia risposta a 12 byte:

æε{I{0ζÆdP}à

Prende prima l'elenco delle classi, quindi l'elenco dei gruppi.

Provalo online o verifica tutti i casi di test .

Spiegazione:

æ             # 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 # (compilatore interattivo Visual C #) , 77 74 byte

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

Provalo online!

Codice commentato:

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

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

Provalo online!

Strumenti Bash + GNU, 68 byte

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

69 byte

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

TIO

prende le stanze degli studenti come primo e secondo argomento come numeri di stringa delimitati da newline restituisce lo stato di uscita 1 per vero o 0 per falso

Perl 5 -pal , 67 62 byte

@NahuelFouilleul ha salvato 5 byte con un riarrangiamento e un grep

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

Provalo online!

Versione 67 byte

Accetta l'elenco delle dimensioni delle classi separato da spazi nella prima riga e l'elenco delle dimensioni delle camere separate da spazi nella successiva.

Lisp comune, 74 byte

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

Non-minified

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

Provalo

Nota che l'ordinamento muta in modo permanente l'elenco e pop associa la variabile all'elemento successivo.

In effetti, questo controlla in modo ricorsivo che il gruppo di studenti più grande possa stare nella stanza più grande. Ci sono 3 casi base:

1. Nessuno studente - ritorna T
2. Studenti, ma niente camere - ritorno NIL
3. Studenti e stanze, ma il più grande gruppo di studenti più grande della stanza più grande - ritorno NIL

Python 2 , 71 67 64 byte

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

Provalo online!

Retina 0.8.2 , 50 byte

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

Provalo online! Il link include la suite di test. Accetta due elenchi di gruppi e stanze (la suite di test utilizza ;come separatore di elenchi). Spiegazione:

\d+
$*

Converti in unario.

%O^`1+

Ordinamento inverso ogni elenco separatamente.

%`$
,

Aggiungi una virgola a ciascun elenco.

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

Verificare che ciascuno dei numeri nel primo elenco possa essere abbinato al numero appropriato nel secondo elenco. Ogni volta \3contiene le stanze precedentemente abbinate e il gruppo successivo \2deve quindi essere in grado di adattarsi alla stanza successiva. I (?>\3?)gestisce il caso della prima stanza quando non ci sono ancora camere precedenti.

Carbone , 28 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Prende un elenco di elenchi di sale e gruppi e di output -se le sale possono ospitare i gruppi. Spiegazione:

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

Ripeti mentre un gruppo può essere assegnato a una stanza.

ＵＭθΦκ⁻ν⌕κ⌈κ

Rimuovi la stanza e il gruppo più grandi dalle loro liste.

¬⊟θ

Verificare che non vi siano gruppi non allocati rimanenti.

JavaScript, 56 byte

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

Provalo

Perl 6 , 34 byte

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

Provalo online!

Prende l'input come un elenco di due elenchi, i gruppi e le classi e restituisce una giunzione None che può essere boolificata su true / false.

Spiegazione:

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

Rubino , 57 byte

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

Provalo online!

Prende cper le lezioni, rper le stanze. Controlla tutte le permutazioni delle stanze invece di utilizzare l'ordinamento, poiché l'ordinamento inverso costa troppi byte. Sembra ancora piuttosto lungo però ...

C # (compilatore interattivo Visual C #) , 105 93 91 82 81 79 77 76 74 byte

Ora corrisponde al punteggio di dana!

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

Genera un errore se falso, niente se vero.

-12 byte grazie a @Destrogio!

Provalo online!

Spiegazione

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

Provalo online!

Con un piccolo consiglio utile di Kevin Cruijssen e semplicemente un'altra occhiata al mio codice, posso ridurre il mio punteggio di un intero 9% semplicemente sostituendo tre parole inglesi!

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

Provalo online!

PowerShell , 80 byte

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

Provalo online!

Script di test meno golfato:

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

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

Provalo online!