আমার প্রথম কোড গল্ফ পোস্ট, কোনও ভুলের জন্য ক্ষমা ...

প্রসঙ্গ

রক ক্লাইম্বিংয়ে ( বিশেষত বোল্ডারিংয়ে ), ভি / ভার্মিন (ইউএসএ) আরোহণের গ্রেডগুলি 'ভিবি' (সবচেয়ে সহজ গ্রেড) থেকে শুরু হয় এবং তারপরে 'ভি0', 'ভি0 +', 'ভি 1', 'ভি 2', 'ভি 3' যান , 'ভি 4', 'ভি 5' ইত্যাদি 'ভি 17' (সবচেয়ে শক্ত গ্রেড) অবধি

কার্য

আপনি ইনপুট হিসাবে আরোহণ গ্রেডের একটি তালিকা / অ্যারে হিসাবে নেবেন এবং আপনাকে সহজ থেকে কঠোরতমভাবে সাজানো গ্রেডগুলির তালিকা / অ্যারেটি ফিরিয়ে দিতে বা মুদ্রণ করতে হবে।

যদি ইনপুট ফাঁকা থাকে, একটি খালি ডেটা কাঠামোটি ফিরিয়ে দিন; অন্যথায় ইনপুট সর্বদা একটি বৈধ হবে।

পরীক্ষার মামলা

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
সূত্র

পরের বার, পোস্ট করার আগে প্রতিক্রিয়া পেতে এটি স্যান্ডবক্সে পোস্ট করুন। দ্বিতীয়ত, আপনার নিজের চ্যালেঞ্জটির সত্যই উত্তর দেওয়া উচিত?

— ইয়ান এইচ।

ডুপ্লিকেট গ্রেডগুলি ইনপুটটিতে উপস্থিত হবে?

— মিঃ এক্সকোডার

@ মিঃ এক্সকোডার কোনও সদৃশ নেই

— ক্রিস_আরেন্ডস

7

