Escriba un programa que tome una cadena y muestre todos los caracteres en orden alfabético. Los espacios y símbolos se pueden ignorar o eliminar, pero las letras mayúsculas y minúsculas deben permanecer en el mismo caso.

Entrada de muestra:

Johnny walked the dog to the park.

Salida de muestra

aaddeeeghhhJklnnoooprtttwy

Reglas:

• Cualquier idioma

• El código más corto gana.

MathGolf , 2 bytes

áδ

Pruébalo en línea!

Salida de ejemplo

      .aaddeeeghhhJkklnnoooprtttwy

Eliminar caracteres no alfabéticos

Para eliminar todos los caracteres no alfabéticos, esta solución funciona:

áδgÆ∞_δ¡

Es lo mismo que el código anterior, seguido de un filtro donde cada personaje se duplica primero, y luego se compara su propia capitalización. Por ejemplo, la cadena "a"se convierte "aa"y luego se capitaliza en "Aa", que no es igual a "aa". De la misma manera, la cadena "B"se convierte "BB"y se capitaliza en "Bb", que no es igual a "BB". Sin embargo, "."se convierte a".." y no cambia cuando se capitaliza, por lo que se filtrará.

Explicación

Realmente necesito más manejo de cadenas en MathGolf ... En este momento ni siquiera hay un operador para convertir a minúsculas / mayúsculas. Lo único que pude usar fue el operador de mayúsculas, que funciona como un operador en mayúsculas para cadenas de longitud 1. Esta solución también clasifica los caracteres no alfabéticos, pero podrían ignorarse. Los caracteres alfabéticos conservan sus mayúsculas y minúsculas en el orden correcto.

á    sort by comparator
 δ   capitalize string

GolfScript, 24/6 caracteres

{26,{65+.32+}%?)},{31&}$

Ejemplo:

> Johnny walked the dog to the park.
aaddeeeghhhJkklnnoooprtttwy  

Si la entrada está restringida a ASCII imprimible, el código puede acortarse en tres caracteres utilizando {95&.64>\91<&},como filtro.

Se puede probar aquí .

La versión que se puede ignorar es aún más corta (6 caracteres):

{31&}$

y rinde salida

> Johnny walked the dog to the park.
      aaddeeeghhhJkkl.nnoooprtttwy

Utilidades principales de GNU: 25 caracteres (29 símbolos de caída)

fold -1|sort -f|tr -d \\n

Ejemplo (de GNU bash 3):

$ echo "Johnny walked the dog to the park."|fold -1|sort -f|tr -d \\n
      .aaddeeeghhhJkklnnoooprtttwy   <<no trailing newline>>

De la pregunta:

Los espacios y símbolos se pueden ignorar o eliminar

¡Elegí dejarlos adentro! Para conservar sólo los caracteres alfabéticos, sustituir fold -1con grep -o \\wde +4 caracteres.

grep -o \\w|sort -f|tr -d \\n

Gracias a la luciérnaga para recomendar grep -omás sed, y para Wumpus fold -1. ;-)

C, 121

Esto es bastante largo en comparación con otras entradas, pero no depende de ninguna función incorporada de clasificación o ToLower:

j;main(k){char s[99],*p=s;gets(s);while(*p){j=p-s-1;k=*p++;while(j>=0&&(s[j]|32)>(k|32))s[j+1]=s[j--];s[j+1]=k;}puts(s);}

Versión más legible:

j; main(k) {
    char s[99], *p=s;
    gets(s);
    while(*p) {
        j = p-s-1;
        k = *p++;
        while(j >= 0 && (s[j]|32) > (k|32))
            s[j+1] = s[j--];
        s[j+1] = k;
    }
    puts(s);
}

Esta es una implementación del tipo de inserción con una comparación que distingue entre mayúsculas y minúsculas entre los elementos (usando la |32operación bit a bit). Esto se debe a que en la codificación ASCII, las letras mayúsculas y minúsculas solo difieren en 2 ⁵ bits.

Ruby - 33 caracteres

$><<gets.chars.sort(&:casecmp)*''

PowerShell: 39

$([string[]][char[]](Read-Host)|sort)" #With spaces and symbols

Resultado

  .aaddeeeghhhJkklnnoooprtttwy

C #: 100

Console.Write(new string(input.ToCharArray().OrderBy(a=>char.ToLower(a)).ToArray()).Trim('.',' '));

Resultado

aaddeeeghhhJkklnnoooprtttwy

APL 16

      ⍞←A[⍋48|⎕av⍳A←⍞]
Johnny walked the dog to the park.
      aaddeeeghhhJkklnnoooprtttwy.

Perl6: 26 caracteres.

Primero ordena la salida en mayúscula, luego en minúscula, elimina los símbolos / espacios en blanco

say [~] sort comb /\w/,get

Si los espacios en blanco / símbolos en la salida también pueden ignorarse, esto es solo 21 caracteres.

say [~] get.comb.sort

Esto clasifica entre mayúsculas y minúsculas, mantiene símbolos (26 caracteres)

say [~] get.comb.sort: &lc

Perl 34

Ahora toma entrada de STDIN.

print sort{lc$a cmp lc$b}<>=~/\w/g

Perl 18

Si la producción incluye mayúsculas primero y símbolos incluidos es aceptable:

print sort<>=~/./g

Haskell, 88

import Data.List
import Data.Char
import Data.Ord
main=interact$sortBy$comparing toLower

