मेरा पहला कोड गोल्फ पोस्ट, किसी भी गलती के लिए माफी ...

प्रसंग

रॉक क्लाइम्बिंग ( विशेष रूप से बोल्डिंग ) में, V / Vermin (USA) पर चढ़ने वाले ग्रेड 'VB' (सबसे आसान ग्रेड) पर शुरू होते हैं, और फिर 'V0', 'V0 +', 'V1', 'V2', 'V3' पर जाते हैं। , 'V4', 'V5' आदि 'V17' तक (सबसे कठिन ग्रेड)।

कार्य

आप ग्रेड चढ़ने की एक सूची / सरणी इनपुट के रूप में लेंगे और आपको सबसे आसान से कठिनतम क्रम में ग्रेड की एक सूची / सरणी को वापस करना होगा या प्रिंट करना होगा।

यदि इनपुट खाली है, तो खाली डेटा संरचना लौटाएं; अन्यथा इनपुट हमेशा मान्य रहेगा।

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

Input | Output
[] |  []
['V1'] |  ['V1']
['V7', 'V12', 'V1'] | ['V1', 'V7', 'V12']
['V13', 'V14', 'VB', 'V0'] |  ['VB', 'V0', 'V13', 'V14']
['V0+', 'V0', 'V16', 'V2', 'VB', 'V6'] | ['VB', 'V0', 'V0+', 'V2', 'V6', 'V16']

यह एक कोड-गोल्फ चुनौती है।

code-golf array-manipulation sorting

— Chris_Rands
स्रोत

अगली बार, इसे पोस्ट करने से पहले प्रतिक्रिया प्राप्त करने के लिए सैंडबॉक्स पर पोस्ट करें । दूसरी बात, क्या आपको वास्तव में अपनी चुनौती का जवाब देना चाहिए?

— इयान एच।

क्या डुप्लिकेट ग्रेड इनपुट में दिखाई देंगे?

— श्री Xcoder

@ Mr.Xcoder कोई डुप्लिकेट नहीं

— Chris_Rands 9

7

PPCG में आपका स्वागत है! पहले प्रश्न के लिए बहुत स्पष्ट और अच्छा। (y)

— आधिकारिक

3

बहुत अच्छा पहला सवाल! इसके जो उत्तर हैं वे इतने भिन्न और रचनात्मक हैं। :)

— लिन

23

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

lambda x:sorted(x,key=lambda y,B10=0:eval(y[1:]+'10'))

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

यह काम किस प्रकार करता है

y         y[1:]+'10'   eval(y[1:]+'10')
=======================================
VB        B10          0  (a variable we defined)
V0        010          8  (an octal literal)
V0+       0+10         10
V1        110          110
V2        210          210
...       ...          ...
V17       1710         1710

— लिन
स्रोत

ऐसा लगता है कि ईएस 6 को पोर्ट करना अरनुल्ड के दृष्टिकोण को हरा नहीं सकता है: a=>a.sort((a,b,B10=0)=>(g=s=>eval(s.slice(1)+10))(a)>g(b))58 बाइट्स हैं।

— लिन

1

a=>a.sort((a,b)=>(g=s=>eval(s.slice(B10=1)+10))(a)-g(b))2 बाइट्स छोटा है, लेकिन यह अभी भी बहुत लंबा है।

— अरनौलड

@ जीबी मुझे लगता है कि यह मान्य था, लेकिन अब यह निश्चित रूप से मान्य है।

— लिन

क्यों '10' का उपयोग करें और कुछ छोटा नहीं है? उदाहरण के लिए '2' 2 बाइट्स बचाता है।

— जीबी

1

@ जीबी ट्रिकल ऑक्टालेशन "010" से 8 तक "V0" के लिए दशमलव के रूप में अनुवाद को ट्रिगर करने के लिए है। 2 के साथ, आपको "02" = 2 मिलेगा, जो "0 + 2" के समान है।

— अरनुलद

15

