^{Üniversite Kodları Yarışması Yarışmamın izniyle alınan meydan okuma}

Birkaç yıldır okulumdaki öğrenci sayısı giderek artıyor. Öncelikle, öğrenci sayısı sınıfta arttırıldı, ancak daha sonra bazı grupların spor salonları gibi veya bu son kursta süpürge odasına kadar ders vermek için bazı alanların dönüştürülmesi gerekiyordu.

Geçen yıl akademik otoriteler yeni bir bina inşa etmek için bütçeye ulaştılar ve çalışmaya başladılar. Sonunda bittiler ve yeni bina zaten kullanılabiliyordu, bu yüzden hareket edebiliriz (eski bina rehabilite edilecek ve başka bir işlev için kullanılacaktır), ancak bizi kursun tam ortasında tuttu. Yönetmen, hareketin gruplara ayrılmadan veya katılmadan mümkün olup olmayacağını veya bazı öğrencilerin grupları değiştirmek zorunda olup olmadığını bilmek istiyor.

Meydan okuma

Mevcut grupların ve yeni sınıfların (kapasitenin) öğrenci sayısı göz önüne alındığında, mevcut grupların her birine yeterli kapasiteye sahip farklı bir sınıf veya mümkünse bir falsey değeri atamak mümkün ise bir hakikat değeri çıkarır.

Test Kılıfları

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

notlar

• Girişi herhangi bir makul formatta alabilirsiniz
• Çıktısını alabilirsiniz herhangi Truthy / Falsey değeri ( 1/0, True/Falsevb ...)
• kod golf

Brachylog , 4 bayt

Bir meydan okuma görmek ve brakilogun herkesi yeneceğini bilmek her zaman güzeldir. Mevcut sınıfları girdi, yeni sınıfları çıktı olarak alır; Öğrencilere uyacak bir yol bulursa doğru çıkacaktır, aksi takdirde yanlış

p≤ᵐ⊆

açıklama

Kod, siparişin gerçekten önemli olmadığı 3 bölümden oluşmaktadır.

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

Çevrimiçi deneyin!

Pyth, 11 bayt

.AgM.t_DMQ0

Listelerin bir listesi olarak giriş yapar, önce sınıf boyutları, ikinci grup boyutları. Online Deneyin burada ya bir kerede tüm test durumları doğrulamak burada .

.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

Jöle , 9 bayt

Sınıfları birinci argüman ve grupları ikinci argüman olarak alır.

Œ!~+Ṡ‘ḌẠ¬

Çevrimiçi deneyin!

Yorumlananlar

Not: Bu Ṡ‘ḌẠ¬çok uzun. Ancak bunun yine de doğru bir yaklaşım olmadığını düşünüyorum.

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

ñÍí§Vñn)e

Deneyin veya tüm test durumlarını TIO'da çalıştırın

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

Deneyin veya tüm test durumlarını TIO'da çalıştırın

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

Çıkış koduna göre çıkışlar, sahte giriş için başarısız.

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

Çevrimiçi deneyin!

MATL , 10 bayt

yn&Y@>~!Aa

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

açıklama

Giriş göz önünde [20, 10, 30], [20, 20, 50, 40]bir örnek olarak. Yığın alttan üste gösterilir.

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 bayt

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

Çevrimiçi deneyin!

05AB1E , 14 12 8 bayt

