Gehäuse duplizieren und wechseln

34

Das Ziel ist, nachdem eine Zeichenkette als Eingabe verwendet wurde, jeden lateinischen Buchstaben zu duplizieren und die Groß- / Kleinschreibung zu ändern (und umgekehrt).

Beispiel Ein- und Ausgänge:

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

Die Eingabe besteht aus druckbaren ASCII-Symbolen.

Du solltest keine nicht-lateinischen Buchstaben, Zahlen oder Sonderzeichen kopieren.

code-golf  string 
— nicael
quelle
17
Dies ist eine sehr schöne, einfache, aber nicht triviale Herausforderung.
— Mego

Antworten:

10

Gelee, 5 Bytes

żŒsQ€

Probieren Sie es online!

Wie es funktioniert

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

Python, 56 54 Bytes

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

Teste es auf Ideone .

— Dennis
quelle
Mist! Out hat mich um 4 Bytes golfen ...
— R. Kap
Wie werden die Nichtbuchstaben beibehalten? Ich würde denken, dass sie als leere Zeichenfolgen angezeigt werden.
— Atlasologe
@atlasologist Wie Sie auf Ideone sehen können, tun sie dies nicht. *Hat eine höhere Priorität als +, wirkt sich also nur auf den cmit vertauschten Fall aus.
— Dennis
Ohh, okay, so habe ich es mir nicht vorgestellt. Nett.
— Atlasologe
16

JavaScript ES6, 70 68 66 64 Bytes

2 Bytes dank @Kevin Lau gespeichert - nicht Kenny

2 Bytes dank @ Cᴏɴᴏʀ O'Bʀɪᴇɴ gespeichert

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

Erläuterung

Dies nutzt eine wirklich hacky:

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

was ungolfed ist:

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

Grundsätzlich wird l < "a"geprüft, ob der Codepunkt des Buchstabens kleiner ist als der Codepunkt von a(daher ein Großbuchstabe). Wenn es so ist, wird es das tun, to + Low + erCasewas dazu führt, l['toLowerCase']()dass das Zeichen in Kleinbuchstaben geschrieben wird. `Anführungszeichen ermöglichen die Formatierung von Zeichenfolgen, sodass Sie sich im Wesentlichen Folgendes vorstellen können:

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

as: "to" + (l<"a" ? "Low" : "Upp") + "erCase"generiert die aufzurufende Funktion (die Zeichenkette in Groß- oder Kleinschreibung schreiben). Wir setzen dies in eckige Klammern [ ... ], um auf eine Eigenschaft zuzugreifen, deren Name als Zeichenfolge angegeben ist. Dies gibt die entsprechende Funktion zurück und wir rufen sie einfach auf.

— Downgoat
quelle
3
/[A-Z]/giist ein kürzerer regulärer Ausdruck: 3
— Value Ink
@ KevinLau-notKenny oh schöner Fang, danke!
— Downgoat
1
to${l<"a"?"Lower":"Upper"}Casezuto${l<"a"?"Low":"Upp"}erCase
— Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ oh schön, danke!
— Downgoat
4
l[`to${l<"a"?"Low":"Upp"}erCase`]()Ich denke, wir haben eine neue Definition des Bösen.
— Gcampbell
10

Ruby, 37 33 (30 + -pFlag) Bytes

swapcasezur Rettung! Art von. -4 Bytes von @Lynn.

gsub(/[a-z]/i){$&+$&.swapcase}
— Wert Tinte
quelle
gsub(/[a-z]/i){$&+$&.swapcase}plus das pFlag ist 31 Bytes.
— Lynn
1
@Lynn Ich glaube, Konsens war ein Unterschied zum Standard-Skript, daher ist das pFlag auch als (space)-p3 Bytes bekannt.
— Wert Tinte
8

C 63 60 Bytes

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

Nutzt die Tatsache, dass 'a' XOR 32 == 'A'usw.

Drei Bytes dank FryAmTheEggman gespart.

— Lynn
quelle
Sie können die s++in der letzten putchar( &&putchar(32^*s++)) verschieben, um ein Byte zu speichern
— Giacomo Garabello
Ich glaube , Sie ersetzen &&mit *, können Sie nicht?
— Aloisdg sagt Reinstate Monica
1
Ich bin mir ziemlich sicher, dass beide nicht funktionieren, wenn ich mir überlege, wie &&das Kurzschlussverhalten funktioniert.
— Lynn
f(char*s){isalpha(putchar(*s))&&putchar(32^*s);*s&&f(1+s);}rekursiv?
— 14.
1
f(char*s){*s&&f(1+s,isalpha(putchar(*s))&&putchar(32^*s));}rekursiv?
— 14.
6

CJam, 11 Bytes

l_el_eu.+.|

Teste es hier.

Erläuterung

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

Pyth , 7 Bytes

sm{+dr2

Testsuite .

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
— Undichte Nonne
quelle
Haha, das ist wirklich schnell: D
— nicael
5

Haskell, 73 Bytes

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

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

Erste echte Cheddar-Antwort !!! Das ist viel weniger klimatisch als ich dachte ...; _;

Funktioniert mit Release 1.0.0-beta.9 , nicht konkurrierend.

Wie Sie sehen, habe ich Cheddar nicht zum Golfen entworfen: /

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

Verwendung:

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

Update: 14.07.16 Ich habe die Ternaries beendet, was 84 Bytes ergibt

Cheddar, 84 Bytes

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

Funktioniert ab Version v1.0.0-beta.14

— Downgoat
quelle
4
Yay! Auf diesen Moment haben wir lange gewartet!
— DJMcMayhem
Bei ein oder zwei Änderungen des Methodennamens gilt auch Sidef
— cat
@cat o_o die Ähnlichkeit ist beunruhigend
— Downgoat
Nun, sie sind beide von Perl, Perl 6, Ruby, Python usw. beeinflusst, es ist also nicht so überraschend: P
— cat
1
@cat oh nein nein nein nein, Cheddar wurde nicht von Python beeinflusst
— Downgoat
4

Retina, 28 27 21 Bytes

Das sind Tabulatoren, keine Leerzeichen.

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

Probieren Sie es online aus

Danke für die Vorschläge an alle.

— mbomb007
quelle
Die Räume werden von SE gegessen.
— Conor O'Brien
[A-Za-z]->i`[A-Z]
— Downgoat
Martin und ich haben uns im Chat unterhalten und uns Folgendes
— ausgedacht
@FryAmTheEggman Ah, ich habe es vergessen _. Ich werde jedoch Registerkarten verwenden, damit ich alle Testfälle gleichzeitig testen kann.
— mbomb007
1
Die Testsuite muss jedoch nicht golfen werden: P Es ist in der Regel ausreichend, nur eine Notiz mit der Aufschrift "Die erste Zeile bewirkt, dass sie in jeder Zeile separat ausgeführt wird" zu hinterlassen. Hier würde es Ihnen die Verrücktheit von Tabulatorzeichen ersparen.
— FryAmTheEggman
4