जावास्क्रिप्ट (ईएस 6) / फ़ायरफ़ॉक्स, 53 बाइट्स

a=>a.sort((a,b)=>(g=s=>parseInt(s,32)%334+s)(a)>g(b))

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

फ़ायरफ़ॉक्स के लिए:

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

let f =

a=>a.sort((a,b)=>(g=s=>parseInt(s,32)%334+s)(a)>g(b))

console.log(JSON.stringify(f([])))
console.log(JSON.stringify(f(['V1'])))
console.log(JSON.stringify(f(['V7', 'V12', 'V1'])))
console.log(JSON.stringify(f(['V13', 'V14', 'VB', 'V0'])))
console.log(JSON.stringify(f(['V0+', 'V0', 'V16', 'V2', 'VB', 'V6'])))

स्निपेट का विस्तार करें

क्रोम या एज (+4 बाइट्स) के लिए:

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

let f =

a=>a.sort((a,b)=>(g=s=>parseInt(s,32)%334+s)(a)>g(b)||-1)

console.log(JSON.stringify(f([])))
console.log(JSON.stringify(f(['V1'])))
console.log(JSON.stringify(f(['V7', 'V12', 'V1'])))
console.log(JSON.stringify(f(['V13', 'V14', 'VB', 'V0'])))
console.log(JSON.stringify(f(['V0+', 'V0', 'V16', 'V2', 'VB', 'V6'])))

स्निपेट का विस्तार करें

कैसे?

हम 3 क्रमिक परिवर्तनों को लागू करते हैं जो लेक्सिकोग्राफ़िक रूप से तुलनीय तारों की ओर ले जाते हैं।

s     | Base32 -> dec. | MOD 334 | +s
------+----------------+---------+---------
"VB"  |           1003 |       1 | "1VB"
"V0"  |            992 |     324 | "324V0"
"V0+" |            992 |     324 | "324V0+"
"V1"  |            993 |     325 | "325V1"
"V2"  |            994 |     326 | "326V2"
"V3"  |            995 |     327 | "327V3"
"V4"  |            996 |     328 | "328V4"
"V5"  |            997 |     329 | "329V5"
"V6"  |            998 |     330 | "330V6"
"V7"  |            999 |     331 | "331V7"
"V8"  |           1000 |     332 | "332V8"
"V9"  |           1001 |     333 | "333V9"
"V10" |          31776 |      46 | "46V10"
"V11" |          31777 |      47 | "47V11"
"V12" |          31778 |      48 | "48V12"
"V13" |          31779 |      49 | "49V13"
"V14" |          31780 |      50 | "50V14"
"V15" |          31781 |      51 | "51V15"
"V16" |          31782 |      52 | "52V16"
"V17" |          31783 |      53 | "53V17"

— Arnauld
स्रोत

क्या आप आधार रूपांतरण / मोडुलो विचार के साथ आए थे? प्रतिभाशाली!

— kamoroso94

1

@ kamoroso94 FWIW, यहां वह कोड है जो मैंने आधार और मोडुलो को खोजने के लिए लिखा था। यह कुछ अन्य संभावित उत्तर देता है (एम <1000 के साथ)।

— अरनुलद

मैंने a=>a.sort((a,b)=>(g=s=>parseInt(s,32)%334+s)(a)>g(b))क्रोम पर कोशिश की , यह सही उत्तर f(["VB","V0","V0+","V1","V2","V3","V4","V5","V6","V7","V8","V9","V10","V11","V12","V13","V14","V15","V16","V17"])नहीं देता कि मुझे यकीन नहीं है कि क्यों; क्रोम पर किनारे-संगत संस्करण ठीक काम करता है।

— 15:

1

@ Ra8 आह, हाँ। यह Chrome के लिए भी अस्थिर प्रतीत होता है। एक प्रकार () कॉलबैक से एक बूलियन वापस करना सिर्फ एक हैक है जो फ़ायरफ़ॉक्स में काम करने के लिए होता है, लेकिन हम वास्तव में एक हस्ताक्षरित मूल्य वापस करने वाले हैं। आपकी प्रतिक्रिया के लिए धन्यवाद!

