Firma quella parola!

12

Che cos'è una firma di parola?

La firma di una parola sono tutte le sue lettere messe in ordine - le firme di this, histe hitssono tutte hist.

La sfida

Scrivere un programma dovrebbe chiedere un input, quindi stampare la firma di quella parola. Quindi un programma di esempio potrebbe essere simile al seguente:

Give me a string: this
The signature signature of 'this' is hist.

Non è richiesta alcuna interazione, purché richieda un input e stampi la firma, va bene.

punteggio

Vince il programma con il numero di byte più piccolo!

Classifica

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Mostra snippet di codice

Sfidato finito!

VINCITORE: jimmy23013

code-golf  string  sorting  word 
— Comunità
fonte
3
Non dobbiamo stampare le frasi Give me a string:e The signature signature of 'this' isgiusto? Possiamo semplicemente prendere direttamente l'input e stampare il risultato?
— Fatalizza il
4
E le lettere duplicate? es. è la firma di broom bmooro bmor?
— Samgak,
3
@isaacg perché sei?
— Tim
3
@Tim Non penso che dovremmo avere sfide così semplici. Te lo chiederò su meta - non si tratta proprio di questa domanda in particolare.
— isaacg,
2
Penso che questa sarebbe stata una sfida più interessante se non fosse possibile utilizzare le funzioni di ordinamento integrate.
— Glen O

Risposte:

49

GolfScript, 1 byte

$

Sì, solo 1 byte.

Provalo qui.

— jimmy23013
fonte
4
Contrassegnato come corretto perché nessuno può battere 1 byte.
9
@Kslkgh In teoria, forse qualcuno può trovare una lingua che può farlo in 0 byte?
— jimmy23013,
2
Direi che questo fallisce per "Hello"
— James Webster,
3
Sembra rompere per qualsiasi cosa con una capitale, ma suppongo che non sia mai stato specificato
— Lain
1
I capitali non infrangono il codice. Prima ordina le maiuscole e poi le minuscole. cioè cbaCBAfed -> ABCabcdef
— Mully
25

C (con x86), 61 byte

s[];main(){qsort(s,read(0,s,99),1,"YXZQQQ\x8a\x00*\x02\x0f\xbe\xc0\xc3");puts(s);}

Quella stringa contiene byte grezzi, non \x..codici effettivi , ed è un callback di codice macchina grezzo passato a qsort. Funziona solo su x86:

59         pop   ecx
58         pop   eax
5a         pop   edx
51         push  ecx
51         push  ecx
51         push  ecx
8a 00      mov   al,  BYTE PTR [eax]
2a 02      sub   al,  BYTE PTR [edx]
0f be c0   movsx eax, al
c3         ret

Che è essenzialmente:

int func(char *a, char *b) { return *a - *b; }

Vedi p6-7 di questo opuscolo in giapponese di shinh .

— Lynn
fonte
Questo non è un linguaggio C generico, poiché ha come target un'architettura specifica. Questo dovrebbe essere specificato nella rubrica
— edc65,
19

Bloccato, 5 byte

Finalmente riesco a usare la mia lingua, Stuck ! : D

s$""j

Ciò accetta un input tramite stdin, ordinamenti, join e stampe implicite. Questo mi ha dato alcune idee per i cambiamenti però.

Modifica: Oh wow, qualcuno ha già pubblicato e mi ha battuto nella mia lingua!

— Kade
fonte
16

GOTO ++, 432 430 byte

Sito del progetto GOTO ++ .

