Dupliquer et changer le cas

34

Le but est, après avoir pris une chaîne comme entrée, de dupliquer chaque lettre latine et de "basculer" sa casse (c.-à-d. Que les majuscules deviennent des minuscules et vice-versa).

Exemple d'entrées et de sorties:

Input      Output
bad        bBaAdD
Nice       NniIcCeE
T e S t    Tt eE Ss tT
s E t      sS Ee tT
1!1!1st!   1!1!1sStT!
n00b       nN00bB     
(e.g.)     (eE.gG.)
H3l|@!     Hh3lL|@!

L'entrée consiste en symboles ASCII imprimables.

Vous ne devez pas dupliquer les lettres non latines, les chiffres, les caractères spéciaux.

code-golf string nicael
la source
17
C'est un très beau défi, simple mais non trivial.
Mego

Réponses:

10

Gelée, 5 octets

żŒsQ€

Essayez-le en ligne!

Comment ça marche

żŒsQ€  Main link. Argument: s (string)

 Œs    Yield s with swapped case.
ż      Zip s with the result.
   Q€  Unique each; deduplicate each pair of characters.
Dennis
la source
17

Python, 56 à 54 octets

lambda s:''.join(c+c.swapcase()*c.isalpha()for c in s)

Testez-le sur Ideone .

Dennis
la source
Dang! Out me golfed par 4 octets ...
R. Kap
Comment cela maintient-il les caractères non-lettre? Je penserais qu'ils apparaissent comme des chaînes vides.
atlasologue
@atlasologist Comme vous pouvez le voir sur Ideone, ils ne le font pas. *a une priorité plus élevée que +, elle n'affecte donc que le ccas avec swappé.
Dennis
Oh, d'accord, je n'y avais pas pensé comme ça. Agréable.
atlasologue
16

JavaScript ES6, 70 68 66 64 octets

2 octets sauvés grâce à @ Kevin Lau - pas Kenny

2 octets sauvés grâce à @ Cᴏɴᴏʀ O'Bʀɪᴇɴ

s=>s.replace(/[A-Z]/gi,l=>l+l[`to${l<"a"?"Low":"Upp"}erCase`]())

Explication

Cela utilise vraiment un hacky:

l[`to${l<"a"?"Low":"Upp"}erCase`]()

quel non-golf est:

l[`to${
   l < "a" ?
   "Low" : 
   "Upp"
}erCase`]()

l < "a"Vérifie fondamentalement si le point de code de la lettre est inférieur au point de code dea (donc en majuscule). Si c'est le cas, il fera ce to + Low + erCasequi est devenu l['toLowerCase']()et rendra le caractère minuscule. `les guillemets permettent le formatage de chaîne, donc vous pouvez essentiellement penser à

`to${l < "a" ?"Low" : "Upp"}erCase`

comme: "to" + (l<"a" ? "Low" : "Upp") + "erCase" qui génère la fonction à appeler (place la chaîne en majuscule ou en minuscule). Nous mettons cela entre crochets, [ ... ]ce qui nous permet d'accéder à une propriété étant donné son nom sous forme de chaîne. Cela retourne la fonction appropriée et ensuite nous l'appelons simplement.

Downgoat
la source
3
/[A-Z]/giest une regex plus courte: 3
Valeur d'encre
@ KevinLau-notKenny oh belle prise, merci!
Downgoat
1
to${l<"a"?"Lower":"Upper"}Casetoto${l<"a"?"Low":"Upp"}erCase
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ oh bien, merci!
Downgoat
4
l[`to${l<"a"?"Low":"Upp"}erCase`]()Je pense que nous avons une nouvelle définition du mal.
Gcampbell
10

Rubis, 37 33 (30 + -pdrapeau) octets

swapcaseà la rescousse! Sorte de. -4 octets de @Lynn.

gsub(/[a-z]/i){$&+$&.swapcase}
Valeur d'encre
la source
gsub(/[a-z]/i){$&+$&.swapcase}plus le pdrapeau est 31 octets.
Lynn
1
@ Lynn Je crois que le consensus était une différence d'édition par rapport au script par défaut; le pdrapeau est donc (space)-p3 octets.
Valeur d'encre
8

