Firma quella parola 2!

Non molto tempo fa, ho pubblicato una sfida chiamata Sign that word! . Nella sfida, devi trovare la firma della parola, ovvero le lettere messe in ordine (es. La firma di thisè hist). Ora, quella sfida ha funzionato abbastanza bene, ma c'era un problema chiave: era MODO troppo facile (vedi la risposta GolfScript ). Quindi, ho pubblicato una sfida simile, ma con più regole, molte delle quali sono state suggerite dagli utenti PPCG nei commenti sul puzzle precedente. Quindi, eccoci qui!

Regole

1. Il tuo programma deve prendere un input, quindi inviare la firma a STDOUT o equivalente in qualunque lingua tu stia usando.
2. Non ti è consentito utilizzare le funzioni di ordinamento integrate, quindi non è consentito l'uso di elementi come $in GolfScript.
3. Multicase deve essere supportato - il tuo programma deve raggruppare lettere sia maiuscole che minuscole. Quindi la firma di Helloè eHllo, non Hellocome ti viene data dalla risposta GolfScript sulla prima versione.
4. Ci deve essere un interprete / compilatore gratuito per il tuo programma, a cui dovresti collegarti.

punteggio

Il tuo punteggio è il conteggio dei byte. Vince il conteggio dei byte più basso.

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, utilizzando 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