পিপিসিজিতে আপনাকে স্বাগতম! প্রথম প্রশ্নের জন্য বেশ পরিষ্কার এবং সুন্দর। (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

— লিন
সূত্র

দেখে মনে হচ্ছে এটি ES6 এ পোর্ট করা আরনাউল্ডের পদ্ধতিকে হারাতে পারে না: 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 বাইট সংক্ষিপ্ত, তবে এটি এখনও অনেক দীর্ঘ।

— আর্নৌল্ড

@ জিবি আমি মনে করি এটি বৈধ ছিল তবে এখন এটি অবশ্যই কার্যকর valid

— লিন

'10' ব্যবহার করুন এবং আরও ছোট কিছু কেন করবেন না? উদাহরণস্বরূপ '2' 2 বাইট সংরক্ষণ করে।

— জিবি

1

@GB The trick is to trigger the translation from the octal notation "010" to 8 as decimal for "V0". With 2, you'd get "02" = 2, which is the same as "0+2".

— Arnauld

15

JavaScript (ES6) / Firefox, 53 bytes

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

Test cases

For Firefox:

Show code snippet

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'])))

Expand snippet

For Chrome or Edge (+4 bytes):

Show code snippet

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'])))

Expand snippet

How?

We apply 3 successive transformations that lead to lexicographically comparable strings.

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
সূত্র

Did you come up with the base conversion/modulo idea? Brilliant!

— kamoroso94

1

@kamoroso94 FWIW, here is the code that I wrote to find the base and the modulo. It gives some other possible answers (with m < 1000).

— Arnauld

I tried a=>a.sort((a,b)=>(g=s=>parseInt(s,32)%334+s)(a)>g(b)) on Chrome, it doesn't give the correct answer to f(["VB","V0","V0+","V1","V2","V3","V4","V5","V6","V7","V8","V9","V10","V11","V12","V13","V14","V15","V16","V17"]) I'm not sure why; the edge-compatible version works fine on chrome.

— Ra8

1

@Ra8 Ah, yes. It appears to be unstable for Chrome as well. Returning a boolean from a sort() callback is just a hack that happens to work in Firefox, but we really are supposed to return a signed value. Thanks for your feedback!

— Arnauld

12

Husk, 5 bytes

ÖiÖm±

Try it online! The results are printed one per line, but internally this is a function that takes and returns a list of strings.

Explanation

This is surprisingly similar to Martin's Retina answer. First we do Öm±, meaning "order by mapping is-digit". This puts VB, V0 and V0+ in the correct order, since they are compared as [0,0], [0,1] and [0,1,0]. Next we do Öi, meaning "order by integer value". Given a string, i returns the first sequence of digits occurring in it as an integer, or 0 if one is not found. The three strings above are all mapped to 0 and the sort is stable, so they will be in the correct order in the output.

— Zgarb
সূত্র

11

Retina, 14 bytes

B
!
O`
!
B
O#`

Try it online!

Explanation

B
!

Replace B with ! so that the lexicographic order of grades puts VB (or then V!) in front of all the numeric grades.

O`

Sort all input lines lexicographically. This doesn't give the right result but it does order V! < V0 < V0+ correctly.

!
B

Turn V! back into VB.

O#`

Sort the lines numerically. Retina simply looks for the first decimal number in a string to determines its sort key. If there is no number (such as for VB), it sets the value to 0. That means all of VB, V0 and V0+ have the same sort key. But Retina's sort is stable and we've already put them in the correct relative order.

— Martin Ender
সূত্র

6

V, 3 bytes

Úún

Try it online!

How does it work?

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

This command is almost a valid solution, since every line that can't be sorted by numbers (AKA, VB) will be placed at the beginning, without the order changed. However, since it's only looking at numbers, it can't distinguish between V0 and V0+. Since Vim uses a stable sort, whichever of these came first will remain first after sorting it. So...

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

— DJMcMayhem
সূত্র

2

How appropriate that V does well on this challenge :P

— Business Cat

5

C#, 121 83 82 83 bytes

Saved 39 bytes thanks to TheLethalCoder and LiefdeWen

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

Try it online!

Bytecount includes using System.Linq.

How?

Gets an array of strings as input.
If the input is equal to VB, set the value to -1, if it's equal to VB0+, set the value to 0.
Order the input based on the number value that comes after the V.

Might be a bit of a hack, but it works! :)

— Ian H.
সূত্র

94 bytes

— LiefdeWen

@LiefdeWen You don't need the ToArray() an IOrderedEnumerable should be fine.

— TheLethalCoder

Sorry accidently removed System.Linq reference, fixed it

— LiefdeWen

@TheLethalCoder You are right as always, 84 bytes

— LiefdeWen

@LiefdeWen .Remove(0,1) for additional -1 byte :)

— Ian H.

4

Ruby, 52 42 41 bytes

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

Try it online!

How it works:

Turn the problem around, produce the full sorted list, then get the intersection with our input.

Thanks Lynn for saving 1 byte.

— G B
সূত্র

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

— Lynn

2

Pyth, 16 bytes

Port of Python answer by OP.

o|hx"B00+"tN+3st

Test suite.

— Leaky Nun
সূত্র

2

05AB1E, 17 13 8 bytes

Σþï}„VB†

Try it online!

— Erik the Outgolfer
সূত্র

হা ... একটি লং শট †চেয়ে ভাল D"VB"åiÁ।

— ম্যাজিক অক্টোপাস আরন

2

জেলি , ৯bytes

Ḋv-.F+LµÞ

A monadic link taking a list of lists of characters and returning the sorted list.

এটি অনলাইন চেষ্টা করুন! (the footer formats the result nicely)

কিভাবে?

Ḋ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

~~To kick things off here is my Python 3 solution...~~ Apologies, posted this too soon against convention, now re-posting...

Python 3, 69 67 bytes

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

Try it online!

— Chris_Rands
সূত্র

5

অবিলম্বে আপনার নিজের চ্যালেঞ্জের জবাব দিতে নিরুৎসাহিত করা হয়েছে। কিছু অন্যান্য লোককে উত্তর দেওয়ার জন্য কিছুটা সময় দিন, কমপক্ষে ৪৮ ঘন্টা, সম্ভবত এটি আরও দীর্ঘ।

