421 , Fransa ve diğer bazı Avrupa ülkelerinde oldukça popüler bir zar oyunudur. Bir sonraki içkiyi kimin alacağını belirlemek için çoğunlukla barlarda ve barlarda oynanır. Tam oyun genellikle iki turda oynanır, her oyuncunun kurtulmaya çalıştığı jetonlarla, ancak bu ilgisizdir. ( Fransızca Wikipedia sayfası .)

Oyun 3 standart küp zar ile oynanır.

Görev

Göreviniz , bu oyunun puanlama kurallarını uygulayarak, boş olmayan bir 3 zarlı rulo [X, Y, Z] listesini en yüksekten en düşüğe doğru sıralamaktır.

Temel puanlama

• 4,2,1 mümkün olan en yüksek kombinasyondur. Kurallara bağlı olarak 8, 10 veya 11 puan alabilir. Noktaları saymak yerine ruloları sıraladığımız için kesin değer önemli değil.
• Üç As: 1,1,1 en yüksek ikinci kombinasyon ve 7 puan alır.
• İki As: X, 1,1 (burada X , 2 ila 6'dır), X puanı alır.
• Türünün Üçü: X, X, X ( X'in 2 ila 6 olduğu) X puanı alır.
• Düzlükler: X, X + 1, X + 2 puan 2 puan.
• Diğer tüm atışlar 1 puan alır.

Yerleşim bağları

İki rulo aynı sayıda puan verdiğinde, aşağıdaki kurallar geçerlidir:

• İki As bir Tür Üçten daha iyidir. Örnek: 5,1,1 atım 5,5,5 .
• Türünün Üçlüsü 2,2,2 bir düzlükten daha iyidir. Örnek: 2,2,2 , 4,5,6'yı geçer .
• Düzlükler en düşükten en yükseğe doğru sıralanır. Örnek: 4,5,6 , 2,3,4 atım .
• Diğer tüm rulolar, zarları en yüksekten en düşüğe doğru sıralayarak çözülür. Örnek: 6,5,2 atım 6,4,3 . (Bu nedenle, oyundaki mümkün olan en düşük kombinasyon 2,2,1'dir .)

Aşağıda, en yüksekten en düşüğe doğru sıralanan 56 ayrı ayrı rulo bulunmaktadır:

421 111 611 666 511 555 411 444 311 333 211 222 654 543 432 321
665 664 663 662 661 655 653 652 651 644 643 642 641 633 632 631
622 621 554 553 552 551 544 542 541 533 532 531 522 521 443 442
441 433 431 422 332 331 322 221

Zorluk kuralları

• Böyle listelerin listesi olarak, herhangi bir makul biçimde rulo alabilir [[3,2,1],[4,2,1]], dizeleri listesi ["321","421"], tamsayılar listesi [321,421]Ancak, her kalıp bir değerle açıkça anlaşılır olması gerekir, vs 1'e kadar 6 .
• Her rulo için, zarların tutarlı olduğu sürece en düşükten en yükseğe veya en yüksekten en düşüğe doğru sıralandığını varsayabilirsiniz. Lütfen cevabınızda varsa hangi sırayı beklediğinizi belirtin.
• Bayt cinsinden en kısa cevap kazanır!

Test senaryoları

Zarları en yüksekten en düşüğe doğru dizilmiş dizelerin listelerini kullanma:

Girdiler

[ "321", "654" ]
[ "222", "321", "211" ]
[ "333", "311", "331", "111" ]
[ "111", "222", "333", "444" ]
[ "321", "421", "521", "621" ]
[ "422", "221", "442", "421", "222" ]
[ "222", "111", "421", "211", "651", "652", "543" ]

Beklenen çıktılar

[ "654", "321" ]
[ "211", "222", "321" ]
[ "111", "311", "333", "331" ]
[ "111", "444", "333", "222" ]
[ "421", "321", "621", "521" ]
[ "421", "222", "442", "422", "221" ]
[ "421", "111", "211", "222", "543", "652", "651" ]

Python , 93 bayt

lambda a:sorted(a,key=lambda x:(x!=421,x>111,-(x%100<12)*x-(x%111<1)*x*.9,(x%111==99)*-x,-x))

Çevrimiçi deneyin!

Retina 0.8.2 , 67 bayt

O$#^`(421|111)|(\d)((11)|\2\2)|(654|543|432|321)|\d{3}
$1$2$#4$#5$&

Çevrimiçi deneyin! Bağlantı, test senaryolarını içerir. Açıklama: Sayısal sıralama anahtarı aşağıdaki gibi oluşturulur:

421     42100421
111     11100111
611-211   610611-  210211
666-222   600666-  600222
654-321    01654-   01321
653-221    00653-   00221

Jöle ,  37  34 bayt

;Ø1,ẋ3$)Ẏṙ-;‘r’Ɗ€;œċ3$Ṇ63¦
6RṚÇiµÞ

(Her biri azalan şekilde sıralanan) zar atma listelerinin listesini kabul eden ve sıralanan sıraların azalan şekilde verildiği monadik bir bağlantı.

Çevrimiçi deneyin! Veya bir test takımına bakın ... veya sözlükbilimsel olarak sıralanan tüm ruloları deneyin

Nasıl?

Bu yöntem, her ruloyu Jelly'in ilk indeks atomunu kullanarak sıralamak için (geçersiz bir giriş rulosu) [4,2,1]ile değiştirerek en yüksekten en düşüğe * tüm ruloların bir listesini oluşturur .0i

* Liste ayrıca davranışı etkilemeyecek tekrarlar ve gereksiz girişler içerir:

[[1,1,1],[6,1,1],[6,6,6],[5,1,1],[5,5,5],[4,1,1],[4,4,4],[3,1,1],[3,3,3],[2,1,1],[2,2,2],[1,1,1],[7,6,5],[6,5,4],[5,4,3],[4,3,2],[3,2,1],[2,1,0],[6,6,6],[6,6,5],[6,6,4],[6,6,3],[6,6,2],[6,6,1],[6,5,5],[6,5,4],[6,5,3],[6,5,2],[6,5,1],[6,4,4],[6,4,3],[6,4,2],[6,4,1],[6,3,3],[6,3,2],[6,3,1],[6,2,2],[6,2,1],[6,1,1],[5,5,5],[5,5,4],[5,5,3],[5,5,2],[5,5,1],[5,4,4],[5,4,3],[5,4,2],[5,4,1],[5,3,3],[5,3,2],[5,3,1],[5,2,2],[5,2,1],[5,1,1],[4,4,4],[4,4,3],[4,4,2],[4,4,1],[4,3,3],[4,3,2],[4,3,1],[4,2,2],0,[4,1,1],[3,3,3],[3,3,2],[3,3,1],[3,2,2],[3,2,1],[3,1,1],[2,2,2],[2,2,1],[2,1,1],[1,1,1]]

;Ø1,ẋ3$)Ẏṙ-;‘r’Ɗ€;œċ3$Ṇ63¦ - Link 1, build rolls: descending pips, P  e.g. [6,5,4,3,2,1]
       )                   - for each:       e.g. X=5
 Ø1                        -   literal [1,1]