(38 sin importaciones desde lib estándar)

k ( 10 9)

Lecturas de stdin

x@<_x:0:0

Ejemplo

x@<_x:0:0
Johhny walked the dog to the park.
"      .aaddeeeghhhhJkklnoooprtttwy"

C #: 83

Console.Write(new string(Console.ReadLine().OrderBy(i=>i+"".ToLower()).ToArray()));

Actualización: 65

Ejecutable en LinQPad

new string(Console.ReadLine().OrderBy(i=>i+"").ToArray()).Dump();

Pitón 3: 45

print(''.join(sorted(input(),key=str.lower)))

J, 12 caracteres

(/:32|a.i.])

Ignora cualquier carácter no alfa.

Javascript - 74

Desafortunadamente, debido a la forma en que JS clasifica los caracteres, no podemos usar la función de clasificación estándar:

prompt().split("").sort(function(a,b){return a.localeCompare(b)}).join("")

En realidad, esto se puede acortar a:

prompt().split("").sort((a,b)=>a.localeCompare(b)).join("")

F # ( 68 56)

Estoy aprendiendo F #, así que estoy seguro de que esto podría ser más corto:

let f s=s|>Seq.sortBy Char.ToLower|>Seq.iter(printf"%c")

Salida:

> f "Johnny walked the dog to the park."
        .aaddeeeghhhJkklnnoooprtttwy 

PHP, 50 bytes

$a=str_split($argn);natcasesort($a);echo join($a);

no elimina las letras que no son, toma la entrada de STDIN; correr con -R.

R, 48 caracteres

cat(sort(unlist(strsplit(scan(,""),""))),sep="")

Ejemplo de uso:

> cat(sort(unlist(strsplit(scan(,""),""))),sep="")
1: Johnny walked the dog to the park.
8: 
Read 7 items
.aaddeeeghhhJkklnnoooprtttwy

q / k4 (3? 5? 8?)

si es suficiente ingresar el código y la entrada directamente en el REPL, es solo asc:

q)asc"Johnny walked the dog to the park."
`s#"      .Jaaddeeeghhhkklnnoooprtttwy"

el `s#es q poco de notación que indica que la cadena está ordenada (puede ser binaria búsquedas, etc.). si tiene que ir, eso cuesta dos caracteres, haciendo cinco:

q)`#asc"Johnny walked the dog to the park."
"      .Jaaddeeeghhhkklnnoooprtttwy"

si desea que se proporcione en stdin, es hora de cambiar a k4 (y nos deshacemos de él `s#de forma gratuita), y es una solución de ocho caracteres:

  x@<x:0:0
Johnny walked the dog to the park.
"      .Jaaddeeeghhhkklnnoooprtttwy"

ese, por cierto, funcionará como un archivo de código exactamente como es (aún ocho caracteres, ya que q está bien con no tener la nueva línea final en un archivo de código). normalmente habría problemas con un banner de bienvenida y con el REPL permaneciendo abierto, pero si pasa la entrada como una herejía, todo eso desaparece:

$ cat asc.k
x@<x:0:0
$ q asc.k<<<'Johnny walked the dog to the park.'
"\n      .Jaaddeeeghhhkklnnoooprtttwy"
$ 

no estoy seguro de dónde proviene esa nueva línea adicional en la salida ...

Jalea, 3 bytes

ŒlÞ

¡Mi primera solución Jelly en este sitio! ¡Gracias a @LeakyNun y @ErikTheOutgolfer por enseñarme cómo usar Jelly y @Dennis por hacerlo! :RE

Explicación

ŒlÞ
  Þ Sort using the function to its left
Œl  Converts to lowercase (because it's sort alphabetically, not by codepoint)

Alternativamente, ŒuÞhace exactamente lo mismo excepto convertir a mayúsculas en su lugar.

Powrshell, 36 bytes

-join($args-split'\W|(.)'-ne''|sort)

Script de prueba:

$f = {

-join($args-split'\W|(.)'-ne''|sort)

}

@(
    ,("Johnny walked the dog to the park.", "aaddeeeghhhJkklnnoooprtttwy")
) | % {
    $s,$expected = $_
    $result = &$f $s
    "$("$result"-eq"$expected"): $result"
}

Salida:

True: aaddeeeghhhJkklnnoooprtttwy

05AB1E , 3 bytes

áΣl

Pruébalo en línea .

Explicación:

á      # Only leave the letters of the (implicit) input-string
 Σ     # Sort those letters by:
  l    #  Their lowercase equivalent
       # (And output the result implicitly)

Java 10, 72 bytes (como función lambda)

s->{for(int i=64;++i<91;)for(var c:s)if((c&~32)==i)System.out.print(c);}

Pruébalo en línea.

Pero dado que es un viejo desafío que establece el programa completo:

Java 10, 126 bytes (como programa completo)

interface M{static void main(String[]a){for(int i=64;++i<91;)for(var c:a[0].toCharArray())if((c&~32)==i)System.out.print(c);}}

Pruébalo en línea.

Explicación:

interface M{                        // Class
  static void main(String[]a){      //  Mandatory main method
    for(int i=64;++i<91;)           //   Loop over the uppercase alphabet
      for(var c:a[0].toCharArray()) //    Inner loop over the characters of the input
        if((c&~32)                  //     If the current character converted to uppercase,
                  ==i)              //     equals the current letter of the alphabet
          System.out.print(c);}}    //      Print the character of the input-loop