Inspiriert von dieser Stapelüberlauf-Frage: Sortieren einer Liste: Zahlen in aufsteigender Reihenfolge, Buchstaben in absteigender Reihenfolge . Ihre Aufgabe ist es, das folgende Problem zu lösen, und da dies Codegolf ist , sollten Sie dies in so wenigen Bytes wie möglich tun.

Sie sollten eine Liste von Objekten als Eingabe mit Buchstaben nehmen (jede angemessene Form: string, charusw.) und Zahlen. Sie sollten dann die Zahlen in aufsteigender Reihenfolge und die Buchstaben in absteigender Reihenfolge sortieren. Sie sollten jedoch Buchstaben in Buchstabenpositionen und Zahlen in Zahlenpositionen belassen. Zum Beispiel, wenn die Liste ist:

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

Die Ausgabeliste sollte folgende Form haben:

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

Durcharbeiten

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

• Sortieren Sie die Nummern in aufsteigender Reihenfolge: [1, 2, 3]
• Sortieren Sie die Buchstaben in absteigender Reihenfolge: ['c', 'b', 'a']
• Schließe dich ihnen wieder an, aber behalte die Reihenfolge bei: ['c', 1', 'b', 2, 'a', 3]

Regeln

• Die Liste enthält nur Buchstaben und Ziffern.
• Die Liste ist möglicherweise leer.
• Die Liste darf nur Buchstaben oder nur Ziffern enthalten.
• Wenn Ihre Sprache keine gemischten Arrays unterstützt, können Sie anstelle von Zahlen auch Ziffern verwenden. Beachten Sie, dass Sie gemischte Typen verwenden müssen, wenn Ihre Sprache dies unterstützt.
• Buchstaben werden nur [a-z]oder sein [A-Z], Sie können wählen, welche.
• Buchstaben werden als aniedrigste und zhöchste Buchstaben sortiert a = 1, z = 26.
• Standardlücken sind verboten.
• I / O kann auf jede Standardmethode ausgeführt werden, einschließlich als Zeichenfolge.

Testfälle

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

Da es sich um Code-Golf die kürzeste Antwort in Bytes gewinnt!

Retina , 10 Bytes

O`\d
O^`\D

Probieren Sie es online!

Die OBühne in Retina kann direkt die Art von selektiver Sortierung durchführen, die für diese Herausforderung erforderlich ist.

Hier sortiert die erste Zeile die Ziffern, während die zweite Zeile die Nicht-Ziffern in umgekehrter Reihenfolge sortiert.

Python 2 , 53 52 Bytes

^{-2 Byte dank g.rocket
-1 Byte dank Jonathan Frech}

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

Probieren Sie es online!

Die sortedListe enthält zuerst die Zahlen und dann die Zeichen [3, 5, 6, 'a', 'b', 'x'], mit denen dann e<xgefiltert wird, was Zahl und was Zeichen sind. In Python ist jede Zahl kleiner als eine Liste (Eingabe) und eine Liste kleiner als eine Zeichenfolge.

APL (Dyalog) , 27 26 Bytes

Erwartet Großbuchstaben

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

Probieren Sie es online!

Dies sind nur zwei Anwendungen des Formulars f@g. Wenden Sie die Funktion fauf die mit gekennzeichneten Elemente an g.

Für die erste Anwendung , die wir verwenden:
 f:  ⍒⊃¨⊂ die absteigenden Typen ( ⍒) jeweils Pick ( ⊃¨) aus dem gesamten Argumente ( ⊂).
 g:  (e←∊∘⎕A) Mitglieder ( ∊) von ( ∘) der A lphabet ( ⎕A) und speichern ( ←) diese Funktion als e.

Für die zweite Anwendung verwenden wir:
 f:  ⍋⊃¨⊂ die aufsteigenden Typen ( ⍋) jeweils Pick ( ⊃¨) aus dem gesamten Argumente ( ⊂).
 g:  (~e) not ( ~) Mitglieder des Alphabets ( e; die zuvor gespeicherte Funktion)

JavaScript (ES6), 71 51 47 Bytes

Sparte 20 Bytes mit nur sort(), wie von @JustinMariner vorgeschlagen. Sparte
dank @CraigAyre 4 weitere Bytes

Verwenden Sie einen ähnlichen Ansatz wie Rods Python-Antwort :

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

Testfälle

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 Bytes

-7 Bytes dank Miff

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

Dies ist das Gleiche wie das Folgende, aber es ermöglicht die Eingabe eines gemischten Typs listanstelle eines atomicVektors (der alles als Zeichen mit gemischten Typen typisieren würde).

Probieren Sie es online!

R , 68 61 Bytes

-7 Bytes dank Miff

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

Anonyme Funktion. In diesem Fall werden alle Ziffern in Zeichen umgewandelt. n[-d]ist das Array ohne die Ziffern. Gibt NULL(leere Liste) bei leerer Eingabe zurück.

Probieren Sie es online!

Japt , 18 15 Bytes

Vielen Dank an @Shaggy für -3 Bytes und für die Hilfe beim Reparieren von Arrays mit 0s.

c ñc
®¤?Vv :Vo

Die erste Zeile wurde absichtlich leer gelassen.

Probieren Sie es online! Verwenden Sie -Q, um das formatierte Array anzuzeigen.

Erläuterung

Die erste Zeile ist leer, um ein Überschreiben des Eingabearrays zu vermeiden.
[5, 'a', 'x', 3, 6, 'b']

c ñc

Erstellen Sie eine Kopie, indem Sie cdas Eingabearray reduzieren ( ) und dann sortieren ( ñ), wobei die Zeichenfolgen durch ihren Zeichencode ( c) dargestellt werden. Dies ist in gespeichert V.
[3, 5, 6, 'a', 'b', 'x']

£

Ordnen Sie dann das Eingabearray mit der Funktion ...

¤?Vv :Vo

Verwandeln Sie Zahlen in binäre Zeichenfolgen (truthy) oder Zeichenfolgen in ""(falsy) ( ¤). Wenn dies der Fall ist, entferne vom Anfang von V( v), andernfalls entferne vom Ende von ( o).

JavaScript, 164 162 158 142 Bytes

Bearbeiten Sie 1: 2 Bytes weniger, nachdem Sie eine redundante Zuweisung von v entfernt haben.

2: 4 Bytes weniger bearbeiten dank TheLethalCoder.

3: 16 Bytes weniger bearbeiten dank brillanter Hinweise von 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")

Es ist mein allererstes Mal im Code-Golf, also kann es sicherlich verbessert werden ... Aber trotzdem einen Versuch wert.

Das Programm führt eine Variante der Auswahlsortierung durch, die nur die Werte desselben Typs wie den aktuellen berücksichtigt (nur eine Zahl und eine Zahl oder einen Buchstaben und einen Buchstaben tauschen).

Lesbare Form:

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 Bytes

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

Probieren Sie es online!

Kaum wettbewerbsfähig. Aber ich muss gemischte Arrays unterstützen? FEIN.

Akzeptiert eine Reihe von Varianten im Bereichsstil und ändert sie an Ort und Stelle. Kopiert die Eingabe in zwei sortierte Sätze und dann zurück in das Eingabe- / Ausgabearray.

Mathematica, 203 Bytes

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

Probieren Sie es online!

Jelly , 14 Bytes

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

Probieren Sie es online!

Grundsätzlich eine Portierung von Rods Python-Lösung .

Pyth , 12 11 Bytes

KSQm.(Kt>\@

Probieren Sie es online! oder Probieren Sie die Test Suite aus.

Erläuterung

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 Bytes

6 Bytes gespart dank @officialaimm

9 Bytes gespart dank @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]

Probieren Sie es online!

05AB1E , 17 Bytes

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

Probieren Sie es 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.

Die Verwendung des Sort-By-Verschlusses war tatsächlich schlechter: Σ©Ç®ai0<*}}¹SaJsvyay.;