;                          -   concatenate        [5,1,1]
      $                    -   last two links as a monad (f(X)):
     3                     -     literal 3
    ẋ                      -     repeat           [5,5,5]
   ,                       -   pair               [[5,1,1],[5,5,5]]
        Ẏ                  - tighten (to a list of rolls rather than pairs of rolls)
          -                - literal -1
         ṙ                 - rotate left by (make rightmost [1,1,1] the leftmost entry)
               Ɗ€          - for €ach: last three links as a monad (f(X)):
            ‘              -   increment  -> X+1
              ’            -   decrement  -> X-1
             r             -   range      -> [X+1,X,X-1]
                           -   ...note: [7,6,5] and [2,1,0] are made but are redundant
           ;               - concatenate
                     $     - last two links as a monad (f(P)):
                    3      -   literal 3
                  œċ       -   combinations with replacement -> [[6,6,6],[6,6,5],...,[6,6,1],[6,5,5],...,[1,1,1]]
                 ;         - concatenate
                         ¦ - sparse application...
                       63  - ...to indices: 63
                      Ṇ    - ...what: NOT   -> replaces the [4,2,1] entry with a 0

6RṚÇiµÞ - Main Link: list of rolls
     µÞ - sort by the monadic link:
6       -   six
 R      -   range -> [1,2,3,4,5,6]
  Ṛ     -   reverse -> [6,5,4,3,2,1]
   Ç    -   call the last link as a monad -> [[1,1,1],[6,1,1],[6,6,6],[5,1,1],...]
    i   -   first index of (e.g.: [1,1,1]->1 or [6,1,1]->2 or [4,2,1]->0)

