बैंड के नाम छाँटें

Question

चुनौती का वर्णन

आप कई कई बैंड, जिनमें से प्रत्येक एक नाम है द्वारा दर्ज की पटरियों के साथ एक संगीत पुस्तकालय है, की तरह Queen, Aerosmith, Sunny Day Real Estate, The Strokes। जब कोई ऑडियो प्लेयर बैंड नाम से आपकी लाइब्रेरी को वर्णानुक्रम में प्रदर्शित करता है, तो यह आमतौर पर Theभाग को बंद कर देता है, क्योंकि कई बैंड नाम शुरू होते हैं The, जिससे आपके मीडिया संग्रह के माध्यम से नेविगेट करना आसान हो जाता है। इस चुनौती में, स्ट्रिंग्स की एक सूची (सरणी) को देखते हुए, आपको इसे इस तरह से सॉर्ट करने की आवश्यकता है (यानी, Theनाम की शुरुआत में शब्द को छोड़ देना )। आप या तो एक विधि या पूर्ण कार्य कार्यक्रम लिख सकते हैं।

नमूना इनपुट / आउटपुट

[Queen, Aerosmith, Sunny Day Real Estate, The Strokes] -> [Aerosmith, Queen, The Strokes, Sunny Day Real Estate]
[The Ramones, The Cure, The Pixies, The Roots, The Animals, Enrique Iglesias] -> [The Animals, The Cure, Enrique Iglesias, The Pixies, The Ramones, The Roots]
[The The, The They, Thermodynamics] -> [The The, Thermodynamics, The They]

नोट्स / एज मामले

• लेक्सोग्राफिक रूप से छांटना केस असंवेदनशील है, इसलिए The Police, The policeऔर the policeसभी समान हैं,

• आपके एल्गोरिथ्म को केवल पहले theशब्द को छोड़ना चाहिए , इसलिए नाम वाले बैंड The Theया The The Bandदूसरे द्वारा सामान्य रूप से सॉर्ट किए जाते हैं the,

• एक बैंड नाम The(एक तीन अक्षर का शब्द) सामान्य रूप से सॉर्ट किया जाता है (कोई लंघन नहीं),

• एक ही नाम वाले दो बैंडों का क्रम, जिनमें से एक की शुरुआत the(जैसे The Policeऔर Police) अपरिभाषित है,

• आप मान सकते हैं कि यदि एक बैंड के नाम में एक से अधिक शब्द हैं, तो वे एक ही स्थान वर्ण द्वारा अलग किए जाते हैं। आपको व्हाट्सएप के प्रमुख या अनुगामी को संभालने की आवश्यकता नहीं है,

• सभी इनपुट स्ट्रिंग्स का मिलान होता है [A-Za-z0-9 ]*, वे अंग्रेजी वर्णमाला, अंकों और अंतरिक्ष वर्णों के केवल निचले और बड़े अक्षरों से मिलकर होते हैं,

• याद रखें कि यह एक कोड-गोल्फ चुनौती है, इसलिए अपने कोड को यथासंभव छोटा करें!

Comments

क्या अंक-केवल नाम वर्णमाला के पहले या बाद में आते हैं?

— AdmBorkBork

— न्यूमरल

किस प्रकार का क्रम है Theऔर The The? (अधिकांश उत्तरों को शायद बदलने की आवश्यकता होगी यदि यह अपरिभाषित के अलावा कुछ भी हो)

— ब्रैड गिल्बर्ट b2gills

लॉस लोबोस के बारे में कैसे?

— njzk2

The वैसे एक वास्तविक बैंड है। (साथ साथ कौन, क्या, कहां, कब, क्यों, और कैसे)

— DanTheMan

Answer 1

पायथन, 56 62 64 बाइट्स

lambda b:sorted(b,key=lambda x:(x,x[4:])[x.lower()[:4]=='the '])

कोशिश करो

