Caixa duplicada e comutada

34

O objetivo é, tendo tomado uma string como entrada, duplicar cada letra latina e "alternar" sua caixa (ou seja, maiúsculas se tornam minúsculas e vice-versa).

Exemplos de entradas e saídas:

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|@!

A entrada consiste em símbolos ASCII imprimíveis.

Você não deve duplicar letras não latinas, números, caracteres especiais.

code-golf string nicael
fonte
17
Este é um desafio muito bom, simples, mas não trivial.
Mego

Respostas:

10

Geléia, 5 bytes

żŒsQ€

Experimente online!

Como funciona

żŒ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
fonte
17

Python, 56 54 bytes

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

Teste em Ideone .

Dennis
fonte
Dang! Out golfed me by 4 bytes ...
R. Kap
Como isso mantém os caracteres não-letra? Eu acho que eles apareceriam como cordas vazias.
atlasologist
@ atlasologist Como você pode ver na Ideone, eles não. *tem precedência mais alta do que +, portanto, afeta apenas o ccaso com swap.
Dennis
Ohh, ok, eu não pensei nisso assim. Agradável.
atlasologist
16

JavaScript ES6, 70 68 66 64 bytes

Guardado 2 bytes graças a @Kevin Lau - não Kenny

Guardado 2 bytes graças a @ Cᴏɴᴏʀ O'Bʀɪᴇɴ

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

Explicação

Isso usa realmente um hacky:

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

qual não-destruído é:

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

Basicamente, l < "a"verifica se o ponto de código da letra é menor que o ponto de código de a(portanto, sendo uma letra maiúscula). Se for, fará o to + Low + erCaseque se tornou l['toLowerCase']()e torna o personagem em minúsculas. `As aspas permitem a formatação de strings; portanto, você pode pensar em:

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

as: "to" + (l<"a" ? "Low" : "Upp") + "erCase"que gera a função a ser chamada (coloque a string em maiúsculas ou minúsculas). Colocamos isso entre colchetes, o [ ... ]que nos permite acessar uma propriedade que recebe seu nome como uma string. Isso retorna a função apropriada e depois a chamamos.

Downgoat
fonte
3
/[A-Z]/gié um regex mais curto: 3
Value Ink
@ KevinLau-notKenny oh boa captura, obrigado!
Downgoat 08/07/19
1
to${l<"a"?"Lower":"Upper"}Caseparato${l<"a"?"Low":"Upp"}erCase
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ oh legal, obrigado!
Downgoat 08/07/19
4
l[`to${l<"a"?"Low":"Upp"}erCase`]()Eu acho que temos uma nova definição de mal.
Gcampbell 09/07/19
10

Ruby, 37 33 (30 + -psinalizador) bytes

swapcasepara o resgate! Tipo de. -4 bytes de @Lynn.

gsub(/[a-z]/i){$&+$&.swapcase}
Value Ink
fonte
gsub(/[a-z]/i){$&+$&.swapcase}mais o psinalizador é de 31 bytes.
Lynn
1
@ Lynn Eu acredito que o consenso era a diferença de edição necessária do script padrão, então a pbandeira é (space)-pconhecida como 3 bytes.
Value Ink
8

C, 63 bytes 60

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

Usa o fato de que 'a' XOR 32 == 'A'etc.

Três bytes salvos graças ao FryAmTheEggman.

Lynn
fonte
você pode mover o s++na última putchar( &&putchar(32^*s++)) para salvar um byte
Giacomo Garabello
Eu acho que você pode substituir &&por *, não é?
aloisdg diz Reinstate Monica
1
Tenho certeza de que os dois não funcionam, se pensar em como &&funciona o comportamento em curto-circuito.
Lynn
f(char*s){isalpha(putchar(*s))&&putchar(32^*s);*s&&f(1+s);}recursivo?
L4m2 19/0318
1
f(char*s){*s&&f(1+s,isalpha(putchar(*s))&&putchar(32^*s));}recursivo?
L4m2
6

CJam, 11 bytes

l_el_eu.+.|

Teste aqui.

Explicação

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
fonte
5

Pitão , 7 bytes

sm{+dr2

Conjunto de teste .

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
Freira Furada
fonte
Haha, isso é muito rápido: D
nicael 08/07/16
5

Python 3.5, 60 56 bytes:

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

Um programa completo. Vai tentar jogar mais golfe.

Experimente Online! (Ideona)

R. Kap
fonte
5

Haskell, 73 bytes

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

Queijo Cheddar , 118 104 bytes

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

Primeira resposta Cheddar real !!! Isso é muito menos climático do que eu pensava que seria ...; _;

Funciona com a versão 1.0.0-beta.9 , não concorrente.

Como você pode ver, eu não projetei o cheddar para jogar golfe: /

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

Uso:

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

Atualização: 14/07/16 Eu terminei os ternários, diminuindo para 84 bytes

Cheddar, 84 bytes

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

funciona a partir da versão v1.0.0-beta.14

Downgoat
fonte
4
Yay! Estamos esperando por esse momento há muito tempo!
DJMcMayhem
Com um ou dois método mudanças de nome, também é válido Sidef
cat
@cat o_o a semelhança é inquietante
Downgoat
Bem, eles estão ambos influenciados pelo Perl, Perl 6, Ruby, Python, etc, por isso não é tão surpreendente: P
cat
1
@cat oh não não não não não, cheddar foi não influenciada por python
Downgoat
4

Retina, 28 27 21 bytes

Essas são abas, não espaços.

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

Experimente online

Obrigado pelas sugestões a todos.

mbomb007
fonte
Os espaços são comidos pelo SE.
Conor O'Brien
[A-Za-z]->i`[A-Z]
Downgoat 08/07/16
Martin e eu estávamos conversando no bate-papo e criamos: retina.tryitonline.net/…
FryAmTheEggman 08/07/16
@FryAmTheEggman Ah, eu esqueci _. Vou usar as guias para poder testar todos os casos de teste de uma só vez.
mbomb007
1
Mas a suíte de testes não precisa ser jogada no golfe: P Basta deixar uma nota dizendo "a primeira linha faz com que ela seja executada separadamente em cada linha" geralmente é suficiente. Aqui, você pouparia a loucura dos caracteres de tabulação.
FryAmTheEggman
4