R , 73 bayt

(x=scan())[order(x!=421,x>111,-(x%%100<12)*x-(!x%%37)*x*.9,x%%37!=25,-x)]

Çevrimiçi deneyin!

• Stdin'den bir tamsayı listesi alarak ve bunları azalan sırada döndüren tam program (yani 421 ... 221)
• @Lynn cevabından kısmen esinlenerek başlatılan , şimdi temelde bunun bir kısmı ... yani @Lynn;
• Bölme kalan 2 bayt x % 37yerine kaydedildi111

Açıklama:

Her sayı için 5 anahtar hesaplanır ve diziyi sıralamak için hiyerarşik olarak kullanılır:

key1 = 0 if equal to 421, 1 otherwise
key2 = 0 if equal to 111, 1 otherwise
key3 = 0 
       - 1.0*x if number is x11 numbers (2 aces)
       - 0.9*x if number is xxx numbers (3 of a kind)
key4 = 0 if number is a straight, 1 otherwise
key5 = -x

Then the array is sorted by key1 first, then by key2 in case of tie and so on...

05AB1E , 76 48 45 bayt

421X3∍6LR©vy11«y3∍}®vy>y<ŸJ})D®3ãJsм)˜©IΣ®sk>

Bunun beklenenden çok daha uzun olduğu ortaya çıktı, ancak en azından uygulanması kolaydır. Daha iyi bir çözüm bulabilir miyim göreceksiniz .. Listeyi şimdi elle yaptım, ama yine de biraz uzun.

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

Açıklama:

421             # Push 421 to the stack
X3∍             # ('1' lengthened to size 3) Push 111 to the stack
6LR             # Take the range [6, 1]
   ©            # Save this range in the register so we can re-use it
   v    }       # Loop over this range:
    y11«        #  Merge '11' with the current number `y`, and push it to the stack
    y3∍         #  Lengthen the current number `y` to size 3, and push it to the stack
   ®v      }    # Load the range [6, 1] from the register, and loop over it again:
     y>y<Ÿ      #  Take the range [`y+1`, `y-1`]
          J     #  And join them together to single 3-digit numbers
)               # Push everything that's now on the stack to a single list
 D              # Duplicate this list
  ®             # Load the range [6, 1] from the register again
   3ã           # Take the cartesian repeated three times
     R          # Reverse this list
      J         # Join every inner list to a single 3-digit number
 s              # Swap, so the duplicate list of above is at the top of the stack again
  м             # And remove all those items from the cartesian list
   )            # Combine both lists (as list of lists)
    ˜           # Flatten it
     ©          # Store this full completed list (now equal to the challenge description,
                #  with some additional values we can ignore) in the register
I               # Take the input-list
 Σ              # Sort it by:
  ®             #  The list we generated above
   sk           #  Take the 0-indexed indices
     >          #  And increase it by 1 (because apparently 0 is placed at the back,
                #  so '421' would always be at the end)

Kodun ilk bölümünün oluşturduğu gerçek liste:

['421','111','611','666','511','555','411','444','311','333','211','222','111','111','765','654','543','432','321','210','','665','664','663','662','661','656','655','','653','652','651','646','645','644','643','642','641','636','635','634','633','632','631','626','625','624','623','622','621','616','615','614','613','612','','566','565','564','563','562','561','556','','554','553','552','551','546','545','544','','542','541','536','535','534','533','532','531','526','525','524','523','522','521','516','515','514','513','512','','466','465','464','463','462','461','456','455','454','453','452','451','446','445','','443','442','441','436','435','434','433','','431','426','425','424','423','422','','416','415','414','413','412','','366','365','364','363','362','361','356','355','354','353','352','351','346','345','344','343','342','341','336','335','334','','332','331','326','325','324','323','322','','316','315','314','313','312','','266','265','264','263','262','261','256','255','254','253','252','251','246','245','244','243','242','241','236','235','234','233','232','231','226','225','224','223','','221','216','215','214','213','212','','166','165','164','163','162','161','156','155','154','153','152','151','146','145','144','143','142','141','136','135','134','133','132','131','126','125','124','123','122','121','116','115','114','113','112','']