C 87, 80

f()Übergeben Sie eine Zeichenfolge als Eingabe an und die Ausgabe wird in STDOUT geschrieben. Die Zeichenfolge wird nicht geändert.

f(char*v){for(;*v;++v)putchar(*v),isalpha(*v)?putchar(*v-32+64*!islower(*v)):0;}
— owacoder
quelle
Können Sie eine Möglichkeit bereitstellen, es online zu testen?
— Aloisdg sagt Reinstate Monica
@aloisdg Versuchen Sie, ideone.com
— Katze
4

sed, 30 bytes

29 Byte Code + 1 Byte Parameter -r

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

Verwendung:

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

J 31 29 Bytes

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

Erläuterung

[:;]<@~."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
— Meilen
quelle
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
quelle
3
Wenn Sie das Wenn-Dann-Sonst durch Wachen ersetzen, können Sie etwa 15 Byte einsparen. Und isLowerist kürzer als das Konstrukt mit elem, für 5 Bytes mehr.
— Arjanen
1
>>=ist concatMap(oder concat.map) mit Argumenten blättern: f n = n >>= (\x->if isAlpha x then[x,r x]else[x]). Sie können den Funktionsnamen weglassen und die Definition von fdurch ersetzen (>>= \x->if isAlpha x then[x,r x]else[x]).
— Nimi
1
Anstelle von können otherwiseSie jeden Ausdruck verwenden, der ausgewertet wird True, z 1<2. Sie können das Ersetzen if .. then .. elsemit einer Liste Verständnis: \x->[x]++[g x|isAlpha x]. Oh, und es gibt einen Fehler: Der zweite toUpperin gmuss ein sein toLower.
— nimi
1
Oh, noch einer: [x]++ist x:.
— nimi
4

Perl, 36 Bytes (35 + -nFlag)

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

( -ptag benötigt)

(-2 Bytes dank @Dom Hasting)

Kurze Erklärung:
ordGibt den numerischen Wert eines Zeichens zurück. ord(any lower case) >= 97und ord(any upper case) <= 90).

Laufen mit: 

perl -pe 's/[a-z]/$&.(ord$&<97?lc$&:uc$&)/ige'
— Dada
quelle
Sie müssen immer noch verwenden, /ioder Ihre regulären Ausdrücke stimmen mit mehreren Codepunkten zwischen Buchstaben überein.
— Oleg V. Volkov
@ OlegV.Volkov oh richtig, danke, Antwort bearbeitet.
— Dada
Mit Ihrer Methode noch ein Byte runter: Probieren Sie es online aus!
— Xcali
4

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

Mit der -pFlagge laufen

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

Nutzt die Tatsache , dass swapcase!zurück nilauf alles andere als ein ASCII - Buchstaben, die übersetzt in eine leere Zeichenfolge , wenn der zurück aus gsubBlock. @Jordan hat ein Byte gespeichert, indem er das vorherige Zeichen in einem Look-Behind erfasst hat.