C, 63 60 octets

f(char*s){for(;*s;s++)isalpha(putchar(*s))&&putchar(32^*s);}

Utilise le fait que 'a' XOR 32 == 'A', etc.

Trois octets sauvés grâce à FryAmTheEggman.

Lynn
la source
vous pouvez déplacer le s++dans le dernier putchar( &&putchar(32^*s++)) pour sauver un octet
Giacomo Garabello
Je pense que vous pouvez remplacer &&par *, n'est-ce pas?
aloisdg dit: Réintégrer Monica
1
Je suis à peu près sûr que les deux ne fonctionnent pas, si je réfléchis au fonctionnement &&du court-circuitage.
Lynn
f(char*s){isalpha(putchar(*s))&&putchar(32^*s);*s&&f(1+s);}récursif?
l4m2
1
f(char*s){*s&&f(1+s,isalpha(putchar(*s))&&putchar(32^*s));}récursif?
l4m2
6

CJam, 11 octets

l_el_eu.+.|

Testez-le ici.

Explication

l      e# Read input.
_el    e# Duplicate, convert to lower case.
_eu    e# Duplicate, convert to upper case.
.+     e# Concatenate the two characters in matching positions from those two
       e# strings. E.g. "ab!" "AB!" would give ["aA" "bB" "!!"].
       e# For each character from the original string and the corresponding 
.|     e# string from this list, take the set union (which eliminates duplicates
       e# and keeps the order the values appear in from left to right, so that
       e# the original case of each letter comes first).
Martin Ender
la source
5

Pyth , 7 octets