niveaugourou 0
s=ENTRETONTEXTE()
§2 a=LeCaracNumero()&s *(1)
n=*(1)
costaud i=*(2)/&i infeg NombreDeLettres(&s)/i=+*(1)
b=LeCaracNumero()&s &i
GOTONULPOURLESNULS %1 }&b inf &a{
a=&b
n=&i
§1 faiblard
GOTOPRINTDUTEXTE()&a
t=PrendsUnMorceau()&s *(0) &n
u=PrendsUnMorceau()&s }&n+*(1){ *(0)
e=BOITEAPINGOUINS()&t &u
s=Marijuana()&e «»
GOTONONNULPOURLESNULS %3 }NombreDeLettres(&s) eg *(1){
GOTOPASMALIN %2
§3 GOTOPRINTDUTEXTE()&s

Non sono sicuro del motivo per cui mi sono inflitto questo, ma l'ho fatto

— Fatalize
fonte
13

gs2, 1 byte

/

Come la risposta GolfScript, ma gs2 utilizza un operatore diverso per l'ordinamento.

— Lynn
fonte
10

Perl, 18 byte

print sort<>=~/./g

Grazie a Dom Hastings per avermi aiutato a salvare 3 byte.

— samgak
fonte
è possibile risparmiare pochi byte utilizzando un /./gposto di split'',: print sort<>=~/./g!
— Dom Hastings,
Con -nE, puoi farlo say sort/./g.
— Dennis,
7

Haskell, 35 byte

import Data.List;main=interact sort
— Lynn
fonte
6

C #, 114 110 caratteri

Prende input da un argomento della riga di comando. Non è un programma molto breve, ma beh ... è C #. : P

namespace System.Linq{class P{static void Main(string[]a){Console.Write(string.Concat(a[0].OrderBy(x=>x)));}}}

Grazie ad Abbas per aver salvato 4 byte!

— ProgramFOX
fonte
1
Puoi salvare 4 caratteri usando Writeinvece di WriteLine. ;)
— Abbas,
@Abbas Grazie! Totalmente perso quello; p
— ProgramFOX
6

Brainfuck, 40 byte

,[>>+>>,]<<[[<<]>>[-[<]>>[.<<->]>+>>]<<]

Questo utilizza l' algoritmo di ordinamento conteggio , che lo rende una soluzione O (n) .

Il codice richiede un nastro infinito sinistro o avvolgente di celle a 8 bit. Provalo online!

Come funziona

,          Read a char from STDIN.
[          While the byte under the pointer (last read char) is non-zero:
  >>+        Move the pointer two steps to the right and increment.
  >>,        Move the pointer two steps to the right and read a char.
]
<<         Move the pointer two steps to the left.

           If the input was "sort", the tape now contains the following:
           0 0 115 0 1 0 111 0 1 0 114 0 1 0 116 0 1 0 0
                                                   ^

[          While the byte under the pointer is non-zero:
  [<<]       Advance two steps to the left until a null byte is encountered.
  >>         Advance two steps to the right.

             This will place the pointer on the first input character.

  [          While the byte under the pointer is non-zero:
    -          Decrement.
    [<]        Move the pointer to the left until a null byte is encountered.
    >>         Move the pointer two steps to the right.

               If the decremented character is non-zero, [<] will move to the
               null byte before it, so >> brings the pointer to the null byte
               after it. If the decremented character is zero, [<] is a no-op, so
               >> advances two steps to the right, to a non-zero byte.

    [          While the byte under the pointer is non-zero:
      .          Print the char under the pointer.
      <<-        Move the pointer two steps to the left and decrement.
      >          Move the pointer to the right.
    ]

               If the decremented character gave zero, this will print the value
               of the accumulator after it, and decrement the character once more
               to make it non-zero, then place the pointer to the right of the
               character, thus exiting the loop.

    >+         Move the pointer to the right and increment.

               This increments the accumulator each time an input character is
               decremented.

    >>         Move the pointer two steps to the right.

               This moves the pointer to the next character.
  ]
  <<         Move the pointer two steps to the left.

             This moves the pointer to the accumulator of the last character.
]

             After 255, th accumulator wraps around to 0, and the loop ends.
— Dennis
fonte
5

CJam, 2 byte

l$

Legge una riga di input ( l) e la ordina ( $).

— Lynn
fonte
4

Coreutils, 24 23

fold -w1|sort|tr -d \\n
— Thor
fonte
4

Java 8, 119 byte

Questo è fondamentalmente competitivo solo con la risposta C #, perché, beh, Java.

(Almeno questo batte GOTO ++. Non proprio un risultato ...)

class C{public static void main(String[]s){s=s[0].split("");java.util.Arrays.sort(s);System.out.print("".join("",s));}}

Grazie a ProgramFOX per il salvataggio di 1 byte, rink.attendant per il salvataggio di 2 byte.

