पूर्णांकों की एक सूची रैंक

21

आपको सकारात्मक पूर्णांक की एक गैर-रिक्त सूची दी गई है, उदाहरण के लिए

[6 2 9 7 2 6 5 3 3 4]

आपको इन नंबरों को उनके मूल्य से रैंक करना चाहिए, लेकिन जैसा कि लीडरबोर्ड में हमेशा होता है, अगर कोई टाई है तो सभी बंधे हुए नंबरों को समान रैंक मिलती है, और उपयुक्त संख्या में रैंक छोड़ दी जाती है। इसलिए उपरोक्त सूची के लिए अपेक्षित आउटपुट होगा

[3 9 1 2 9 3 5 7 7 6]

उदाहरण के लिए, इनपुट में उच्चतम मूल्य था 9, इसलिए यह एक 1(पहला रैंक) बन जाता है । तीसरा उच्चतम मूल्य है 6, इसलिए दोनों 6बन जाते हैं 3, और रैंक 4पूरी तरह से छोड़ दिया जाता है।

नियम

आप इनपुट और आउटपुट के लिए किसी भी सुविधाजनक, स्पष्ट, फ्लैट सूची प्रारूप का उपयोग कर सकते हैं। आउटपुट में पहली / सबसे छोटी रैंक हमेशा 1 होनी चाहिए ।

आप एक प्रोग्राम या फ़ंक्शन लिख सकते हैं और इनपुट प्राप्त करने और आउटपुट प्रदान करने के हमारे किसी भी मानक तरीके का उपयोग कर सकते हैं।

आप किसी भी प्रोग्रामिंग भाषा का उपयोग कर सकते हैं , लेकिन ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है।

यह कोड-गोल्फ है , इसलिए सबसे छोटा वैध उत्तर - बाइट्स में मापा जाता है - जीतता है।

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

[8] -> [1]
[1 15] -> [2 1]
[18 14 11] -> [1 2 3]
[11 16 14 8] -> [3 1 2 4]
[15 15 15 15 15] -> [1 1 1 1 1]
[10 2 5 4 15 5] -> [2 6 3 5 1 3]
[5 5 10 10 5 11 18] -> [5 5 3 3 5 2 1]
[2 4 9 4 17 9 17 16] -> [8 6 4 6 1 4 1 3]
[11 17 19 17 10 10 15 3 18] -> [6 3 1 3 7 7 5 9 2]
[2 11 4 8 3 3 12 20 4 18] -> [10 4 6 5 8 8 3 1 6 2]
[12 6 10 2 19 19 6 19 8 6 18] -> [5 8 6 11 1 1 8 1 7 8 4]
[5 6 14 19 13 5 19 9 19 9 9 19] -> [11 10 5 1 6 11 1 7 1 7 7 1]
[9 2 12 3 7 11 15 11 6 8 11 17 11] -> [8 13 3 12 10 4 2 4 11 9 4 1 4]
[3 5 15 7 18 5 3 9 11 2 18 1 10 19] -> [11 9 4 8 2 9 11 7 5 13 2 14 6 1]
[6 11 4 19 14 7 13 16 10 12 7 9 7 10 10] -> [14 6 15 1 3 11 4 2 7 5 11 10 11 7 7]
[11 20 11 1 20 16 11 11 4 8 9 7 11 14 10 14] -> [6 1 6 16 1 3 6 6 15 13 12 14 6 4 11 4]
[4 7 15 2 3 2 3 1 14 2 10 4 7 6 11 2 18] -> [9 6 2 13 11 13 11 17 3 13 5 9 6 8 4 13 1]
[5 1 17 7 1 9 3 6 9 7 6 3 2 18 14 4 18 16] -> [12 17 3 8 17 6 14 10 6 8 10 14 16 1 5 13 1 4]
[5 6 8 10 18 13 20 10 7 1 8 19 20 10 10 18 7 2 1] -> [16 15 11 7 4 6 1 7 13 18 11 3 1 7 7 4 13 17 18]
[12 17 8 2 9 7 15 6 19 5 13 16 14 20 10 11 18 4 3 1] -> [9 4 13 19 12 14 6 15 2 16 8 5 7 1 11 10 3 17 18 20]
code-golf  array-manipulation  sorting 
— मार्टिन एंडर
स्रोत
1
बारीकी से संबंधित। अंतर यह है कि चुनौती गारंटी देती है कि इनपुट को क्रमबद्ध किया गया है, जिसका अर्थ है कि अधिकांश उत्तर indexOfफ़ंक्शन के एक रूप पर निर्भर करते हैं । मेरा मानना ​​है कि बिना इनपुट के कई भाषाओं में विकल्प कम हैं।
— मार्टिन एंडर
3
— लिन
मुझे खेद है, लेकिन मेरा मानना ​​है कि यह लिन की कड़ी के बहुत करीब है। अंतर कम से कम हैं: मानों को छोटा कर दिया जाता है, आप पहले से ही छंटे हुए इनपुट को नहीं मान सकते हैं और आउटपुट के आधे हिस्से में इसका क्रम बदली हुई है। जुड़े हुए सवाल पर स्वीकृत जवाब लगभग काम करता है। न्यूनतम प्रयास के साथ, कोई इसे काम कर सकता है। जैसे, मैं खड़ा हूं कि यह एक डुप्लिकेट है।
— इस्माईल मिगुएल
मैं असहमत हूं, यह स्पष्ट रूप से डुप्लिकेट नहीं है।
— टिमटेक 9:16
मैं टाइमटेक से सहमत हूं, यह चुनौती सरल है, लेकिन डुप्लिकेट नहीं।
— tuskiomi 21

