¡Firma esa palabra 2!

17

¡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

Mostrar fragmento de código

code-golf  string  sorting  word 
— Comunidad
fuente
2
¿Deben pedirse minúsculas y mayúsculas? Por ejemplo, para ThHihs, ¿podemos generar hHhisto tenemos que generar hhHisto Hhhist?
— Fatalize
2
@Kslkgh No deseo instalar un intérprete de GolfScript para entender la pregunta. Los requisitos deben especificarse claramente en la pregunta misma.
— feersum
1
@feersum No es necesario. Hay un enlace en la respuesta a un intérprete en línea. Pero lo aclararé.
8
El manejo correcto de minúsculas / mayúsculas en Unicode da miedo, por lo que esta pregunta se limita voluntariamente a letras ASCII: [a-zA-Z]?
— Matthieu M.
3
Olvidó cerrar el paréntesis después de "ver esta respuesta de GolfScript". xkcd.com/859
— nyuszika7h

Respuestas:

11

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
— Jakube
fuente
5

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.

— xnor
fuente
5

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)

— Sp3000
fuente
Creo que se puede hacer "".join(c*b ...)de "".join(c ... if b) la misma manera sum(n ... if b)puede ser sum(n*b ...).
— xnor
Contrayendo los dos bucles en un solo bucle con un centinela, y comprimiendo la comprobación de igualdad: c=1 for d in(input()+'~')*26:print(d[ord(d)&32^c:],end='');c+=d>'z'(67)
— xnor
@xnor He agregado el primer consejo (¡gracias!) pero creo que deberías publicar el segundo como respuesta separada :)
— Sp3000
4

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
— Fatalizar
fuente
2
Marcas de un excelente lenguaje de programación: todos los comandos están en francés y el sitio web oficial dice "Envíe su logotipo y parezca tonto".
— Alex A.
@AlexA. Marca de un gran lenguaje de programación: function(arg)y function() argambos son válidos. Además, los corchetes prioritarios son } {y no los aburridos( )
— Fatalize
4

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í

— jimmy23013
fuente
Un golf fácil: ses lo mismo que jken una lista de cuerdas.
— isaacg
4

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>
Expandir fragmento

— edc65
fuente
4

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.

— Frikinside
fuente
1
@frikinside Si bien no puede ayudar a esta solución, ya separadoras se desecharon, Javascript ES6 flecha funciones podría ayudar a acortar este. (No todos los navegadores admiten ES6 todavía, prueba Firefox). ¡Sin embargo, tal vez ayude a sus soluciones futuras! :) Un ejemplo de cómo se vería:console.log(input.split('').sort((a,b)=>a.toLowerCase().localeCompare(b.toLowerCase())).join(''))
— jrich
En realidad, yo @UndefinedFunction eligen utilizar Javascript llano a propósito, para el "desafío", pero THX mucho por la sugerencia agradable!
— Frikinside
@ edc65 realidad yo era consciente de que, en un comentario anterior (como dijo u) y yo no lo olvides, no me tengo tiempo hasta ahora.
— Frikinside
4

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.

— xnor
fuente
3

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
— Kamehameha
fuente
Cuando corro con HelloWorldhi, consigo['d', 'e', 'H', 'h', 'i', 'lll', 'oo', 'r', 'W']
— Azul
@muddyfish oops my bad. Pegué el código incorrecto al probar un par de cosas. Gracias por eso :)
— Kamehameha
No es necesario el if l[j]tampoco.
— Azul
@muddyfish Niza, se convierten en cadenas vacías (y se quitan cuando joined). -8 bytes. Gracias :)
— Kamehameha
1
@SirParselot Sí, pero eso parecía modificar la entrada como se indica en la pregunta, así que no lo hice
— Kamehameha
3

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.

— jrenk
fuente
Las letras mayúsculas no funcionan ... necesitan arreglar esto.
— jrenk
Se corrigió que el código también funciona cuando la entrada tiene letras mayúsculas.
— jrenk
3

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.

— nimi
fuente
2
¿Por qué no solo import Data.Char;f y=[c|x<-[' '..],c<-y,toLower c==x](53 bytes)? (Esto llevará un tiempo terminar, porque length [' '..] == 1114080, pero es finito.)
— Lynn
1
@Mauris: WOW! Por cierto: 8.5 segundos en una computadora portátil de 4 años no es demasiado larga.
— nimi
3

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.

— Tryth
fuente
2

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í .

— Tryth
fuente
2

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é

— Azul
fuente
Se puede reemplazar if q not in i:con if~-(q in i):.
— PurkkaKoodari
Lo hago porque estoy llamando a la .remove()función en él.
— Azul
2

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
— AdmBorkBork
fuente
2

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)
— Glen O
fuente
2

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.

— gilad hoch
fuente
2

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.

sesión de muestra

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
— Matteo Italia
fuente
1

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
— samgak
fuente
1

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.

— axiac
fuente
1

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.

— nimi
fuente
1

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
— DLosc
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.