Çevrimiçi deneyin.

Gördüğünüz gibi boş öğeler içeriyor; 765veya gibi sayılar 210; ve aralıktaki sayılar [216, 112]. Ama bunları göz ardı edebiliriz, çünkü aslında sıralamak istediğimiz öğeler doğru sırada.

Orijinal 76 bayt çözümü:

Σ•X˜„Éε´õñ€9Ú ù?ä0₅9úd5àPÎøŒccuĆYÑ,o¾eíË¿¼À8@gID=vÆOΣxjF¨O‡J₃^εR™\èv•667вsk>

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın (test paketi yok, çünkü hala sıkıştırılmış sayılarla sıralamayı durdurmak için kapanma braketini görmeyen bir hata var ).

Açıklama:

Σ             # Sort by:
 •...•667в    #  The correctly sorted list of all possible rolls from the challenge
 sk           #  Take the 0-indexed indices
   >          #  And increase it by 1 (because apparently 0 is placed at the back,
              #  so '421' would always be at the end)

Açıklama •X˜„Éε´õñ€9Ú ù?ä0₅9úd5àPÎøŒccuĆYÑ,o¾eíË¿¼À8@gID=vÆOΣxjF¨O‡J₃^εR™\èv•667в:

İkisi arasındaki herşey •bir olduğunu sıkıştırılmış sayı aşağıdaki programla oluşturulur:

Z>β 255B

Çevrimiçi deneyin.

• Z>: Listenin maks. + 1'ini al ( 667bu durumda)
• β: Listeyi Base'den 667tek bir sayıya dönüştürün
• 255B: Ve bu tek sayıyı tabana dönüştürün 255(05AB1E kod sayfasını kullanarak), bu yüzden sıkıştırılmış numaramız var .

Bunu kullanarak 667вbu sıkıştırılmış sayıyı tekrar orijinal listeye dönüştürür.

JavaScript (ES7), 96 bayt

d=>d.sort((a,b,g=(n,[x,y,z]=n)=>n**=n-421?y*z-1?x-y|y-z?~y%x|~z%y?1:2:3:x-1?3.1:5:5)=>g(b)-g(a))

Puanlama kurallarına sıkı sıkıya bağlı kalarak ruloları sıralar. Tek tek rulolara sahip dizelerden oluşan bir dizi değerin azalan sırada olmasını bekler;["654"]

Çevrimiçi deneyin!

açıklama

Rulo kategorileri aşağıdaki üslere yükseltilir:

421                 5
Three Aces          5
Two Aces            3.1
Three-of-a-Kind     3
Straights           2
Other               1

Ungolfed

Koşullu kontrolleri zihinsel olarak açmak bana bir baş ağrısı veriyor ve bir şekilde daha fazla golf oynayabileceğinden eminim ....

var f =
d => d.sort(
    (
     a, b,
     g = (n, [x, y, z] = n) =>               // destructure rolls, e.g. "321" => ["3","2","1"]
        n **=                                // differentiate scores by raising to the exponent corresponding to its category in the table above
                                             // all conditionals check for a falsy value
            n - 421
                ? y * z - 1                  // ends with "11"
                    ? x - y | y - z          // three-of-a-kind
                        ? ~y % x | ~z % y    // straights, with operators chosen to correctly convert strings to numbers
                            ? 1
                            : 2
                        : 3
                    : x - 1                  // three aces
                        ? 3.1
                        : 5
                : 5
    ) =>
    g(b) - g(a)
)

Javascript, 101 karakter, 116 bayt (UTF-8)

a=>(r=d=>(i="ƥoɣʚǿȫƛƼķōÓÞʎȟưŁ".indexOf(String.fromCharCode(d)),i<0?700-d:i),a.sort((a,b)=>r(a)-r(b)))

Ruloları temsil eden bir sayı dizisi alır [ 321, 654 ].

Çevrimiçi deneyin!

Açıklama:

Ben 56 olası farklı rulo (gerçekten herhangi sipariş uymayan olanlar) ilk 16 aldı ve bir dize olarak onları kodlanmış: "ƥoɣʚǿȫƛƼķōÓÞʎȟưŁ". Bu dizenin her karakteri ilk 16 olası ruloya karşılık gelir ( ƥis 421, ois 111, ...). Şimdi her iki eleman ave bdizi için dizinlerini dizeden kontrol ediyoruz, eğer dahil edilmişlerse dizin kullanılır, aksi takdirde (dizin -1) rulo numarasının kendisini kullanırız (dizinin 700sırasını tersine çevirmek için dahil olmayanlar, yani azalan sırada sıralamak için).

Temiz , 169102 bayt

Temiz derleyici onları bu şekilde mutlu edecekleri için tüm sekizlik kaçışlar bir bayt olarak sayılır, ancak TIO ve SE iyi biçimlendirilmemiş UTF-8 olmadıkları için olmaz.

import StdEnv
$l=[e\\c<-:"\245\157\143\232\377\53\233\274\67\115\323\336\216\37\260\101\231\230\227\226\225\217\215\214\213\204\203\202\201\171\170\167\156\155\52\51\50\47\40\36\35\25\24\23\n\11\273\272\271\261\257\246\114\113\102\335",e<-l|c==toChar e]

Çevrimiçi deneyin!

Modulo 256 tamsayıları olarak tüm zarların benzersiz olduğu gerçeğini kullanır.
Uygun olarak, Char(çoğunlukla) bir modulo 256 tamsayısı olarak işlem görür.

Pyth , 48 bayt

oxs[]j421T]j7 2_sm+Ld,,ddjT9tS6_m_+LdS3 4.C_S6 3

Girdi, her öğenin azalan sıraya göre iç içe dizisi olarak olmasını bekler. Buradan çevrimiçi olarak deneyin veya tüm test senaryolarını burada bir kerede doğrulayın .

oxs[]j421T]j7 2_sm+Ld,,ddjT9tS6_m_+LdS3 4.C_S6 3)NQ   Final 3 tokens inferred from context
                                                      Implicit: Q=eval(input()), T=10
    ]j421T                                            Convert 421 to base 10, wrap in array -> [[4,2,1]]
          ]j7 2                                       Convert 7 to base 2, wrap in array -> [[1,1,1]]
                 m          tS6                       Map d in [2,3,4,5,6] using:
                      ,dd                               [d,d]
                         jT9                            Convert 10 to base 9 -> [1,1]
                  +Ld,                                  Prepend d to each of the above
               _s                                     Flatten and reverse -> [[6,1,1],[6,6,6]...[2,2,2]]
                                m       4             Map d in [0,1,2,3] using:
                                  +LdS3                 [d+1,d+2,d+3]
                                 _                      Reverse the above
                               _                      Reverse the result -> [[6,5,4]...[3,2,1]]
                                           _S6        [6,5,4,3,2,1]
                                         .C    3      All 3-element combinations of the above, respecting order
  s[                                            )     Wrap the 5 previous sections in an array, concatenate
ox                                               NQ   Order Q using each element's index in the above list

05AB1E , 24 bayt

Σ5βËyθyP‚yнÃ6βyË_y¥PΘy)(

Çevrimiçi deneyin!

Genel algoritma:

Σ          )( # sort by the following, in decreasing priority:
 5βË          # 1 for 421, 0 otherwise
 yθyP‚yнÃ6β   # 7 for 111, X for XXX and X11, 0 otherwise
 yË_          # 0 for XXX, 1 otherwise
 y¥PΘ         # 1 for sequences, 0 otherwise
 y            # the roll itself

Detaylar:

5β          # parse the roll as a base-5 number
  Ë         # are all digits equal? (base-5 421 is 111)

yθ          # last die (equal to the 1st die iff we have XXX)
  yP        # product of dice (equal to the 1st die iff we have X11)
    ‚       # wrap the two in an array
     yнà    # keep only those that are equal to the 1st die
        6β  # parse as a base-6 number (111 -> [1, 1] -> 7)

yË          # are all dice equal?
  _         # boolean negation

y¥          # deltas ([a, b, c] -> [b - a, c - b])
  P         # product
   Θ        # 1 if it's equal to 1, 0 otherwise