जवाबों:

13

कोड गोल्फ स्टैक एक्सचेंज में माउस इनपुट के बारे में मूर्खतापूर्ण नियमों के लिए एक्सेल में समाधान: (WESRRMICGSE) 28 बाइट्स

rank(RC[1],r1c1:r1024:c1024)

10,23,34,2,स्रोत में प्रवेश करने के बाद कंपाइलर में csv ( ) के रूप में इनपुट सूची । कोई उद्धरण नहीं, कोई कोष्ठक नहीं, अल्पविराम अनुगामी।

WESRRMICGSE बिल्कुल एक्सेल में प्रोग्रामिंग की तरह है, इसके अलावा आप एक बाइट को बचाने के लिए प्रारंभिक '=' चिन्ह को छोड़ सकते हैं। कार्यक्षमता में अंतर इस तथ्य से आता है कि WESRRMICGSE कोड को स्वचालित रूप से कॉपी करने के लिए सूत्र को नीचे खींच देगा और एक पूर्णांक इनपुट के साथ प्रदान किए गए विभिन्न आउटपुट प्रदान करेगा। इनपुट के रूप में एक सूची प्रदान की, वह सूची बी कॉलम (इनपुट कॉलम) में जाती है, और इनपुट की संख्या से मेल खाने के लिए सूत्र स्वचालित रूप से ड्रग डाउन होता है। (उदाहरण: इनपुट 34,21,45, सूत्र के साथ कुल 3 कोशिकाओं के लिए फॉर्मूला 2 कोशिकाओं को 'नीचे' खींचेगा)।

संपादित करें: मुझे उम्मीद नहीं थी कि यह उत्तर लोकप्रिय होगा। वाह!

— tuskiomi
स्रोत
21
भाषा का नाम थोड़ा अप्रिय है ...
— कॉनर ओ'ब्रायन
आप किन नियमों का उल्लेख करते हैं और वे वास्तव में मूर्ख कैसे हैं?
— लुइस मेंडू
3
@LuisMendo यहां घोषित किए गए नियम: meta.codegolf.stackexchange.com/questions/10199/… मुझे लगता है कि नियम मूर्खतापूर्ण है क्योंकि मुझे एक 'दुभाषिया' लिखने में 5 मिनट का समय लगा था, जो वास्तव में वे बात कर रहे हैं। जितना अधिक इस भाषा को चुनौतियों में इस्तेमाल किया जा सकता है, उतने ही बड़े नियम बनेंगे। मैं इसे लिंक में शामिल करना सुनिश्चित करूँगा।
— tuskiomi
9

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

lambda l:map(sorted(l+[l])[::-1].index,l)

प्रत्येक मान के लिए, घटते क्रम से क्रमबद्ध सूची में उसका सूचकांक खोजें। 0 के बजाय 1 का सबसे बड़ा मान देने के लिए, हम सूची के एक अतिरिक्त "अनन्तता" तत्व का उपयोग करते हैं, क्योंकि पायथन 2 संख्याओं की तुलना में सूचियों को बड़ा मानता है।