— TheLethalCoder

@ লেথলকোডার ঠিক আছে, স্ট্যাক ওভারফ্লোতে এমন আচরণকে উত্সাহ দেওয়া হচ্ছে! আমার উত্তর মুছে ফেলা উচিত?

— ক্রিস_র্যান্ডস

@ ক্রিস_আর্যান্ডস হ্যাঁ, আমি আপনাকে এটি মুছে ফেলার পরামর্শ দিই।

— মিঃ এক্সকোডার

9

@ ডাউনভোটার: নতুন সদস্যকে এমন কিছু করার জন্য যে তারা জানত না যে তাকে শীতল করা উচিত নয়; মারাত্মকভাবে যেমনটি করা উচিত ছিল তেমনভাবে উল্লেখ করা আরও ভাল।

— ঝাঁকুনি

নোট যদিও কেউ আপনার সমাধান পোস্ট না করে আপনি এটি করতে স্বাগত জানাই। অবশ্যই অপেক্ষা করার পরে

— 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+"])

এটি অনলাইন চেষ্টা করুন!

কিভাবে কাজ করে?

এটি মূলত @ আর্নল্ডের আশ্চর্যজনক জাভাস্ক্রিপ্ট উত্তরের একটি বন্দর , তবে সুইফ্টের জন্য অনুকূলিত।

এটি নীচের সারণীতে বর্ণিত প্রতিটি মানকে ডিক্সিকোগ্রাফিকভাবে অরিবেশনীয় স্ট্রিংয়ের মানচিত্র দেয়:

প্রাথমিক স্ট্রিং -> ফলাফল

ভি 1 -> 325V1
ভি 10 -> 46 ভি 10
ভি 11 -> 47 ভি 11
ভি 12 -> 48 ভি 12
ভি 13 -> 49 ভি 13
ভি 14 -> 50 ভি 14
ভি 15 -> 51 ভি 15
ভি 16 -> 52 ভি 16
ভি 17 -> 53 ভি 17
ভি 2 -> 326 ভি 2
ভি 3 -> 327V3
ভি 4 -> 328 ভি 4
ভি 5 -> 329V5
ভি 6 -> 330V6
ভি 7 -> 331V7
ভি 8 -> 332V8
ভি 9 -> 333V9
ভি0 + -> 324V0 +
ভি0 -> 324V0
ভিবি -> 1 ভিবি

কোড ব্যাখ্যা

String((Int($0,radix:32) ?? 992)%334)- প্রতিটি স্ট্রিংকে একটি বেস -32 নম্বর থেকে দশমিক হিসাবে রূপান্তর করে। মান "V0 +" এর ক্ষেত্রে, কলটি Int(_:radix:)শূন্য হবে এবং আমরা "V0", 992 এর মান নিই We আমরা অতিরিক্তভাবে ফলাফলটিও গ্রহণ করি 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}

এটি অনলাইন চেষ্টা করুন!

সাজানো ক্রমে পুরো আর্গুমেন্ট তালিকাটি তৈরি করতে জিবি'র রুবি উত্তর হিসাবে একই প্রক্রিয়াটি ব্যবহার করে , তারপরে -inইনপুট তালিকাটি নির্বাচন করুন।

— AdmBorkBork
সূত্র

1

