Escreva um programa que pega uma string e gera todos os caracteres em ordem alfabética. Os espaços e símbolos podem ser ignorados ou excluídos, mas as letras maiúsculas e minúsculas devem permanecer no mesmo caso.

Entrada de amostra:

Johnny walked the dog to the park.

Saída de amostra

aaddeeeghhhJklnnoooprtttwy

Regras:

• Qualquer língua

• O código mais curto vence.

MathGolf , 2 bytes

áδ

Experimente online!

Saída de exemplo

      .aaddeeeghhhJkklnnoooprtttwy

Removendo caracteres não alfabéticos

Para remover todos os caracteres não alfabéticos, esta solução funciona:

áδgÆ∞_δ¡

É o mesmo que o código acima, seguido por uma filtragem em que cada caractere é dobrado primeiro e depois comparado sua própria capitalização. Por exemplo, a cadeia de caracteres "a"é convertida "aa"e, em seguida, capitalizada para "Aa", o que não é igual a "aa". Da mesma forma, a sequência "B"é convertida "BB"e maiúscula em "Bb", o que não é igual a "BB". No entanto, "."é convertido ".."e inalterado quando em maiúscula, para que seja filtrado.

Explicação

Eu realmente preciso de mais manipulação de strings no MathGolf ... No momento, não há nem mesmo um operador para converter em letras minúsculas / maiúsculas. A única coisa que eu poderia usar era o operador de capitalização, que funciona como um operador em maiúsculas para cadeias de comprimento 1. Essa solução também classifica caracteres não alfabéticos, mas esses podem ser ignorados. Os caracteres alfabéticos preservam suas letras maiúsculas e minúsculas e são exibidos na ordem correta.

á    sort by comparator
 δ   capitalize string

GolfScript, 24/6 caracteres

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

Exemplo:

> Johnny walked the dog to the park.
aaddeeeghhhJkklnnoooprtttwy  

Se a entrada for restrita a ascii imprimível, o código poderá ser reduzido por três caracteres usando {95&.64>\91<&},como filtro.

Pode ser testado aqui .

A versão pode ser ignorada é ainda mais curta (6 caracteres):

{31&}$

e produz saída

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

Utilitários principais GNU - 25 caracteres (29 símbolos descartados)

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

Exemplo (do GNU bash 3):

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

Da pergunta:

Espaços e símbolos podem ser ignorados ou excluídos

Eu escolhi deixá-los dentro! Para reter apenas caracteres alfabéticos, substitua fold -1com grep -o \\wa +4 caracteres.

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

Graças à Firefly para recomendar grep -omais sed, e Wumpus para fold -1. ;-)

C, 121

Isso é bastante longo comparado a outras entradas, mas não depende de nenhuma classificação interna ou das funções do 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);}

Versão mais legível:

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 é uma implementação de classificação por inserção com uma comparação sem distinção entre maiúsculas e minúsculas entre elementos (usando a |32operação bit a bit). Isso ocorre porque na codificação ASCII letras maiúsculas e minúsculas diferem apenas pelos 2 ⁵ bits.

Ruby - 33 Chars

$><<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

Classifica a saída em maiúscula primeiro e, em seguida, em minúscula, exclui símbolos / espaço em branco

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

Se espaços em branco / símbolos na saída também puderem ser ignorados, são apenas 21 caracteres.

say [~] get.comb.sort

Isso classifica sem distinção entre maiúsculas e minúsculas, mantém símbolos (26 caracteres)

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

Perl 34

Agora recebe entrada de STDIN.

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

Perl 18

Se a saída incluindo maiúsculas e símbolos incluídos for aceitável:

print sort<>=~/./g

Haskell, 88

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

(38 sem importações da lib padrão)

k ( 10 9)

Lê a partir de stdin

x@<_x:0:0

Exemplo

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

Atualização: 65

Executável no LinQPad

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

Python 3: 45

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

J, 12 caracteres

(/:32|a.i.])

Ignora qualquer caractere não alfa.

Javascript - 74

Infelizmente, devido à maneira como o JS classifica os caracteres, não podemos usar a função de classificação padrão:

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

Na verdade, isso pode ser reduzido para:

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

F # ( 68 56)

Estou aprendendo F #, então tenho certeza que isso pode ser mais curto:

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

Resultado:

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

PHP, 50 bytes

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

não remove não letras, recebe informações do STDIN; corra com -R.

R, 48 caracteres

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

Exemplo 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?)

se for suficiente inserir o código e a entrada diretamente no REPL, é apenas asc:

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

o `s#é pouco de notação q que indica que a corda está em ordem de classificação (pode ser binário procurou, etc.). se for necessário, isso custa dois caracteres, perfazendo cinco:

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

se você quiser que ele seja fornecido no stdin, é hora de mudar para o k4 (e nos livramos dele de `s#graça), e é uma solução de oito caracteres:

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

aquele, btw, funcionará como um arquivo de código exatamente como está (ainda com oito caracteres, pois q é bom por não ter a nova linha final em um arquivo de código). normalmente, haveria problemas com um banner de boas-vindas e com o REPL aberto, mas se você passar a entrada como herestring, tudo isso desaparecerá:

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

não tenho certeza de onde vem essa nova linha extra na saída ....

Geléia, 3 bytes

ŒlÞ

Minha primeira solução Jelly neste site! Obrigado a @LeakyNun e @ErikTheOutgolfer por me ensinarem como usar Jelly e @Dennis para fazê-lo! : D

Explicação

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

Como alternativa, ŒuÞfaz exatamente a mesma coisa, exceto convertendo para maiúsculas.

Powrshell, 36 bytes

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

Script de teste:

$f = {

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

}

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

Resultado:

True: aaddeeeghhhJkklnnoooprtttwy

05AB1E , 3 bytes

áΣl

Experimente online .

Explicação:

á      # 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 função lambda)

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

Experimente online.

Mas já que é um desafio antigo afirmar o 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);}}

Experimente online.

Explicação:

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