Duplica e cambia custodia

34

L'obiettivo è, dopo aver preso una stringa come input, duplicare ogni lettera latina e "alternare" il suo caso (cioè il maiuscolo diventa minuscolo e viceversa).

Ingressi e uscite di esempio:

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'input è costituito da simboli ASCII stampabili.

Non dovresti duplicare lettere, numeri, caratteri speciali non latini.

code-golf  string 
— nicael
fonte
17
Questa è una sfida molto bella, semplice ma non banale.
— Mego

Risposte:

10

Gelatina, 5 byte

żŒsQ€

Provalo online!

Come funziona

żŒ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 byte

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

Provalo su Ideone .

— Dennis
fonte
Dang! Mi ha giocato a golf di 4 byte ...
— R. Kap
Come mantiene i caratteri non lettera? Penso che si presenterebbero come stringhe vuote.
— atlanteologo
@atlasologo Come puoi vedere su Ideone, non lo fanno. *ha una precedenza più alta di +, quindi influisce solo sul ccaso scambiato.
— Dennis,
Oh, okay, non ci ho pensato in quel modo. Bello.
— atlanteologo
16

JavaScript ES6, 70 68 66 64 byte

Salvato 2 byte grazie a @Kevin Lau - non a Kenny

Salvato 2 byte grazie a @ Cᴏɴᴏʀ O'Bʀɪᴇɴ

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

Spiegazione

Questo utilizza un vero hacky:

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

quale non golfato è:

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

Fondamentalmente l < "a"controlla se il punto di codice della lettera è inferiore al punto di codice di a(quindi essere una lettera maiuscola). Se è così farà ciò to + Low + erCaseche è diventato l['toLowerCase']()e rende il personaggio in minuscolo. `le virgolette consentono la formattazione delle stringhe, quindi essenzialmente puoi pensare a:

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

as: "to" + (l<"a" ? "Low" : "Upp") + "erCase"che genera la funzione da chiamare (imposta la stringa in maiuscolo o minuscolo). Lo mettiamo tra parentesi quadre [ ... ]che ci consente di accedere a una proprietà dato il suo nome come stringa. Questo restituisce la funzione appropriata e quindi la chiamiamo semplicemente.

— Downgoat
fonte
3
/[A-Z]/giè una regex più breve: 3
— Value Ink
@ KevinLau-notKenny oh bella cattura, grazie!
— Downgoat,
1
to${l<"a"?"Lower":"Upper"}Caseato${l<"a"?"Low":"Upp"}erCase
— Conor O'Brien l'
@ CᴏɴᴏʀO'Bʀɪᴇɴ oh bello, grazie!
— Downgoat,
4
l[`to${l<"a"?"Low":"Upp"}erCase`]()Penso che abbiamo una nuova definizione di male.
— gcampbell,
10

Rubino, 37 33 (30 + -pbandiera) byte

swapcaseAl salvataggio! Una specie di. -4 byte da @Lynn.

gsub(/[a-z]/i){$&+$&.swapcase}
— Value Ink
fonte
gsub(/[a-z]/i){$&+$&.swapcase}inoltre la pbandiera è di 31 byte.
— Lynn,
1
@Lynn Credo che il consenso fosse la differenza di modifica necessaria dallo script predefinito, quindi la pbandiera è (space)-palias 3 byte.
— Value Ink
8

C, 63 60 byte

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

Usa il fatto che 'a' XOR 32 == 'A', ecc.

Tre byte salvati grazie a FryAmTheEggman.

— Lynn
fonte
puoi spostare il s++nell'ultimo putchar( &&putchar(32^*s++)) per salvare un byte
— Giacomo Garabello
Penso che puoi sostituirlo &&con *, vero?
— aloisdg dice Reinstate Monica il
1
Sono abbastanza sicuro che entrambi non funzionino, se penso a come &&funziona il comportamento in corto circuito.
— Lynn,
f(char*s){isalpha(putchar(*s))&&putchar(32^*s);*s&&f(1+s);}ricorsivo?
— l4m2
1
f(char*s){*s&&f(1+s,isalpha(putchar(*s))&&putchar(32^*s));}ricorsivo?
— l4m2
6

CJam, 11 byte

l_el_eu.+.|

Provalo qui.

Spiegazione

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

Pyth , 7 byte

sm{+dr2

Suite di 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
— Perdente Suora
fonte
Haha, è davvero veloce: D
— nicael,
5

Haskell, 73 byte

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

Cheddar , 118 104 byte

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

Prima vera risposta Cheddar !!! Questo è molto meno climatico di quanto pensassi sarebbe ...; _;

Funziona con la versione 1.0.0-beta.9 , non competitiva.

Come puoi dire, non ho progettato il cheddar per essere goloso: /

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...");

Aggiornamento: 14/07/16 Ho terminato i ternari facendo scendere questo valore a 84 byte

Cheddar, 84 byte

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

funziona dalla versione v1.0.0-beta.14

— Downgoat
fonte
4
Sìì! Aspettiamo questo momento da molto tempo!
— DJMcMayhem
Con una o due modifiche al nome del metodo, è valido anche Sidef
— cat
@cat o_o la somiglianza è inquietante
— Downgoat
Bene, sono entrambi influenzati da Perl, Perl 6, Ruby, Python, ecc., Quindi non è così sorprendente: P
— cat
1
@cat oh no no no no no, cheddar non è stato influenzato dal pitone
— Downgoat
4

Retina, 28 27 21 byte

Quelle sono schede, non spazi.

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

Provalo online

Grazie per i suggerimenti a tutti.

— mbomb007
fonte
Gli spazi sono mangiati da SE.
— Conor O'Brien,
[A-Za-z]->i`[A-Z]
— Downgoat,
Martin e io stavamo parlando in chat e ci siamo inventati
— FryAmTheEggman
@FryAmTheEggman Ah, mi sono dimenticato _. Userò le schede per poter testare tutti i casi di test contemporaneamente.
— mbomb007,
1
Ma la suite di test non deve essere giocata a golf: P Basta lasciare una nota che dice "la prima riga la fa funzionare separatamente su ciascuna riga" di solito è abbastanza buona. Qui, ti risparmierebbe la follia dei personaggi delle schede.
— FryAmTheEggman,
4

