मैं इस समस्या में भाग गया, जबकि इस साइट के लिए एक और चुनौती पर काम कर रहा हूं। उस चुनौती में मैं " मारियो कार्ट 8 स्कोरिंग " का उपयोग करता हूं । खिलाड़ी को k वें स्थान पर जितने अंक मिलते हैं, उसे इस 1-अनुक्रमित सरणी द्वारा दर्शाया जाता है: [15,12,10,9,8,7,6,5,4,3,2,1]। तो 1 स्थान को 15 अंक मिलते हैं, दूसरे स्थान को 12 अंक मिलते हैं, आदि।

इस तरह से अंक निर्दिष्ट करना काफी आसान है, हालांकि मुश्किल हिस्सा यह आता है कि मैं कैसे संबंधों को संभालता हूं। मैं जो कुछ करता हूं वह प्रत्येक बांधने वाले खिलाड़ी को प्रत्येक बांधने की जगह के लिए दिए गए अंकों का औसत देता है। उदाहरण के लिए, यदि केवल 1 और 2 को बांधा जाता है, तो दोनों खिलाड़ियों को (15 + 12) / 2 = 13.5 अंक मिलते हैं। (ध्यान दें: आपको निकटतम इंट में प्रवेश करने की अनुमति है, इसलिए 13 या 14 दोनों भी स्वीकार्य हैं।) फिर 3 - 12 वें स्थान पर अपनी स्थिति के लिए सामान्य राशि प्राप्त करें।

चुनौती

12 गैर-नकारात्मक पूर्णांक स्कोर जो कि क्रमिक रूप से क्रमबद्ध हैं, को देखते हुए प्रत्येक खिलाड़ी को प्राप्त अंकों की संख्या को आउटपुट करता है। आप इनपुट के रूप में अंक सूची [15,12,10,9, ...] भी ले सकते हैं। ध्यान दें कि प्रत्येक खिलाड़ी को जितने अंक मिलते हैं, वह अंकों के वास्तविक मूल्यों पर निर्भर नहीं करता है, लेकिन वे अन्य अंकों की तुलना कैसे करते हैं।

परीक्षण के मामलों