— अरनौलड

12

भूसी , 5 बाइट्स

ÖiÖm±

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

व्याख्या

यह आश्चर्यजनक रूप से मार्टिन के रेटिना उत्तर के समान है । पहले हम करते हैं Öm±, जिसका अर्थ है "मानचित्रण द्वारा क्रम-अंक"। यह डालता है VB, V0और V0+सही क्रम में, चूंकि उनकी तुलना की जाती है [0,0], [0,1]और [0,1,0]। अगला हम करते हैं Öi, जिसका अर्थ है "पूर्णांक मूल्य द्वारा आदेश"। एक स्ट्रिंग को देखते हुए, iइसमें पूर्णांक के रूप में होने वाले अंकों का पहला अनुक्रम लौटाता है, या यदि नहीं मिला है, तो 0। उपरोक्त तीन तार 0 पर मैप किए गए हैं और सॉर्ट स्थिर है, इसलिए वे आउटपुट में सही क्रम में होंगे।

— Zgarb
स्रोत

11

रेटिना , 14 बाइट्स

B
!
O`
!
B
O#`

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

व्याख्या

B
!

सभी न्यूमेरिक ग्रेड के सामने ग्रेड (या फिर ) के लेक्सोग्राफ़िक क्रम को प्रतिस्थापित Bकरें ।!VBV!

O`

सभी इनपुट लाइनों को क्रमबद्ध रूप से क्रमबद्ध करें। यह सही परिणाम नहीं देता है लेकिन यह V! < V0 < V0+सही ढंग से आदेश देता है।

!
B

में V!वापस मुड़ें VB।

O#`

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

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

6

वी , 3 बाइट्स

Úún

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

यह कैसे काम करता है?

ú   # Sort on...
 n  #   the first decimal number on the line

यह आदेश लगभग एक वैध समाधान है, क्योंकि हर पंक्ति जिसे संख्याओं (AKA ) द्वारा क्रमबद्ध नहीं किया जा सकता है VB, बिना क्रम बदले, शुरुआत में रखा जाएगा। हालांकि, बाद से यह केवल संख्या को देख रहा है, यह के बीच भेद नहीं कर सकते हैं V0और V0+। चूंकि विम एक स्थिर प्रकार का उपयोग करता है, इनमें से जो भी पहले आया उसे छांटने के बाद पहले स्थान पर रहेगा। इसलिए...

Ú   # Sort lexicographically (will place 'V0' before 'V0+')
 ú  # Sort by...
  n #   The first number on the line

— DJMcMayhem
स्रोत

2

इस चुनौती पर V कितना अच्छा करता है: P

— बिजनेस कैट

5

सी #, 121 83 82 83 बाइट्स

सहेजी गयी 39 TheLethalCoder और LiefdeWen करने के लिए धन्यवाद बाइट्स

a=>a.OrderBy(x=>x[1]>65?-1:x=="V0+"?0.5:int.Parse(x.Remove(0,1)))

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

बायटेकाउंट में शामिल हैं using System.Linq।

कैसे?

इनपुट के रूप में स्ट्रिंग्स की एक सरणी मिलती है।
यदि इनपुट के बराबर है VB, तो मान को -1 पर सेट करें, यदि यह बराबर है VB0+, तो मान को 0 पर सेट करें।
के बाद आने वाले नंबर मान के आधार पर इनपुट का आदेश दें V।

थोड़ा हैक हो सकता है, लेकिन यह काम करता है! :)

— इयान एच।
स्रोत

94 बाइट्स

— LiefdeWen

@ LiefdeWen आप ToArray()एक IOrderedEnumerableठीक होना चाहिए की जरूरत नहीं है।

— TheLethalCoder

क्षमा करें, System.Linq संदर्भ को आकस्मिक रूप से हटा दिया गया, इसे ठीक कर दिया

— LiefdeWen

