이 스택 오버플로 질문에서 영감을 얻었습니다 . 목록 정렬 : 오름차순 숫자, 내림차순 문자 . 당신의 임무는 다음과 같은 문제를 해결하는 것입니다. 이것이 code-golf 이므로 가능한 적은 바이트로 해결해야합니다.

당신은 입력 문자를 포함하는 등 개체의 목록이 소요됩니다 (합리적인 형태 : string, char, 등)와 숫자를. 그런 다음 숫자를 오름차순으로 정렬하고 문자를 내림차순으로 정렬해야합니다. 그러나 문자를 문자 위치에, 숫자를 숫자 위치에 유지해야합니다. 예를 들어 목록이 다음과 같은 경우

[L, D, L, L, D, L]

출력 목록은 다음과 같은 형식이어야합니다.

[L, D, L, L, D, L]

작업

입력: ['a', 2, 'b', 1, 'c', 3]

• 숫자를 오름차순으로 정렬하십시오. [1, 2, 3]
• 문자를 내림차순으로 정렬하십시오. ['c', 'b', 'a']
• 다시 가입하지만 순서는 동일하게 유지하십시오. ['c', 1', 'b', 2, 'a', 3]

규칙

• 목록에는 문자와 숫자 만 포함됩니다.
• 목록이 비어있을 수 있습니다.
• 목록에는 문자 또는 숫자 만 포함될 수 있습니다.
• 경우에 언어가 혼합 된 형태의 배열을 지원하지 않는 대신 숫자의 숫자 문자를 사용할 수 있습니다. 언어가이를 지원하는 경우 혼합 유형을 사용해야합니다.
• 글자는 [a-z]또는 만 될 것입니다 [A-Z], 당신은 어느 것을 선택할 수 있습니다.
• 문자는 a가장 낮은 것으로 정렬됩니다 ( z예 :) a = 1, z = 26.
• 표준 허점 은 금지되어 있습니다.
• I / O는 문자열을 포함한 모든 표준 수단 일 수 있습니다.

테스트 사례

[5, 'a', 'x', 3, 6, 'b'] -> [3, 'x', 'b', 5, 6, 'a']

[ 3, 2, 1] -> [ 1, 2, 3 ]

[ 'a', 'b', 'c' ] -> [ 'c', 'b', 'a' ]

[] -> []

[ 2, 3, 2, 1 ] -> [1, 2, 2, 3]

이것이 코드 골프 이므로 바이트 단위의 최단 답변이 이깁니다!

레티 나 , 10 바이트

O`\d
O^`\D

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

ORetina 의 스테이지는이 과제에 필요한 종류의 선택적 정렬을 직접 수행 할 수 있습니다.

여기에서 첫 번째 줄은 숫자를 정렬하는 반면 두 번째 줄은 비 숫자를 정렬합니다.

파이썬 2 , 53 52 바이트

^{g.rocket 덕분에 -2 바이트
Jonathan Frech 덕분에 -1 바이트}

def F(x):n=sorted(x);print[n.pop((e<x)-1)for e in x]

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

sorted목록 먼저 다음 문자 같은 번호가됩니다 [3, 5, 6, 'a', 'b', 'x']다음, 사용 e<x어떤 숫자가 숯불 무엇인지, 파이썬에서 임의의 숫자가 적은 목록 (입력)보다하고 목록을 적은 문자열보다 필터.

APL (Dyalog) , 27 26 바이트

문자가 대문자 일 것으로 예상

(⍋⊃¨⊂)@(~e)(⍒⊃¨⊂)@(e←∊∘⎕A)

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

이것은 양식의 두 가지 응용 프로그램입니다 f@g. 기능을 적용하십시오.f 표시된 항목에 을g .

첫 번째 응용 프로그램에서는 다음을 사용합니다.
 f:  전체 인수 ( ) 에서 ⍒⊃¨⊂ 내림차순 ( ⍒), 각 선택 ⊃¨( ⊂).
 g:  (e←∊∘⎕A) 회원 ( ∊(의) ∘)에 의 lphabet ( ⎕A), 저장 (← 등)이 함수 e.

두 번째 응용 프로그램에서는 다음을 사용합니다.
 f:  전체 인수 ( ) 에서 ⍋⊃¨⊂ 오름차순 등급 ( ⍋), 각 선택 ⊃¨( ⊂).
 g:  (~e) not ( ~) 알파벳 멤버 ( e; 이전에 저장 한 함수)

자바 스크립트 (ES6), 71 51 47 바이트

@JustinMariner가sort() 제안한 것처럼을 사용하여 20 바이트
를 절약 했습니다. @CraigAyre 덕분에 4 바이트를 더 절약했습니다

Rod의 Python 답변 과 비슷한 접근법을 사용하십시오 .

a=>[...a].map(n=>a.sort()[1/n?'shift':'pop']())

테스트 사례

let f =

a=>[...a].map(n=>a.sort()[1/n?'shift':'pop']())

console.log(JSON.stringify(f(['a', 2, 'b', 1, 'c', 3]))) // -> ['c', 1', 'b', 2, 'a', 3]
console.log(JSON.stringify(f([5, 'a', 'x', 3, 6, 'b']))) // -> [3, 'x', 'b', 5, 6, 'a']
console.log(JSON.stringify(f([3, 2, 1]))) // -> [ 1, 2, 3 ]
console.log(JSON.stringify(f(['a', 'b', 'c']))) // -> [ 'c', 'b', 'a' ]
console.log(JSON.stringify(f([]))) // -> []
console.log(JSON.stringify(f([2, 3, 2, 1]))) // -> [1, 2, 2, 3]

R , 83 76 바이트

Miff 덕분에 -7 바이트

function(n){u=unlist
d=n%in%0:9
n[d]=sort(u(n[d]))
n[!d]=sort(u(n[!d]),T)
n}

이것은 아래와 동일하지만 벡터 가 list아닌 혼합 유형 입력을 허용합니다 atomic(모든 유형을 혼합 유형의 문자로 타입 캐스트).

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

R , 68 61 바이트

Miff 덕분에 -7 바이트

function(n){d=n%in%0:9
n[d]=sort(n[d])
n[!d]=sort(n[!d],T)
n}

익명의 기능. 이 경우 모든 숫자는 문자로 캐스트됩니다. n[-d]숫자가없는 배열입니다. NULL빈 입력에서 (빈 목록)을 반환 합니다.

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

apt , 18 15 바이트

-3 바이트의 @Shaggy와 0s 로 배열을 수정하는 데 도움을 주셔서 감사 합니다.

c ñc
®¤?Vv :Vo

첫 번째 줄은 의도적으로 비워 둔 것입니다.

온라인으로 사용해보십시오! 사용-Q형식화 된 배열을 보는 데 합니다.

설명

입력 배열을 덮어 쓰지 않도록 첫 줄은 비어 있습니다.
[5, 'a', 'x', 3, 6, 'b']

c ñc

c입력 배열 을 평탄화 ( )하여 복사 한 다음 ñ문자 코드 ( c)로 표시되는 문자열 로 정렬 ( )하십시오. 에 저장됩니다 V.
[3, 5, 6, 'a', 'b', 'x']

£

그런 다음 함수로 입력 배열을 매핑하십시오 ...

¤?Vv :Vo

숫자를 이진 문자열 (거짓)로 바꾸거나 문자열을 ""(거짓) ( ¤)로 바꿉니다 . 진실이라면 V( v) 의 시작 부분에서 제거하고, 그렇지 않으면 끝 ( o) 에서 제거하십시오 .

자바 스크립트, 164 (162) 158 142 바이트

편집 1 : v의 중복 할당을 제거한 후 2 바이트가 적습니다.

편집 2 : TheLethalCoder 덕분에 4 바이트가 적습니다.

편집 3 : Justin Mariner의 훌륭한 힌트 덕분에 16 바이트 감소

x=>eval("n=v=>typeof(v)=='number';l=x.length;for(i=0;i<l;x[i++]=x[m],x[m]=w){for(v=w=x[j=m=i];++j<l;)n(e=x[j])==n(w)&&e<v==n(w)&&(m=j,v=e)}x")

코드 골프에서 처음 봤으므로 확실히 향상 될 수 있습니다 ...하지만 여전히 시도해 볼 가치가 있습니다.

프로그램은 선택 정렬의 변형을 수행하며, 현재 정렬 유형과 동일한 유형의 값만 고려합니다 (숫자와 숫자 또는 문자와 문자 만 교환).

읽을 수있는 형태 :

x=>eval("
    n=v=>typeof(v)=='number';
    l=x.length;
    for(i=0;i<l;x[i++]=x[m],x[m]=w){
        for(v=w=x[j=m=i];++j<l;) 
            n(e=x[j])==n(w) && e<v==n(w) && (m=j,v=e)
    }
    x
")

C ++ 17 (gcc) , 219 바이트

#include <variant>
#include <set>
using V=std::variant<char,int>;void f(V*a,V*b){std::set<V>S[2];for(V*c=a;c<b;++c)S[c->index()].insert(*c);auto
C=S->rbegin();auto N=S[1].begin();for(;a<b;++a)*a=(a->index()?*N++:*C++);}

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

경쟁이 거의 없습니다. 그러나 혼합형 배열을 지원해야합니까? 벌금.

범위 스타일의 변형 배열을 허용하고 적절하게 수정합니다. 입력을 두 개의 정렬 된 세트로 복사 한 다음 다시 입력 / 출력 배열로 복사합니다.

Mathematica, 203 바이트

(K=Reverse;B=Complement;L=Length;S=Position[#,_Integer];T=Sort@Cases[#,_Integer];G=K@B[#,T];V=B[Range@L@#,Flatten@S];R=K@Sort@#;Table[R[[Min@S[[i]]]]=T[[i]],{i,L@T}];Table[R[[V[[i]]]]=G[[i]],{i,L@G}];R)&

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

젤리 , 14 바이트

FOÞɓṪ}Ḣ}ẇØa$?€

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

기본적으로 Rod의 Python 솔루션 포트입니다 .

Pyth , 12 11 바이트

KSQm.(Kt>\@

온라인으로 사용해보십시오! 또는 테스트 스위트를 사용해보십시오.

설명

KSQm.(Kt<d\@  - Full program with implicit input.

KSQ           - Assign a variable K to the lexicographically sorted input.
   m          - Map over the input (with a variable d).
    .(K       - Pop the sorted list at this location:
       >\@    - If d is lexicographically lower than '@', at 0 (the first element). Else, at -1 (the last element).

파이썬, (145) 139 130 바이트

@officialaimm 덕분에 6 바이트 절약

@Chris_Rands 덕분에 9 바이트 절약

g=lambda s,a:sorted(x for x in s if(type(x)==str)==a)
def f(s):l,n=g(s,1),g(s,0)[::-1];return[[n,l][type(x)==str].pop()for x in s]

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

05AB1E , 17 바이트

SaJ¹á{R¹þ{«vyay.;

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

SaJ               # Push 1 if letter 0 else, for all letters in string.
   ¹á{R           # Reverse sort letters from input.
       ¹þ{        # Regular sort digits from input.
          «       # Concatenate those two things.
           v      # For each letter in the sorted string...
            ya    # 0 if digit, 1 if letter.
              y.; # Replace first instance of 0/1 with digit/letter.

정렬 기준 폐쇄를 사용하는 것이 실제로 더 나빴습니다. Σ©Ç®ai0<*}}¹SaJsvyay.;

파이썬 3, 77 바이트

이 답변은 언어에서 문자와 숫자를 비교할 수없는 경우 '1', '2'등을 사용할 수 있다고 말하는 의견을 기반으로합니다. 파이썬 3에서는 'a'와 1을 비교할 수 없습니다.

def f(s):x=sorted(s,key=lambda c:ord(c)-95);return[x.pop(-(c>'.'))for c in s]

q / kdb +, 54 53 바이트

해결책:

{x[w,q]:asc[x w:(&)d],desc x q:(&)(~)d:-7=type@/:x;x}

예 :

q){x[w,q]:asc[x w:(&)d],desc x q:(&)(~)d:-7=type@/:x;x}(5;"a";"x";3;6;"b") / mixed list
3
"x"
"b"
5
6
"a"
q){x[w,q]:asc[x w:(&)d],desc x q:(&)(~)d:-7=type@/:x;x}3 2 1   / simple list
1 2 3
q){x[w,q]:asc[x w:(&)d],desc x q:(&)(~)d:-7=type@/:x;x}"abc"   / simple list
"cba"
q){x[w,q]:asc[x w:(&)d],desc x q:(&)(~)d:-7=type@/:x;x}2 3 2 1 / simple list
1 2 2 3

설명:

목록에서 문자를 찾고, 내림차순으로 정렬하고, 목록에서 Long을 찾고, 오름차순으로 정렬하고, 예를 들어 목록을 가져 오기 위해 조인 ("x";"b";"a";3;5;6)한 다음 정렬 된 값을 목록의 원래 위치에 다시 지정하십시오 (예 : at) 0 3 4 1 2 5.

골프는 q 키워드 ( each, where및 not)를 k이에 상응하는 것으로 바꿉니다 (괄호로 묶어야 함).

{x[w,q]:asc[x w:where d],desc x q:where not d:-7=type each x;x} / ungolfed
{                                                           ; } / lambda function with 2 statements
                                                 type each x    / return types of elements in mixed list
                                              -7=               / true where item is a long
                                            d:                  / save this bool array in d
                                        not                     / invert
                                  where                         / indices where true (we have chars)
                                q:                              / save these indices in q
                              x                                 / values of x at these indices
                         desc                                   / sort them descending
                        ,                                       / join/contatenate
                where d                                         / indices where we have digits
              w:                                                / save this in w
            x                                                   / values of x at these indices
        asc[           ]                                        / sort them ascending
 x[w,q]:                                                        / assign this list to x at indices w,q
                                                             x  / return x

편집

• 대괄호가 필요하지 않으므로 -1 바이트 desc

C (GCC) , 125 (113) 110 바이트

main(i){char*b,*c,s[99];for(gets(c=b=s);*++c||*(c=++b);)i=*b&64,i^*c&64||*c>*b^!i&&(i=*c,*c=*b,*b=i);puts(s);}

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

설명 :

main(i)
{
    char*b,*c,s[99];

    // slightly modified stupid bubblesort, this line in fact
    // does nested looping with a single for statement
    for(gets(c=b=s);*++c||*(c=++b);)
    // (undefined behavior here, there's no sequence point between accesses to c,
    // so this could go wrong. Works with the gcc version on tio.)

        // determine whether the current b is a letter:
        i=*b&64,

        // for doing anything, b and c must be the same "type":
        i^*c&64

            // when c > b for letter or c <= b for digit
            || *c>*b^!i

            // then swap
            && (i=*c,*c=*b,*b=i);

    puts(s);
}

문자는 대문자로 예상됩니다.

PHP, 66 바이트 :

for($a=$argv,sort($a);a&$c=$argv[++$i];)echo$a[$c<A?++$k:--$argc];

명령 행 인수에서 입력을 받고 문자열을 인쇄합니다. -nr또는로 실행온라인으로 사용해보십시오.

PHP 7.1의 경고를 나타냅니다. 교체 a&로 ""<수정합니다.

수학, 107 바이트

(s=#;s[[p]]=Sort[s[[p=#&@@@s~($=Position)~_String]],#2~Order~#>0&];s[[c]]=Sort@s[[c=#&@@@s~$~_Integer]];s)&

C # (. NET 코어) 171 바이트

a=>{var b=a.Where(x=>x is int).ToList();b.Sort();int i=0,j=0;return a.Select(x=>b.Contains(x)?b[i++]:a.Except(b).OrderByDescending(y=>y).ToList()[j++]);}

바이트 수에는 다음이 포함됩니다.

using System.Linq;

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

설명:

a =>
{
    var b = a.Where(x => x is int).ToList(); // Filter to only ints and transform to list
    b.Sort();                                // Sort the list
    int i = 0, j = 0;                        // Create index counters
    return a.Select(x =>                     // Replace each input element with
                    b.Contains(x) ?          // If it is in list b:
                    b[i++] :                 // Get the next element from b
                    a.Except(b)              // Otherwise take input and filter out those in b
                     .OrderByDescending(x=>x)// Order them z to a
                     .ToList()[j++]);        // Get the next element

Perl 5 , 107 + 1 (-n) = 108 바이트

y/][//d;@a=split/, /;@l=sort grep/\D/,@a;@d=sort grep/\d/,@a;@r=map{/\d/?pop@d:shift@l}@a;$"=", ";say"[@r]"

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

루비 , 265 바이트

x.sort_by(&:to_s).select{|a| a.is_a?(String)}.zip(x.map.with_index {|a, i| a.is_a?(String) ? i : nil}.compact).each{|a,i| x[i] = a}
x.sort_by(&:to_s).select{|a| a.is_a?(Integer)}.zip(x.map.with_index {|a, i| a.is_a?(Integer) ? i : nil}.compact).each{|a,i| x[i] = a}

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

첫 번째 타이머, 내 솔루션은 분명히 최고의 솔루션이 아닙니다. 그러나 이것이 첫 번째 답변이므로 재미를 위해 게시하는 것으로 생각했습니다.

더 나은 루비 답변을보기 위해 최선을 다하고 최선의 방법이 무엇인지 알아보십시오. 나는 미래의 답변을 개선하기를 희망합니다 =)

읽을 수있는

x = ["c", 1, "a", 3, "b", 2]

b = x.map.with_index {|a, i| a.is_a?(Integer) ? i : nil}.compact
s = x.map.with_index {|a, i| a.is_a?(String) ? i : nil}.compact

o = x.sort_by(&:to_s).select{|a| a.is_a?(Integer)}
d = x.sort_by(&:to_s).select{|a| a.is_a?(String)}

d.zip s
d.zip(s).each {|a, i| x[i] = a}

o.zip b
o.zip(b).each {|a, i| x[i] = a }

p x

하스켈, 108 바이트

There may be shorter ways, but I just had to try it with the Lens library.

import Control.Lens
import Data.List
i(!)f=partsOf(traverse.filtered(!'='))%~f.sort
f x=x&i(<)id&i(>)reverse

I could define f to just be the composition of the two i invocations, but I'd still have to apply x to it to avoid a type error from the monomorphism restriction. Note that the type of f is Traversable t => t Char -> t Char so it can be used with Strings which are lists of Chars as well as with arrays of Chars.

Here are the test cases:

*Main> map f ["5ax36b","321","abc","","2321"]
["3xb56a","123","cba","","1223"]

Python 3, 91 bytes

def f(s):x=sorted(s,key=lambda c:(type(c)==str,c));return[x.pop(-(type(c)==str))for c in s]

Clojure, 151 bytes

#(map(fn[t c](nth((if(=(type 1)t)vec reverse)(sort((group-by type %)t)))(-(c t)1)))(map type %)(reductions(partial merge-with +)(for[i %]{(type i)1})))

Example:

(def f #( ... ))
(f [5 \a \x 3 6 \b])
; (3 \x \b 5 6 \a)

This calculates the cumulative sum count of integers and characters, and uses it to lookup the correct element from a sorted list of corresponding type's elements.

APL (Dyalog), 26 bytes

a[⍒i][⍋⍋27>i←(⎕a,⌽⍳9)⍳a←⎕]

(uses ⎕IO=1)

Try it online!