— Histokrat
quelle
Matching mit //und dann mit $`[-1]ist klug.
— Jordanien
1
Ich schaffte es sechs Bytes mit Lookbehind abrasieren: gsub(/(?<=(.))/){$1.swapcase!}. Das gleiche Grundkonzept, zögern Sie also nicht, es zu verwenden.
— Jordanien
Cool! Das sieht für mich ein Byte kürzer aus.
— Histokrat
Äh, ja, ein Byte. Ich glaube, ich hatte einen zusätzlichen Code zum Testen, den ich versehentlich gezählt habe.
— Jordanien
Es ist nicht erforderlich, die selbstmodifizierende Version von zu verwenden .swapcase!. (Ich meine, entfernen Sie die !.)
— Manatwork
4

R, 191 187 168 156 98 99 Bytes

99 Bytes aufgrund von Verbesserungen für Giuseppe und MickyT .

paste0(x<-unlist(strsplit(readline(),"")),gsub("[^A-Za-z]","",chartr("a-zA-Z","A-Za-z",x)),collapse="")
— rturnbull
quelle
98 Bytes - vielleicht finden wir nächstes Jahr einen weiteren Golf, hahaha.
— Giuseppe
1
Ich hasse es, der Träger von schlechtem Neuem zu sein, aber es scheitert bei Testfällen mit Leerzeichen. readline()kann verwendet werden, kostet aber ein Byte
— MickyT
@ MickyT danke, jetzt behoben.
— Rturnbull
@ MickyT scanwird mit in Anführungszeichen eingeschlossenen Eingaben funktionieren (wie es häufig bei Befehlszeilenargumenten in anderen Sprachen der Fall ist)
— Giuseppe
@ Giuseppe Sorry, das habe ich nicht gemerkt. Ich dachte nur, es wird automatisch in Leerzeichen aufgeteilt, es sei denn, Sie geben ein Nicht-Leerzeichen-Zeichen an. Entschuldigung rturnbull
— MickyT
3

05AB1E , 7 Bytes

Code:

vyyš«Ù?

Erläuterung:

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

Verwendet die CP-1252- Codierung. Probieren Sie es online!

— Adnan
quelle
Vielleicht könnten Sie einen Link zum Dolmetscher bereitstellen?
— Nicoleel
2
@nicael Es ist verbunden ... Es ist genau dort auf Github.
— mbomb007
Also kein Online-Dolmetscher? :(
— nicael
@nicael Dann lade es herunter und starte es. Es muss keinen Online- Dolmetscher geben, nur einen Dolmetscher.
— mbomb007
1
@nicael Ja, es ist noch kein Online-Dolmetscher verfügbar :(. Die Offline-Version sollte jedoch funktionieren.
— Adnan
3

Eigentlich 8 Bytes

`;Öo╔`MΣ

Probieren Sie es online!

Erläuterung:

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

MATL, 11 9 Bytes

tYov"@uv!

Probieren Sie es online

Erläuterung

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

Perl, 28 22 21 Bytes (20 + -pFlag)

s/[a-z]/$&.$&^$"/ige
— Oleg V. Volkov
quelle
Ich stelle mir vor, Sie können ein Byte speichern, indem Sie $"anstelle von verwenden ' ', aber ich habe nicht getestet.
— msh210
@ msh210, schön! Wie kann ich vergessen, perlvar auf Standardzeichenfolgen zu überprüfen? Vielen Dank!
— Oleg V. Volkov
3

Stax , 7 6 Bytes

Danke an @recursive für ein gespeichertes Byte!

┤§ÆP♦■

Führen Sie es aus und debuggen Sie es unter staxlang.xyz! (Link ist zur entpackten Version)

Entpackt (7 Bytes):

c:~\{um

Erläuterung:

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
quelle
Vielen Dank, dass Sie stax ausprobiert haben. Eine einfache Verbesserung, die Sie vornehmen können, ist die Verwendung uvon :g. Es werden alle eindeutigen Elemente in einem Array abgerufen, genau das, was Sie in diesem Fall möchten. Davon abgesehen sieht das gut aus.
— rekursiven
@recursive Danke! Habe das vergessen: / Wird bald bearbeitet.
— Khuldraeseth na'Barya
Funktioniert nicht für 123. Möglicherweise müssen Sie das Format für alle Eingaben ändern (dh sie zitieren). Die Verbindung ist ebenfalls unterbrochen. Sie ersetzen müssen m=11mit m=2. Auf staxlang.xyz gibt es einen PPCG-Post-Generierungsbutton, den Sie möglicherweise verwenden möchten.
— Weijun Zhou
@ WeijunZhou Danke, behoben!
— Khuldraeseth na'Barya
2

Python, 59 Bytes

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

Bearbeitet, um wiederholte nicht-alphabetische Zeichen zu korrigieren

— Atlasologe
quelle
2

PHP 4.1, 57 Bytes

Dieser Code setzt den Zugriff über einen Webserver (z. B. Apache) mit der Standardkonfiguration voraus.

Sie können die Zeichenfolge übergeben , indem Sie die Taste Senden Smit irgendwelchen Mitteln ( POST, GET, COOKIE, SESSION...).

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

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

Verwendung:

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

CL-USER 2 > (f "bad")
"bBaAdD"
— sadfaf
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.