Python 3, 77 Bytes

Diese Antwort basiert auf dem Kommentar, der besagt, dass Sie "1", "2" usw. verwenden können, wenn Zeichen und Ziffern in der Sprache nicht vergleichbar sind. 'a' und 1 sind in Python 3 nicht vergleichbar.

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

Lösung:

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

Beispiele:

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

Erläuterung:

Suchen Sie die Zeichen in der Liste, sortieren Sie sie in absteigender Reihenfolge, suchen Sie die Longs in der Liste, sortieren Sie sie in aufsteigender Reihenfolge, fügen Sie sie hinzu, um eine Liste von z. B. zu erhalten ("x";"b";"a";3;5;6), und weisen Sie die sortierten Werte wieder ihren ursprünglichen Positionen in der Liste zu, z0 3 4 1 2 5 .

Golf spielen ist nur q keywords Schalt out ( each, whereund not) für ihre kÄquivalente (die sie erfordert in Klammern zu umwickelnden).

{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

Bearbeitungen

• -1 Byte, da keine eckigen Klammern erforderlich sind 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);}

Probieren Sie es online!

Erklärt:

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

Buchstaben werden in Großbuchstaben erwartet.

PHP, 66 Bytes:

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

Nimmt Eingaben von Befehlszeilenargumenten entgegen und druckt eine Zeichenfolge. Laufen Sie mit -nroder versuchen Sie es online .

Gibt eine Warnung in PHP 7.1 aus; ersetzen a&mit ""<zu reparieren.

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 Byte

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

Die Byteanzahl umfasst auch:

using System.Linq;

Probieren Sie es online!

Erläuterung:

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

Probieren Sie es 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}

Probieren Sie es online!

Erster Timer hier, meine Lösung ist definitiv nicht die beste. Aber da dies meine erste Antwort ist, dachte ich, ich poste nur zum Spaß.

Ich freue mich darauf, bessere Ruby-Antworten zu sehen und herauszufinden, was der beste Ansatz ist. Ich hoffe ich verbessere mich in Zukunft =)

Lesbar

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

Es mag kürzere Wege geben, aber ich musste es nur mit der LensBibliothek versuchen .

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

Ich könnte definieren f, dass es sich nur um die Zusammensetzung der beiden iAufrufe handelt, aber ich müsste mich trotzdem darauf beziehen x, um einen Typfehler aufgrund der Monomorphismus-Einschränkung zu vermeiden. Beachten Sie, dass die Art der fist , Traversable t => t Char -> t Chardamit es mit verwendet werden kann , Strings die Listen sind Chars sowie mit Arrays von Chars.

Hier sind die Testfälle:

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

Beispiel:

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

Dieser berechnet die kumulative Summe Anzahl der ganzen Zahlen und Zeichen, und verwendet es , das richtige Element , das aus einer sortierten Liste zum Nachschlagen des Typs der Elemente entsprechen.

APL (Dyalog) , 26 Bytes

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

(verwendet ⎕IO=1)

Probieren Sie es online!