var QUESTION_ID=55090;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),e.has_more?getAnswers():process()}})}function shouldHaveHeading(e){var a=!1,r=e.body_markdown.split("\n");try{a|=/^#/.test(e.body_markdown),a|=["-","="].indexOf(r[1][0])>-1,a&=LANGUAGE_REG.test(e.body_markdown)}catch(n){}return a}function shouldHaveScore(e){var a=!1;try{a|=SIZE_REG.test(e.body_markdown.split("\n")[0])}catch(r){}return a}function getAuthorName(e){return e.owner.display_name}function process(){answers=answers.filter(shouldHaveScore).filter(shouldHaveHeading),answers.sort(function(e,a){var r=+(e.body_markdown.split("\n")[0].match(SIZE_REG)||[1/0])[0],n=+(a.body_markdown.split("\n")[0].match(SIZE_REG)||[1/0])[0];return r-n});var e={},a=1,r=null,n=1;answers.forEach(function(s){var t=s.body_markdown.split("\n")[0],o=jQuery("#answer-template").html(),l=(t.match(NUMBER_REG)[0],(t.match(SIZE_REG)||[0])[0]),c=t.match(LANGUAGE_REG)[1],i=getAuthorName(s);l!=r&&(n=a),r=l,++a,o=o.replace("{{PLACE}}",n+".").replace("{{NAME}}",i).replace("{{LANGUAGE}}",c).replace("{{SIZE}}",l).replace("{{LINK}}",s.share_link),o=jQuery(o),jQuery("#answers").append(o),e[c]=e[c]||{lang:c,user:i,size:l,link:s.share_link}});var s=[];for(var t in e)e.hasOwnProperty(t)&&s.push(e[t]);s.sort(function(e,a){return e.lang>a.lang?1:e.lang<a.lang?-1:0});for(var o=0;o<s.length;++o){var l=jQuery("#language-template").html(),t=s[o];l=l.replace("{{LANGUAGE}}",t.lang).replace("{{NAME}}",t.user).replace("{{SIZE}}",t.size).replace("{{LINK}}",t.link),l=jQuery(l),jQuery("#languages").append(l)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",answers=[],page=1;getAnswers();var SIZE_REG=/\d+(?=[^\d&]*(?:&lt;(?:s&gt;[^&]*&lt;\/s&gt;|[^&]+&gt;)[^\d&]*)*$)/,NUMBER_REG=/\d+/,LANGUAGE_REG=/^#*\s*([^,]+)/;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table></div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table></div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody></table><table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody></table>

Pyth, 10 byte

sm@+drd1zG

Provalo online: dimostrazione

Spiegazione:

             implicit: z = input string
 m       G   map each letter (variable d) of the alphabet to:
   +drd1        d + upper(d)
  @     z       filter z for these two letters
s            sum, join to a string

Haskell, 51

f s=[x|(a,b)<-zip['a'..'z']['A'..],x<-s,x==a||x==b]

Il zipcrea un elenco di coppie di caratteri [('a','A'), ...('z','Z')]. A causa del troncamento, non è necessario specificare il secondo endpoint. Per ogni coppia nell'elenco, prendiamo le lettere nella stringa di input sche sono uno dei due caratteri nella coppia.

Python 3, 72 70 byte

s=input()
print("".join(d*(ord(d)&31==c)for c in range(27)for d in s))

Presuppone che l'input sia costituito solo da [a-zA-Z].

(-2 byte grazie a @xnor)

GOTO ++, 531 byte

niveaugourou 0
s=ENTRETONTEXTE()
§2 a=LeCaracNumero()&s *(1)
n=*(1)
costaud i=*(2)/&i infeg NombreDeLettres(&s)/i=+*(1)
b=LeCaracNumero()&s &i
c=&b
d=&a
GOTONULPOURLESNULS %4 }&b sup *(96){
c=-*(32)
§4 GOTONULPOURLESNULS %5 }&a sup *(96){
d=-*(32)
§5 GOTONULPOURLESNULS %1 }&c inf &d{
a=&b
n=&i
§1 faiblard
GOTOPRINTDUTEXTE()&a
s=Marijuana()}BOITEAPINGOUINS()}PrendsUnMorceau()&s *(0) &n{ }PrendsUnMorceau()&s }&n+*(1){ *(0){{ «»
GOTONONNULPOURLESNULS %3 }NombreDeLettres(&s) eg *(1){
GOTOPASMALIN %2
§3 GOTOPRINTDUTEXTE()&s

Pagina del progetto GOTO ++

Ecco una versione leggermente più leggibile e commentata del codice (Nota che GOTOinizia un commento in GOTO ++):

niveaugourou 0                                          GOTO Allow every keyword to be used
s=ENTRETONTEXTE()                                       GOTO Read from STDIN
§2 a=LeCaracNumero()&s *(1)                             GOTO Get first char in s
n=*(1)                                                  
costaud i=*(2)/&i infeg NombreDeLettres(&s)/i=+*(1)     GOTO Loop on every char of s
b=LeCaracNumero()&s &i                                  GOTO b = i-th char
c=&b                                            
d=&a
GOTONULPOURLESNULS %4 }&b sup *(96){                    GOTO If b is uppercase, goto §4 
c=-*(32)                                                GOTO Get the uppercase ASCII value of b
§4 GOTONULPOURLESNULS %5 }&a sup *(96){                 GOTO same as above but with a
d=-*(32)                                                
§5 GOTONULPOURLESNULS %1 }&c inf &d{                    GOTO If b is after a in alphabetical order, goto §1 (next loop iteration)
a=&b                                                    GOTO Else replace a by b
n=&i                                                                
§1 faiblard                                             GOTO End loop
GOTOPRINTDUTEXTE()&a                                    GOTO Print the value of a
t=PrendsUnMorceau()&s *(0) &n                           GOTO Get the part of s before a
u=PrendsUnMorceau()&s }&n+*(1){ *(0)                    GOTO Get the part of s after a
e=BOITEAPINGOUINS()&t &u                                GOTO Create an array of penguins containing the two substrings
s=Marijuana()&e «»                                      GOTO Concatenate the penguins in the array
GOTONONNULPOURLESNULS %3 }NombreDeLettres(&s) eg *(1){  GOTO If s is one char long, goto §3
GOTOPASMALIN %2                                         GOTO Else goto §2
§3 GOTOPRINTDUTEXTE()&s                                 GOTO Print the last char

Pyth, 15 14 byte

s*V/LzJ.irG1GJ

Grazie per isaacg per la rimozione di 1 byte.

Non so ancora molto su Pyth, quindi questo potrebbe non essere ben giocato.

Provalo qui.

JavaScript (ES6), 71 74

Limitato ad A-Za-z (vedi commento di @Matthieu M)

Modifica Troppo utilizzato per comporre una singola espressione con virgole, per evitare "return". Qui è richiesto un output, quindi posso usare un semplicefor e dimenticare le virgole.

Utilizzando la comprensione dell'array il conteggio dei byte è 73, ma non è più valido EcmaScript 6

Nota usuale: test di esecuzione dello snippet su qualsiasi browser compatibile con EcmaScript 6 (in particolare Chrome non MSIE. Ho testato su Firefox, Safari 9 potrebbe andare)

f=w=>{v=[];for(c of w)v[n=parseInt(c,36)]=(v[n]||'')+c;alert(v.join``)}

<input id=I value='Hellzapoppin'><button onclick=f(I.value)>-></button>

Javascript, 112 194 byte

r=[];t=[];a=s.split('').map(function(x){t[i=parseInt(x,36)]?t[i].push(x):t[i]=[x];return i;});while(l=a.length)r[l-1]=t[a.splice(a.indexOf(Math.max.apply({},a)),1)].pop();console.log(r.join(''))

Questo è lontano dal "golf", ma sono un po 'occupato in questo momento, appena modificato per rimuovere l'ordinamento.

Python 3, 64

Un piccolo miglioramento sulla risposta di Sp3000 , che utilizza l'idea di iterare iterando gli indici dei caratteri e, per ognuno, iterando attraverso l'input per prendere i caratteri che corrispondono al caso.

c=1
for d in(input__+'~')*26:print(end=d[ord(d)&31^c:]);c+=d>'z'

Questo utilizza un singolo loop, ripetendo ciclicamente l'ingresso 26 volte. Il separatore ~viene utilizzato per sapere quando passare al prossimo indice di caratteri c. A prescindere dal fatto che il carattere dcorrisponda a un valore cmaiuscolo, gli ultimi cinque bit del valore bit di dsono xorati conc , con uno 0 che indica una corrispondenza.

Quindi, il carattere dviene stampato esattamente quando il risultato è 0, con una stringa vuota altrimenti.

Python 2.7, 114 106 byte

l=[0]*123
for e in raw_input():l[ord(e)]+=1
print''.join(chr(j)*l[j]for i in range(26)for j in(i+65,i+97))

Registra la presenza di un carattere in un array di lunghezza 123 (per includere sia gli intervalli AZ che az) e quindi scorre attraverso di esso per ottenere le voci diverse da zero.
Inefficiente, ma più efficiente della forza bruta (ma più a lungo :().

Test it-

<< HelloWorldhi
>> deHhillloorW

PHP, 275 270 byte

<?php
for($i=65;$i<123;$i++){$v[$i]=chr($i);}foreach(str_split($argv[1])as$c){$a=array_search($c,$v);if($a<97){$p[]=($a+32);$z[]=$a;}else{$p[]=$a;}}foreach($p as$chr){$m=min($p);if($z[0]+32==$m){echo chr($m-32);unset($z[0]);}else{echo chr($m);}unset($p[array_search($m,$p)]);}

Spiegazione:
Il codice genera un array con ogni lettera dell'alfabeto, che ha il suo valore ASCII come chiave dell'array. Successivamente il codice genera un nuovo array che contiene i valori ASCII dell'input. Quindi il valore più basso viene stampato e rimosso.

Uso:
chiama lo script con un argomento: php -d error_reporting=0 script.php Hello

Versione non golfata:

<?php
$input = $argv[1];
$valueArray = [];
for($i=65;$i<123;$i++) {
    $valueArray[$i] = chr($i);
}
$new = str_split($input);
foreach($new as $char) {
    if(array_search($char, $valueArray)<97) {
        $newArray[] = (array_search($char, $valueArray)+32);
        $checkArray[] = array_search($char, $valueArray);
    } else {
        $newArray[] = array_search($char, $valueArray);
    }
}
foreach($newArray as $chr) {
    if($checkArray[0]+32 == min($newArray)) {
        $string .= chr(min($newArray)-32);
        unset($checkArray[0]);
    } else {
        $string .= chr(min($newArray));
    }
    $key = array_search(min($newArray), $newArray);
    unset($newArray[$key]);
}

echo $string;

Tutti i consigli sono molto apprezzati.

Haskell, 83 53 byte

import Data.Char
f y=[c|x<-[' '..],c<-y,toLower c==x]

Utilizzo: f "HelloWorldhi"->"deHhillloorW" .

Come funziona: lascia che ysia la stringa di input

[ |x<-[' '..]                  ]  -- for every x from Space to the last Unicode character
             ,c<-y                -- loop through all character c from the input string
 c                ,toLower c==x   -- and keep those where the lowercase version equals x

Modifica: 30 byte salvati, immagina! Grazie @Mauris.

Python 3, 61 byte

Una nuova risposta per una tecnica diversa!

z=['']*42
for c in input():z[ord(c)&31]+=c
print(*z,sep='')

Notando questo ord('a')&31==ord('A')&31e quello ord('z')&31==ord('Z')&31, possiamo semplicemente creare un array di stringhe vuote e per ogni carattere aggiungerlo all'indice di array del suo valore ASCII &31. Quando lo stampi, verrà ordinato.

Limitato all'input a-zA-Z.

Python 3, 97 92 byte

from itertools import*;print(*min(permutations(input()),key=lambda z:str(z).lower()),sep='')

Il modo migliore per ordinare è chiaramente generare tutte le permutazioni e quindi scegliere il minimo, che sembra essere semplicemente ordinato :)

Le stringhe sono minuscole prima del confronto per rispettare le regole "case-aware".

Attenzione: può essere molto lento con stringhe grandi.

Un interprete si trova qui .

Python 3, 118 byte

i=input();i,x=map(list,(i,i.lower()))
while x:q=min(x);x.remove(q);q=[q.upper(),q][q in i];i.remove(q);print(q,end="")

Potrebbe essere golf molto più breve, lo so

Powershell, 164 byte

Sono sicuro che esiste un modo più pulito per farlo, ma non sono riuscito a trovare nient'altro. Accetta semplicemente l'input come una matrice di caratteri, esegue un ordinamento di inserzione e sputa l'output. Perde orribilmente, anche in altre lingue che non giocano a golf.

Codice:

$a=[char[]]($args[0]);For($u=1;$u-lt$a.Count;$u++){$n=$a[$u];$l=$u;while(($l-gt0)-and((""+$a[$l-1]).CompareTo(""+$n)-gt0)){$a[$l]=$a[$l-1];$l--}$a[$l]=$n};$a-join''

Uso:

PS C:\scripts> .\sign-word-2.ps1 tTHhis
hHistT

Espanso e spiegato:

$a=[char[]]($args[0])               # Takes command-line argument, recasts as char array
For($u=1;$u-lt$a.Count;$u++){       # Performs a quick-n-dirty insertion sort
  $n=$a[$u]
  $l=$u
  while(($l-gt0)-and((""+$a[$l-1]).CompareTo(""+$n)-gt0)){
  # Ugly, ugly code here. String.CompareTo(String) is case-insensitive, but
  # because we cast as a char[], Char.CompareTo(Char) is case-sensitive ...
  # So, need to do an on-the-fly re-casting as a string with ""+
    $a[$l]=$a[$l-1]
    $l--
  }
  $a[$l]=$n
}
$a-join''             # Without the -join'', it would print out the chars with a space between

Julia, 61 byte

f=s->s>""?(k=indmax([s...]%32);f(s[k+1:end]s[1:k-1])s[k:k]):s

Julia lo visualizzerà come output di stringa se lo si chiama nel REPL. Se deve stampare su STDOUT, ha bisogno di 78 byte:

x->(f=s->s>""?(k=indmax([s...]%32);f(s[k+1:end]s[1:k-1])s[k:k]):s;print(f(x)))

Un interprete per Julia può essere trovato qui . Un altro, in cui ho già inserito un po 'di codice, è qui . Si noti che, con il secondo, sarà necessario rendere visibile il terminale (in basso) trascinando il limite verso l'alto. Facendo clic su "Esegui", verrà eseguito nel terminale dalla normale riga di comando (e quindi non mostrerà l'output se chiamato senza println). In alternativa, puoi semplicemente digitare julianel terminale stesso, quindi gestire tutto all'interno del REPL che verrà fuori.

E per un po 'di divertimento extra, ecco alcune altre implementazioni

Ordinamento Gnome (83 byte):

s->(for m=2:endof(s),n=m:-1:2 s[n]%32<s[n-1]%32&&(s=s[[1:n-2,n,n-1,n+1:end]])end;s)

Il mio algoritmo di ordinamento (84 byte):

s->(k=1;while length(k)>0 k=find(diff([s...]%32).<0);s=s[setdiff(1:end,k)]s[k]end;s)

Scala, 82 byte

print((""/:args(0)){case(s,c)=>val(a,b)=s.span(h=>{if(h<97)32 else 0}+h<c);a+c+b})

dalla riga di comando:

$ scala -e 'print((""/:args(0)){case(s,c)=>val(a,b)=s.span(h=>{if(h<97)32 else 0}+h<c);a+c+b})' Hello
eHllo

probabilmente si può giocare a golf un po 'più avanti ... solo implementando l'ordinamento per inserzione usando fold.

codice macchina x86, 51 42 byte

00000000  b3 82 89 da 8b 07 80 fc  0d 74 12 b9 20 20 09 c1  |.........t..  ..|
00000010  38 e9 7e 06 86 c4 89 07  31 d2 43 eb e7 85 d2 74  |8.~.....1.C....t|
00000020  df c6 47 01 24 b4 09 cd  21 c3                    |..G.$...!.|
0000002a

Bubble sort, con alcuni trucchi di riutilizzo dei registri per radere byte qua e là; il file .COM viene eseguito in DosBox, riceve l'input dalla riga di comando e stampa l'output sull'output standard.

Assemblaggio commentato:

    org 100h

section .text

start:
    ; bubble sort - external loop
ext:
    ; start from the first character (assume bh=0, true on every DOS)
    mov bl,82h
    ; "not-swapped" flag - 82h => no swaps in current iteration;
    ; 0 => a swap happened (the 82h will come in handy later)
    mov dx,bx
    ; bubble sort - internal loop
int:
    ; read 2 characters at time in the full ax
    mov ax,word[bx]   ; al     ah
                      ; ^[bx]  ^[bx+1]
    ; check if we are at the end (the command line is CR terminated)
    cmp ah,0dh
    je skip
    ; make uppercase in cx
    mov cx,2020h
    or cx,ax
    ; compare
    cmp cl,ch
    jle next
    ; wrong order - swap and rewrite
    xchg al,ah
    mov word[bx],ax
    ; mark that we did a swap
    xor dx,dx
next:
    ; next character
    inc bx
    jmp int
skip:
    ; loop as far as we swapped something
    test dx,dx
    jz ext
end:
    ; $-terminate the string
    mov byte[bx+1],'$'
    ; print
    ; dx already contains the location of the string, since that's the
    ; flag value we used for "no swaps"
    mov ah,9
    int 21h
    ret

Java (JDK 10) , 125 byte

s->{for(int i=s.length,j;i-->1;)for(j=i;j-->0;)s[i]^=(s[i]&95)<(s[j]&95)?s[j]^(s[j]=s[i]):0;System.out.print(new String(s));}

Provalo online!

Usando un tipo ingenuo.

Perl, 88 byte

@_=/./g;a:{for(0..@_-2){@_[$_,$_+1]=@_[$_+1,$_],redo a if uc$_[$_]gt uc$_[$_+1]}}print@_

Solo un semplice Bubble Sort. Chiama con l'opzione -n ​​per passare il testo.

per esempio:

echo "tThHiIsS" | perl -n sort2.pl

Produzione:

hHiIsStT

PHP, 106 byte

Il codice:

$c=count_chars($argv[1]);$r=str_repeat;for($i=64;++$i<91;)echo$r(chr($i),$c[$i]),$r(chr($i+32),$c[$i+32]);

Non c'è niente di speciale nel codice; count_chars()produce un array indicizzato da codici ASCII che contiene il numero di occorrenze per ciascun carattere ASCII. Il resto è una noiosa iterazione su questo array.

Esempio di esecuzione:

$ php -d error_reporting=0 sign.php qwertyuioplkjhgfdsazxcvbnmQWERTYUIOPLKasdfJHGFDSAZXCVBNM
AaaBbCcDddEeFffGgHhIiJjKkLlMmNnOoPpQqRrSssTtUuVvWwXxYyZz

È possibile salvare un byte aggiuntivo tramite PHP 7: sostituire $c[$i]con ($c=count_chars($argv[1]))[$i]e rimuovere l'assegnazione $cdall'inizio del programma.

Haskell, 74 byte

l=(`mod`32).fromEnum
f=foldr(#)""
e#[]=[e]
e#a@(h:t)|l e<l h=e:a|1<2=h:e#t

Completamente diverso dall'altra mia risposta . Questa volta è un semplice tipo di inserimento.

Pip, 18 14 byte

Repository GitHub per Pip

Sembra che non ci sia competizione con Pyth, ma questo è abbastanza rispettabile.

FcAZ OcQUC_FIa

Funziona solo su stringhe contenenti a-zA-Z. Per ogni lettera dell'alfabeto, utilizza un'operazione di filtro per afferrare le lettere dalla stringa di input che equivalgono a quella lettera senza distinzione tra maiuscole e minuscole:

                    a <- cmdline arg, AZ <- string containing uppercase alphabet (implicit)
FcAZ                For each character c in AZ:
           FIa      Filter characters of a on the following lambda function:
      UC_           Uppercase of character...
         Qc         ... is equal to c
     O              Output the resulting list, joined on empty string by default

Due note:

• Lo spazio è necessario; in caso contrario, la sequenza AZOverrebbe analizzata come A ZOanziché AZ O;
• Il programma non genera una nuova riga finale. Per aggiungerne uno, inserisci un xalla fine del codice (stampando così una stringa vuota dopo che il ciclo è terminato).

Esecuzione di esempio (utilizzando la xvariante):

dlosc@dlosc:~/pip$ pip -e "FcAZ OcQUC_FIax" "HelLo wOrld"
deHlLloOrw

Perl 5 -a , 31 byte

for$i(a..z){print grep/$i/i,@F}

Provalo online!