— TheMadHaberdasher
fonte
È possibile salvare un carattere rimuovendo lo spazio tra String[]e s.
— Programma FOX
Oh, me ne sono dimenticato. Ora il mio conteggio dei byte è un bel numero quadrato. Grazie!
— TheMadHaberdasher
Penso che puoi usare System.out.printinvece diprintln
— rink.attendant.6
Grazie! Questo è il mio primo tentativo di code golf, quindi devo ancora imparare cose del genere.
— TheMadHaberdasher,
Puoi salvare 12 personaggi conpublic static void main(String[]s){s[0].chars().sorted().forEach(i->System.out.print((char)i));}
— assylias il
3

JavaScript (ES6), 32 byte

La demo funziona solo in Firefox e Edge al momento della scrittura, poiché Chrome / Opera non supporta ES6 per impostazione predefinita:

Modifica: non ho esaminato le risposte prima della pubblicazione, ma ora mi rendo conto che è praticamente la stessa di quella di NinjaBearMonkey .

f=x=>alert([...x].sort().join``)
<form action=# onsubmit='f(document.getElementById("I").value);return false;'>
  <input type=text pattern=\w+ id=I>
  <button type=submit>Sort letters</button>
</form>
Espandi frammento

— rink.attendant.6
fonte
2

SWI-Prolog, 34 byte

a(X):-msort(X,Y),writef("%s",[Y]).

Chiamato come tale:a(`this`).

— Fatalize
fonte
2

Scala, 21 byte

print(args(0).sorted)

esegui dall'esempio della riga di comando:

$ scala -e "print(args(0).sorted)" this
hist
— Gilad Hoch
fonte
2

Julia, 21 byte

s->join(sort([s...]))

E per divertimento, ecco come potresti farlo senza utilizzare una funzione di ordinamento integrata, per 53 byte:

f=s->s>""?(k=indmax(s);f(s[k+1:end]s[1:k-1])s[k:k]):s
— Glen O
fonte
2

JavaScript, 34 byte

alert([...prompt()].sort().join``)

Il motivo per cui è così lungo è che JavaScript può solo ordinare gli array, quindi la stringa deve essere suddivisa in un array, ordinata e quindi riunita nuovamente in una stringa. Questo è ECMAScript 6; l'equivalente in ES5 è:

alert(prompt().split('').sort().join(''))
— NinjaBearMonkey
fonte
Dovrebbe specificare EcmaScript 6 mentre sta usando ...e stringhe modello
— edc65
@ edc65 Hai ragione, ho dimenticato. Fatto.
— NinjaBearMonkey il
1

Python 2, 33 32 byte

print`sorted(raw_input())`[2::5]

Fortemente ispirato dalla risposta di @ Kamehameha. Convertito in pitone 2. Non posso giocare a golf molto di più.

— Blu
fonte
1
Puoi usarlo reprper portarlo giù un altro byte (Ora sai perché ho scelto la versione della soluzione Python 3: P) - print`sorted(raw_input())`[2::5](Quelli sono backtick, non virgolette singole)
— Kamehameha,
1

APL, 7 caratteri

Non funziona su ngn-apl per me, ma dovrebbe funzionare in teoria:

X[⍋X←⍞]

⍞legge una riga dall'input standard, a cui è assegnato X. ⍋Xsono gli indici di Xcui producono un ordine crescente e in X[...]realtà ordinano Xper questi indici.

— Lynn
fonte
1
Funziona su Dyalog (versione desktop, non TryAPL).
— Alex A.
1

JavaScript, 54 byte

chiama il file js con il nodo

console.log(process.argv[2].split('').sort().join(''))
— Marcel
fonte
1

Nim, 102 101 79 73 byte

let s=stdin.readAll
for i in 1..'~':
 for j in s:(if i==j:stdout.write j)

Ancora imparando Nim e allenando i trucchi del golf. Apparentemente è meglio non usare il built-in sort, che richiederebbe molte importazioni (grazie a @Mauris)

— SP3000
fonte
let s=stdin.readAll;for i in 1..'~':(for j in s:(if i==j:echo j))è di 65 byte.
— Lynn,
@Mauris Wow, non pensavo che non usare l'ordinamento incorporato sarebbe più breve! L'unico problema però: c'è un modo per farlo echosenza la nuova riga finale?
— Sp3000,
Oh, oops, ovviamente. stdout.write jsembra funzionare ed è leggermente più corto del tuo &=loop.
— Lynn,
@Mauris In effetti, sembra funzionare - grazie :)
— Sp3000
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.