Scrivi un programma che prende una stringa e genera tutti i caratteri in ordine alfabetico. Spazi e simboli possono essere ignorati o eliminati, ma le lettere maiuscole e minuscole devono rimanere nello stesso caso.

Input di esempio:

Johnny walked the dog to the park.

Uscita campione

aaddeeeghhhJklnnoooprtttwy

Regole:

• Qualunque lingua

• Vince il codice più corto.

MathGolf , 2 byte

áδ

Provalo online!

Esempio di output

      .aaddeeeghhhJkklnnoooprtttwy

Rimozione di caratteri non alfabetici

Per rimuovere tutti i caratteri non alfabetici, questa soluzione funziona:

áδgÆ∞_δ¡

È lo stesso del codice sopra, seguito da un filtro in cui ogni carattere viene prima raddoppiato, quindi confrontato la propria maiuscola. Ad esempio, la stringa "a"viene convertita in "aa"e quindi maiuscola "Aa", che non è uguale a "aa". Allo stesso modo, la stringa "B"viene convertita in "BB"e maiuscola "Bb", che non è uguale a "BB". Tuttavia, "."viene convertito in ".."e rimane invariato quando viene capitalizzato, quindi verrà filtrato.

Spiegazione

Ho davvero bisogno di una maggiore gestione delle stringhe in MathGolf ... In questo momento non c'è nemmeno un operatore da convertire in minuscolo / maiuscolo. L'unica cosa che potevo usare era l'operatore di capitalizzazione, che funziona come un operatore maiuscolo per stringhe di lunghezza 1. Questa soluzione ordina anche caratteri non alfabetici, ma questi potrebbero essere ignorati. I caratteri alfabetici conservano il loro caso e vengono emessi nell'ordine corretto.

á    sort by comparator
 δ   capitalize string

GolfScript, 24/6 caratteri

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

Esempio:

> Johnny walked the dog to the park.
aaddeeeghhhJkklnnoooprtttwy  

Se l'input è limitato agli ascii stampabili, il codice può essere abbreviato di tre caratteri usando {95&.64>\91<&},come filtro.

Può essere testato qui .

La versione che può essere ignorata è ancora più breve (6 caratteri):

{31&}$

e produce output

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

Utilità di base GNU - 25 caratteri (29 simboli di rilascio)

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

Esempio (da GNU bash 3):

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

Dalla domanda:

Spazi e simboli possono essere ignorati o eliminati

Ho scelto di lasciarli dentro! Per conservare solo i caratteri alfabetici, sostituisci fold -1con grep -o \\wper +4 caratteri.

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

Grazie a Firefly per raccomandare grep -osopra sed, e Wumpus per fold -1. ;-)

C, 121

Questo è piuttosto lungo rispetto ad altre voci, ma non si basa su alcun ordinamento incorporato o funzioni 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);}

Versione più leggibile:

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

Questa è un'implementazione dell'ordinamento per inserzione con un confronto senza distinzione tra maiuscole e minuscole tra gli elementi (usando l' |32operazione bit a bit). Questo perché nella codifica ASCII le lettere maiuscole e minuscole differiscono solo per 2 ⁵ bit.

Rubino - 33 caratteri

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

PowerShell: 39

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

Risultato

  .aaddeeeghhhJkklnnoooprtttwy

C #: 100

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

Risultato

aaddeeeghhhJkklnnoooprtttwy

16 APL

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

Perl6: 26 caratteri

Prima ordina l'output in maiuscolo, poi in minuscolo, elimina i simboli / spazi bianchi

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

Se anche gli spazi bianchi / i simboli nell'output possono essere ignorati, questi sono solo 21 caratteri.

say [~] get.comb.sort

Questo distingue tra maiuscole e minuscole, mantiene i simboli (26 caratteri)

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

Perl 34

Ora accetta input da STDIN.

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

Perl 18

Se l'output include prima le maiuscole e i simboli inclusi sono accettabili:

print sort<>=~/./g

Haskell, 88

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

(38 senza importazioni dalla lib standard)

k ( 10 9)

Legge da stdin

x@<_x:0:0

Esempio

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

Aggiornamento: 65

Eseguibile in LinQPad

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

Python 3: 45

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

J, 12 caratteri

(/:32|a.i.])

Ignora qualsiasi carattere non alfa.

Javascript - 74

Sfortunatamente, a causa del modo in cui JS ordina i caratteri, non possiamo usare la funzione di ordinamento standard:

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

In realtà questo può essere abbreviato in:

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

F # ( 68 56)

Sto imparando F # quindi sono sicuro che questo potrebbe essere più breve:

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

Produzione:

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

PHP, 50 byte

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

non rimuove le non lettere, accetta input da STDIN; corri con -R.

R, 48 caratteri

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

Esempio di utilizzo:

> 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 è sufficiente inserire il codice e l'input direttamente nel REPL, è solo asc:

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

la `s#è bit q notazione che indica che la stringa è in modo ordinato (binaria può essere cercato, ecc). se deve andare, questo costa due personaggi, facendo cinque:

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

se lo vuoi fornito su stdin, è tempo di passare a k4 (e ce ne liberiamo `s#gratuitamente), ed è una soluzione di otto caratteri:

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

quello, tra l'altro, funzionerà come un file di codice esattamente come è (ancora otto caratteri, poiché q va bene non avendo l'ultima riga finale in un file di codice). normalmente ci sarebbero problemi con un banner di benvenuto e con il REPL che restava aperto, ma se si passa l'input come herestring, tutto ciò che va via:

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

non sono sicuro da dove provenga quella nuova riga aggiuntiva nell'output ....

Gelatina, 3 byte

ŒlÞ

La mia prima soluzione Jelly su questo sito! Grazie a @LeakyNun e @ErikTheOutgolfer per avermi insegnato come usare Jelly e @Dennis per realizzarlo! : D

Spiegazione

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

In alternativa, ŒuÞfa esattamente la stessa cosa tranne la conversione in maiuscolo.

Powrshell, 36 byte

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

Script di prova:

$f = {

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

}

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

Produzione:

True: aaddeeeghhhJkklnnoooprtttwy

05AB1E , 3 byte

áΣl

Provalo online .

Spiegazione:

á      # 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 byte (come funzione lambda)

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

Provalo online.

Ma dal momento che è una vecchia sfida affermando il programma completo:

Java 10, 126 byte (come programma 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);}}

Provalo online.

Spiegazione:

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