@Chris H को यह इंगित करने के लिए धन्यवाद कि lstrip()यह The Theसही ढंग से हैंडल नहीं हो रहा था , क्योंकि पट्टी सभी मिलान वर्णों को नष्ट कर रही थी और इसे रिक्त स्ट्रिंग के रूप में छांट रही थी, और @manatwork उपयोग में दोष खोजने के लिए replace()। नए संस्करण को काम करना चाहिए।

पुराना संस्करण:

lambda b:sorted(b,key=lambda x:x.lower().lstrip('the '))

Comments

मैं आश्वस्त नहीं हूं। अंतिम सूची में "जानवरों" को जोड़ना ['The The', 'The', 'The Animals', 'Thermodynamics', 'The They']। 2nd एज केस का सुझाव है कि ['द एनिमल', 'द', 'द', 'थर्मोडायनामिक्स', 'द वे'] या (2 और 3 आइटम स्वैप) होना चाहिए। थोड़ा सा अंदाजा लगाता है कि अंदर की जगह को strip('the ')नजरअंदाज किया जा रहा है - कोशिश करेंfor x in ['The The', 'The They', 'Thermodynamics', 'The', 'The Animals']: print (x.lower().strip('the '))

— क्रिस एच

यह replace()बहुत बेहतर नहीं है: 'what the snake'.replace('the ','',1)परिणाम 'what snake'।

— मैनटवर्क

Answer 2

वी , 32 28 बाइट्स

ç^The /dwA_
:sort
ç_/$xIThe 

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

स्वयं पर ध्यान दें: एक संक्षिप्त नाम दें :sortताकि मुझे एक आदेश के लिए 6 पूरे बाइट्स की आवश्यकता न हो!

स्पष्टीकरण:

ç^The /     "On every line starting with 'The ',
       dw   "Delete a word
         A_ "And (A)ppend an underscore '_'

:sort       "Sort all lines alphabetically

ç_/         "On every line containing an underscore,
   $x       "Delete the last character
     IThe   "And prepened 'The '

Comments

V से परिचित नहीं है, लेकिन ऐसा लगता है कि यह बिना तार के ठीक काम करता है। क्या यह संयोग इनपुट के साथ है, या वास्तव में अनावश्यक है?

— 21

@kirkpatt अच्छा विचार है! यह लगभग काम करता है, लेकिन काफी नहीं। उदाहरण के लिए, इस इनपुट के साथ यह गलत तरीके से "द रैमोन्स" और "द रूट्स" के बाद "रेडियोहेड" डालता है। हालांकि, कि मुझे एक विचार देता है ...

— DJMcMayhem

क्या होता है अगर theसभी लोअरकेस में है, जैसे the pAper chAse?

— AdmBorkBork

Answer 3

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

अनुगामी लाइनफीड महत्वपूर्ण है।

%`^
$';
T`L`l`.+;
m`^the 

O`
.+;

I / O प्रति पंक्ति एक बैंड है।

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

व्याख्या

%`^
$';

;विभाजक के रूप में उपयोग करके, प्रत्येक पंक्ति को डुप्लिकेट करें ।

T`L`l`.+;

;निचले मामले में सब कुछ सामने रखें ।

m`^the 

किसी भी thes को निकालें जो एक लाइन की शुरुआत में दिखाई देता है।

O`

लाइनों को छाँटें।

.+;

उन पंक्तियों की शुरुआत को हटा दें जो हमने छंटाई के लिए उपयोग किए थे।

Comments

क्या आप पहले 3 चरणों को एक चरण में पैक नहीं कर सकते हैं? PCRE की तरह: एस / (?i:the )?(.*)/ \L$1\E;$0/

— फाल्को

@Falco .NET प्रतिस्थापन स्ट्रिंग में केस परिवर्तन का समर्थन नहीं करता है और मैंने अभी तक उन्हें रेटिना के कस्टम प्रतिकृति में नहीं जोड़ा है।