@ TheLethalCoder आप हमेशा की तरह सही हैं, 84 बाइट्स

— LiefdeWen

@LiefdeWen .Remove(0,1)अतिरिक्त -1 बाइट के लिए :)

— इयान एच।

4

रूबी , 52 42 41 बाइट्स

->x{[?B,0,"0+",*1..17].map{|a|"V#{a}"}&x}

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

यह काम किस प्रकार करता है:

समस्या को चारों ओर घुमाएं, पूरी छँटाई सूची का उत्पादन करें, फिर हमारे इनपुट के साथ प्रतिच्छेदन प्राप्त करें।

धन्यवाद 1 बाइट बचाने के लिए लिन।

— जीबी
स्रोत

चतुर! ->x{[?B,0,"0+",*1..17].map{|a|"V#{a}"}&x}एक बाइट बचाता है।

— लिन

2

पायथ , 16 बाइट्स

ओपी द्वारा पोर्ट ऑफ पायथन का जवाब ।

o|hx"B00+"tN+3st

टेस्ट सूट ।

— लीक नन
स्रोत

2

05AB1E , 17 13 8 बाइट्स

Σþï}„VB†

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

— आउटगोल्फर को एरिक करें
स्रोत

हा ... लूंग-शॉट †से बेहतर है D"VB"åiÁ।

— मैजिक ऑक्टोपस Urn

2

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

Ḋv-.F+LµÞ

पात्रों की सूचियों की सूची लेने और क्रमबद्ध सूची को वापस करने के लिए एक विवादास्पद लिंक।

इसे ऑनलाइन आज़माएं! (पाद लेख अच्छी तरह से परिणाम स्वरूप)

कैसे?

Ḋv-.F+LµÞ - Link: list of lists of characters
       µÞ - sort by key:
Ḋ         -   dequeue (remove the 'V' from the item)
  -.      -   literal -0.5
 v        -   evaluate as Jelly code with argument -0.5
          -   ...this means `VB` and `V0+` become -0.5
          -      (to binary and addition respectively)
          -      while others become their literal numbers
    F     -   flatten
     +L   -   add the length of the item
          -   ...'VB', 'V0', 'V0+', 'V1', 'V2'... -> 1.5, 2, 2.5, 3, 4, ...

— जोनाथन एलन
स्रोत

2

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

f l=['V':x|x<-"B":"0":"0+":map show[1..17],_:y<-l,x==y]

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

— XNOR
स्रोत

2

~~यहाँ चीजों को किक करने के लिए मेरा पायथन 3 समाधान है ...~~ क्षमा याचना, इसे जल्द ही सम्मेलन के खिलाफ पोस्ट किया, अब पुनः पोस्ट कर रहा है ...

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

lambda l:sorted(l,key=lambda x:'B00+'.find(x[1:])+1or int(x[1:])+3)

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

— Chris_Rands
स्रोत

5

यह आपकी अपनी चुनौती का तुरंत जवाब देने के लिए हतोत्साहित है। कुछ अन्य लोगों को जवाब देने के लिए कुछ समय दें, कम से कम 48 घंटे, शायद लंबे समय तक।

— TheLethalCoder

@ TheLethalCoder ओह ठीक है, स्टैक ओवरफ्लो पर इस तरह के व्यवहार को प्रोत्साहित किया जाता है! क्या मुझे अपना उत्तर हटा देना चाहिए?

— क्रिस_ैंड्स

@Chris_Rands हां, मैं आपको इसे हटाने का सुझाव देता हूं।

— श्री Xcoder

9

@Downvoter: कुछ नया करने के लिए एक नए सदस्य को नीचे उतारना, जो उन्हें नहीं पता था कि वह ठंडा नहीं है; बहुत आसान है कि वे इशारा न करें, जैसा कि घातक ने किया था।

— झबरा

ध्यान दें कि यदि कोई आपके समाधान को पोस्ट नहीं करता है तो आप ऐसा करने के लिए स्वागत करते हैं। कोर्स के इंतजार के बाद

