¡Firma esa palabra 2!

No hace mucho tiempo, publiqué un desafío llamado ¡ Firma esa palabra! . En el desafío, debe encontrar la firma de la palabra, que son las letras ordenadas (por ejemplo, la firma de thisis hist). Ahora bien, ese desafío funcionó bastante bien, pero hubo un problema clave: fue MUY fácil (vea la respuesta de GolfScript ). Entonces, publiqué un desafío similar, pero con más reglas, la mayoría de las cuales han sido sugeridas por los usuarios de PPCG en los comentarios sobre el rompecabezas anterior. ¡Así que, aquí vamos!

Reglas

1. Su programa debe tener una entrada, salida y luego la firma en STDOUT o su equivalente en cualquier idioma utilizando su.
2. No está permitido el uso integrado de funciones de ordenación, así que cosas como $no está permitido en GolfScript.
3. Multicaso debe ser apoyada - sus cartas grupo de programas deben de mayúsculas y minúsculas juntos. Entonces, la firma de Helloes eHllo, no Hellocomo la respuesta de GolfScript en la primera versión.
4. Debe haber un intérprete / compilador gratuito para su programa, al que debe vincular.

Puntuación

Tu puntuación es tu recuento de bytes. El conteo de bytes más bajo gana.

Tabla de clasificación

Aquí hay un fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores por idioma.

Para asegurarse de que su respuesta se muestre, comience con un título, utilizando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

sm@+drd1zG

Pruébelo en línea: demostración

Explicación:

             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]

El zipcrea una lista de pares de caracteres [('a','A'), ...('z','Z')]. Debido al truncamiento, no es necesario especificar el segundo punto final. Para cada par de la lista, tomamos las letras en la cadena de entrada sque son cualquiera de los dos caracteres del par.

Python 3, 72 70 bytes

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

Asume que la entrada consta de solo [a-zA-Z].

(-2 bytes gracias a @xnor)

GOTO ++, 531 bytes

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

Página del proyecto GOTO ++

Aquí hay una versión ligeramente más legible y comentada del código (tenga en cuenta que GOTOcomienza un comentario en 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 bytes

s*V/LzJ.irG1GJ

Gracias por Isaac por eliminar 1 byte.

Todavía no sé mucho sobre Pyth, por lo que es posible que esto no se juegue bien.

Pruébalo aquí

JavaScript (ES6), 71 74

Limitado a A-Za-z (ver comentario de @Matthieu M)

Editar también se utiliza para componer una sola expresión con comas, para evitar el 'retorno'. Aquí se requiere una salida, por lo que puedo usar un simple fory olvidarme de las comas.

Usando la comprensión de la matriz, el conteo de bytes es 73, pero eso ya no es EcmaScript 6 válido

Nota habitual: pruebe ejecutar el fragmento en cualquier navegador compatible con EcmaScript 6 (en particular, no Chrome ni MSIE. Probé en Firefox, Safari 9 podría funcionar)

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 bytes

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

Esto está muy lejos de "golf" pero estoy un poco ocupado en este momento, solo editado para eliminar la clasificación.

Pitón 3, 64

Una pequeña mejora en la respuesta de Sp3000 , que utiliza la idea de iterar iterando los índices de caracteres, y para cada uno, iterando a través de la entrada para tomar caracteres que coincidan con el caso.

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

Esto usa un solo bucle, pasando por la entrada 26 veces. El separador ~se usa para saber cuándo ir al siguiente índice de caracteres c. A si personajed coincide con el valor cen mayúsculas y minúsculas, los últimos cinco bits del valor de bit de dson corregidos con c, con un 0 que indica una coincidencia.

Entonces, el carácter dse imprime exactamente cuando el resultado es 0, con una cadena vacía de otra manera.

Python 2.7, 114 106 bytes

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 presencia de un carácter en una matriz de 123 longitudes (para incluir los rangos AZ y az) y luego lo itera para obtener las entradas distintas de cero.
Ineficiente, pero más eficiente que la fuerza bruta (pero ya :().

Probándolo

<< HelloWorldhi
>> deHhillloorW

PHP, 275 270 bytes

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

Explicación:
El código genera una matriz con cada letra del alfabeto, que tiene su valor ASCII como clave de matriz. A continuación, el código genera una nueva matriz que contiene los valores ASCII de la entrada. Luego, el valor más bajo se imprime y se elimina.

Uso:
Llame al script con un argumento: php -d error_reporting=0 script.php Hello

Versión sin golf:

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

Cualquier consejo es muy apreciado.

Haskell, 83 53 bytes

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

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

Cómo funciona: deja y ser la cadena de entrada

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

Editar: 30 bytes guardados, ¡imagínense eso! Gracias @Mauris.

Python 3, 61 bytes

Una nueva respuesta a una técnica diferente!

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

Observando eso ord('a')&31==ord('A')&31y aquello ord('z')&31==ord('Z')&31, simplemente podemos crear una matriz de cadenas vacías y para cada carácter agregarlo al índice de la matriz de su valor ASCII&31 . Cuando lo imprima, se ordenará.

Limitado a la entrada a-zA-Z.

Python 3, 97 92 bytes

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

La mejor manera de ordenar es claramente generar todas las permutaciones, y luego elegir el mínimo, que simplemente se ordena :)

Las cadenas están en minúsculas antes de la comparación para cumplir con las reglas de 'mayúsculas y minúsculas'.

Advertencia: puede ser muy lento con cuerdas grandes.

Un intérprete se encuentra aquí .

Python 3, 118 bytes

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

Podría jugar golf mucho más corto, lo sé

Powershell, 164 bytes

Estoy seguro de que hay una forma más limpia de hacer esto, pero no pude encontrar nada más. Simplemente toma la entrada como una matriz de caracteres, realiza una ordenación por inserción y escupe la salida. Pierde horriblemente, incluso a otros idiomas que no son de golf.

Código:

$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

Ampliado y explicado:

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

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

Julia lo mostrará como una salida de cadena si lo llama en REPL. Si tiene que imprimir a STDOUT, entonces necesita 78 bytes:

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 intérprete para Julia se puede encontrar aquí . Otro, en el que ya he puesto algo de código, es aquí . Tenga en cuenta que, con el segundo, deberá hacer que el terminal (en la parte inferior) sea visible arrastrando el límite hacia arriba. Al hacer clic en "ejecutar", se ejecutará en el terminal en la línea de comando normal (y, por lo tanto, no mostrará el resultado si se llama sin println). Alternativamente, puede escribir juliaen el terminal en sí, luego manejar todo lo que aparezca dentro del REPL.

Y para un poco más de diversión, aquí hay algunas otras implementaciones

Gnome Sort (83 bytes):

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)