— मार्टिन एंडर

Answer 4

पाइके, 16 बाइट्स

.#l1D"the ".^4*>

यहाँ कोशिश करो!

.#                - sort_by(V, input)
  l1              -  i = i.lower()
      "the ".^    -   i.startswith("the ")
              I   -  if ^:
               4> -   i[4:]

Answer 5

पर्ल, 52 बाइट्स

-13 बाइट के लिए धन्यवाद @manatwork
-1 बाइट के लिए @ msh210 को धन्यवाद

sub f{lc pop=~s/^the //ri}print sort{f($a)cmp f$b}<>

इनपुट के रूप में प्रति पंक्ति एक बैंड, और इसलिए आउटपुट है।

कार्यान्वयन काफी सीधे आगे है: कार्यक्रम एक कस्टम फ़ंक्शन ( f) की मदद से छांटे गए बैंड की सूची को प्रिंट करता है, जो अंतिम अग्रणी के बिना कम केस बैंड का नाम देता है the।

Comments

मिलान के बजाय प्रतिस्थापन के साथ कम है sub f{lc$_[0]=~s/^the //ir}:।

— manatwork 9

1 बाइट कम वास्तव में, धन्यवाद।

— दादा

वास्तव में मैं या तो 2 या 3 बाइट्स को छोटा मानता हूं: दोनों lcपैरामीटर के लिए कोष्ठक और iप्रतिस्थापन में ध्वज की कोई आवश्यकता नहीं है । या आप एक परीक्षण के मामले में मिले हैं जहां काम नहीं करता है?

— manatwork

यदि आप प्रत्येक बैंड का नाम अलग लाइन पर लेते हैं तो फिर से सोचने पर कमांड लाइन विकल्पों की मात्रा भी कम हो सकती है perl -e 'sub f{lc$_[0]=~s/^the //ri}print sort{f($a)cmp f$b}<>' <<< $'Queen\nAerosmith\nSunny Day Real Estate\nThe Strokes':।

— manatwork

तीन बाइट्स सहेजें lc popके बजाय lc$_[0], और sayके बजाय print। (उत्तरार्द्ध की आवश्यकता होती है -M5.01, जो मुफ़्त है।) स्ट्राबेरी में परीक्षण किया गया 5.20.2 प्रश्न से केवल पहला परीक्षण मामला है।

— msh210

Answer 6

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

lambda x:sorted(x,key=lambda a:a[4*(a.lower()[:4]=='the '):].lower())

"द" नाम के आधार पर कीवर्ड तर्क के sortedसाथ पायथन की विधि का उपयोग करता है key। यह एक मेमना है; इसे कॉल करने के लिए, इसे f=सामने रखकर एक नाम दें ।

अब अतिरिक्त मामले असंवेदनशीलता के साथ!

Comments

यह केस असंवेदनशीलता की आवश्यकता को पूरा नहीं करता है, हालांकि ... एक बैंड नाम के साथ शुरू हो सकता है the , जिस स्थिति में यह विधि ठीक से काम नहीं करेगी।

— shooqie

@shooqie ओह, मैंने वह आवश्यकता नहीं देखी। मैं इसे ठीक कर दूंगा।

— कॉपर

Answer 7

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

->a{a.sort_by{|s|s.upcase.sub /^THE /,''}}

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

Answer 8

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

*.sort({fc S:i/^'the '//})

स्पष्टीकरण:

# ｢*｣ is the input to this Whatever lambda
*.sort(

  # sort based on the return value of this Block lambda
  {
    fc # foldcase the following

    # string replace but not in-place
    S
      :ignorecase
      /
        # at the start of the string
        ^

        # match ｢the ｣
        'the '

      # replace with nothing
      //
  }
)

परीक्षा:

use v6.c;
use Test;

my @tests = (
  « Queen Aerosmith 'Sunny Day Real Estate' 'The Strokes' »
    => « Aerosmith Queen 'The Strokes' 'Sunny Day Real Estate' »,
  « 'The Ramones' 'The Cure' 'The Pixies' 'The Roots' 'The Animals' 'Enrique Iglesias' »
    => « 'The Animals' 'The Cure' 'Enrique Iglesias' 'The Pixies' 'The Ramones' 'The Roots' »,
  « 'The The' 'The They' Thermodynamics »
    => « 'The The' Thermodynamics 'The They' »,
);

# give it a lexical name for clarity
my &band-sort = *.sort({fc S:i/^'the '//});

plan +@tests;

for @tests -> ( :key(@input), :value(@expected) ) {
  is-deeply band-sort(@input), @expected, @expected.perl;
}

1..3
ok 1 - ("Aerosmith", "Queen", "The Strokes", "Sunny Day Real Estate")
ok 2 - ("The Animals", "The Cure", "Enrique Iglesias", "The Pixies", "The Ramones", "The Roots")
ok 3 - ("The The", "Thermodynamics", "The They")

Answer 9

PowerShell v2 +, 33 32 29 बाइट्स

$args|sort{$_-replace'^the '}

@MathiasRJessen के लिए 3 बाइट्स को सहेजा गया

इनपुट कमांड-लाइन तर्कों के माध्यम से है। स्क्रिप्ट ब्लॉक के परिणामों के आधार पर मूल नामों को सॉर्ट {...}करता है -replaceजो अग्रणी (केस-असंवेदनशील) को बाहर निकालने के लिए एक रेगेक्स करता है "the "।

उदाहरण

PS C:\Tools\Scripts\golfing> .\sort-band-names.ps1 'the Ramones' 'The cure' 'The Pixies' 'The Roots' 'the Animals' 'Enrique Iglesias'
the Animals
The cure
Enrique Iglesias
The Pixies
the Ramones
The Roots

PS C:\Tools\Scripts\golfing> .\sort-band-names.ps1 'The The' 'The They' 'Thermodynamics'
The The
Thermodynamics
The They

PS C:\Tools\Scripts\golfing> .\sort-band-names.ps1 'THE STOOGES' 'The Strokes' 'The The' 'the they' 'the band' 'STP'
the band
THE STOOGES
STP
The Strokes
The The
the they

Comments

-replaceडिफ़ॉल्ट रूप से असंवेदनशील है, '^the 'पैटर्न के लिए पर्याप्त होगा

— मैथियास आर जेसन

@ MathiasR.Jessen हाँ, अनुस्मारक के लिए धन्यवाद।

— AdmBorkBork

@ValueInk मैथियास की केस असंवेदनशीलता के बारे में टिप्पणी और अंतिम उदाहरण मैंने जोड़ा।

— AdmBorkBork

Answer 10

जावास्क्रिप्ट / ECMAScript 6 93 70 बाइट्स

70 सलाह के लिए नील और डाउनगेट का धन्यवाद

B=>B.sort((a,b)=>R(a).localeCompare(R(b)),R=s=>s.replace(/^the /i,''))

70-बाइट संस्करण के लिए पठनीय संस्करण

let sortBandNames = (bandNames) => {
    let stripThe = (name) => name.replace(/^the /i, '');
    let compareFunc = (a, b) => stripThe(a).localeCompare(stripThe(b));
    return bandNames.sort(compareFunc)
};

93

f=B=>{R=s=>s.toLowerCase().replace(/the /,'');return B.sort((a,b)=>R(a).localeCompare(R(b)))}

93-बाइट संस्करण के लिए पठनीय संस्करण

let sortBandNames = (bandNames) => {
    let stripThe = (name) => name.toLowerCase().replace(/the /, '');
    let compareFunc = (a, b) => stripThe(a).localeCompare(stripThe(b));
    return bandNames.sort(compareFunc)
};

Comments

कि regexp इसमें नहीं होना चाहिए ^? इसके अलावा, localeCompare मेरे सिस्टम पर असंवेदनशील है, इसलिए मुझे इसकी आवश्यकता नहीं थी toLowerCase, बस /iregexp पर एक ध्वज था। अंत में आप इसे निम्नानुसार गोल्फ कर सकते हैं: B=>B.sort((a,b)=>...,R=s=>...)- sortजो अतिरिक्त पैरामीटर सेट करता है, उसे अनदेखा करता है R।

— नील

रेगेक्स में ^ कहां जाएंगे? यह एक नकार होगी और अभिव्यक्ति "द" को मैच और मिटाने वाली होगी। मैं लोअर-केस रूपांतरण के बिना लोकेल तुलना का उपयोग करने का प्रयास करूँगा।

— पांडैकरोड

@Pandacoder शुगोल्ड रेगेक्स की ^शुरुआत में जाता है

— डाउगोएट

@Downgoat दिए गए सभी मामलों का परीक्षण करने से, और कुछ मामलों के साथ मैं विशेष रूप से RegEx को तोड़ने के इरादे से आया था, ^ के साथ या उसके बिना मुझे व्यवहार में कोई परिवर्तन नहीं मिलता है, केवल एक अतिरिक्त चरित्र जो कुछ भी पूरा नहीं करता है।

— पांडकोडर 23

@Pandacoder जो इसे वैध नहीं बनाता है। ^ एक एंकर है जिसे कल्पना के अनुसार शुरुआत में "द" की आवश्यकता होती है

— डाउनगोट

Answer 11

जावा 8, 178 बाइट्स

void q(String[]s){java.util.Arrays.sort(s,(a,b)->(a.toLowerCase().startsWith("the ")?a.substring(4):a).compareToIgnoreCase(b.toLowerCase().startsWith("the ")?b.substring(4):b));}

Ungolfed संस्करण:

void sort(String[] bands) {
    java.util.Arrays.sort(bands, (a, b) -> 
        (a.toLowerCase().startsWith("the ") ? a.substring(4) : a).compareToIgnoreCase(
            b.toLowerCase().startsWith("the ") ? b.substring(4) : b
        )
    );
}

इस तरह से कॉल करें:

public static void main(String[] args) {
    String[] bands = {"The Strokes", "Queen", "AC/DC", "The Band", "Cage the Elephant", "cage the elephant"};
    sort(bands); // or q(bands) in the golfed version
    System.out.println(java.util.Arrays.toString(bands));
}

Comments

मुझे पता है कि आपने लगभग एक साल पहले इसका उत्तर दिया है, लेकिन आप कुछ चीजों को गोल्फ कर सकते हैं। जब से तुम राज्य आप जावा 8 उपयोग करते हैं, आप बदल सकते हैं void q(String[]s){...}करने के लिए s->{...}। और आप दोनों के (x.toLowerCase().startsWith("the ")?x.substring(4):x)साथ बदल सकते हैं x.replaceFirst("(?i)the ","")। तो कुल हो जाता है: s->{java.util.Arrays.sort(s,(a,b)->a.replaceFirst("(?i)the ","").compareToIgnoreCase(b.replaceFirst("(?i)the ","")));}- 118 बाइट्स

— केविन क्रूज़सेन

रिप्लेसफर्स्ट के साथ नीट ट्रिक। जब मैंने इसका उत्तर दिया तो मुझे अन्य उत्तर पर कुछ बार बताया गया था जिसकी s->{ ... }अनुमति नहीं थी और मुझे टाइप और व्हाट्सएप के साथ एक पूर्ण विधि हस्ताक्षर होना चाहिए था। मैं नहीं जानता कि अगर तब से बदल गया है।

— जस्टिन

फिर वापस के बारे में निश्चित नहीं है, लेकिन इन दिनों इसकी अनुमति है और जावा या सी # .NET में गोल्फिंग के करीब सभी द्वारा उपयोग किया जाता है।

— केविन क्रूज़सेन

Answer 12

निम , 96 बाइट्स

import algorithm,strutils,future
x=>x.sortedByIt toLower it[4*int(it.toLower[0..3]=="the ")..^0]

^{वे importबहुत सारे बाइट्स लेते हैं:|}

मेरे पायथन उत्तर का अनुवाद ।

यह एक अनाम प्रक्रिया है; इसका उपयोग करने के लिए, इसे एक परीक्षण प्रक्रिया में पारित किया जाना चाहिए। यहाँ एक पूर्ण कार्यक्रम है जिसे आप परीक्षण के लिए उपयोग कर सकते हैं:

import algorithm,strutils,future
proc test(x: seq[string] -> seq[string]) =
 echo x(@["The The", "The They", "Thermodynamics"]) # Substitute your input here
test(x=>x.sortedByIt toLower it[4*int(it.toLower[0..3]=="the ")..^0])

Answer 13

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

import Data.List
p(t:'h':'e':' ':s)|elem t"Tt"=s
p s=s
sortBy(\a b->p a`compare`p b)

के साथ बुलाना

sortBy(\a b->p a`compare`p b)["The The", "The They", "Thermodynamics"]

परीक्षण का मामला:

let s = sortBy(\a b->p a`compare`p b)
and[s["Queen", "Aerosmith", "Sunny Day Real Estate", "The Strokes"]==["Aerosmith", "Queen", "The Strokes", "Sunny Day Real Estate"],s["The Ramones", "The Cure", "The Pixies", "The Roots", "The Animals", "Enrique Iglesias"]==["The Animals", "The Cure", "Enrique Iglesias", "The Pixies", "The Ramones", "The Roots"],s["The The", "The They", "Thermodynamics"]==["The The", "Thermodynamics", "The They"]]

Answer 14

MATL , 16 बाइट्स

tk'^the '[]YX2$S

इनपुट प्रारूप है (प्रत्येक पंक्ति एक परीक्षण मामले से मेल खाती है)

{'Queen', 'Aerosmith', 'Sunny Day Real Estate', 'The Strokes'} 
{'The Ramones', 'The Cure', 'The Pixies', 'The Roots', 'The Animals', 'Enrique Iglesias'}
{'The The', 'The They', 'Thermodynamics'}

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

व्याख्या

t        % Implicitly input cell array of strings. Push another copy
k        % Convert to lowercase
'^the '  % String to be used as regex pattern: matches initial 'the '
[]       % Empty array
YX       % Regex replacement: replace initial 'the ' in each string by empty array
2$S      % Sort input according to the modified cell array. Implicitly display

Answer 15

सी #, 139 बाइट्स

using System.Linq;System.Collections.IEnumerable S(string[] l)=> l.OrderBy(b=>(b.ToLower().StartsWith("the ")?b.Substring(4):b).ToLower());

ऑनलाइन कोशिश करो!

उत्तर गिनती के बिना जवाब 102 बाइट्स होगा।

Comments

मेरा मानना ​​है कि आप ToLower()केस-असंवेदनशील आवश्यकता के कारण फाइनल को अनदेखा कर सकते हैं

— TheLethalCoder

इसके अलावा आप इसे एक अनाम फ़ंक्शन बना सकते हैं जिसमें कुछ बाइट्स बचाना चाहिए:

— TheLethalCoder

l=>l.OrderBy(b=>(b.ToLower().StartsWith("the ")?b.Substring(4):b));67 बाइट्स के लिए और फिर आप पर जोड़ने की जरूरत using System.Linq;भी

— TheLethalCoder

@ TheLethalCoder: ToLowerकेस-असंवेदनशील आवश्यकता के कारण मुझे दूसरा चाहिए। अन्यथा आदेश केस-संवेदी होगा।

— raznagul

ठीक है कि इसे एक अनाम समारोह में परिवर्तित करने के बारे में अभी भी हालांकि खड़ा है

— TheLethalCoder

Answer 16

BASH, 64 बाइट्स

sed 's/^the / /;s/^The /    /'|sort -fb|sed 's/^ /the /;s/^ /The /'

इनपुट: स्टडिन, प्रति पंक्ति एक बैंड। आउटपुट: स्टडआउट

नोट: दूसरी प्रतिस्थापन (s / ^ / / और s / ^ / / /) टैब वर्ण का उपयोग करते हैं, इसलिए वे हमेशा सही तरीके से कॉपी / पेस्ट नहीं करते हैं।

Answer 17

बैश + कोरुटिल्स, 44 बाइट्स

sed '/^the /I!s,^,@ ,'|sort -dk2|sed s,@\ ,,

स्पष्टीकरण: इनपुट और आउटपुट प्रारूप प्रति पंक्ति एक बैंड है

sed '/^the /I!s,^,@ ,'   # prepend '@ ' to each line not starting with 'the ', case
                         #insensitive. This adds a temporary field needed by sort.
sort -dk2                # sort in ascending dictionary order by 2nd field onward
sed s,@\ ,,              # remove the temporary field

टेस्ट रन (अंत मार्कर के रूप में ईओएफ के साथ यहां-दस्तावेज़ का उपयोग करके):

./sort_bands.sh << EOF
> Queen
> Aerosmith
> Sunny Day Real Estate
> The Strokes
> EOF

आउटपुट:

Aerosmith
Queen
The Strokes
Sunny Day Real Estate

Answer 18

विम, 18 बाइट्स

अब जब मुझे एहसास हुआ कि यह संभव है, तो मैं अपने 26 बाइट वी उत्तर से शर्मिंदा हूं, खासकर जब से वी विम से छोटा माना जाता है। लेकिन यह बहुत ज्यादा एक बिलिन है।

:sor i/\(The \)*/<CR>

स्पष्टीकरण (विम सहायता से सीधे):

                            *:sor* *:sort*
:[range]sor[t][!] [b][f][i][n][o][r][u][x] [/{pattern}/]
            Sort lines in [range].  When no range is given all
            lines are sorted.

            With [i] case is ignored.

            When /{pattern}/ is specified and there is no [r] flag
            the text matched with {pattern} is skipped, so that
            you sort on what comes after the match.
            Instead of the slash any non-letter can be used.

Answer 19

सी, 216 212 135 + 5 ( qsort) = 221 217 140 बाइट्स

M(void*a,void*b){char*A,*B;A=*(char**)a;B=*(char**)b;A=strcasestr(A,"The ")?A+4:A;B=strcasestr(B,"The ")?B+4:B;return strcasecmp(A,B);}

खैर, मैं अंत में यह खत्म करने के लिए चारों ओर हो गया C। गोल्फ युक्तियाँ बहुत सराहना की है।

इस सबमिशन में, Mआपूर्ति की जाने वाली तुलना फ़ंक्शन है qsort। इसलिए, इस आह्वान करने के लिए, आप का उपयोग करना चाहिए qsortप्रारूप में qsort(argv++,argc--,8,M)जहां argvकमांड लाइन तर्क होता है और argcप्रदान किए गए तर्कों की संख्या है।

यह ऑनलाइन की कोशिश करो!

Answer 20

05AB1E , 27 बाइट्स (गैर-प्रतिस्पर्धात्मक)

vyð¡RD¤…TheQsgα£Rðý})‚øí{ø¤

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

व्याख्या

vyð¡RD¤…TheQsgα£Rðý})‚øí{ø¤   Argument l
v                 }           For each y in l, do:
 yð¡                            Split y on space
    RD                          Reverse and duplicate
      ¤…TheQ                    Last element equals "The" (true = 1, false = 0)
            sgα                 Absolute difference with length of array
               £                Get elements from index 0 to calculated difference
                R               Reverse
                 ðý             Join on space
                    )‚øí      Pair each element with original
                        {ø¤   Sort and get the original band name

Answer 21

ग्रूवी, 34 बाइट्स

{it.sort{it.toLowerCase()-'the '}}

41% मेरा जवाब है .toLowerCase(), मुझे अभी मार दो।

---

उत्पादन

जब चल रहा है ...

({it.sort{it.toLowerCase()-'the '}})(['The ramones','The Cure','The Pixies','The Roots','The Animals','Enrique Iglesias'])

परिणाम है...

[The Animals, The Cure, Enrique Iglesias, The Pixies, The ramones, The Roots]

कोई डीबग या त्रुटि आउटपुट के साथ।

Answer 22

क्यू / केडीबी +, ३६ ३३ बाइट्स

समाधान:

{x(<)@[x;(&)x like"[Tt]he *";4_]}

उदाहरण:

q){x(<)@[x;(&)x like"[Tt]he *";4_]}("Queen";"Aerosmith";"Sunny Day Real Estate";"The Strokes";"the Eagles")
"Aerosmith"
"the Eagles"
"Queen"
"The Strokes"
"Sunny Day Real Estate"

स्पष्टीकरण:

प्रत्येक इनपुट स्ट्रिंग से किसी भी "[टीटी] वह" को स्ट्रिप करें, इस सूची को सॉर्ट करें, फिर सॉर्ट की गई सूची के अनुक्रमण के आधार पर मूल सूची को सॉर्ट करें।

{x iasc @[x;where x like "[Tt]he *";4_]} / ungolfed solution
{                                      } / lambda function
        @[x;                       ;  ]  / apply function to x at indices
                                    4_   / 4 drop, remove first 4 items
            where x like "[Tt]he *"      / where the input matches 'The ...' or 'the ...'
   iasc                                  / returns sorted indices
 x                                       / index into original list at these indices

Answer 23

जाप , 11 10 बाइट्स

ñ_v r`^e 

कोशिश करो

Answer 24

जावा 176 158 बाइट्स

public String[]sort(String[]names){
  for(int i=-1;++i<names.length;)
    if(names[i].startsWith("(The |the )"))
      names[i]=names[i].substring(4);
  return Arrays.sort(names,String.CASE_INSENSITIVE_ORDER);
  }

मुख्य कार्य

public static void main(String[]args){
  Scanner s = new Scanner(System.in);
  List<String> list= new ArrayList<>();
  while(!(String h = s.nextLine).equalsIgnoreCase("~")){
    list.add(h);
  }
System.out.println(sort(list.toArray(newString[0]))

); }

गोल्फ प्रकार समारोह:

String[]s(String[]n){for(int i=-1;++i<n.length;)if(n[i].startsWith("(The |the )"))n[i]=n[i].substring(4);return Arrays.sort(n,String.CASE_INSENSITIVE_ORDER);}

18 बाइट बचाने के लिए @raznagul को धन्यवाद

Comments

यदि कोई नाम से शुरू होता है तो काम नहीं करता है the । सॉर्ट केस असंवेदनशील होना चाहिए।

— शौकी

यह बिल्कुल काम नहीं करेगा ... स्ट्रिंग्स अपरिवर्तनीय हैं। आप public String[]sort(String[]names){ for(int i=-1;++i<names.length;) names[i]=names[i].replaceFirst("(the|The)", ""); return Arrays.sort(names,String.CASE_INSENSITIVE_ORDER); }तब से करना चाहते हैं और द काम करना चाहिए, और एक अपरिवर्तनीय

— स्ट्रेट्रिक फीनिक्स

निश्चित है कि, लेकिन मुझे एक बैंड है जो एक छोटे से "द"

— रोमन ग्रैफ़

Arrays.sortरिटर्न प्रकार शून्य

— user902383

@ RomanGräfthe pAper chAse

— AdmBorkBork