Ispirato a questa domanda Stack Overflow: Ordinamento di un elenco: numeri in ordine crescente, lettere in ordine decrescente . Il tuo compito è risolvere il seguente problema e, dato che si tratta di code-golf , dovresti farlo nel minor numero di byte possibile.

Si dovrebbe prendere un elenco di oggetti come input contenente lettere (qualsiasi forma ragionevole: string, char, ecc) e numeri. È quindi necessario ordinare i numeri in ordine crescente e le lettere in ordine decrescente. Tuttavia, è necessario mantenere le lettere nelle posizioni delle lettere e i numeri nelle posizioni dei numeri. Ad esempio, se l'elenco è:

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

L'elenco di output dovrebbe essere sotto forma di:

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

Workthrough

Ingresso: ['a', 2, 'b', 1, 'c', 3]

• Ordina i numeri in ordine crescente: [1, 2, 3]
• Ordina le lettere in ordine decrescente: ['c', 'b', 'a']
• Unisciti a loro ma mantieni l'ordine uguale: ['c', 1', 'b', 2, 'a', 3]

Regole

• L'elenco conterrà solo lettere e cifre.
• L'elenco potrebbe essere vuoto.
• L'elenco può contenere solo lettere o solo cifre.
• Se la tua lingua non supporta matrici di tipo misto, puoi utilizzare caratteri numerici anziché numeri. Nota che se la tua lingua lo supporta, devi usare tipi misti.
• Le lettere saranno solo [a-z]o [A-Z], puoi scegliere quale.
• Le lettere sono ordinate come le apiù basse, zovvero quelle più alte a = 1, z = 26.
• Sono vietate le scappatoie standard .
• L'I / O può essere con qualsiasi mezzo standard, incluso come stringa.

Casi test

[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]

Dato che si tratta di code-golf, vince la risposta più breve in byte!

Retina , 10 byte

O`\d
O^`\D

Provalo online!

Il Opalcoscenico di Retina può eseguire direttamente il tipo di selezione selettiva richiesta da questa sfida.

Qui la prima riga ordina le cifre mentre la seconda riga ordina le non cifre al contrario.

Python 2 , 53 52 byte

^{-2 byte grazie a g.rocket
-1 byte grazie a Jonathan Frech}

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

Provalo online!

L' sortedelenco avrà prima i numeri e poi i caratteri simili [3, 5, 6, 'a', 'b', 'x'], quindi utilizza e<xper filtrare ciò che è numero e ciò che è carattere, in Python qualsiasi numero è inferiore a un elenco (input) e un elenco è inferiore a una stringa.

APL (Dyalog) , 27 26 byte

Si aspetta che i caratteri siano maiuscoli

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

Provalo online!

Queste sono solo due applicazioni del modulo f@g, applica la funzione fsugli elementi indicati da g.

Per il primo utilizzo applicazione che:
 f:  ⍒⊃¨⊂ gradi discendente ( ⍒) ogni prelievo ( ⊃¨) dall'intero argomento ( ⊂).
 g:  (e←∊∘⎕A) members ( ∊) of ( ∘) the A lphabet ( ⎕A), e store ( ←) questa funzione come e.

Per il secondo uso applicazione che:
 f:  ⍋⊃¨⊂ i gradi ascendenti ( ⍋) ogni prelievo ( ⊃¨) dall'intero argomento ( ⊂).
 g:  (~e) not ( ~) membri dell'alfabeto ( e; la funzione che abbiamo memorizzato prima)

JavaScript (ES6), 71 51 47 byte

Hai salvato 20 byte semplicemente usando sort(), come suggerito da @JustinMariner Hai
salvato altri 4 byte grazie a @CraigAyre

Utilizzando un approccio simile alla risposta di Rod's Python :

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

Casi test

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 byte

-7 byte grazie a Miff

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

Questo è lo stesso del seguito, ma consente input di tipo misto come listun atomicvettore anziché come un vettore (che dovrebbe digitare tutto come caratteri con tipi misti).

Provalo online!

R , 68 61 byte

-7 byte grazie a Miff

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