एक अधिक प्रत्यक्ष समाधान 42 बाइट्स है और पायथन 3 में भी काम करता है।

lambda l:[1+sum(y<x for x in l)for y in l]

प्रत्येक तत्व के लिए, छोटे तत्वों की संख्या को गिना जाता है, 1 को 1-अनुक्रमित में स्थानांतरित करने के लिए जोड़ रहा है।

— XNOR
स्रोत
7

आर, 24 25 20 बाइट्स

नकारात्मक वेक्टर पर "न्यूनतम" संबंधों की विधि के साथ मानक रैंक फ़ंक्शन का उपयोग करता है। catइसे STDOUT में आउटपुट करने के लिए जोड़ा गया। @Guiseppe को धन्यवाद दिया

cat(rank(-scan(),,"mi"))

उदाहरण

> cat(rank(-scan(),,"mi"))
1: 9 2 12 3 7 11 15 11 6 8 11 17 11
14: 
Read 13 items
8 13 3 12 10 4 2 4 11 9 4 1 4
>
— MickyT
स्रोत
मुझे लगता है कि आपको catइसे पूरा कार्यक्रम बनाने के लिए इसमें लपेटने की आवश्यकता है ।
— एलेक्स ए। 19
@AlexA। मुझे इसके बारे में ही ख्याल आ रहा था। क्या यह कहना उचित होगा कि यह अपने आप में एक फ़ंक्शन है और इस मामले में rank(-a,,'min')ठीक होगा जहां वेक्टर फॉर्म में सूची इनपुट है?
— मिक्यट
उस मामले में हम इसे एक स्निपेट मानेंगे, क्योंकि यह मानता है कि नाम में पहले से ही एक चर मौजूद है। इसे एक उचित कार्य प्रस्तुत करने के लिए आपको आवश्यकता होगी function(a)rank(-a,,'min')।
— एलेक्स ए।
के "mi"बजाय सिर्फ छोटा किया जा सकता है "min"।
— ग्यूसेप
@AlexA। इसे लपेटने की आवश्यकता क्यों है cat? यदि प्रस्तुत किया गया था function(a)rank(-a,,'mi')कि पर्याप्त माना जाएगा और कार्यक्रम आउटपुट समान हैrank(-scan(),,'mi')
— मार्क
4

PowerShell v2 +, 43 41 बाइट्स

($a=$args)|%{@($a|sort -d).indexof($_)+1}

स्वतंत्र रूप से विकसित, लेकिन मैं देखता हूं कि यह @ xnor के पायथन समाधान के समान एल्गोरिथ्म है , इसलिए / श्रग ।

अलग-अलग कमांड-लाइन तर्कों के रूप में इनपुट लेता है (यानी, एक अंतरिक्ष अलग सूची)। आउटपुट (डिफ़ॉल्ट स्वरूपण) तत्वों के बीच एक नई रेखा है।

इनपुट सूची के प्रत्येक तत्व के लिए, यह sortइनपुट सूची को -dबढ़ते क्रम में, .indexOf()वर्तमान तत्व को ले जाता है , और जोड़ता है 1। @(...)एकल-अंक इनपुट के लिए खाते में डाली गई स्पष्ट सरणी पर ध्यान दें । परिणामी संख्या पाइप लाइन पर छोड़ दी जाती है और आउटपुट निहित है।

@Matt की बदौलत 2 बाइट्स बचाए!

उदाहरण

PS C:\Tools\Scripts\golfing> .\rank-the-integers.ps1 6 2 9 7 2 6 5 3 3 4
3
9
1
2
9
3
5
7
7
6
— AdmBorkBork
स्रोत
क्या आपके कारण sort -dकोई काम नहीं हुआ? जो मेरे लिए असंदिग्ध है।
— मैट
@ मैट ऑड। मेरे Win8.1 ISE पर, यह कहा गया है कि -Descendingऔर -Debugअस्पष्ट हैं। लेकिन Win8.1 पर सीधे शेल में और Win10 पर शेल और ISE पर यह ठीक काम करता है। यह पहली बार नहीं होगा कि मेरे विशेष Win8.1 स्थापित नासमझ है ...: - / गोल्फ के लिए धन्यवाद!
— AdmBorkBork
यह भी सभी परीक्षण मामलों के लिए काम नहीं किया? $args|%{@($args|sort -d).indexof($_)+1}यह छोटा है, लेकिन मुझे यह जानने के लिए कोई अच्छा नज़र नहीं आया है कि यह काम करता है
— मैट
@ मैट वह काम नहीं करता है क्योंकि $argsलूप के स्क्रिप्ट ब्लॉक के लिए इनपुट के रूप में दूसरा कार्य {...}, जैसे कि यदि आप filterया का उपयोग कर रहे थे function।
— AdmBorkBork
3