C, 87 80

Passe uma string como entrada f()e a saída será gravada em STDOUT. A sequência não é modificada.

f(char*v){for(;*v;++v)putchar(*v),isalpha(*v)?putchar(*v-32+64*!islower(*v)):0;}
owacoder
fonte
Você pode fornecer uma maneira de experimentá-lo online?
Aloisdg diz Reinstate Monica
@aloisdg Tente ideone.com
cat
4

sed, 30 bytes

Código de 29 bytes + parâmetro de 1 byte -r

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

Uso:

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
fonte
4

J, 31 29 bytes

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

Explicação

[:;]<@~."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
milhas
fonte
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
fonte
3
Ao substituir o if-then-else pelos guardas, você pode salvar 15 bytes ou mais. E isLoweré mais curto que o construto com elem, por 5 bytes a mais.
Arjanen 9/07
1
>>=é concatMap(ou concat.map) com argumentos invertidas: f n = n >>= (\x->if isAlpha x then[x,r x]else[x]). Você pode ficar sem ponto e omitir o nome da função e substituir a definição de fpor (>>= \x->if isAlpha x then[x,r x]else[x]).
nimi
1
Em vez de otherwisevocê pode usar qualquer expressão que avalie True, por exemplo 1<2. Você pode substituir o if .. then .. elsecom uma compreensão da lista: \x->[x]++[g x|isAlpha x]. Ah, e há um erro: o segundo toUpperem gdeve ser a toLower.
nimi
1
Oh, mais um: [x]++é x:.
nimi
4

Perl, 36 bytes (35 + -nsinalizador)

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

( -ptag necessária)

(-2 bytes graças a @Dom Hasting)

Breve explicação:
ordretorna o valor numérico de um caractere. ord(any lower case) >= 97E ord(any upper case) <= 90).

Correr com : 

perl -pe 's/[a-z]/$&.(ord$&<97?lc$&:uc$&)/ige'
dada
fonte
Você ainda precisa usar /iou o seu regexp corresponderá a vários pontos de código entre as letras.
Oleg V. Volkov
@ OlegV.Volkov oh certo, obrigado, resposta editada.
Dada
Obtenha mais um byte usando o seu método: Experimente online!
Xcali 03/04
4

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

Com a -pbandeira, corra

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

Aproveita o fato de que swapcase!retornará nilcom qualquer coisa, exceto uma letra ASCII, que se traduz em uma sequência vazia quando retornada do gsubbloco. @Jordan salvou um byte capturando o caractere anterior em um look-behind.

