Signez ce mot 2!

Il n'y a pas si longtemps, j'ai publié un défi appelé Sign this word! . Dans le défi, vous devez trouver la signature du mot, qui est les lettres mises en ordre (par exemple, la signature de thisest hist). Maintenant, ce défi a plutôt bien fonctionné, mais il y avait un problème clé: c'était beaucoup trop facile (voir la réponse GolfScript ). J'ai donc publié un défi similaire, mais avec plus de règles, dont la plupart ont été suggérées par les utilisateurs de PPCG dans les commentaires sur le puzzle précédent. Alors c'est parti!

Règles

1. Votre programme doit prendre une entrée, puis sortir la signature sur STDOUT ou l'équivalent dans la langue que vous utilisez.
2. Vous n'êtes pas autorisé à utiliser les fonctions de tri intégrées, donc les choses comme $dans GolfScript ne sont pas autorisées.
3. Multicase doit être pris en charge - votre programme doit regrouper les lettres majuscules et minuscules ensemble. Donc, la signature de Helloest eHllo, pas Hellocomme vous le donne la réponse GolfScript sur la première version.
4. Il doit y avoir un interprète / compilateur gratuit pour votre programme, auquel vous devez lier.

Notation

Votre score est votre nombre d'octets. Le nombre d'octets le plus bas gagne.

Classement

Voici un extrait de pile pour générer à la fois un classement régulier et un aperçu des gagnants par langue.

Pour vous assurer que votre réponse s'affiche, veuillez commencer votre réponse avec un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les barrant. Par exemple:

# 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 octets

sm@+drd1zG

Essayez-le en ligne: Démonstration

Explication:

             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]

Le zipcrée une liste de paires de caractères [('a','A'), ...('z','Z')]. En raison de la troncature, le deuxième point de terminaison n'a pas besoin d'être spécifié. Pour chaque paire de la liste, nous prenons les lettres de la chaîne d'entrée squi sont l'un des deux caractères de la paire.

Python 3, 72 70 octets

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

Suppose que l'entrée se compose uniquement de [a-zA-Z].

(-2 octets grâce à @xnor)

GOTO ++, 531 octets

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

Page du projet GOTO ++

Voici une version légèrement plus lisible et commentée du code (notez que cela GOTOcommence un commentaire dans 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 octets

s*V/LzJ.irG1GJ

Merci pour isaacg d'avoir supprimé 1 octet.

Je ne sais pas encore grand chose sur Pyth, donc cela peut ne pas être bien joué.

Essayez-le ici.

JavaScript (ES6), 71 74

Limité à A-Za-z (voir le commentaire de @Matthieu M)

Modifier Trop utilisé pour composer une seule expression avec des virgules, pour éviter le «retour». Ici, une sortie est requise, donc je peux utiliser un simple foret oublier les virgules.

En utilisant la compréhension du tableau, le nombre d'octets est 73, mais ce n'est plus EcmaScript 6 valide

Remarque habituelle: test de l'exécution de l'extrait sur n'importe quel navigateur compatible EcmaScript 6 (notamment pas Chrome ni MSIE. J'ai testé sur Firefox, Safari 9 pourrait aller)

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 octets

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

C'est loin de "jouer au golf" mais je suis un peu occupé en ce moment, juste édité pour supprimer le tri.

Python 3, 64

Une petite amélioration par rapport à la réponse du Sp3000 , qui utilise l'idée d'itérer en itérant les indices de caractères, et pour chacun d'entre eux, d'itérer à travers l'entrée pour prendre des caractères qui correspondent à la casse.

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

Cela utilise une seule boucle, bouclant l'entrée 26 fois. Le séparateur ~est utilisé pour savoir quand passer à l'index de caractère suivant c. Pour savoir si le caractère dcorrespond à la valeur cjusqu'à la casse, les cinq derniers bits de la valeur de bit de dsont xor-ed avecc , avec un 0 indiquant une correspondance.

Ensuite, le caractère dest imprimé exactement lorsque le résultat est 0, avec une chaîne vide sinon.

Python 2.7, 114 106 octets

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