ऑक्टेव, 15 बाइट्स

@(x)sum(x<x')+1

ऑक्टेव के लिए मेरे MATL उत्तर का पोर्ट। यह Matlab R2016b में भी काम करता है।

कोड एक अनाम फ़ंक्शन को परिभाषित करता है। इसे कॉल करने के लिए, इसे किसी वैरिएबल पर असाइन करें। Ideone में यह कोशिश करो ।

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

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

a=>a.map(e=>a.map(d=>r+=e<d,r=1)&&r)

संपादित करें: 2 बाइट्स @ETHproductions की बदौलत सहेजे गए।

— नील
स्रोत
.mapFTW ;-)a=>a.map(e=>a.map(d=>r+=e<d,r=1)&&r)
— 23
3
@ETHproductions आपको हमेशा मेरा मज़ा क्यों खराब करना है?
— नील
2

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

<S‘ð€

TryItOnline!

कैसे?

<S‘ð€ - Main link: listOfValues
   ð  - dyadic chain separation
    € - for each
<     - less than (vectorises) - yields a list of 1s and 0s
 S    - sum - yields number of values the current value is less than (those that beat it)
  ‘   - increment - the place of a value is the number that beat it plus 1.
— जोनाथन एलन
स्रोत
यह जे कोड के समान है जो मैं प्रस्तुत करने वाला था? 1+(+/@:<)"0 1~
— डेन
समान दिखता है (कम करने के लिए राशि का उपयोग करता है?), लेकिन यह किसी भी तरह से आपको अपना कोड पोस्ट करने से रोकना चाहिए!
— जोनाथन एलन
मुझे लगता है कि मैं और अधिक आश्चर्यचकित था कि "प्रेरित चेन जुदाई" और "प्रत्येक के लिए" एक जे-प्रेरित भाषा में क्या करते हैं।
— डेन
आह, आपकी व्याख्या से अच्छी तरह से मुझे लगता है कि आपका कोड अधिक पसंद है >€µS‘, या वास्तव में पसंद है <@€µS‘( ऑपरेटर के @तर्कों को उलट देता है <)। J ~को चेन के बाईं ओर निहित किया गया है µ, जो <कि तर्क (s) है (यदि ) हैं तो monadic (dyadic के बजाय) पृथक्करण और वेक्टराइज़ हैं।
— जोनाथन एलन
2

पर्ल 6 ,  42  26 बाइट्स

:kएक उलट [R,]क्रमबद्ध सूची में पहला सूचकांक खोजें

{map {[R,](.sort).first(*==$^a,:k)+1},@$_}

उन मानों की गणना करें जो बड़े हैं, और एक जोड़ें

{map {1+.grep(*>$^a)},@$_}
— ब्रैड गिल्बर्ट b2gills
स्रोत
2

जावास्क्रिप्ट, 87 49 बाइट्स

f=a=>a.slice().map(function(v){return a.sort(function(a,b){return b-a}).indexOf(v)+1 })

a=>[...a].map(v=>a.sort((a,b)=>b-a).indexOf(v)+1)

धन्यवाद Conor O'Brien और ETHproductions!

— ओलिवर
स्रोत
1
आप मानचित्र में एक अनाम फ़ंक्शन का उपयोग कर सकते हैं, अर्थात v=>a.sort((a,b)=>b-a).indexOf(v)+1।
— कॉनर ओ'ब्रायन
आपको इसकी बिल्कुल भी आवश्यकता नहीं है .slice(), क्योंकि .mapयह सरणी की एक प्रति पर काम करता है।
— ETHproductions
और हमारी साइट की नीति यह है कि फ़ंक्शन को नाम देने की आवश्यकता नहीं है, इसलिए आप अग्रणी f=को भी हटा सकते हैं।
— कॉनर ओ'ब्रायन
@ETHproductions यदि मैं स्लाइस को हटाता हूं, तो [18,13,18]रिटर्न के [1,1,2]बजाय पास में[1, 3, 1]
— ओलिवर
ओह, यह अजीब है ... मुझे लगता है कि यह इसलिए है क्योंकि a.sort()इसमें क्रमबद्ध सरणी संग्रहीत होती है a। लेकिन आप बदल सकते हैं a.slice()करने के लिए [...a]कुछ बाइट्स को बचाने के लिए।
— ETHproductions
2