C, 87 80

Passa una stringa come input a f()e l'output viene scritto in STDOUT. La stringa non viene modificata.

f(char*v){for(;*v;++v)putchar(*v),isalpha(*v)?putchar(*v-32+64*!islower(*v)):0;}
— owacoder
fonte
Potete fornire un modo per provarlo online?
— aloisdg dice Reinstate Monica il
@aloisdg Prova ideone.com
— cat
4

sed, 30 byte

Codice 29 byte + parametro 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 byte

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

Spiegazione

[:;]<@~."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
— miglia
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
Sostituendo if-then-else con guardie, è possibile salvare circa 15 byte. Ed isLowerè più breve del costrutto con elem, per 5 byte in più.
— Arjanen,
1
>>=è concatMap(o concat.map) con argomenti capovolto: f n = n >>= (\x->if isAlpha x then[x,r x]else[x]). È possibile andare a vuoto e omettere il nome della funzione e sostituire la definizione di fcon (>>= \x->if isAlpha x then[x,r x]else[x]).
— nimi,
1
Invece di otherwisete puoi usare qualsiasi espressione che valuti True, ad es 1<2. È possibile sostituire il if .. then .. elsecon una lista di comprensione: \x->[x]++[g x|isAlpha x]. Oh, e c'è un bug: il secondo toUpperin gdeve essere un toLower.
— nimi,
1
Oh, ancora uno: [x]++è x:.
— nimi,
4

Perl, 36 byte (35 + -nbandiera)

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

(-p tag necessario)

(-2 byte grazie a @Dom Hasting)

Breve spiegazione:
ordrestituisce il valore numerico di un carattere. ord(any lower case) >= 97, eord(any upper case) <= 90) .

Corri con : 

perl -pe 's/[a-z]/$&.(ord$&<97?lc$&:uc$&)/ige'
— Dada
fonte
Devi ancora usare /io il tuo regexp abbinerà diversi punti di codice tra le lettere.
— Oleg V. Volkov,
@ OlegV.Volkov oh giusto, grazie, risposta modificata.
— Dada,
Riduci un altro byte usando il tuo metodo: provalo online!
— Xcali
4

Rubino, 31 + 1 = 32 30 + 1 = 31 byte

Con la -pbandiera, corri

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

Sfrutta il fatto che swapcase!tornerà nilsu qualsiasi cosa tranne una lettera ASCII, che si traduce in una stringa vuota quando viene restituita dal gsubblocco. @Jordan ha salvato un byte catturando il personaggio precedente in uno sguardo dietro.

