Inspirado por esta pregunta de desbordamiento de pila: ordenar una lista: números en forma ascendente, letras en forma descendente . Su tarea es resolver el siguiente problema y, como se trata de código de golf , debe hacerlo en el menor número de bytes posible.

Debe tomar una lista de objetos como de entrada que contiene las letras (en cualquier forma razonable: string, char, etc) y los números. Luego debe ordenar los números en orden ascendente y las letras en orden descendente. Sin embargo, debe mantener letras en posiciones de letras y números en posiciones de números. Por ejemplo, si la lista es:

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

La lista de salida debe tener la forma de:

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

Trabajar a través

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

• Ordena los números en orden ascendente: [1, 2, 3]
• Ordena las letras en orden descendente: ['c', 'b', 'a']
• Únete a ellos pero mantén el orden igual: ['c', 1', 'b', 2, 'a', 3]

Reglas

• La lista solo contendrá letras y dígitos.
• La lista puede estar vacía.
• La lista solo puede contener letras o solo dígitos.
• Si su idioma no admite matrices de tipo mixto, puede usar caracteres de dígitos en lugar de números. Tenga en cuenta que si su idioma lo admite, debe usar tipos mixtos.
• Las letras solo serán [a-z]o [A-Z], puede elegir cuál.
• Las letras se ordenan como las amás bajas, zes decir , las más altas a = 1, z = 26.
• Las lagunas estándar están prohibidas.
• La E / S puede ser por cualquier medio estándar, incluso como una cadena.

Casos de prueba

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

Como se trata de código golf, ¡ la respuesta más corta en bytes gana!

Retina , 10 bytes

O`\d
O^`\D

Pruébalo en línea!

La Oetapa en Retina puede realizar directamente el tipo de clasificación selectiva requerida por este desafío.

Aquí la primera línea ordena los dígitos, mientras que la segunda línea ordena los no dígitos en reversa.

Python 2 , 53 52 bytes

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

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

Pruébalo en línea!

La sortedlista tendrá primero los números y luego los caracteres como [3, 5, 6, 'a', 'b', 'x'], luego se usará e<xpara filtrar qué es número y qué es char, en python cualquier número es menor que una lista (entrada) y una lista es menor que una cadena.

APL (Dyalog) , 27 26 bytes

Espera que los caracteres sean mayúsculas

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

Pruébalo en línea!

Estas son solo dos aplicaciones del formulario f@g, aplique la función fen los elementos indicados por g.

Para el primer uso de la aplicación que:
 f:  ⍒⊃¨⊂ los grados descendentes ( ⍒) cada selección ( ⊃¨) de todo el argumento ( ⊂).
 g:  (e←∊∘⎕A) miembros ( ∊) de ( ∘) el Alfabeto A ( ⎕A), y almacenar ( ←) esta función como e.

Para el segundo uso de la aplicación que:
 f:  ⍋⊃¨⊂ los grados ascendente ( ⍋) cada selección ( ⊃¨) de todo el argumento ( ⊂).
 g:  (~e) no ( ~) miembros del alfabeto ( e; la función que almacenamos antes)

JavaScript (ES6), 71 51 47 bytes

Ahorró 20 bytes simplemente usando sort(), como lo sugiere @JustinMariner. Ahorró
4 bytes más gracias a @CraigAyre

Usando un enfoque similar a la respuesta de Rod Python :

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

Casos de prueba

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 gracias 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}

Esto es lo mismo que a continuación, pero permite la entrada de tipo mixto en listlugar de un atomicvector (que escribiría todo como caracteres con tipos mixtos).

Pruébalo en línea!

R , 68 61 bytes

-7 bytes gracias a Miff

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

Función anónima. Todos los dígitos se convierten a caracteres en este caso. n[-d]es la matriz sin los dígitos. Devuelve NULL(lista vacía) en la entrada vacía.

Pruébalo en línea!

Japt , 18 15 bytes

Gracias @Shaggy por -3 bytes y por ayudar a arreglar matrices con 0s.

c ñc
®¤?Vv :Vo

La primera línea se deja en blanco intencionalmente.

Pruébalo en línea! usando -Qpara ver la matriz formateada.

Explicación

La primera línea está en blanco para evitar sobrescribir la matriz de entrada.
[5, 'a', 'x', 3, 6, 'b']

c ñc