— TheLethalCoder

1

स्विफ्ट 3 , 102 बाइट्स

var r={String((Int($0,radix:32) ?? 992)%334)+$0};func f(l:[String]){print(l.sorted(by:{r($0)<r($1)}))}

यह एक फंक्शन है। आप इसे इस प्रकार कह सकते हैं:

f(l:["V0","VB","V13","V0+"])

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

यह कैसे काम करता है?

यह मूल रूप से @Arnauld द्वारा अद्भुत जावास्क्रिप्ट उत्तर का एक बंदरगाह है , लेकिन स्विफ्ट के लिए अनुकूलित है।

यह मानों में से प्रत्येक को लेक्सोग्राफिक रूप से क्रमबद्ध स्ट्रिंग्स के रूप में नीचे दी गई तालिका में दिखाया गया है:

प्रारंभिक स्ट्रिंग -> परिणाम

V1 -> 325V1
V10 -> 46V10
V11 -> 47V11
V12 -> 48V12
V13 -> 49V13
V14 -> 50V14
V15 -> 51V15
V16 -> 52V16
V17 -> 53V17
V2 -> 326V2
V3 -> 327V3
V4 -> 328V4
V5 -> 329V5
V6 -> 330V6
V7 -> 331V7
V8 -> 332V8
V9 -> 333V9
V0 + -> 324V0 +
V0 -> 324V0
वीबी -> 1 वीबी

कोड स्पष्टीकरण

String((Int($0,radix:32) ?? 992)%334)- प्रत्येक स्ट्रिंग को आधार -32 संख्या से दशमलव में परिवर्तित करता है। यदि मान "V0 +" है, तो कॉल को Int(_:radix:)शून्य पर लौटना होगा, और हम "V0", 992 का मान लेते हैं। हम इसके परिणाम को लेते हैं mod 334, और अंत में इसे स्ट्रिंग में परिवर्तित करते हैं।
+$0- ऊपर बनाए गए स्ट्रिंग के लिए वर्तमान मूल्य जोड़ता है। उदाहरण के लिए, यदि स्ट्रिंग है V9, तो रिटर्न के ऊपर का फ़ंक्शन 333और हम जोड़ते हैं V9, जिसके परिणामस्वरूप 333V9।
var r={...}- rएक अनाम बंद करने के लिए एक चर घोषित करता है , क्योंकि यह दो बार इस्तेमाल होने के बाद से बहुत सारे बाइट्स बचाता है।
func f(l:[String])- एक फ़ंक्शन fको एक पैरामीटर l, स्ट्रिंग्स की एक सूची के साथ परिभाषित करता है ।
print(l.sorted(by:{r($0)<r($1)}))- दी गई सूची को छांटने के परिणाम को प्रिंट करता है, जिसमें कुंजी rऊपर परिभाषित चर है।

— मिस्टर एक्सकोडर
स्रोत

1

पॉवरशेल , 45 बाइट्स

param($a)'B',0,'0+'+1..17|%{"V$_"}|?{$_-in$a}

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

उसी प्रक्रिया का उपयोग करता है जैसे कि GB की रूबी उत्तर क्रम में पूर्ण तर्क सूची बनाने के लिए करती है, फिर उन लोगों का चयन करें -inजो इनपुट सूची हैं।

— AdmBorkBork
स्रोत

1

Google शीट, 142 बाइट्स

=ArrayFormula(If(A1="","",Sort(Transpose(Split(A1,",")),Transpose(IfError(Find(Split(A1,","),"VBV0V0+"),Value(Mid(Split(A1,","),2,3))+9)),1)))

इनपुट एक स्ट्रिंग है A1जिसमें प्रत्येक प्रविष्टि अल्पविराम द्वारा अलग होती है।
आउटपुट सूत्र की कोशिका है और इसके n-1नीचे की कोशिकाएँ जहाँ nप्रविष्टियाँ की संख्या है A1।