sm{+dr2

Suite de test .

sm{+dr2    input: Q
sm{+dr2dQ  implicit arguments

        Q  input
 m         for each character as d:
     r2d       swapcase
   +d          prepend d
  {            deduplicate
s          join as string
Fuite, nonne
la source
Haha, c'est vraiment rapide: D
nicael
5

Python 3.5, 60 56 octets:

for i in input():print(end=i+i.swapcase()[:i.isalpha()])

Un programme complet. Je vais essayer de jouer plus au golf.

Essayez-le en ligne! (Idéone)

R. Kap
la source
5

Haskell, 73 octets

l=['a'..'z']
u=['A'..]
(>>= \c->c:maybe""pure(lookup c$zip l u++zip u l))
Lynn
la source
5

Cheddar , 118 à 104 octets

(s)->s.chars.map((i)->{if String.letters has i.lower{if i<"a"{i+i.lower}else{i+i.upper}}else{i}}).join()

Première vraie réponse au cheddar !!! C’est beaucoup moins décisif que je ne le pensais…;

Fonctionne avec la version 1.0.0-beta.9 , non concurrente.

Comme vous pouvez le constater, je n’ai pas conçu le cheddar pour devenir golfy: /

Ungolfed:

(str) -> str.chars.map(
    (i) -> {
        if String.letters has i {
            if i < "a" { // Check char code, meaning it's upper case if true
                i+i.lower
            }
            else {
                i+i.upper
            }
        } else {
            i
        }
    }
).join()

Usage:

var doThing = <code here>;
doThing("input...");

Mise à jour: 14/07/16 J'ai terminé les ternaires, ce qui en fait un octet de 84 octets.

Cheddar, 84 octets

(s)->s.chars.map((i)->String.letters has i.lower?i<"a"?i+i.lower:i+i.upper:i).join()

fonctionne à partir de la version v1.0.0-beta.14

Downgoat
la source
4
Yay! Nous attendons ce moment depuis longtemps!
DJMcMayhem
Avec un ou deux changements de nom de méthode, est également valide Sidef
cat
@cat o_o la similarité est troublante
Descendante
Eh bien, ils sont tous les deux influencés par Perl, Perl 6, Ruby, Python, etc., alors ce n'est pas surprenant: P
cat
1
@cat oh non non non non non, le cheddar n'a pas été influencé par le python
Descendante
4

Retina, 28 27 21 octets

Ce sont des onglets, pas des espaces.

.
$&  $&
T`lL    p`Ll_`  .

Essayez-le en ligne

Merci à tous pour les suggestions.

mbomb007
la source
Les espaces sont mangés par SE.
Conor O'Brien
[A-Za-z]->i`[A-Z]
Rédigé le
Martin et moi discutions en chat, et nous avons proposé: retina.tryitonline.net/…
FryAmTheEggman
@FryAmTheEggman Ah, j'ai oublié _. Je vais utiliser des onglets pour pouvoir tester tous les tests en même temps.
mbomb007
1
Mais il n’est pas nécessaire de jouer au jeu de test: P Il suffit généralement de laisser une note disant que «la première ligne est exécutée séparément sur chaque ligne». Ici, cela vous épargnerait la folie des caractères de tabulation.
FryAmTheEggman
4

C, 87 80

Passez une chaîne en entrée f()et la sortie est écrite dans STDOUT. La chaîne n'est pas modifiée.

f(char*v){for(;*v;++v)putchar(*v),isalpha(*v)?putchar(*v-32+64*!islower(*v)):0;}
owacoder
la source
Pouvez-vous fournir un moyen d'essayer en ligne?
aloisdg dit Réintégrer Monica
@aloisdg Essayez ideone.com
Cat
4

sed, 30 octets

29 octets code + 1 octet paramètre -r

s/([a-z])|([A-Z])/&\u\1\l\2/g

Usage:

echo -e 'bad\nNice\nT e S t\ns E t\n1!1!1st!\nn00b\n(e.g.)\nH3l|@!' |\
sed -r 's/([a-z])|([A-Z])/&\u\1\l\2/g'
Marco
la source
4

J, 31 29 octets

[:;]<@~."1@,.tolower,.toupper

Explication

[:;]<@~."1@,.tolower,.toupper  Input: s
                      toupper  Convert s to all uppercase
             tolower           Convert s to all lowercase
                    ,.         Join them as columns in a 2d array
   ]                           Identity function, get s
           ,.                  Prepend s as a column to the 2d array
      ~."1@                    Take the unique chars on each row
    <@                         Box them
[:;                            Unbox the list of boxes and join their contents and return
milles
la source
4

Haskell, 121, 101, 85, 82

import Data.Char
g n|isLower n=toUpper n|1<2=toLower n
(>>= \x->x:[g x|isAlpha x])
Zylviij
la source
3
En remplaçant le if-then-else par des gardes, vous pouvez économiser environ 15 octets. Et isLowerest plus court que la construction avec elem, pour 5 octets de plus.
arjanen
1
>>=est concatMap(ou concat.map) avec des arguments retournées: f n = n >>= (\x->if isAlpha x then[x,r x]else[x]). Vous pouvez aller sans point, omettre le nom de la fonction et remplacer la définition de favec (>>= \x->if isAlpha x then[x,r x]else[x]).
nimi
1
Au lieu de otherwisevous pouvez utiliser n'importe quelle expression qui évalue à True, par exemple 1<2. Vous pouvez remplacer la if .. then .. elseavec une compréhension de la liste: \x->[x]++[g x|isAlpha x]. Oh, et il y a un bug: le second toUpperdans gdoit être toLower.
nimi
1
Oh, un de plus: [x]++est x:.
nimi
4

Perl, 36 octets ( -ndrapeau 35 + )

s/[a-z]/$&.(ord$&<97?lc$&:uc$&)/ige

( -ptag nécessaire)

(-2 octets grâce à @Dom Hasting)

Explication courte:
ordrenvoie la valeur numérique d'un caractère. ord(any lower case) >= 97, Et ord(any upper case) <= 90).

Courir avec : 

perl -pe 's/[a-z]/$&.(ord$&<97?lc$&:uc$&)/ige'
Dada
la source
Vous devez toujours utiliser /iou votre expression rationnelle correspondra à plusieurs points de code entre les lettres.
Oleg V. Volkov
@ OlegV.Volkov oh oui, merci, réponse modifiée.
Dada
Vous avez obtenu un octet de plus, selon votre méthode: essayez-le en ligne!
Xcali
4

Ruby, 31 + 1 = 32 30 + 1 = 31 octets

Avec le -pdrapeau, courir

gsub(/(?<=(.))/){$1.swapcase!}

Profite du fait que swapcase!renverra niln'importe quoi sauf une lettre ASCII, ce qui se traduira par une chaîne vide lorsqu'il sera renvoyé en dehors du gsubbloc. @ Jordan a sauvegardé un octet en capturant le caractère précédent dans un regard.

histocrate
la source
Faire correspondre avec //puis utiliser $`[-1]est intelligent.
Jordanie
1
J'ai réussi à raser six octets avec lookbehind: gsub(/(?<=(.))/){$1.swapcase!}. Même concept de base, alors n'hésitez pas à l'utiliser.
Jordanie
Cool! Cela me semble un octet plus court.
histocrat
Euh, oui, un octet. Je pense que j'avais un code supplémentaire à tester que j'ai compté par accident.
Jordanie
Il n’est pas nécessaire d’utiliser la version à modification automatique de .swapcase!. (Je veux dire, enlevez le !.)
manatwork
4

R, 191 187 168 156 98 99 octets

99 octets dus à des améliorations de Giuseppe et MickyT .

paste0(x<-unlist(strsplit(readline(),"")),gsub("[^A-Za-z]","",chartr("a-zA-Z","A-Za-z",x)),collapse="")
tourbull
la source
98 octets - peut-être l'année prochaine, nous pourrons trouver un autre golf, hahaha.
Giuseppe
1
Je déteste être le porteur de bad new, mais cela échoue dans les cas de test avec des espaces. readline()peut être utilisé, mais cela coûtera un octet
MickyT
@MickyT merci, corrigé maintenant.
rturnbull
@MickyT scanfonctionnera avec les entrées placées entre guillemets (comme c'est souvent le cas pour les arguments de ligne de commande dans d'autres langues)
Giuseppe
@ Giuseppe Désolé, je n'avais pas réalisé cela. Je pensais simplement qu'il se scindait automatiquement sur les espaces, sauf si vous spécifiez un caractère autre qu'un espace. Désolé rturnbull
MickyT
3

05AB1E , 7 octets

Code:

vyyš«Ù?

Explication:

v       # For each in input.
 yyš    # Push y and y swapcased.
    «Ù  # Concatentate and uniquify.
      ? # Print without a newline.

Utilise le codage CP-1252 . Essayez-le en ligne!

Adnan
la source
Peut-être pourriez-vous fournir un lien à l'interprète?
nicael
2
@nicael C'EST LIÉ ... C'est juste là sur github.
mbomb007
Donc pas d'interprète en ligne? :(
nicael
@ nicael Ensuite, téléchargez-le et lancez-le. Il n’est pas nécessaire d’avoir un interprète en ligne , mais un interprète.
mbomb007
1
@nicael Ouais, il n'y a pas encore d'interprète en ligne disponible :(. La version hors ligne devrait fonctionner si.
Adnan
3

En fait, 8 octets

`;Öo╔`MΣ

Essayez-le en ligne!

Explication:

`;Öo╔`MΣ
`;Öo╔`M   for each character in input:
 ;          duplicate the character
  Ö         swap case
   o        append to original character
    ╔       remove duplicated characters
       Σ  concatenate
Mego
la source
3

MATL, 11 à 9 octets

tYov"@uv!

Essayez-le en ligne

Explication

        % Implicitly grab input as string
t       % Duplicate the input
Yo      % Swap case of all characters
v       % Vertically concatenate the original and swap-cased versions
"       % For each column (letter in the original)
  @u    % Compute the unique values (without sorting)
  v!    % Vertically concatenate with the existing output and transpose
        % Implicit end of for loop and implicit display
Suever
la source
3

Perl, 28 22 21 octets (20 + -pdrapeau)

s/[a-z]/$&.$&^$"/ige
Oleg V. Volkov
la source
J'imagine que vous pouvez enregistrer un octet en utilisant à la $"place de ' ', mais je n'ai pas encore testé.
msh210
@ msh210, sympa! Comment pourrais-je oublier de vérifier les chaînes par défaut de perlvar? Merci!
Oleg V. Volkov
3

Stax , 7 à 6 octets

Merci à @recursive pour un octet enregistré!

┤§ÆP♦■

Exécutez-le et corrigez-le sur staxlang.xyz! (lien est à la version décompressée)

Décompressé (7 octets):

c:~\{um

Explication:

c:~\{um
c          Copy the top element of the stack (the input, in this case).
 :~        Switch case of each letter in the copy.
   \       Zip. This produces an array of two-character strings.
    { m    Map a block over this array of two-character strings.
     u       Get all unique elements.
           Implicit concatenate and print.
Khuldraeseth na'Barya
la source
Merci d'avoir essayé Stax. Une amélioration simple que vous pouvez apporter consiste à utiliser à la uplace :g. Il obtiendra tous les éléments uniques dans un tableau, ce qui est exactement ce que vous voulez dans ce cas. Autre que cela, cela semble bien joué au golf.
récursive
@recursive Merci! Oublié celui-là: / Sera édité bientôt.
Khuldraeseth na'Barya
Ça ne marche pas pour 123. Vous devrez peut-être modifier le format de toutes les entrées (c.-à-d. Les citer). Le lien est également brisé. Vous devez remplacer m=11par m=2. Il y a un bouton de génération de PPCG sur staxlang.xyz, vous pouvez donc utiliser celui-ci.
Weijun Zhou
@ WeijunZhou Merci, réparé!
Khuldraeseth na'Barya
2

Python, 59 octets

lambda s:''.join((x,x+x.swapcase())[x.isalpha()]for x in s)

Édité pour corriger les caractères répétés non alphabétiques

atlasologue
la source
2

Julia, 40 octets

!s=[print(c,isalpha(c)?c$' ':"")for c=s]

Essayez-le en ligne!

Dennis
la source
not s is (list comprehension)OK, Julia ...
Cat
2

PHP 4.1, 57 octets

Ce code suppose l'accès via un serveur Web (Apache, par exemple), en utilisant la configuration par défaut.

Vous pouvez passer la chaîne en envoyant la clé Spar tout moyen ( POST, GET, COOKIE, SESSION...).

<?for($i=0;$c=$S[$i++];)echo$c,ctype_alpha($c)?$c^' ':'';
Ismael Miguel
la source
2

C #, 82 71 octets

s=>string.Concat(s.Select(c=>c+(char.IsLetter(c)?(char)(c^32)+"":"")));

C # lambda où se trouvent l’entrée et la sortie string. Essayez-le en ligne .

11 octets grâce au truc @Lynn.

aloisdg dit réintégrer Monica
la source
2

Common Lisp (Lispworks), 262 octets

(defun f(s)(let((b""))(dotimes(i(length s))(if(lower-case-p(elt s i))(progn #1=(setf b(concatenate 'string b(string #2=(elt s i))))(setf b(concatenate 'string b(string(char-upcase #2#)))))(progn #1#(setf b(concatenate 'string b(string(char-downcase #2#)))))))b))

ungolfed:

(defun f (s)
  (let ((b ""))
    (dotimes (i (length s))
      (if (lower-case-p (elt s i))
          (progn
           #1=(setf b (concatenate 'string b (string #2=(elt s i))))
           (setf b (concatenate 'string b (string (char-upcase #2#)))))
        (progn
          #1#
          (setf b (concatenate 'string b (string (char-downcase #2#)))))))
    b))

Usage:

CL-USER 1 > (f "abc")
"aAbBcC"

CL-USER 2 > (f "bad")
"bBaAdD"
Sadfaf
la source