Mi propio algoritmo de clasificación (84 bytes):

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 bytes

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

desde la línea de 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

probablemente se pueda jugar un poco más ... simplemente implementando el tipo de inserción usando fold.

código de máquina x86, 51 42 bytes

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

Clasificación de burbujas, con algunos trucos de reutilización de registros para reducir bytes aquí y allá; el archivo .COM se ejecuta en DosBox, recibe la entrada de la línea de comando e imprime la salida a la salida estándar.

Asamblea comentada:

    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 bytes

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

Pruébalo en línea!

Usando una especie ingenua.

Perl, 88 bytes

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

Solo un simple Bubble Sort. Llame con la opción -n para pasar el texto.

p.ej:

echo "tThHiIsS" | perl -n sort2.pl

Salida:

hHiIsStT

PHP, 106 bytes

El código:

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

No hay nada especial en el código; count_chars()produce una matriz indexada por códigos ASCII que contiene el número de ocurrencias para cada carácter ASCII. El resto es una iteración aburrida sobre esta matriz.

Ejemplo de ejecución:

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

Se puede guardar un byte adicional usando PHP 7: reemplazar $c[$i]con ($c=count_chars($argv[1]))[$i]y eliminar la asignación $cdesde el comienzo del programa.

Haskell, 74 bytes

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

Completamente diferente de mi otra respuesta . Esta vez es un tipo de inserción simple.

Pip, 18 14 bytes

Repositorio de GitHub para Pip

Parece que no hay competencia con Pyth, pero esto es bastante respetable.

FcAZ OcQUC_FIa

Funciona solo en cadenas que contienen a-zA-Z . Para cada letra del alfabeto, utiliza una operación de filtro para tomar las letras de la cadena de entrada que igualan esa letra sin distinción entre mayúsculas y minúsculas:

                    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

Dos notas:

• El espacio es necesario; de lo contrario, la secuencia AZOse escanearía comoA ZO lugar de AZ O;
• El programa no genera una nueva línea final. Para agregar uno, pon unx al final del código (imprimiendo así una cadena vacía después de finalizar el bucle).

Ejecución de muestra (utilizando la xvariante):

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

Perl 5 -a , 31 bytes

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

Pruébalo en línea!