यह एक लंबा, गन्दा फार्मूला है तो चलो इसे अनपैक करें।

If(A1="","",~)अशक्त इनपुट को ठीक करता है। इसके बिना, खाली इनपुट #VALUE!त्रुटि देता है क्योंकि Splitफ़ंक्शन रिक्त इनपुट पर काम नहीं करता है।
Transpose(Split(A1,","))विभाजन A1के लिए अल्पविराम पर और एक कॉलम में यह transposes क्योंकि Sortसमारोह केवल स्तंभों पर काम करता है।
Transpose(IfError(Find(),Value()+9)) इन टुकड़ों में टूट गया है:
- Find(Split(A1,","),"VBV0V0+")उस स्ट्रिंग में प्रत्येक पैरामीटर खोजने की कोशिश करता है। ये पहले तीन एकमात्र ऐसे हैं जिन्हें तार के रूप में क्रमबद्ध किया जाना चाहिए ताकि हम Findउनके क्रम को प्राप्त करने के लिए उपयोग करें।
- Value(Mid(Split(A1,","),2,3))+9ग्रेड का संख्यात्मक मूल्य प्राप्त होता है। यह केवल V1 और उच्चतर के लिए मायने रखता है ताकि वे संख्यात्मक रूप से ठीक-ठीक हल करें। +9अंत में यह सुनिश्चित करने के बाद से V1 के बाद V0 + आता है Findमूल्य होगा 5। तकनीकी रूप से, तब, केवल +5आवश्यकता होती है, लेकिन यह मुझे अतिरिक्त बाइट सुनिश्चित करने के लिए कोई और बाइट नहीं देता है, यह सुनिश्चित करता है कि यह सही तरीके से है।
- IfError(Find(~),Value(~))Findयदि स्ट्रिंग पाया गया था (यानी, ग्रेड VB, V0, या V0 + है) मान लौटाता है । यदि यह नहीं पाया जा सकता है, तो यह ग्रेड प्लस नौ का संख्यात्मक मान लौटाता है।
- Transpose(IfError(~))फिर से इसे एक कॉलम में बदल देता है ताकि Sortइसका उपयोग किया जा सके।
Sort(Transpose(Split(~)),Transpose(IfError(Find(~),Value(~)+9)),1) कस्टम सॉर्ट क्रम आरोही का उपयोग करके विभाजन इनपुट को छाँटकर यह सब लपेटता है।
ArrayFormula(~)संपूर्ण चीज़ को लपेटता है इसलिए यह उस सरणी में पहले मान को वापस करने के बजाय एक सरणी के रूप में परिणाम देता है। यही कारण है कि एक सेल में सूत्र इसके नीचे की कोशिकाओं को भरने के लिए भी कारण बनता है।

— इंजीनियर टोस्ट
स्रोत

मुझे लगता है कि यह पहली बार है जब मैंने कभी गूगल शीट्स का इस्तेमाल किया है। आप के लिए यश, और +1!

— हीथ

1

बैश + कोरुटिल्स, 21

tr B .|sort -V|tr . B

ग्नू sortके -Vऑरिजन सॉर्टिंग मोड में लगभग वही होता है जो हम चाहते हैं। Bएक के लिए स्विच .और हम कर रहे हैं।

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

— डिजिटल आघात
स्रोत

1

हास्केल , 90 84 83 61 बाइट्स

import Data.List
f"VB"=[]
f(_:'1':[a])='X':[a]
f x=x
sortOn f

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

fएक ऐसा फंक्शन है जो क्लाइम्बिंग ग्रेड को स्ट्रिंग्स में परिवर्तित करता है जिसकी तुलना की जा सकती है। धर्मान्तरित तो VBखाली स्ट्रिंग तो यह सर्वोच्च प्राथमिकता हो जाता है हो सकता है, यह तो बदल देता है V1के साथ Xतार कि तीन लंबी की प्राथमिकता कम करने के लिए कर रहे हैं में V10- V17। शेष के लिए हम कुछ नहीं करते हैं।