[21,21,15,14,12,9,6,5,4,3,2,1] => [ 14,14 , 10,9,8,7,6,5,4,3,2, 1]
[20,15,15,15,10,9,8,7,6,5,4,3,3] => [15, 10,10,10 , 8,7,6,5,4,3,2, 1]
- स्पष्टीकरण: (१२ + १० + ९) / ३ = १०.३३३३
[1,1,1,1,1,1,1,1,1,1,1,1] => [ 7,7,7,7,7,7,7,7,7,7,7, 7 ]
- स्पष्टीकरण: (१५ + १२ + १० + ९ + + + + + ६ + ५ + ४ + ३ + २ + १) / १२- +.९ ४. 12३
[20,20,20,20,10,10,10,9,8,7,6,5] => [ 12,12,12,12 , 7,7,7 , 5,4,3,2 1]
- स्पष्टीकरण: (१५ + १२ + १० + ९) / ४ = ११.५, (+ +) + ६) / ३ = 12
[100,99,98,95,95,95,94,93,93,92,91,91] => [[15,12,10, 8,8,8 , 6, 5,5 , 3, 2, 2 2 ]
- स्पष्टीकरण: (९ + 7 + /) / ३ = 8, (५ + ४) / २ = ४.५, (२ + १) / २ / १-१

संबंधित: "स्कीप" के साथ स्कोर की एक सूची रैंक करें

code-golf array-manipulation

— geokavel
स्रोत

5

जावास्क्रिप्ट (ईएस 6), 57 बाइट्स

करी सिंटैक्स में इनपुट लेता है (p)(s), जहां p अंकों की सूची है और s स्कोर की सूची है।

p=>s=>s.map(v=>s.reduce((t,x,i)=>x-v?t:t+p[n++,i],n=0)/n)

परीक्षण के मामलों

कोड स्निपेट दिखाएं

let f =

p=>s=>s.map(v=>s.reduce((t,x,i)=>x-v?t:t+p[n++,i],n=0)/n)

points = [15,12,10,9,8,7,6,5,4,3,2,1];

console.log(JSON.stringify(f(points)([21,21,15,14,12,9,6,5,4,3,2,1])))
console.log(JSON.stringify(f(points)([20,15,15,15,10,9,8,7,6,5,4,3])))
console.log(JSON.stringify(f(points)([1,1,1,1,1,1,1,1,1,1,1,1])))
console.log(JSON.stringify(f(points)([20,20,20,20,10,10,10,9,8,7,6,5])))
console.log(JSON.stringify(f(points)([100,99,98,95,95,95,94,93,93,92,91,91])))

Expand snippet

— Arnauld
स्रोत

5

आर , 3 बाइट्स

जाहिर तौर पर आर में इसके लिए बिल्ट-इन है। इनपुट के रूप में pअंक और sकोर की एक सूची लेता है ।

ave

इसे ऑनलाइन आज़माएं!

उदाहरण:

p=c(15,12,10,9,8,7,6,5,4,3,2,1)

> ave(p,c(20,15,15,15,10,9,8,7,6,5,4,3))
 [1] 15.00000 10.33333 10.33333 10.33333  8.00000  7.00000  6.00000  5.00000  4.00000  3.00000  2.00000  1.00000
> ave(p,c(1,1,1,1,1,1,1,1,1,1,1,1))
 [1] 6.833333 6.833333 6.833333 6.833333 6.833333 6.833333 6.833333 6.833333 6.833333 6.833333 6.833333 6.833333

— बीएलटी
स्रोत

नौकरी के लिए सही उपकरण!

— जिओवेल

5

यह 3 बाइट्स (सिर्फ ave) होना चाहिए अन्यथा यह सिर्फ एक स्निपेट है (जिसकी अनुमति नहीं है)। सौभाग्य से, यह आपको 5 बाइट्स बचाता है।

— caird coinheringaahing

@ धन्यवाद, आप बिलकुल सही कह रहे हैं।

— बीएलटी

4

पर्ल 5 , 109 +1 (-ए) = 110 बाइट्स

@p=(1..10,12,15);while(@F){$/=$,=0;do{$,++;$/+=pop@p}while($w=shift@F)==$F[0];push@r,(int.5+$//$,)x$,}say"@r"

इसे ऑनलाइन आज़माएं!

बिंदु मानों को हार्डकोड करने के लिए 17 बाइट्स शामिल हैं।

— Xcali
स्रोत

4

MATL , 12 10 बाइट्स

2 बाइट्स @geokavel की बदौलत !

7#uti2XQw)

इनपुट ;पूर्णांक स्कोर के एक स्तंभ वेक्टर ( विभाजक के रूप में) और अंकों के साथ एक स्तंभ वेक्टर हैं। आउटपुट में newlines द्वारा अलग किए गए परिणाम होते हैं।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

       % Implicitly take first input. 
       % STACK: [21;21;15;14;12;9;6;5;4;3;2;1]
7#u    % Unique consecutive integer labels
       % STACK: [1;1;2;3;4;5;6;7;8;9;10;11]
t      % Duplicate
       % STACK: [1;1;2;3;4;5;6;7;8;9;10;11], [1;1;2;3;4;5;6;7;8;9;10;11]
i      % Take second input
       % STACK: [1;1;2;3;4;5;6;7;8;9;10;11], [1;1;2;3;4;5;6;7;8;9;10;11], [15;12;10;9;8;7;6;5;4;3;2;1]
2XQ    % Average second argument as grouped by the first
       % STACK: [1;1;2;3;4;5;6;7;8;9;10;11], [13.5;10;9;8;7;6;5;4;3;2;1]
w      % Swap
       % STACK: [[13.5;10;9;8;7;6;5;4;3;2;1], [1;1;2;3;4;5;6;7;8;9;10;11]
)      % Reference indexing
       % STACK: [13.5;10;9;8;7;6;5;4;3;2;1]
       % Implicitly display

— लुइस मेंडो
स्रोत

Nics समाधान! मुझे लगता है कि आप कुछ बाइट्स को निकटतम int (पूर्णांक की आवश्यकता नहीं) के लिए नहीं बचा सकते हैं।

— geokavel

@geokavel ओह, तुम सही हो! राउंडिंग की आवश्यकता के रूप में मैंने चुनौती को गलत बताया। धन्यवाद!

— लुइस मेंडो

3

05AB1E , 12 बाइट्स

γ€g£vygFyÅAˆ

इसे ऑनलाइन आज़माएं!

व्याख्या

γ              # group the scores into chunks of consecutive equal elements
 €g            # get the length of each chunk
   £           # split the points list into chunks of these sizes
    v          # for each chunk y in the points list
     ygF       # len(y) times do:
        yÅA    # get the arithmetic mean of y
           ˆ   # add to global list
               # implicitly output global list

— Emigna
स्रोत

2

सी # (.NET कोर) , 154 बाइट्स

x=>s=>{for(int i=0;i<12;){int b=0,j=i,a=0,c=0;for(;j<12&&x[i]==x[j];j++,b++){a+=s[j];}a=(int)Math.Round(a/(b+.0));for(;c<b;c++){x[i+c]=a;}i+=b;}return x;}

इसे ऑनलाइन आज़माएं!

सी # (.NET कोर) + लिनक, 170 + 23 बाइट्स का उपयोग करना

x=>s=>x.GroupBy(z=>z).Select(y=>Enumerable.Repeat(Math.Round(s.Skip(Array.IndexOf(x,y.Key)).Take(y.Count()).Average()),y.Count())).Aggregate((a,b)=>a.Concat(b)).ToArray()

इसे ऑनलाइन आज़माएं!

— Dennis.Verweij
स्रोत

2

जे, 15 बाइट्स

[:;<@(##+/%#)/.

इसे ऑनलाइन आज़माएं!

1 2 ... 12 15दाएं हाथ के तर्क के रूप में स्कोर की सूची ( ) और बाएं हाथ के तर्क के रूप में स्कोर करने के लिए मान लेता है। यदि यह एक तार्किक इनपुट नहीं है, ~तो इनपुट को ले जाने के क्रम में इनवर्टर के लिए 1-बाइट जोड़ें ।

गोल्फ के लिए कुछ चीजें हो सकती हैं, जिनमें शामिल हैं

मुक्केबाजी का मेरा उपयोग
अंत में टोपी

व्याख्या

मैं इसे कुछ कार्यों में विभाजित करूँगा।

avg_and_dupe =. # # +/ % #
score        =. [: ; <@avg_and_dupe/.

avg_and_dupe एक सूची का औसत लेता है और सूची की लंबाई के रूप में इसे कई बार डुप्लिकेट करता है
score एक इनपुट (बाएं तर्क) स्कोर (सही तर्क) की एक सूची दी।

avg_and_dupe

# # +/ % #
#           Length
  #         Copy as many times as the left argument
    +/ % #  Average
    +/       Sum
       %     Divided by
         #   Length

यह इतनी अच्छी तरह से काम करता है क्योंकि इसे दो कांटे के रूप में माना जाता है । यदि आप अभी भी अपना सिर खुजला रहे हैं (मुझे पता है कि मैं पहले था), तो पूछें और मैं इसके बारे में अधिक गहराई से स्पष्टीकरण प्रदान कर सकता हूं कि यह क्यों काम करता है।

स्कोर

[: ; <@avg_and_dupe/.
                   /.  Key: using the values given, partition the scores
     <@avg_and_dupe     For each partition:
       avg_and_dupe      Average and duplicate
     <                   Then box
   ;                   Raze the boxes into a single list

अगर यह अभी भी भ्रामक है, तो मैं /.-key के लिए एक स्पष्टीकरण भी जोड़ सकता हूं , लेकिन मुझे लगता है कि विकी पेज इसे बहुत अच्छी तरह से समझाता है।

— गोभी
स्रोत

ध्यान दें कि ओपी जोड़ा गया You can also take the points list [15,12,10,9,...] as input.है कि अगर आप किसी भी बाइट बचाता है

— स्टीफन

2

पायथन 2 , 66 बाइट्स

-8 बाइट्स लीक नन के लिए धन्यवाद।

lambda s,p:[sum(p[s.index(i):][:s.count(i)])/s.count(i)for i in s]

इसे ऑनलाइन आज़माएं!

— totallyhuman
स्रोत

2

जेली , 11 बाइट्स

ṁ⁴Œg¤Æmṁ$€F

इसे ऑनलाइन आज़माएं!

-3 बाइट्स के लिए धन्यवाद नई जेली सुविधाओं को सूचित करने के लिए फायरफ्लेम: डी

— HyperNeutrino
स्रोत

हाँ, यह शायद बहुत लंबी है कि संबंधित चुनौती के समाधान कितने कम हैं।

— जियोकॉवेल

@geokavel कष्टप्रद बात यह है कि सूची बनाने के लिए कोड उस एक पर J समाधान से अधिक लंबा है; _;

— हाइपरएनुट्रीनो

मैं यह बताना भूल गया कि आप अंक सूची को इनपुट के रूप में भी ले सकते हैं। मैं उसे जोड़ने जा रहा हूं।

— geokavel

11 बाइट्स। नए अंकगणित माध्य के बजाय मोनाड का उपयोग करता है S÷Lऔर इसके बजाय मोल्ड करता है xL, जो $दो के बजाय अनुमति देता है µ।

— फायरफ्लेम २४१

1

@ मीलों गैर-प्रतिस्पर्धा वास्तव में अब कोई चीज नहीं है ।

— श्री एक्सकोडर

1

पायथन 3 , 67 बाइट्स

lambda s,p:[sum(v for j,v in zip(s,p)if j==i)/s.count(i)for i in s]

इसे ऑनलाइन आज़माएं!

पायथन 2 , 108 70 बाइट्स

lambda s,p:[1.*sum(v for j,v in zip(s,p)if j==i)/s.count(i)for i in s]

इसे ऑनलाइन आज़माएं!

— TFeld
स्रोत

1

पायथन 3 , 72 बाइट्स

lambda s,p:[sum(p[s.index(i):12-s[::-1].index(i)])/s.count(i)for i in s]

इसे ऑनलाइन आज़माएं!

— श्री एक्सकोडर
स्रोत

1

प्रोटॉन , 62 बाइट्स

(s,p)=>[sum(p[s.index(i)to][to s.count(i)])/s.count(i)for i:s]

इसे ऑनलाइन आज़माएं!

प्रोटॉन , 63 बाइट्स

(s,p)=>map(i=>sum(p[s.index(i)to][to s.count(i)])/s.count(i),s)

इसे ऑनलाइन आज़माएं!

— श्री एक्सकोडर
स्रोत

^ ^ मैं सिर्फ प्रोटॉन के साथ अगली बार शुरू करने वाला हूं।

— 19 अक्टूबर को पूरी तरह से अमानवीय

1

दिल्लोग एपीएल, 14 बाइट्स

∊{(⊂≢⍴+/÷≢)⍵}⌸

बाएं तर्क के रूप में अंकों की सूची और सही तर्क के रूप में अंक सूची लेता है। ()यदि इसे सीधे नाम से नहीं बुलाया जाता है , तो इसे लपेटने के लिए 2 बाइट्स जोड़ें ।

{... }⌸बाएं तर्क में कुंजी द्वारा समूह सही तर्क और प्रत्येक समूह (कुंजी ऑपरेटर) को ब्रेसिज़ में फ़ंक्शन लागू करें।

⊂≢⍴+/÷≢ एक कांटा है जहां:

+/÷≢ समूह के लिए औसत अंक (टैली द्वारा विभाजित राशि)

≢⍴ टैली पुनर्वसन (समूह में मदों की संख्या से मिलान करने के लिए औसत की नकल करें)

⊂ परिणाम बॉक्स (यह कुंजी ऑपरेटर द्वारा लागू होने वाले परिणाम के मिश्रण का प्रतिकार करना है)

∊ एक साधारण सूची में कुंजी ऑपरेटर (जो वैक्टर का नेस्टेड वेक्टर है) के परिणाम को सूचीबद्ध और समतल करता है।

TryAPL ऑनलाइन

— गिल
स्रोत

1

हास्केल, 152 बाइट्स

f::[Int]->[Int]
f=concat.g(15:12:[10,9..1])[]
g[q]t _=[q:t]
g(q:r)t(x:z)|x>head z=(replicate(l(q:t))(sum(q:t)`div`l(q:t))):g r[]z|1<2=g 
r(q:t)z
l=length

यह आयात करने के लिए एक दर्द है groupByऔर on, इसलिए मुझे अपना खुद का करना पड़ा।

शीघ्र ही एवरेजिंग फंक्शन को छोटा कर दिया जाएगा।

हस्ताक्षर की आवश्यकता शायद संकलक झंडे से बचा जा सकता है।

— लीफ़ विलर्ट्स
स्रोत

मारियो कार्ट स्कोरिंग w / संबंध

चुनौती

परीक्षण के मामलों

जावास्क्रिप्ट (ईएस 6), 57 बाइट्स

परीक्षण के मामलों

आर , 3 बाइट्स

पर्ल 5 , 109 +1 (-ए) = 110 बाइट्स

MATL , 12 10 बाइट्स

व्याख्या

05AB1E , 12 बाइट्स

सी # (.NET कोर) , 154 बाइट्स

सी # (.NET कोर) + लिनक, 170 + 23 बाइट्स का उपयोग करना

जे, 15 बाइट्स

व्याख्या

avg_and_dupe

स्कोर

पायथन 2 , 66 बाइट्स

जेली , 11 बाइट्स

पायथन 3 , 67 बाइट्स

पायथन 2 , 108 70 बाइट्स

पायथन 3 , 72 बाइट्स

प्रोटॉन , 62 बाइट्स

प्रोटॉन , 63 बाइट्स

दिल्लोग एपीएल, 14 बाइट्स

हास्केल, 152 बाइट्स