€{í0ζÆdP

Port @Sok 'ın Pyth cevap , çok emin onu da upvote olun!

Girdiyi bir liste olarak alır, sınıf listesi birinci madde ve grup listesi ikinci öğe olarak alır.

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

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

Eski 12 baytlık cevap:

æε{I{0ζÆdP}à

Önce sınıf listesini, ardından grup listesini alır.

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

æ             # 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 # Etkileşimli Derleyici) , 77 74 bayt

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

Çevrimiçi deneyin!

Yorumlanan kod:

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

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

Çevrimiçi deneyin!

Bash + GNU araçları, 68 bayt

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

69 bayt

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

TIO

öğrenci odalarını newline ile sınırlandırılmış string sayıları olarak birinci ve ikinci argüman olarak alır, true için 1, status false için 0 döndürür.

Perl 5 -pal , 67 62 bayt

@NahuelFouilleul, yeniden düzenleme ve grep ile 5 bayt kurtardı

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

Çevrimiçi deneyin!

67 bayt sürümü

Birinci satırdaki boşlukla ayrılmış sınıf boyutlarının listesini ve sonraki satırdaki boşlukla ayrılmış oda boyutlarının listesini alır.

Ortak Lisp, 74 bayt

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

Sigara minified

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

Dene

Sıralamanın listeyi kalıcı olarak değiştirdiğini ve pop'un değişkeni bir sonraki öğeye yeniden bağladığını unutmayın.

Aslında bu, tekrarlı bir şekilde, en büyük öğrenci grubunun en büyük odaya sığabileceğini kontrol eder. 3 temel durum vardır:

1. Öğrenci yok - T dönüş
2. Öğrenciler ama oda yok - NIL’e geri dönün
3. Öğrenciler ve odalar, ancak en büyük odalardan daha büyük öğrenci grupları - dönüş NIL

Python 2 , 71 67 64 bayt

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

Çevrimiçi deneyin!

Retina 0.8.2 , 50 bayt

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

Çevrimiçi deneyin! Bağlantı test paketi içerir. İki grup ve oda ;listesini alır (test takımı liste ayırıcı olarak kullanır ). Açıklama:

\d+
$*

Birliğe dönüştür.

%O^`1+

Her listeyi ayrı ayrı sıralayın.

%`$
,

Her listeye virgül ekleyin.

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

İlk listedeki numaraların her birinin ikinci listedeki uygun numara ile eşleştirilebildiğini kontrol edin. Her seferinde \3önceden eşleşen odaları içerir ve bir sonraki grubun bir \2sonraki odaya sığması gerekir. Daha (?>\3?)önce hiç oda bulunmadığı zaman ilk odadaki durumu ele alır.

Mangal kömürü , 28 bayt

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

Çevrimiçi deneyin!Bağlantı, kodun ayrıntılı bir versiyonudur. Odalar gruplara -uygunsa, oda ve grup listelerini ve çıktılarını listeler . Açıklama:

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

Bir grup bir odaya atanırken tekrarlayın.

ＵＭθΦκ⁻ν⌕κ⌈κ

En büyük odayı ve grubu listelerinden çıkarın.

¬⊟θ

Ayrılmamış grup kalmadığını kontrol edin.

JavaScript, 56 bayt

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

Dene

Perl 6 , 34 bayt

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

Çevrimiçi deneyin!

İki listenin, grupların ve sınıfların bir listesi olarak girdi alır ve doğru / yanlış değerine yükseltilebilecek bir Yok Kavşağı döndürür.

Açıklama:

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

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

Çevrimiçi deneyin!

Alır c, sınıflar için rodalar için. Sıralama kullanmak yerine odaların tüm izinlerini kontrol eder, çünkü ters sıralama çok fazla bayt tutar. Yine de oldukça uzun görünüyor ...

C # (Visual C # Etkileşimli Derleyici) , 105 93 91 82 81 79 77 76 74 bayt

Şimdi dana'nın skoruyla eşleşiyor!

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

Yanlış ise yanlış atar, doğru değilse hiçbir şey alamaz.

@Destrogio sayesinde -12 bayt!

Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin!

Kevin Cruijssen'in küçük bir tavsiyesi ve kodumla ilgili başka bir bakışta, sadece üç İngilizce kelimeyi değiştirerek puanımı% 9 azaltabilirim!

Java (OpenJDK 8) , 166 bayt

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

Çevrimiçi deneyin!

PowerShell , 80 bayt

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

Çevrimiçi deneyin!

Daha az golf oynadığı test senaryosu:

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

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

Çevrimiçi deneyin!