Enregistre la présence d'un caractère dans un tableau de longueur 123 (pour inclure les plages AZ et az), puis itère à travers celui-ci pour obtenir les entrées non nulles.
Inefficace, mais plus efficace que le brut le forçant (mais plus longtemps :().

Le tester-

<< HelloWorldhi
>> deHhillloorW

PHP, 275 270 octets

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

Explication:
Le code génère un tableau avec chaque lettre de l'alphabet, qui a sa valeur ASCII comme clé de tableau. Ensuite, le code génère un nouveau tableau qui contient les valeurs ASCII de l'entrée. Ensuite, la valeur la plus basse est imprimée et supprimée.

Utilisation:
Appelez le script avec un argument: php -d error_reporting=0 script.php Hello

Version non golfée:

<?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;

Tous les conseils sont grandement appréciés.

Haskell, 83 53 octets

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

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

Comment ça marche: laissez y soit la chaîne d'entrée

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

Edit: 30 octets enregistrés, imaginez ça! Merci @Mauris.

Python 3, 61 octets

Une nouvelle réponse pour une technique différente!

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

Notant ceci ord('a')&31==ord('A')&31et cela ord('z')&31==ord('Z')&31, nous pouvons simplement créer un tableau de chaînes vides et pour chaque caractère l'ajouter à l'index du tableau de sa valeur ASCII&31 . Lorsque vous l'imprimerez, il sera trié.

Limité à l'entrée a-zA-Z.

Python 3, 97 92 octets

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

La meilleure façon de trier est clairement de générer toutes les permutations, puis de choisir le minimum, qui se trouve être trié :)

Les chaînes sont en minuscules avant la comparaison pour respecter les règles «respectant la casse».

Avertissement: peut être très lent avec de grosses cordes.

Un interprète se trouve ici .

Python 3, 118 octets

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="")

Pourrait être joué au golf beaucoup plus court, je sais

Powershell, 164 octets

Je suis sûr qu'il existe une façon plus propre de le faire, mais je n'ai rien pu trouver d'autre. Prend juste l'entrée comme un tableau de caractères, fait un tri par insertion et crache la sortie. Perd horriblement, même dans d'autres langues autres que le golf.

Code:

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

Usage:

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

Développé et expliqué:

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

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

Julia l'affichera comme une sortie de chaîne si vous l'appelez dans le REPL. S'il doit imprimer sur STDOUT, il a besoin de 78 octets:

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 interprète pour Julia peut être trouvé ici . Un autre, dans lequel j'ai déjà mis du code, est ici . Notez qu'avec le second, vous devrez rendre le terminal (en bas) visible en faisant glisser la limite vers le haut. Cliquer sur "exécuter" le fera fonctionner dans le terminal sur la ligne de commande normale (et ne montrera donc pas la sortie si elle est appelée sans println). Alternativement, vous pouvez simplement taperjulia dans le terminal lui-même, puis gérer tout ce qui apparaîtra dans le REPL.

Et pour un peu plus de plaisir, voici quelques autres implémentations

Tri Gnome (83 octets):

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)

Mon propre algorithme de tri (84 octets):

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 octets

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

à partir de la ligne de commande:

$ 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

peut probablement être joué un peu plus loin ... il suffit d'implémenter le tri par insertion à l'aide du pli.

code machine x86, 51 42 octets

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

Tri par bulles, avec quelques astuces de réutilisation des registres pour raser les octets ici et là; le fichier .COM s'exécute dans DosBox, reçoit l'entrée de la ligne de commande et imprime la sortie sur la sortie standard.

Montage commenté:

    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 octets

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

Essayez-le en ligne!

Utiliser un tri naïf.

Perl, 88 octets

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

Juste un simple tri de bulles. Appelez avec l'option -n pour passer le texte.

par exemple:

echo "tThHiIsS" | perl -n sort2.pl

Production:

hHiIsStT

PHP, 106 octets

Le code:

$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]);

Il n'y a rien de spécial dans le code; count_chars()produit un tableau indexé par des codes ASCII qui contient le nombre d'occurrences pour chaque caractère ASCII. Le reste est une itération terne sur ce tableau.

Exemple d'exécution:

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

Un octet supplémentaire peut être enregistré en utilisant PHP 7: remplacez $c[$i]par ($c=count_chars($argv[1]))[$i]et supprimez l'affectation de $cdepuis le début du programme.

Haskell, 74 octets

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

Complètement différent de mon autre réponse . Cette fois, il s'agit d'un simple tri par insertion.

Pip, 18 14 octets

Dépôt GitHub pour Pip

Il semble qu'il n'y ait pas de concurrence avec Pyth, mais c'est assez respectable.

FcAZ OcQUC_FIa

Fonctionne uniquement sur les chaînes contenant a-zA-Z. Pour chaque lettre de l'alphabet, utilise une opération de filtrage pour récupérer les lettres de la chaîne d'entrée qui égalent cette lettre sans tenir compte de la casse:

                    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

Deux notes:

• L'espace est nécessaire; sinon, la séquence AZOserait numérisée commeA ZO au lieu de AZ O;
• Le programme ne produit pas de nouvelle ligne de fin. Pour en ajouter un, mettez unx à la fin du code (imprimant ainsi une chaîne vide après la boucle).

Exemple d'exécution (en utilisant la xvariante):

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

Perl 5 -a , 31 octets

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

Essayez-le en ligne!