Funzione anonima. In questo caso, tutte le cifre sono espresse in caratteri. n[-d]è l'array senza le cifre. Restituisce NULL(elenco vuoto) su input vuoto.

Provalo online!

Japt , 18 anni 15 byte

Grazie @Shaggy per -3 byte e per l'aiuto nella correzione di array con 0s.

c ñc
®¤?Vv :Vo

La prima riga viene lasciata intenzionalmente vuota.

Provalo online! utilizzando-Q per visualizzare l'array formattato.

Spiegazione

La prima riga è vuota per evitare di sovrascrivere l'array di input.
[5, 'a', 'x', 3, 6, 'b']

c ñc

Crea una copia appiattendo ( c) l'array di input, quindi ordina ( ñ) con le stringhe rappresentate dal loro codice char ( c). Questo è memorizzato in V.
[3, 5, 6, 'a', 'b', 'x']

£

Quindi mappare l'array di input con la funzione ...

¤?Vv :Vo

Trasforma i numeri in stringhe binarie (verità) o stringhe in ""(falsa) ( ¤). Se è vero, rimuovi dall'inizio di V( v), altrimenti rimuovi dalla fine ( o).

JavaScript, 164 162 158 142 byte

modifica 1: 2 byte in meno dopo aver rimosso un'assegnazione ridondante di v.

modifica 2: 4 byte in meno grazie a TheLethalCoder.

modifica 3: 16 byte in meno grazie ai brillanti suggerimenti di Justin Mariner

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

È la mia prima volta nel code-golf, quindi può sicuramente essere migliorato ... Ma comunque, vale la pena provare.

Il programma esegue una variante dell'ordinamento di selezione, che tiene conto solo dei valori dello stesso tipo di quello corrente (scambiando solo un numero e un numero, oppure una lettera e una lettera)

Modulo leggibile:

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 byte

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

Provalo online!

Difficilmente competitivo. Ma devo supportare array di tipo misto? FINI.

Accetta una serie di varianti nello stile di intervallo e la modifica in posizione. Copia l'input in due set ordinati, quindi di nuovo nell'array input / output.

Mathematica, 203 byte

(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)&

Provalo online!

Gelatina , 14 byte

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

Provalo online!

Fondamentalmente una porta della soluzione Python di Rod .

Pyth , 12 11 byte

KSQm.(Kt>\@

Provalo online! oppure prova la suite di test.

Spiegazione

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).

Python, 145 139 130 byte

6 byte salvati grazie a @officialaimm

9 byte salvati grazie a @Chris_Rands

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]

Provalo online!

05AB1E , 17 byte

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

Provalo online!

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.

L'uso della chiusura ordinata in realtà era peggio: Σ©Ç®ai0<*}}¹SaJsvyay.;

Python 3, 77 bytes

This answer is based on the comment that says you can use '1', '2', etc if chars and digits are not comparable in the language. 'a' and 1 are not comparable in Python 3.

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

q/kdb+, 54 53 bytes

Solution:

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

Examples:

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

Explanation:

Find the chars in the list, sort descending, find the longs in the list, sort them ascending, join to get a list of, e.g. ("x";"b";"a";3;5;6), then assign the sorted values back to their original positions in the list, e.g. at 0 3 4 1 2 5.

Golfing is just switching out q keywords (each, where and not) for their k equivalent (which requires them to be wrapped in brackets).

{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

Edits

• -1 byte as don't need square brackets around desc

C (gcc), 125 113 110 bytes

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

Try it online!

Explained:

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

Letters are expected in uppercase.

PHP, 66 bytes:

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

takes input from command line arguments, prints a string. Run with -nr or try it online.

Yields a warning in PHP 7.1; replace a& with ""< to fix.

Mathematica, 107 bytes

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

C# (.NET Core), 171 bytes

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

Byte count also includes:

using System.Linq;

Try it online!

Explanation:

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 bytes

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

Try it online!

Ruby, 265 bytes

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}

Try it online!

First timer here, My solution is definetly not the best one. But since this is my first answer, I thought in posting just for the fun of it.

Looking foward to see better Ruby answers, to see what is the best approach. I hope I improve in future answers =)

Readable

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

Haskell, 108 bytes

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!