Inspiré de cette question Stack Overflow: Tri d'une liste: chiffres en ordre croissant, lettres en ordre décroissant . Votre tâche consiste à résoudre le problème suivant et, comme il s'agit de code-golf , vous devez le faire en aussi peu d'octets que possible.

Vous devez prendre une liste d'objets en entrée contenant des lettres (toute forme raisonnable: string, char, etc.) et des chiffres. Vous devez ensuite trier les chiffres dans l'ordre croissant et les lettres dans l'ordre décroissant. Cependant, vous devez conserver les lettres dans les positions des lettres et les chiffres dans les positions des nombres. Par exemple, si la liste est:

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

La liste de sortie doit être sous la forme de:

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

Se sortir de

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

• Triez les nombres par ordre croissant: [1, 2, 3]
• Trier les lettres par ordre décroissant: ['c', 'b', 'a']
• Rejoignez-les mais gardez la même commande: ['c', 1', 'b', 2, 'a', 3]

Règles

• La liste ne contiendra que des lettres et des chiffres.
• La liste est peut-être vide.
• La liste ne peut contenir que des lettres ou uniquement des chiffres.
• Si votre langue ne prend pas en charge les tableaux de types mixtes, vous pouvez utiliser des caractères numériques au lieu de chiffres. Notez que si votre langue le prend en charge, vous devez utiliser des types mixtes.
• Les lettres ne seront que [a-z]ou [A-Z], vous pouvez choisir laquelle.
• Les lettres sont triées comme aétant les plus basses, les zplus élevées c'est-à-dire a = 1, z = 26.
• Les failles standard sont interdites.
• Les E / S peuvent être effectuées par n'importe quel moyen standard, y compris sous forme de chaîne.

Cas de 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]

Comme il s'agit de code-golf, la réponse la plus courte en octets gagne!

Rétine , 10 octets

O`\d
O^`\D

Essayez-le en ligne!

La Oscène de la rétine peut effectuer directement le type de tri sélectif requis par ce défi.

Ici, la première ligne trie les chiffres tandis que la deuxième ligne trie les non-chiffres à l'envers.

Python 2 , 53 52 octets

^{-2 octets grâce à g.rocket
-1 octets grâce à Jonathan Frech}

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

Essayez-le en ligne!

La sortedliste aura d'abord les nombres puis les caractères comme [3, 5, 6, 'a', 'b', 'x'], puis e<xfiltrera ce qui est nombre et ce qui est char, en python tout nombre est inférieur à une liste (entrée) et une liste est inférieure à une chaîne.

APL (Dyalog) , 27 26 octets

Attend que les caractères soient en majuscules

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

Essayez-le en ligne!

Ce ne sont que deux applications du formulaire f@g, appliquez la fonction fsur les éléments indiqués par g.

Pour la première utilisation de l' application nous:
 f:  ⍒⊃¨⊂ les notes descendantes ( ⍒) chaque choix ( ⊃¨) de l'argument entier ( ⊂).
 g:  (e←∊∘⎕A) membres ( ∊) de ( ∘) l ' A lphabet ( ⎕A), et stockent ( ←) cette fonction comme e.

Pour la deuxième utilisation de l' application nous:
 f:  ⍋⊃¨⊂ les notes ascendantes ( ⍋) chaque choix ( ⊃¨) de l'argument entier ( ⊂).
 g:  (~e) not ( ~) membres de l'alphabet ( e; la fonction que nous avons stockée auparavant)

JavaScript (ES6), 71 51 47 octets

Enregistré 20 octets en utilisant simplement sort(), comme suggéré par @JustinMariner
Enregistré 4 octets supplémentaires grâce à @CraigAyre

En utilisant une approche similaire à celle de Rod's Python :

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

Cas de 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 octets

-7 octets grâce à Miff

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

C'est la même chose que ci-dessous, mais cela permet une entrée de type mixte en tant que listplutôt que comme un atomicvecteur (ce qui transcrirait tout en caractères de types mixtes).

Essayez-le en ligne!

R , 68 61 octets

-7 octets grâce à Miff

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

Fonction anonyme. Dans ce cas, tous les chiffres sont convertis en caractères. n[-d]est le tableau sans les chiffres. Renvoie NULL(liste vide) sur une entrée vide.

Essayez-le en ligne!

Japt , 18 15 octets

Merci @Shaggy pour -3 octets et pour l'aide à la correction des tableaux avec 0s.

c ñc
®¤?Vv :Vo

La première ligne est intentionnellement laissée en blanc.

Essayez-le en ligne! à l'aide de -Qpour afficher le tableau formaté.

Explication

La première ligne est vide pour éviter d'écraser le tableau d'entrée.
[5, 'a', 'x', 3, 6, 'b']

c ñc