গুগল শিটস, 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কমাতে বিভক্ত হয়ে এটিকে একটি কলামে স্থানান্তর করে কারণ Sortফাংশনটি কেবল কলামগুলিতে কাজ করে।
Transpose(IfError(Find(),Value()+9)) এই টুকরো টুকরো টুকরো হয়:
- Find(Split(A1,","),"VBV0V0+")সেই স্ট্রিংয়ের প্রতিটি প্যারামিটার সন্ধান করার চেষ্টা করে। এই প্রথম তিনটি কেবলমাত্র স্ট্রিং হিসাবে বাছাই করা উচিত তাই আমরা Findতাদের সাজানোর ক্রম পেতে ব্যবহার করি ।
- Value(Mid(Split(A1,","),2,3))+9গ্রেডের সংখ্যাসূচক মান পায়। এটি কেবল ভি 1 এবং উচ্চতরর জন্য গুরুত্বপূর্ণ তাই তারা সংখ্যার দিক দিয়ে ঠিক সূক্ষ্ম করে। +9শেষে তা নিশ্চিত করার জন্য যেহেতু তার V1 থেকে পরে V0 + + আসে Findমান হতে হবে 5। প্রযুক্তিগতভাবে, তবে, কেবলমাত্র +5প্রয়োজনীয় তবে এটি সঠিকভাবে সাজানোর জন্য অতিরিক্ত দ্বিগুণ নিশ্চিত করতে আমার আর কোনও বাইট ব্যয় করতে হবে না।
- IfError(Find(~),Value(~))Findস্ট্রিংটি পাওয়া গেলে মানটি প্রদান করে (যেমন, গ্রেডটি ভিবি, ভি0, বা ভি0 +)। যদি এটি সন্ধান না করা যায় তবে এটি গ্রেড প্লাস নাইন এর সংখ্যাসম্যটি প্রদান করে।
- 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

@ লিন প্রথম পরামর্শটি কাজ করে, তবে দ্বিতীয়টি তা করে না, আমার দরকার [a]অন্যথায় V1প্যাটার্নটি মিলবে যা আমি সমস্যা সমাধানের চেষ্টা করছি।

— গম উইজার্ড

1

আর , 45 বাইট

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

কিভাবে কাজ করে?

গ্রেডের সঠিক অর্ডারযুক্ত ভেক্টরকে 'l' এ নিয়োগ করুন;
- 'সেপ = "" যুক্তি তৈরি করা এড়াতে' পেস্ট 'এর পরিবর্তে' পেস্ট0 'ব্যবহার করুন;
মিশ্রিত, অমীমাংসিত গ্রেডের আপনার ইনপুট ভেক্টরে 'l' এর মিলগুলির উপর ভিত্তি করে সূচক 'l'।

— Mendizale
সূত্র

0

পাইথন 2, 77 বাইট

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

— Setop
সূত্র

আমি মনে করি এটি একটি স্নিপেট হিসাবে গণনা! কারণ আপনি ফলাফলটি মুদ্রণ করছেন না বা এটি কোনও কার্য সংজ্ঞা নয়। আপনি এটি একটি ল্যাম্বডায় তৈরি করতে পারেন বা ফলাফল মুদ্রণ করতে পারেন।

— অফিসিয়ালাইম

1

@officialaimm দুর্দান্ত চেষ্টা করে তবে V0 এর আগে V0 + s কাজ করে না।

— Setop

0

Jelly, 17 11 bytes

fØD
ṢÇÞÇV$Þ

Try it online!

— Erik the Outgolfer
সূত্র

0

TXR Lisp: 45 bytes

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

Run:

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

Perl 5, 56 + 1 (-a) = 57 bytes

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

Try it online!

— Xcali
সূত্র

আরোহণ গ্রেডগুলি বাছাই করুন

প্রসঙ্গ

কার্য

পরীক্ষার মামলা

পাইথন 2 , 58 54 বাইট

কিভাবে এটা কাজ করে

JavaScript (ES6) / Firefox, 53 bytes

Test cases

How?

Husk, 5 bytes

Explanation

Retina, 14 bytes

Explanation

V, 3 bytes

How does it work?

C#, 121 83 82 83 bytes

Ruby, 52 42 41 bytes

How it works:

Pyth, 16 bytes

05AB1E, 17 13 8 bytes

জেলি , ৯bytes

কিভাবে?

হাস্কেল , 55 বাইট

Python 3, 69 67 bytes

সুইফট 3 , 102 বাইট

কিভাবে কাজ করে?

কোড ব্যাখ্যা

পাওয়ারশেল , 45 বাইট

গুগল শিটস, 142 বাইট

বাশ + কোর্টিলস, 21

হাস্কেল , 90 84 83 61 বাইট

আর , 45 বাইট

কিভাবে কাজ করে?

Jelly, 17 11 bytes

TXR Lisp: 45 bytes

Perl 5, 56 + 1 (-a) = 57 bytes