— histocrat
fonte
Abbinarsi //e quindi usare $`[-1]è intelligente.
— Giordania,
1
Sono riuscito a radersi sei byte con lookbehind: gsub(/(?<=(.))/){$1.swapcase!}. Stesso concetto di base, però, quindi sentiti libero di usarlo.
— Giordania,
Freddo! A me sembra un byte più corto.
— istocratico,
Ehm, sì, un byte. Penso di avere del codice aggiuntivo per verificare che ho contato per errore.
— Giordania,
Non è necessario utilizzare la versione automodificante di .swapcase!. (Voglio dire, rimuovi il !.)
— arte
4

R, 191 187 168 156 98 99 byte

99 byte a causa di miglioramenti da parte di Giuseppe e MickyT .

paste0(x<-unlist(strsplit(readline(),"")),gsub("[^A-Za-z]","",chartr("a-zA-Z","A-Za-z",x)),collapse="")
— rturnbull
fonte
98 byte - forse l'anno prossimo, possiamo trovare un altro golf di questo, hahaha.
— Giuseppe,
1
Odio essere il portatore di cattivi nuovi, ma fallisce nei casi di test con spazi. readline()può essere utilizzato, ma avrà un costo di un byte
— MickyT
@MickyT grazie, risolto ora.
— rturnbull,
@MickyT scanfunzionerà con input dato racchiuso tra virgolette (come spesso accade per gli argomenti della riga di comando in altre lingue)
— Giuseppe
@Giuseppe Scusami non me ne sono accorto. Ho solo pensato che si dividesse automaticamente su spazi bianchi a meno che non specifichi un carattere non spazioso. Siamo spiacenti rturnbull
— MickyT
3

05AB1E , 7 byte

Codice:

vyyš«Ù?

Spiegazione:

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

Utilizza la codifica CP-1252 . Provalo online!

— Adnan
fonte
Forse potresti fornire un link all'interprete?
— nicael,
2
@nicael È collegato ... È proprio lì su Github.
— mbomb007,
Quindi nessun interprete online? :(
— nicael
@nicael Quindi scaricalo ed eseguilo. Non ci deve essere un interprete online , solo un interprete.
— mbomb007,
1
@nicael Sì, non è ancora disponibile un interprete online :(. La versione offline dovrebbe funzionare comunque.
— Adnan
3

In realtà, 8 byte

`;Öo╔`MΣ

Provalo online!

Spiegazione:

`;Ö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 byte

tYov"@uv!

Provalo online

Spiegazione

        % 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 byte (20 + -pflag)

s/[a-z]/$&.$&^$"/ige
— Oleg V. Volkov
fonte
Immagino che puoi salvare un byte usando $"invece di ' ', ma non ho testato.
— msh210
@ msh210, bello! Come potrei dimenticare di controllare perlvar per stringhe predefinite? Grazie!
— Oleg V. Volkov,
3

Stax , 7 6 byte

Grazie a @recursive per un byte salvato!

┤§ÆP♦■

Eseguilo e esegui il debug su staxlang.xyz!(il collegamento è alla versione decompressa)

Senza pacchetto (7 byte):

c:~\{um

Spiegazione:

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
Grazie per aver provato stax. Un semplice miglioramento che puoi apportare è utilizzare uinvece di :g. Otterrà tutti gli elementi unici in un array, che è esattamente quello che vuoi in questo caso. A parte questo, questo sembra ben giocato.
— ricorsivo il
@recursive Grazie! Dimenticato quello: / Verrà modificato presto.
— Khuldraeseth na'Barya,
Non funziona per 123. Potrebbe essere necessario modificare il formato per tutti gli input (ad esempio, citarli). Anche il collegamento è interrotto. È necessario sostituire m=11con m=2. C'è un pulsante di generazione di messaggi PPCG su staxlang.xyz, quindi potresti voler usare quello.
— Weijun Zhou,
@WeijunZhou Grazie, risolto!
— Khuldraeseth na'Barya,
2

Python, 59 byte

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

Modificato per correggere i caratteri non alfabetici ricorrenti

— atlasologist
fonte
2

PHP 4.1, 57 byte

Questo codice presuppone l'accesso tramite un server Web (Apache, ad esempio), utilizzando la configurazione predefinita.

È possibile passare la stringa con l'invio della chiave Scon qualsiasi mezzo ( POST, GET, COOKIE, SESSION...).

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

Lisp comune (Lispworks), 262 byte

(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
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.