Faites une copie en aplatissant ( c) le tableau d'entrée, puis triez ( ñ) avec les chaînes représentées par leur code de caractère ( c). Ceci est stocké dans V.
[3, 5, 6, 'a', 'b', 'x']

£

Puis mappez le tableau d'entrée par la fonction ...

¤?Vv :Vo

Transformez les nombres en chaînes binaires (véridiques) ou en chaînes ""(fausses) ( ¤). Si c'est vrai, supprimez-le du début de V( v), sinon supprimez-le de la fin ( o).

JavaScript, 164 162 158 142 octets

modifier 1: 2 octets de moins après avoir supprimé une affectation redondante de v.

éditez 2: 4 octets de moins grâce à TheLethalCoder.

modifier 3: 16 octets de moins grâce aux astuces brillantes de 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")

C'est ma toute première fois en code-golf, donc ça peut sûrement être amélioré ... Mais ça vaut quand même la peine d'essayer.

Le programme effectue une variante de tri par sélection, qui ne prend en compte que les valeurs du même type que la valeur courante (en échangeant uniquement un chiffre et un chiffre, ou une lettre et une lettre)

Forme lisible:

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 octets

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

Essayez-le en ligne!

Peu compétitif. Mais je dois prendre en charge les tableaux de type mixte? BIEN.

Accepte un tableau de variantes dans un style de plage et le modifie sur place. Copie l'entrée dans deux ensembles triés, puis de nouveau dans le tableau d'entrée / sortie.

Mathematica, 203 octets

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

Essayez-le en ligne!

Gelée , 14 octets

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

Essayez-le en ligne!

Fondamentalement, un portage de la solution Python de Rod .

Pyth , 12 11 octets

KSQm.(Kt>\@

Essayez-le en ligne! ou Essayez la suite de tests.

Explication

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 octets

6 octets économisés grâce à @officialaimm

9 octets enregistrés grâce à @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]

Essayez-le en ligne!

05AB1E , 17 octets

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

Essayez-le en ligne!

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'utilisation de la fermeture de tri était en fait pire: Σ©Ç®ai0<*}}¹SaJsvyay.;

Python 3, 77 octets

Cette réponse est basée sur le commentaire qui dit que vous pouvez utiliser «1», «2», etc. si les caractères et les chiffres ne sont pas comparables dans la langue. 'a' et 1 ne sont pas comparables en 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 octets

Solution:

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

Exemples:

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

Explication:

Trouver les caractères dans la liste, trier par ordre décroissant, trouver les longs dans la liste, les trier par ordre croissant, joindre pour obtenir une liste de, par exemple ("x";"b";"a";3;5;6), puis attribuer les valeurs triées à leurs positions d'origine dans la liste, par exemple à 0 3 4 1 2 5.

Le golf consiste simplement à remplacer q mots clés ( each, whereet not) par leur kéquivalent (ce qui nécessite qu'ils soient placés entre crochets).

{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

Modifications

• -1 octet car pas besoin de crochets autour desc

C (gcc) , 125 113 110 octets

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

Essayez-le en ligne!

Expliqué:

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

Les lettres sont attendues en majuscules.

PHP, 66 octets:

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

prend l'entrée des arguments de la ligne de commande, imprime une chaîne. Courez avec -nrou essayez-le en ligne .

Donne un avertissement en PHP 7.1; remplacer a&par ""<pour corriger.

Mathematica, 107 octets

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

C # (.NET Core) , 171 octets

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

Le nombre d'octets comprend également:

using System.Linq;

Essayez-le en ligne!

Explication:

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 octets

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

Essayez-le en ligne!

Rubis , 265 octets

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}

Essayez-le en ligne!

Première minuterie ici, ma solution n'est certainement pas la meilleure. Mais comme c'est ma première réponse, j'ai pensé en publiant juste pour le plaisir.

Regarder plus loin pour voir de meilleures réponses Ruby, pour voir quelle est la meilleure approche. J'espère que je m'améliorerai dans les réponses futures =)

Lisible

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 octets

Il peut y avoir des moyens plus courts, mais je devais juste l'essayer avec la Lensbibliothèque.

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

Je pourrais définir fsimplement la composition des deux iinvocations, mais je devrais quand même y appliquer xpour éviter une erreur de type de la restriction du monomorphisme. Notez que le type de fest Traversable t => t Char -> t Charainsi il peut être utilisé avec Strings qui sont des listes de Chars ainsi qu'avec des tableaux de Chars.

Voici les cas de test:

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

Python 3, 91 octets

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 octets

#(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})))

Exemple:

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

Cette cumulative calcule la somme comptage des nombres entiers et des caractères, et l' utilise pour rechercher l'élément correct à partir d' une liste triée des correspondants les éléments de types.

APL (Dyalog) , 26 octets

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

(utilise ⎕IO=1)

Essayez-le en ligne!