सूची उपयोग हम क्रमबद्ध करने के लिए Data.Listsकी sortOnहै (जैसा कि लिन ने सुझाव दिया) समारोह एक बिंदु मुक्त समारोह बनाने के लिए।

— गेहूं का जादूगर
स्रोत

वह बस है g=sortOn f, जो भीतर भी है Data.List।

— लिन

1

इसके अलावा, f(_:'1':a)='X':a4 बाइट्स बचाता है!

— लिन

1

@Lynn पहला सुझाव काम करता है, हालांकि दूसरा नहीं, मुझे जरूरत है [a]अन्यथा V1पैटर्न से मिलान किया जाएगा जो समस्या है जिसे मैं दरकिनार करने की कोशिश कर रहा हूं।

— गेहूं जादूगर

1

आर , 45 बाइट्स

l=paste0('V',c('B','0','0+',1:17));l[l%in%x]

यह कैसे काम करता है?

ग्रेड के सही क्रमबद्ध वेक्टर को 'l' में असाइन करें;
- 'Sep = "" "तर्क बनाने से बचने के लिए' पेस्ट 'के बजाय' paste0 'का उपयोग करें;
मिश्रित, बिना ग्रेड के आपके इनपुट वेक्टर में 'l' के मिलान के आधार पर सूचकांक 'l'।

— हिमस्खलन
स्रोत

0

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

sorted(input(),key=lambda s:float(s[1:].replace("B","-1").replace("+",".5")))

— Setop
स्रोत

मुझे लगता है कि यह एक स्निपेट के रूप में गिना जाता है! क्योंकि आप न तो परिणाम प्रिंट कर रहे हैं और न ही यह एक फ़ंक्शन परिभाषा है। आप इसे एक लैम्ब्डा में बना सकते हैं या परिणाम को प्रिंट कर सकते हैं।

— आधिकारिक १२

1

@officialaimm अच्छा प्रयास करें, लेकिन V0 से पहले V0 + s पर काम न करें।

— सेट अप

0

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

fØD
ṢÇÞÇV$Þ

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

— आउटगोल्फर को एरिक करें
स्रोत

0

TXR लिस्प : 45 बाइट्स

(op sort @1 :(ret`@(mod(toint @1 32)334)@1`))

चलाएँ:

1> (op sort @1 :(ret`@(mod(toint @1 32)334)@1`))
#<interpreted fun: lambda (#:arg-01-0168 . #:rest-0167)>
2> [*1 ()]
nil
3> [*1 (list "V0+" "V0" "V16" "V2" "VB" "V6")]
("VB" "V0" "V0+" "V2" "V6" "V16")

— Kaz
स्रोत

0

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

map{$i=$_;s/V//;$a[/B/?0:/^0/?length:$_+2]=$i}@F;say"@a"

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

— Xcali
स्रोत

चढ़ाई के ग्रेड को छाँटें

प्रसंग

कार्य

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

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

यह काम किस प्रकार करता है

जावास्क्रिप्ट (ईएस 6) / फ़ायरफ़ॉक्स, 53 बाइट्स

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

कैसे?

भूसी , 5 बाइट्स

व्याख्या

रेटिना , 14 बाइट्स

व्याख्या

वी , 3 बाइट्स

यह कैसे काम करता है?

सी #, 121 83 82 83 बाइट्स

रूबी , 52 42 41 बाइट्स

यह काम किस प्रकार करता है:

पायथ , 16 बाइट्स

05AB1E , 17 13 8 बाइट्स

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

कैसे?

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

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

स्विफ्ट 3 , 102 बाइट्स

यह कैसे काम करता है?

कोड स्पष्टीकरण

पॉवरशेल , 45 बाइट्स

Google शीट, 142 बाइट्स

बैश + कोरुटिल्स, 21

हास्केल , 90 84 83 61 बाइट्स

आर , 45 बाइट्स

यह कैसे काम करता है?

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

TXR लिस्प : 45 बाइट्स

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