Signez ce mot 2!

17

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

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

Communauté
la source
2
Faut-il commander des minuscules et des majuscules? Par exemple, pour ThHihs, pouvons-nous produire hHhistou devons-nous produire hhHistou Hhhist?
Fatalize
2
@Kslkgh Je ne souhaite pas installer d'interpréteur GolfScript pour comprendre la question. Les exigences doivent être clairement spécifiées dans la question elle-même.
feersum
1
@feersum Vous n'en avez pas besoin. Il y a un lien dans la réponse vers un interprète en ligne. Mais je vais le clarifier.
8
La gestion correcte des minuscules / majuscules dans Unicode est effrayante, cette question est-elle donc volontairement limitée aux lettres ASCII: [a-zA-Z]?
Matthieu M.
3
Vous avez oublié de fermer la parenthèse après "voir cette réponse GolfScript". xkcd.com/859
nyuszika7h

Réponses:

11

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
Jakube
la source
5

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.

xnor
la source
5

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)

Sp3000
la source
Je pense que vous pouvez faire "".join(c*b ...)pour "".join(c ... if b) la même manière sum(n ... if b)peut être sum(n*b ...).
xnor
Réduire les deux boucles en une seule boucle avec une sentinelle et compresser le contrôle d'égalité: c=1 for d in(input()+'~')*26:print(d[ord(d)&32^c:],end='');c+=d>'z'(67)
xnor
@xnor J'ai ajouté le premier conseil (merci!) mais je pense que vous devriez poster le second comme réponse séparée :)
Sp3000
4

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
Fatalize
la source
2
Marques d'un grand langage de programmation: toutes les commandes sont en français et le site officiel dit "Envoyez votre logo et regardez idiot."
Alex A.
@AlexA. Marque d'un excellent langage de programmation: function(arg)et function() argsont tous deux valides. En outre, les supports de priorité sont } {et non l'ennuyeux( )
Fatalize
4

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.

jimmy23013
la source
Un golf facile: sc'est la même chose que jksur une liste de cordes.
isaacg
4

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>

edc65
la source
4

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.

frikinside
la source
1
@frikinside Bien que cela puisse ne pas aider cette solution puisque le tri a été interdit, les fonctions flèches Javascript ES6 pourraient aider à raccourcir cela. (Tous les navigateurs ne prennent pas encore en charge ES6, essayez Firefox). Peut-être que cela aidera vos futures solutions! :) Un exemple de ce à quoi cela pourrait ressembler:console.log(input.split('').sort((a,b)=>a.toLowerCase().localeCompare(b.toLowerCase())).join(''))
jrich
@UndefinedFunction En fait, je choisis d'utiliser javascript simple exprès, pour le "défi" mais merci beaucoup pour la belle suggestion!
frikinside
@ edc65 en fait, j'en étais conscient dans un commentaire précédent (comme vous l'avez dit) et je ne l'ai pas oublié, je n'avais pas le temps jusqu'à présent.
frikinside
4

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.

xnor
la source
3

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
Kamehameha
la source
Quand je le lance avec HelloWorldhi, je reçois['d', 'e', 'H', 'h', 'i', 'lll', 'oo', 'r', 'W']
Blue
@muddyfish oops my bad. J'ai collé le mauvais code en essayant deux ou trois choses. Merci pour ça :)
Kamehameha
Vous n'avez pas besoin non if l[j]plus.
Blue
@muddyfish Nice, elles deviennent des chaînes vides (et sont supprimées lorsqu'elles sont éditées join). -8 octets. Merci :)
Kamehameha
1
@SirParselot Oui, mais cela ressemblait à modifier l'entrée comme indiqué dans la question, alors ne l'a pas fait
Kamehameha
3

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.

jrenk
la source
Les lettres majuscules ne fonctionnent pas ... besoin de résoudre ce problème.
jrenk
Correction du fait que le code fonctionne également lorsque l'entrée contient des lettres majuscules.
jrenk
3

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.

nimi
la source
2
Pourquoi pas seulement import Data.Char;f y=[c|x<-[' '..],c<-y,toLower c==x](53 octets)? (Cela prendra un certain temps pour se terminer, car length [' '..] == 1114080- mais c'est fini.)
Lynn
1
@Mauris: Wow! Btw: 8.5sec sur un ordinateur portable de 4 ans n'est pas trop long.
nimi
3

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.

Tryth
la source
2

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 .

Tryth
la source
2

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

Bleu
la source
Vous pouvez remplacer if q not in i:par if~-(q in i):.
PurkkaKoodari
Je le fais parce que j'appelle la .remove()fonction dessus.
Blue
2

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
AdmBorkBork
la source
2

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)
Glen O
la source
2

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.

gilad hoch
la source
2

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.

exemple de session

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
Matteo Italia
la source
2

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.

Olivier Grégoire
la source
1

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
samgak
la source
1

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.

axiaque
la source
1

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.

nimi
la source
1

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
DLosc
la source