गणितज्ञ, 44 बाइट्स 42 बाइट्स 40 बाइट्स

xPosition[SortBy[x,-#&],#][[1,1]]&/@x

3 बाइट निजी उपयोग चरित्र है U+F4A1( वोल्फ्राम डॉक्स पृष्ठ )

संपादित करें: बाइट बचत के लिए JHM का धन्यवाद ।

— ngenisis
स्रोत
1
परीक्षण के मामले में विफल {10,2,5,4,15,5}(आउटपुट {2,6,3,5,1,3}नहीं होना चाहिए {2,5,3,4,1,3}। ध्यान दें कि 4इसे छोड़ दिया जाना चाहिए क्योंकि 5इनपुट में दो एस हैं )।
— जुंगहवान मिन
विधिवत रूप से सुधारा गया।
— ngenisis
1
-2 बाइट्स स्विच करके xऔर #(प्रभावी रूप से कोष्ठक से छुटकारा पाकर) xPosition[SortBy[x,-#&],#][[1,1]]&/@x:।
— जुंगह्वान मिन
2

जे , 14 8 बाइट्स

1+1#.</~

कैसे?

1+1#.</~ - Consumes and returns a list of integers
       ~ - Use the same list for both inputs
     </  - Create a table of less-than comparisons
  1#.    - Treat each row like digits of a base-one number, returning a list of integers
1+       - Increment the results

पिछला समाधान

1+(+/@:<)"0 1~
— डेन
स्रोत
हैलो, मुझे 8 बाइट्स के लिए एक छोटा संस्करण मिला है 1+1#.</~। पंक्ति -1 रूपांतरण का उपयोग करके पंक्ति-वार योग किया जाता है। एक अन्य विकल्प 1+\:~i.]जो 8 बाइट्स भी है।
— मील
अच्छा! क्या आप अपना जवाब पोस्ट करना चाहते हैं? मैं अन्यथा आधार-एक सुधार को शामिल करूँगा।
— डेन
2
नहीं, मैं सिर्फ बाइट-बचत का सुझाव देकर ठीक हूं। बेझिझक उनका इस्तेमाल करें
— मील
1

वंडर , 28 बाइट्स

@(->@+1:0iO#0rev sort#I#1)#0

उपयोग:

(@(->@+1:0iO#0rev sort#I#1)#0)[6 2 9 7 2 6 5 3 3 4]

किसी इनपुट के अवरोही-सॉर्ट किए गए संस्करण में आइटम के पहले इंडेक्स में 1 जोड़ने वाले फ़ंक्शन के साथ इनपुट सरणी पर मैप करें।

— मामा फन रोल
स्रोत
1

गणितज्ञ, 37 बाइट्स

Min@Position[-Sort@-#,i]~Table~{i,#}&

एक शुद्ध कार्य जो समस्या के नियमों के अनुसार, इसे इनपुट करेगा। उदाहरण के लिए:

Min@Position[-Sort@-#, i]~Table~{i, #} &[{6, 2, 9, 7, 2, 6, 5, 3, 3, 4}]
(*{3, 9, 1, 2, 9, 3, 5, 7, 7, 6}*)
— जे। एंटोनियो पेरेज़
स्रोत
1

जेलिफ़िश , 15 बाइट्स

p`&& ~i
  >/+`<

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

व्याख्या

जेलिफ़िश की सूची में किसी मूल्य के सूचकांक को खोजने के लिए एक अच्छा तरीका प्रतीत नहीं होता है, इसलिए यह गिनती के दृष्टिकोण का उपयोग करता है कि कितने मान वर्तमान से बड़े हैं और परिणाम बढ़ाते हैं। यह काफी हद तक एक असमान फ़ंक्शन का निर्माण करके किया जाता है जो किसी दिए गए तत्व के लिए इस मान की गणना करता है।

     `<

यह तुलना ऑपरेटर का एक थ्रेडेड संस्करण बनाता है, इसलिए यदि आप इसे एक पूर्णांक और एक सूची देते हैं, तो यह उस पूर्णांक और सूची के प्रत्येक तत्व के बीच तुलना परिणामों की एक सूची वापस कर देगा।

     ~i
     `<

यह इनपुट सूची के साथ पिछले फ़ंक्शन के दाहिने हाथ के तर्क को काटता है। तो परिणाम एक असमान फ़ंक्शन है जो पूर्णांक लेता है और आपको प्रोग्राम के इनपुट के साथ तुलना परिणामों की सूची देता है।

   & ~i
   /+`<

यहां, /+इसके अलावा कमी है, जिसका अर्थ है कि यह "इस सूची का योग" फ़ंक्शन है। &पिछले फ़ंक्शन पर यह रचना करता है, इसलिए हमारे पास अब एक असमान फ़ंक्शन है जो गिनता है कि इनपुट में कितने मान उस पूर्णांक से बड़े हैं।

  && ~i
  >/+`<

हम इस पर वेतन वृद्धि समारोह की रचना भी करते हैं।

 `&& ~i
  >/+`<

अंत में, हम इस फ़ंक्शन को भी थ्रेड करते हैं, ताकि यह स्वचालित रूप से इसे पारित की गई सूची के प्रत्येक पूर्णांक पर लागू हो। कोड के लेआउट के कारण, iइस फ़ंक्शन के इनपुट के रूप में भी लिया जाना चाहिए, ताकि यह वांछित आउटपुट की गणना करता है।

p`&& ~i
  >/+`<

अंत में, यह परिणाम प्रिंट करता है।

— मार्टिन एंडर
स्रोत
1

brainfuck, 124 बाइट्स

->,[>>>+>,]<[-<+]+[-->[<[<<<<]>>>+>[>[>>]<[[<<+<<]>+>[->>>>]]<+>>>]+[-<<+]->]<[<
<<<]>+.,>>[>[>->+>>]<<[-<<<<]>-]+[->+]+>>>>]

प्रारूपित:

->
,[>>>+>,]
<[-<+]
+
[
  -->
  [
    <[<<<<]
    >>>+>
    [
      >[>>]
      <
      [
        [<<+<<]
        >+>[->>>>]
      ]
      <+> >>
    ]
    +[-<<+]
    ->
  ]
  <[<<<<]
  >+.,>>
  [
    >[>->+>>]
    <<[-<<<<]
    >-
  ]
  +[->+]
  +>>>>
]

यह 8-बिट ब्रेनफक कार्यान्वयन के लिए डिज़ाइन किया गया है। इनपुट और आउटपुट बाइट वैल्यू के माध्यम से हैं ।

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

प्रत्येक तत्व के लिए, यह उससे अधिक तत्वों की संख्या को गिनाता है, फिर परिणाम प्लस को प्रिंट करता है। यह सभी तत्वों को बढ़ाकर तब तक पूरा किया जाता है जब तक कि वर्तमान तत्व शून्य के बराबर नहीं हो जाता है, परिणाम को अद्यतन करते हुए जब भी कोई अन्य तत्व वर्तमान तत्व से पहले शून्य हो जाता है।

टेप 4-सेल नोड्स में टूट गया है,

b c 0 0

जहां cतत्व है और bएक नेविगेशन ध्वज है जो वर्तमान तत्व के लिए नकारात्मक है, अन्यथा एक।

परिणाम और वर्तमान तत्व की एक प्रति सरणी के बाईं ओर रखी जाती है।

— मिच श्वार्ट्ज
स्रोत
1

जावा, 215 बाइट्स

public class G{public static void L(int[]A){int[]r=new int[A.length];for(int i=0;i<A.length;i++){int c=1;for(int j=0;j<A.length;j++){if(A[j]>A[i])c++;}r[i]=c;}for(int i=0;i<r.length;i++)System.out.print(r[i]+",");}}

स्पष्टीकरण:

बहुत ही आत्म व्याख्यात्मक।

मूल रूप से सरणी में प्रत्येक पूर्णांक के लिए यह जाँचता है कि कितने इससे बड़े हैं, फिर रैंकिंग के साथ नए सरणी को प्रिंट करता है।

मुझे खेद है कि यह बहुत संक्षिप्त नहीं है, लेकिन इनमें से एक पर यह मेरा पहला प्रयास है और मैंने जावा के लिए एक प्रविष्टि नहीं देखी। मुझे यकीन है कि इसे और नीचे गिराया जा सकता है।

इसे केवल स्टैटिक विधि के संदर्भ में और एक ऐरे को पास करके चलाया जा सकता है। मुझे नहीं लगा कि मुख्य कार्य लिखना आवश्यक था लेकिन अगर यह है तो मैं भविष्य में ऐसा करूँगा।

— हेनरी
स्रोत
क्या आप इस व्हॉट्सएप को हटा सकते हैं? जैसा कि यह है कि यह वास्तव में बिल्कुल नहीं है। (यानी रिक्त स्थान r = new)
— Rɪᴋᴇʀ
@EasterlyIrk हाँ, माफ करना, मैं ऐसा करने के लिए इस्तेमाल नहीं किया गया। मुझे लगता है कि मैंने सभी अनावश्यक व्हाट्सएप से छुटकारा पा लिया।
— हेनरी
क्या आप "जीएन" या "कुछ" जैसे छोटे रैंक को "रैंकनॉट्सगोल्फ" नाम दे सकते हैं?
— R
@EasterlyIrk हाँ, धन्यवाद।
— हेनरी
मैं अच्छी तरह से जावा नहीं करता, लेकिन क्या आप तीनों में कुछ रिक्त स्थान निकाल सकते हैं for (?
— R
0

PHP, 101 बाइट्स

कुछ छोटा रास्ता होना चाहिए।

function f(&$a){for($r=1;$v++<max($a);$r+=$n,$n=0)foreach($a as$k=>$w)if($w===$v){$a[$k]="$r";$n++;}}

फ़ंक्शन इनपुट को पूर्णांक के सरणी के रूप में लेता है, संख्यात्मक चर के रूप में रैंक के साथ इनपुट चर को अधिलेखित करता है।

उपयोग: $a=[1,2,4,2,2,3];f($a);print_r($a);

— टाइटस
स्रोत
0

रूबी, 45 40 बाइट्स

->a{a.map{|x|a.sort.reverse.index(x)+1}}
— ली डब्ल्यू
स्रोत
इसे कैसे कहा जाता है? मैं इसे परीक्षण मामलों से मिलान करने के लिए नहीं मिल सकता है, समान रैंक वाला बग प्रतीत होता है। उदाहरण के लिए [10, 2, 5, 4, 15, 5]मुझे आउटपुट देता है [2, 5, 3, 4, 1, 3]जब यह होना चाहिए [2, 6, 3, 5, 1, 3]- मुझे लगता है कि आप इसे ठीक करने के लिए सोचते हैं .uniq- 5 बाइट्स बचा रहा है!
— नील स्लेटर
मुझे लगता है कि यह सवाल गलत है। कि जगह के लिए धन्यवाद!
— ली डब्ल्यू
0

क्लोजर, 48 44 बाइट्स

अद्यतन: के forबजाय का उपयोग करmap

#(for[i %](+(count(filter(partial < i)%))1))

बस वर्तमान मूल्य से छोटे प्रत्येक मान को फ़िल्टर करता है, सूची की लंबाई और वेतन वृद्धि को एक से गिनता है।

— NikoNyrh
स्रोत
0

PHP, 84 बाइट्स

function r($l){$s=$l;rsort($s);foreach($l as$n)$r[]=array_search($n,$s)+1;return$r;}

उपयोग: फ़ंक्शन को पूर्णांक के अपने सरणी में पास करें और यह रैंक किए गए पूर्णांकों की संबंधित सरणी को लौटा देगा।

यहां से पासिंग टेस्ट।

— Progrock
स्रोत
0

के (ओके) , 11 बाइट्स

समाधान:

1+(x@>x)?x:

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

उदाहरण:

1+(x@>x)?x:6 2 9 7 2 6 5 3 3 4
3 9 1 2 9 3 5 7 7 6
1+(x@>x)?x:5 6 14 19 13 5 19 9 19 9 9 19
11 10 5 1 6 11 1 7 1 7 7 1

स्पष्टीकरण:

सॉर्ट की गई सूची में मूल सूची की स्थिति देखें, फिर एक जोड़ें।

1+(x@>x)?x: / the solution
         x: / save input as x
  (  >x)    / return indices of x sorted in descending order
   x@       / apply these indices to x (thus sort x)
        ?   / lookup right in left
1+          / add one
— streetster
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.