도전 설명

당신은 이름이 각각의 많은 밴드에 의해 기록 된 많은 트랙과 음악 라이브러리를 가지고 같은 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(like The Policeand Police)로 시작하며 정의되지 않습니다.

• 밴드 이름이 둘 이상의 단어로 구성된 경우 단일 공백 ​​문자로 구분된다고 가정 할 수 있습니다. 선행 또는 후행 공백을 처리 할 필요가 없습니다.

• 모든 입력 문자열이 일치합니다 [A-Za-z0-9 ]*. 즉 영어 알파벳의 소문자와 대문자, 숫자 및 공백 문자로만 구성됩니다.

• 이는 코드 골프 과제이므로 코드를 최대한 짧게 만드십시오!

파이썬, 56 62 64 바이트

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

시도 해봐

스트립이 일치하는 모든 문자를 폭파하고 빈 문자열로 정렬하고 @manatwork 사용하여 결함을 찾기 때문에 @Chris H 덕분에 올바르게 lstrip()처리되지 않았 음 을 지적했습니다 . 새 버전이 작동합니다.The Thereplace()

구 버전:

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

V , 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 '

망막 , 34 바이트

후행 줄 바꿈이 중요합니다.

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

O`
.+;

I / O는 라인 당 하나의 밴드입니다.

온라인으로 사용해보십시오!

설명

%`^
$';

;구분자로 사용하여 각 줄을 복제하십시오 .

T`L`l`.+;

;소문자 앞에서 모든 것을 돌립니다.

m`^the 

the줄의 시작 부분에 나타나는 모든을 제거하십시오 .

O`

줄을 정렬하십시오.

.+;

정렬에 사용한 줄의 시작 부분을 제거하십시오.

파이크, 16 바이트

.#l1D"the ".^4*>

여기 사용해보십시오!

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

펄, 52 바이트

@manatwork 덕분에 -13 바이트 감사
@ msh210 덕분에 -1 바이트 감사

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

라인 당 하나의 대역이 입력으로서 출력도 마찬가지입니다.

구현은 매우 간단합니다. 프로그램은 사용자 정의 함수 ( f) 의 도움을 받아 정렬 된 밴드 목록을 인쇄 하여 최종 행간없이 소문자 밴드 이름을 반환합니다 the.

파이썬, 66 72 69 바이트

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

키워드 인수 sorted와 함께 Python의 메소드를 사용 key하여 이름에서 "The"를 뺀 순서로 정렬하십시오. 이것은 람다입니다. 그것을 부르려면 f=앞에 두어 이름을 지정하십시오 .

이제 대소 문자를 구분하지 않습니다!

루비, 42 바이트

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

온라인으로 사용해보십시오!

펄 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")

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

JavaScript / ECMAScript 6 93 70 바이트

70 Neil과 Downgoat에게 조언을 해주셔서 감사합니다

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)
};

자바 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));}

언 골프 버전 :

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));
}

Nim , 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])

하스켈, 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"]]

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

C #, 139 바이트

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

온라인으로 시도하십시오!

사용 횟수를 세지 않으면 대답은 102 바이트입니다.

BASH, 64 바이트

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

입력 : stdin, 라인 당 하나의 밴드. 출력 : stdout

참고 : 두 번째 대체 (s / ^ The / / 및 s / ^ / The /)는 탭 문자를 사용하므로 항상 올바르게 복사 / 붙여 넣기하지는 않습니다.

Bash + coreutils, 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

테스트 실행 (EOF가 포함 된 여기 문서를 끝 마커로 사용) :

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

산출:

Aerosmith
Queen
The Strokes
Sunny Day Real Estate

Vim, 18 바이트

이제 이것이 가능하다는 것을 깨달았으므로 26 바이트 V 응답에 부끄럽습니다. 특히 V가 vim보다 짧아야하기 때문입니다. 그러나 이것은 거의 내장되어 있습니다.

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

설명 (vim help에서 직접) :

                            *: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.

C는 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)argvargc

온라인으로 사용해보십시오!

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

그루비, 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]

디버그 또는 오류 출력이 없습니다.

q / kdb +, 36 33 바이트

해결책:

{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"

설명:

각 입력 문자열에서 "[Tt] he"를 제거하고이 목록을 정렬 한 다음 정렬 된 목록의 색인 작성을 기반으로 원래 목록을 정렬하십시오.

{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

Japt , 11 10 바이트

ñ_v r`^e 

시도 해봐

자바 176158 바이트

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에게 감사합니다