histocrata
fonte
Combinar //e usar $`[-1]é inteligente.
Jordan
1
Eu consegui raspar seis bytes com lookbehind: gsub(/(?<=(.))/){$1.swapcase!}. Mesmo conceito básico, no entanto, fique à vontade para usá-lo.
Jordânia
Legal! Isso parece um byte mais curto para mim.
histocrat 29/08/16
Sim, um byte. Eu acho que tinha algum código extra lá para testar que contei acidentalmente.
Jordan
Não há necessidade de usar a versão auto-modificável do .swapcase!. (Quer dizer, remover o !.)
manatwork
4

R, 191 187 168 156 98 99 bytes

99 bytes devido a melhorias no Giuseppe e no MickyT .

paste0(x<-unlist(strsplit(readline(),"")),gsub("[^A-Za-z]","",chartr("a-zA-Z","A-Za-z",x)),collapse="")
rturnbull
fonte
98 bytes - talvez no próximo ano, possamos encontrar outro ponto sobre isso, hahaha.
Giuseppe
1
Eu odeio ser portador de más novas, mas falha nos casos de teste com espaços. readline()pode ser usado, mas vai custar um byte
MickyT 2/18
@MickyT obrigado, corrigido agora.
rturnbull
@MickyT scantrabalhará com entrada dada entre aspas (como é frequentemente o caso para os argumentos de linha de comando em outros idiomas)
Giuseppe
@ Giuseppe Desculpe, eu não percebi isso. Eu apenas pensei que ele se dividir automaticamente em espaço em branco, a menos que você especifique um caractere que não seja um espaço em branco. Desculpe rturnbull
MickyT
3

05AB1E , 7 bytes

Código:

vyyš«Ù?

Explicação:

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

Usa a codificação CP-1252 . Experimente online!

Adnan
fonte
Talvez você possa fornecer um link para o intérprete?
Nicael 8/07
2
@nicael Está ligado ... Está bem ali no github.
Mbomb007
Então, nenhum intérprete online? :(
nicael
@nicael Faça o download e execute-o. Não precisa haver um intérprete on - line , apenas um intérprete.
Mbomb007
1
@nicael Sim, não há ainda on-line intérprete disponível :( A versão offline deve funcionar embora..
Adnan
3

Na verdade, 8 bytes

`;Öo╔`MΣ

Experimente online!

Explicação:

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

MATL, 11 9 bytes

tYov"@uv!

Experimente Online

Explicação

        % 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
fonte
3

Perl, 28 22 21 bytes (20 + -psinalizador)

s/[a-z]/$&.$&^$"/ige
Oleg V. Volkov
fonte
Eu imagino que você pode salvar um byte usando em $"vez de ' ', mas eu não testei.
Msh210
@ msh210, legal! Como eu poderia esquecer de verificar o perlvar em busca de strings padrão? Obrigado!
Oleg V. Volkov
3

Stax , 7 6 bytes

Obrigado a @recursive por um byte salvo!

┤§ÆP♦■

Execute e depure-o em staxlang.xyz! (o link é para a versão descompactada)

Descompactado (7 bytes):

c:~\{um

Explicação:

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
fonte
Obrigado por experimentar o stax. Uma melhoria fácil que você pode fazer é usar em uvez de :g. Ele obterá todos os elementos exclusivos de uma matriz, exatamente o que você deseja neste caso. Fora isso, isso parece bem jogado.
recursivo
@recursive Thanks! Esqueceu-se disso: / Será editado em breve.
Khuldraeseth na'Barya
Não funciona para 123. Pode ser necessário alterar o formato de todas as entradas (ou seja, citá-las). O link também está quebrado. Você precisa substituir m=11por m=2. Há um botão de pós-geração de PPCG no staxlang.xyz, portanto você pode querer usá-lo.
Weijun Zhou
@ WeijunZhou Obrigado, corrigido!
Khuldraeseth na'Barya
2

Python, 59 bytes

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

Editado para corrigir caracteres não alfabéticos repetidos

atlasologist
fonte
2

Julia, 40 bytes

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

Experimente online!

Dennis
fonte
not s is (list comprehension)ok Julia ...
cat
2

PHP 4.1, 57 bytes

Este código pressupõe o acesso através de um servidor web (Apache, por exemplo), usando a configuração padrão.

Você pode passar a cadeia por enviar a chave Spor qualquer meio ( POST, GET, COOKIE, SESSION...).

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

C #, 82 71 bytes

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

C # lambda onde estão a entrada e a saída string. Experimente online .

11 bytes graças ao truque @Lynn.

aloisdg diz Restabelecer Monica
fonte
2

Lisp comum (Lispworks), 262 bytes

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

Uso:

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

CL-USER 2 > (f "bad")
"bBaAdD"
sadfaf
fonte