Haga una copia al acoplar ( c) la matriz de entrada, luego ordenar ( ñ) con cadenas representadas por su código char ( c). Esto se almacena en V.
[3, 5, 6, 'a', 'b', 'x']

£

Luego mapee la matriz de entrada por la función ...

¤?Vv :Vo

Convierta los números en cadenas binarias (verdad) o cadenas en ""(falsedad) ( ¤). Si es verdad, elimine desde el principio de V( v), de lo contrario, elimine desde el final ( o).

JavaScript, 164 162 158 142 bytes

editar 1: 2 bytes menos después de eliminar una asignación redundante de v.

editar 2: 4 bytes menos gracias a TheLethalCoder.

editar 3:16 bytes menos gracias a las brillantes sugerencias 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")

Es mi primera vez en code-golf, por lo que seguramente se puede mejorar ... Pero aún así, vale la pena intentarlo.

El programa realiza una variante de selección, que solo tiene en cuenta los valores del mismo tipo que el actual (intercambiando solo un número y un número, o una letra y una letra)

Forma legible:

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

Pruébalo en línea!

Apenas competitivo. ¿Pero debo admitir matrices de tipo mixto? MULTA.

Acepta una variedad de variantes en el estilo de rango y lo modifica en su lugar. Copia la entrada en dos conjuntos ordenados y luego nuevamente en la matriz de entrada / salida.

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

Pruébalo en línea!

Jalea , 14 bytes

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

Pruébalo en línea!

Básicamente un puerto de la solución Python de Rod .

Pyth , 12 11 bytes

KSQm.(Kt>\@

Pruébalo en línea! o Prueba el conjunto de pruebas.

Explicación

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 guardados gracias a @officialaimm

9 bytes guardados gracias 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]

Pruébalo en línea!

05AB1E , 17 bytes

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

Pruébalo en línea!

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.

Usar el cierre de clasificación en realidad fue peor: Σ©Ç®ai0<*}}¹SaJsvyay.;

Python 3, 77 bytes

Esta respuesta se basa en el comentario que dice que puede usar '1', '2', etc., si los caracteres y los dígitos no son comparables en el idioma. 'a' y 1 no son 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 bytes

Solución:

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

Ejemplos:

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

Explicación:

Encuentre los caracteres en la lista, ordene descendentemente, encuentre los largos en la lista, ordénelos ascendentes, únase para obtener una lista de, por ejemplo ("x";"b";"a";3;5;6), luego asigne los valores ordenados a sus posiciones originales en la lista, por ejemplo, en 0 3 4 1 2 5.

El golf es simplemente cambiando las palabras clave (q each, wherey not) por su kequivalente (en el que puedan ser envuelto entre paréntesis).

{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

Ediciones

• -1 byte ya que no necesita corchetes alrededor 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);}

Pruébalo en línea!

Explicado:

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

Se esperan letras en mayúsculas.

PHP, 66 bytes:

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

toma datos de los argumentos de la línea de comandos, imprime una cadena. Ejecutar -nro probarlo en línea .

Produce una advertencia en PHP 7.1; reemplazar a&con ""<para arreglar.

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

El recuento de bytes también incluye:

using System.Linq;

Pruébalo en línea!

Explicación:

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

Pruébalo en línea!

Rubí , 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}

Pruébalo en línea!

Primer temporizador aquí, mi solución definitivamente no es la mejor. Pero como esta es mi primera respuesta, pensé en publicar solo por diversión.

Mirando hacia adelante para ver mejores respuestas de Ruby, para ver cuál es el mejor enfoque. Espero mejorar en futuras respuestas =)

Legible

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

Puede haber formas más cortas, pero solo tuve que probarlo con la Lensbiblioteca.

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

Podría definir fsimplemente la composición de las dos iinvocaciones, pero todavía tendría que aplicar xpara evitar un error de tipo de la restricción de monomorfismo. Tenga en cuenta que el tipo de fes Traversable t => t Char -> t Charpara que pueda usarse con Strings, que son listas de Chars, así como con matrices de Chars.

Aquí están los casos de prueba:

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

Ejemplo:

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

Esto calcula el recuento de suma acumulativa de enteros y caracteres, y lo utiliza para buscar el elemento correcto de una lista ordenada de los elementos del tipo correspondiente.

APL (Dyalog) , 26 bytes

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

(usos ⎕IO=1)

Pruébalo en línea!