Ihre Eingabe wird ein englischer Satz, eine Phrase oder ein Wort sein. Es wird nur enthalten a-zA-Z' -,.!?. Ihre Aufgabe ist es, die Eingabe zu übernehmen, Leerzeichen zu entfernen und dann die Großschreibung neu zu verteilen, sodass Buchstaben in Indizes, die zuvor großgeschrieben wurden (und nur Buchstaben in Indizes, die zuvor großgeschrieben wurden), großgeschrieben werden.

Wenn die Eingabe beispielsweise lautet A Quick Brown Fox Jumped Over The Lazy Dog, lauten die (0-basierten) Indizes der Großbuchstaben 0, 2, 8, 14, 18, 25, 30, 34, 39. Dann entfernen Sie Leerzeichen aus dem Eingang: AQuickBrownFoxJumpedOverTheLazyDog. Als nächstes schreiben Sie alle Buchstaben in Kleinbuchstaben, aber in Großbuchstaben bei 0, 2, 8, 14, 18, 25, 30, 34, 39:, AqUickbrOwnfoxJumpEdovertHelazYdogwas Ihre Ausgabe ist.

Eingang

Ihre Eingabe wird ein englischer Satz, eine Phrase oder ein Wort sein. Es darf nur Kleinbuchstaben, Großbuchstaben, Bindestriche, Apostrophe, Kommas, Punkte, Fragezeichen, Ausrufezeichen und Leerzeichen enthalten.

Ausgabe

Die Eingabe mit entfernten Leerzeichen, Kleinbuchstaben-d, mit Buchstaben am Index der Großbuchstaben in Großbuchstaben-d.

HINWEIS: Ihr Programm kann nicht mit einem IndexOutOfRange-Fehler oder einem ähnlichen Fehler abstürzen (Fehler, bei dem die Ausführung abgebrochen wird).

Testfälle

Hi! Test!
Hi!tEst!

A Quick Brown Fox Jumped Over The Lazy Dog
AqUickbrOwnfoxJumpEdovertHelazYdog

testing TESTing TeStING testing testing TESTING
testingtESTIngteStInGTEstingtestingtestiNG

TESTING... ... ... success! EUREKA???!!! maybe, don't, NOOOOO
TESTING.........success!eureKA???!!!maybe,don't,nooooo

Enter        PASSWORD ---------
Enterpassword---------

A a B b C c D d E e F f G g H h I i J j K k L l M m N n O o P p Q q R r S s T t U u V v W w X x Z z
AabbCcddEeffGghhIijjKkllMmnnOoppQqrrSsttUuvvWwxxZz

  TEST
teST

Jelly , 14 13 Bytes

nŒlTɓḲFŒlŒuṛ¦

Probieren Sie es online!

Wie es funktioniert

nŒlTɓḲFŒlŒuṛ¦  Main link. Argument: s (string)

 Œl            Convert s to lowercase.
n              Perform character-wise "not equal" comparison.
   T           Get the indices of all truthy elements, i.e., the indices of all
               uppercase letters in s. Let's call the resulting array J.
    ɓ          Begin a dyadic chain with left argument s and right argument J.
     ḲF        Split s at spaces and flatten, removing the spaces.
       Œl      Convert s to lowercase.
            ¦  Sparse application:
         Œu        Convert s to uppercase.
           ṛ       Take the resulting items of the uppercased string at all indices
                   in J, the items of the lowercased string at all others.

C (gcc) , 82 79 74 72 69 67 66 Bytes

f(c){for(char*s=c,*p=c;c=*s++;c&&putchar(c^(*p++|~c/2)&32))c&=95;}

Probieren Sie es online!

Python 2 , 114 Bytes

x=input()
X=x.replace(' ','')
print''.join([X[i].upper()if x[i].isupper()else X[i].lower()for i in range(len(X))])

Probieren Sie es online!

Äquivalent:

Python 2 , 114 Bytes

lambda x:''.join([[str.lower,str.upper][x[i].isupper()](x.replace(' ','')[i])for i in range(len(x)-x.count(' '))])

Probieren Sie es online!

Python 3 , 78 75 72 Bytes

s=input()
for c in s:s=s[c>' '!=print(end=(c+c).title()[s<'@'or'['<s]):]

Vielen Dank an @xnor für das Golfen mit 6 Bytes!

Probieren Sie es online!

05AB1E , 15 14 Bytes

-1 Byte danke an Emigna

ðKuvy¹Nè.lil}?

Probieren Sie es online!

ðK             # Remove spaces
  u            # Convert to uppercase
   vy          # For each character...
     ¹Nè       #   Get the character at the same index from the original input
        .lil}  #   If it was a lowercase letter change this one to lowercase
             ? # Print without a newline

Haskell , 98 95 89 88 81 Bytes

Vielen Dank an @name, @nimi, @Zgarb und @Laikoni, die geholfen haben, insgesamt 14 Byte zu sparen

import Data.Char
\s->zipWith(\p->last$toLower:[toUpper|isUpper p])s$filter(>' ')s

Ungolfed:

import Data.Char
\sentence -> zipWith (\oldChar newChar ->
                        if isUpper oldChar
                        then toUpper newChar
                        else toLower newChar)
                     sentence
                     (filter (/= ' ') sentence)

V , 24 Bytes

ÄVuÓó
ejlDò/¥2lõ
vuk~òGd

Probieren Sie es online!

Diese Art von Herausforderungen ist genau das, wofür V gemacht wurde. :)

Erläuterung:

Ä           " Duplicate this line
 Vu         " Convert it to lowercase
   Óó       " Remove all spaces
e           " Move to the end of this line
 j          " Move down a line (to the original)
  l         " Move one char to the right
   D        " And delete the end of this line
    ò       " Recursively:
     /      "   Search for:
         õ  "     An uppercase character
      ¥2l   "     On line 2
            "     (This will break the loop when there are no uppercase characters left)
vu          "   Convert it to lowercase
  k         "   Move up a line
   ~        "   Convert this to uppercase also
    ò       " Endwhile
     G      " Move to the last line
      d     " And delete it

Python 2, 100 Bytes

s=input()
print"".join([c.lower(),c.upper()][s[i].isupper()]for i,c in enumerate(s.replace(" ","")))

Alice , 32 Bytes

/..- ~l+u~mSloy
\ia''-y.'Qa.+a@/

Probieren Sie es online!

Erläuterung

Dies ist eine Standardvorlage für Programme, die vollständig im Ordinalmodus arbeiten. Ausgepackt sieht das Programm wie folgt aus:

i.' -l.uQm.lay.a-'~y+'~aS+o@

i       take input as string
.       duplicate
' -     remove spaces from copy
l.u     create all-lowercase and all-uppercase versions
Q       reverse stack, so original string is on top
m       truncate original string to length of spaces-removed string
.lay    convert everything except uppercase characters to \n
.a-'~y  convert everything except \n (i.e., convert uppercase characters) to ~
+       superimpose with lowercase string
        \n becomes the corresponding lowercase character, and ~ remains as is
'~aS    convert ~ to \n
+       superimpose with uppercase string
        lowercase in existing string stays as is because it has a higher code point
        \n becomes corresponding uppercase character
o       output
@       terminate

JavaScript (ES6), 94 91 85 Byte

s=>s.replace(/./g,c=>c==" "?"":c[`to${"@"<s[x]&s[x++]<"["?"Upp":"Low"}erCase`](),x=0)

• 6 Bytes mit Unterstützung von ETHproductions & Arnauld gespeichert.

Versuch es

o.innerText=(f=

s=>s.replace(/./g,c=>c==" "?"":c[`to${"@"<s[x]&s[x++]<"["?"Upp":"Low"}erCase`](),x=0)

)(i.value="Hi! Test!");oninput=_=>o.innerText=f(i.value)

<input id=i><pre id=o>

Retina , 77 71 Bytes

.+
$&¶$&
T`L `l_`.+$
+`((.)*)[A-Z].*(¶(?<-2>.)*)
$1$3 
.+¶

T`l `L_` .?

Probieren Sie es online! Link enthält Testsuite. Erläuterung: In der ersten Stufe wird die Zeile dupliziert, während in der zweiten Stufe das Duplikat unterstrichen und die Leerzeichen gelöscht werden. Die dritte Stufe durchläuft dann jeden Großbuchstaben von rechts nach links und versucht, in der zweiten Zeile ein Leerzeichen vor dem entsprechenden Zeichen einzufügen. Die erste Zeile wird gelöscht und die Leerzeichen werden verwendet, um die relevanten Zeichen des Ergebnisses in Großbuchstaben zu schreiben. Bearbeiten: 6 Bytes dank @Kobi gespeichert.

Perl, 95 94 + 1 = 95 Bytes

+1 Byte Strafe für -n

Speichern Sie ein Byte, indem Sie von s/\s//gbis ersetzens/ //g

$s=$_;s/ //g;$_=lc($_);while(/(.)/gs){$p=$&;$p=uc($p)if(substr($s,$-[0],1)=~/[A-Z]/);print$p;}

Probieren Sie es online!

Erläuterung:

1. Erstellen Sie eine Kopie der Eingabezeichenfolge.

2. Entfernen Sie alle Leerzeichen und wandeln Sie die Zeichenfolge in Kleinbuchstaben um.

3. Beginnen Sie dann mit der Schleife über jeden Buchstaben. Testen Sie den Buchstaben in Großbuchstaben an derselben Position in der gespeicherten Zeichenfolge. Wenn es oben ist, wird der aktuelle Buchstabe mit einem Großbuchstaben versehen. Brief drucken.

Beachten Sie, dass Perl mit der Befehlszeilenoption "-n" ausgeführt werden muss

MATL , 18 Bytes

kXz"@GX@)tk<?Xk]&h

Gleicher Ansatz wie die 05AB1E-Antwort von Riley .

Probieren Sie es online!

Python 3 , 117 Bytes

s=input()
y=list(s.replace(' ','').lower())
i=0
for c in y:
 if s[i].isupper():y[i]=c.upper()
 i+=1
print(''.join(y))

Probieren Sie es online!

Dies ist so ziemlich mein erster Code Golf, also ist es wahrscheinlich schlecht, abzüglich der Hilfe aus den Kommentaren unten!

PS Ja, es ist dumm, dass das Definieren und Inkrementieren iBytes über den Bereich (len (y)) spart. Naja.

C # (.NET Core) , 108 101 Bytes

using System.Linq;s=>s.Replace(" ","").Select((c,i)=>s[i]>64&s[i]<91?char.ToUpper(c):char.ToLower(c))

Probieren Sie es online!

• 7 Bytes gespart, nachdem festgestellt wurde, dass die charKlasse statisch ToUpper()und ToLower()methodisch ist.

Holzkohle , 33 Bytes

Ａ⁰χＦＬθ¿⁼§θι Ａ⁺¹χχ¿№α§θ⁻ιχ↥§θι↧§θι

Probieren Sie es online!

Da ich immer noch nicht weiß, wie man eine Zeichenfolge mit Leerzeichen als einzelnen Eingabeparameter in den Charcoal-Code übergibt, weise ich im Header der Charcoal-Variablen die Testzeichenfolge zu, die die erste Eingabe darstellt ( θ):

ＡA Quick Brown Fox Jumped Over The Lazy Dogθ

Der Code hat also die gleiche Anzahl von Bytes, als ob die Zeichenfolge als erste Eingabe übergeben worden wäre.

Sie können hier die ausführliche Version des Codes sehen.

PHP, 181 Bytes

Ich versuche die kleinere Anzahl von Bytes zu bekommen, dies ist mein Code:

<?php
$s=readline();
preg_match_all('/[A-Z]/',$s,$m,PREG_OFFSET_CAPTURE);
$s=strtolower(str_replace(' ','',$s));
while($d=each($m[0]))$s[$d[1][1]]=strtoupper($s[$d[1][1]]);
echo $s;

Probieren Sie es online!

Java 8, 184 177 161 Bytes

s->{String r="";for(int i=0,j=i,t,u;i<s.length;){t=s[i++];if(t>32){u=s[j++];r+=(char)(t<65|t>90&t<97|t>122?t:u>64&u<91?t&~32:u>96&u<123|u<33?t|32:t);}}return r;}

Kann definitiv noch mehr golfen werden.
- 16 Bytes dank @ OlivierGrégoire, indem die Eingabe als char[]statt genommen wird String.

Erläuterung:

Probieren Sie es hier aus.

s->{                           // Method with char-array parameter and String return-type
  String r="";                 //  Result-String
  for(int i=0,j=i,t,u;         //  Some temp integers and indices
      i<s.length;){            //  Loop over the String
    t=s[i++];                  //   Take the next character and save it in `t` (as integer)
                               //   and raise index `i` by 1
    if(t>32){                  //   If `t` is not a space:
     u=s[j++];                 //   Take `u` and raise index `j` by 1
     r+=                       //   Append the result-String with:
      (char)                   //    Integer to char conversion of:
       (t<65|t>90&t<97|t>122?  //     If `t` is not a letter:
        t                      //      Simply use `t` as is
       :u>64&u<91?             //     Else if `u` is uppercase:
        t&~32                  //      Take `t` as uppercase
       :u>96&u<123|u<33?       //     Else if `u` is lowercase or a space:
        t|32                   //      Take `t` as lowercase
       :                       //     Else:
        t);                    //      Take `t` as is
    }
  }                            //  End of loop
  return r;                    //  Return result-String
}                              // End of method

Common Lisp, 104 Bytes

(defun f(s)(map'string(lambda(x y)(if(upper-case-p x)(char-upcase y)(char-downcase y)))s(remove #\  s)))

Probieren Sie es online!

Ungewöhnlich kurz für das wortreiche Common Lisp!

Einfacher Code:

(defun f (s)                     ; receive the string as parameter
  (map 'string                   ; map the following function of two arguments
       (lambda (x y)             ; x from the original string, y from the string with removed spaces
         (if (upper-case-p x)    ; if x is uppercase
             (char-upcase y)     ; get y uppercase
             (char-downcase y))) ; else get y lowercase
       s
       (remove #\  s)))

Java (OpenJDK 8) , 150 117 113 97 Bytes

s->{for(int i=0,j=0,c;i<s.length;)if((c=s[i++]&95)>0)System.out.printf("%c",c^(s[j++]|~c/2)&32);}

Probieren Sie es online!

Beim Golfspielen bin ich auf 102 Bytes gekommen:

s->{for(int i=0,j=0,c;i<s.length;)if((c=s[i++]&95)>0)System.out.printf("%c",c<64?c|32:c|s[j]&32,j++);}

Probieren Sie es online!

Aber ich erinnerte mich, dass dies allmählich so aussah, als würde Dennis 'C antworten, und so portierte ich einfach sein bisschen herumwirbeln und ... Magie geschah. Der große Vorteil des Hafens besteht darin, dass die Zweige und die darin enthaltenen Wiederholungen entfernt werden.

Google Sheets, 213 Bytes

=ArrayFormula(JOIN("",IF(REGEXMATCH(MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1),"[A-Z]"),MID(UPPER(SUBSTITUTE(A1," ","")),ROW(OFFSET(A1,0,0,LEN(A1))),1),MID(LOWER(SUBSTITUTE(A1," ","")),ROW(OFFSET(A1,0,0,LEN(A1))),1))))

Die Eingabe erfolgt in Zelle A1und die Formel gliedert sich wie folgt:

• ArrayFormula()Lassen Sie uns jeden Begriff ROW()unabhängig bewerten
• JOIN() Verkettet alle diese unabhängigen Ergebnisse zu einer einzigen Zeichenfolge
• IF(REGEXMATCH(),UPPER(),LOWER() Dies bewirkt, dass abwechselnd Groß- und Kleinbuchstaben verwendet werden, je nachdem, an welcher Position in der Eingabe die Groß- und Kleinschreibung vorlag
• ROW(OFFSET())ein Array von Werten zurückgibt , 1um A1.lengthdie in dem eingespeist wird MID()Funktion , so dass wir jedes Zeichen wiederum auswerten können ,

Ergebnisse von Testfällen: (Es ist einfacher zu lesen, wenn Sie auf die größere Version klicken.)

Ruby , 80 Bytes

->a{n=a.downcase.delete' '
n.size.times{|i|(?A..?Z)===a[i]&&n[i]=n[i].upcase}
n}

Probieren Sie es online!

Perl, 92 Bytes

$p[$i++]=$-[0]while s/[A-Z]/lc($&)/e;s/\s//g;for$c(@p){substr($_,$c,1)=~tr[a-z][A-Z]};print;

Erläuterung:

$p[$i++]=$-[0]while s/[A-Z]/lc($&)/e;   #get locations of caps into an array at the same time converting letters to lowercase

s/\s//g;   #delete all spaces

for$c(@p){substr($_,$c,1)=~tr[a-z][A-Z]};   #convert lowercase letters to uppercase where uppercase letters were present

print;   # print (of course) :)

C 103 Bytes

i,j,c;f(char*s){for(i=j=0;c=tolower(s[j++]);)c-32&&putchar(c-32*(s[i]>64&&s[i]<91&&c>96&&c<123))&&++i;}

Probieren Sie es online!

Python 3 , 125 , 124 Bytes

lambda s:''.join(c.upper()if i in(s.find(q)for q in s if q.isupper())else c for i,c in enumerate(s.replace(' ','').lower()))

Probieren Sie es online!

Python 2, 106 105 Bytes

s=input()
print''.join(map(lambda(c,u):[c.lower,c.upper][u](),zip(s.replace(' ',''),map(str.isupper,s))))

Bearbeiten: Speichern Sie ein Byte über print ''.join=> print''.join.

Lambda-Form, 99 Bytes

lambda s:''.join(map(lambda(c,u):[c.lower,c.upper][u](),zip(s.replace(' ',''),map(str.isupper,s))))

SCALA, 128 Zeichen, 128 Byte

var l=s.toLowerCase().filter(x=>x!=32)
for(i<-0 to l.size-1){if(s(i).isUpper)l=l.substring(0,i)+l(i).toUpper+l.substring(i+1)}
l

Danke für diese Herausforderung. Probieren Sie es online!

q / kdb + 49 Bytes

Lösung:

{@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}

Beispiele:

q){@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}"Hi! Test!"
"Hi!tEst!"

q){@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}"A Quick Brown Fox Jumped Over The Lazy Dog"
"AqUickbrOwnfoxJumpEdovertHelazYdog"

q){@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}"testing TESTing TeStING testing testing TESTING"
"testingtESTIngteStInGTEstingtestingtestiNG"

q){@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}"TESTING... ... ... success! EUREKA???!!! maybe, don't, NOOOOO"
"TESTING.........success!eureKA???!!!maybe,don't,nooooo"

q){@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}"Enter        PASSWORD ---------"
"Enterpassword---------"

q){@[a;(&)(#:[a:lower x except" "]#x)in .Q.A;upper]}"A a B b C c D d E e F f G g H h I i J j K k L l M m N n O o P p Q q R r S s T t U u V v W w X x Z z"
"AabbCcddEeffGghhIijjKkllMmnnOoppQqrrSsttUuvvWwxxZz"

q){@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}"  TEST"
"teST"

Erläuterung:

Suchen Sie nach Indizes, bei denen die Eingabe in Großbuchstaben erfolgt, und wenden Sie die Funktion upperauf diese Indizes in einer Version der Eingabezeichenfolge an, bei der keine Leerzeichen verwendet werden. Beachten Sie, dass wir die Funktion nicht über die Länge der Zeichenfolge hinaus anwenden können. Verwenden Sie daher take ( #), um die Eingabezeichenfolge auf die Länge der durch Leerzeichen entfernten Version in Kleinbuchstaben zu kürzen.

{@[a;where count[a:lower x except " "]#x in .Q.A;upper]} / ungolfed
{                                                      } / lambda function
 @[ ;                                           ;     ]  / apply FUNC to VAR at INDICES: @[VAR;INDICES;FUNC]
                                                 upper   / uppercase, upper["abc"] -> "ABC"
                                       x in .Q.A         / boolean list where input is in uppercase alphabet ABC..XYZ
                                      #                  / take this many elements from list on the right (ie truncate)
           count[                    ]                   / returns length of the stuff inside the brackets, count["ABC"] -> 3                                        
                         x except " "                    / remove " " from string
                   lower                                 / lowercase, lower["ABC"] -> "abc"
                 a:                                      / save in variable a
     where                                               / returns indices where true where[101b] -> 0 2
   a                                                     / our lowercased, space-stripped input

Bonus:

Nachdem ich die Antworten gelesen hatte, dachte ich, ich würde eine Lösung ausprobieren, bei der ich über die Eingabe iteriere. Bisher habe ich nur eine 53-Byte-Lösung verwaltet:

{a{$[y in .Q.A;upper x;x]}'#:[a:lower x except" "]#x}

Swift 3.0, 199 Bytes

var s="AS Ff",i=[String](),p=[Int](),j=0;for c in s.characters{if c>="A"&&c<="Z"{p.append(j)};if c != " "{i.append(String(c).lowercased())};j=j+1};for c in p{i[c]=i[c].uppercased()};print(i.joined())

Probieren Sie es online!

Perl 5 , 40 Bytes

37 Byte Code + -FFlag. (Beachten Sie, dass Sie in alten Versionen von Perl möglicherweise -anFlags hinzufügen müssen. )

print$F[$i++]=~/[A-Z]/?uc:lc for/\S/g

Probieren Sie es online!

Erläuterungen:
Dank -F, @Feine Liste mit allen Zeichen des Eingangs enthält.
for/\S/gDurchläuft jedes Nicht-Leerzeichen der Eingabe. Wir verwenden, um $izu zählen, bei welcher Iteration wir uns befinden. Wenn $F[$i++]es sich um ein Großbuchstaben ( /[A-Z]/) handelt, drucken wir den aktuellen Großbuchstaben ( uc), andernfalls den Kleinbuchstaben ( lc). Beachten Sie dies ucund lcgeben Sie das Argument unverändert zurück, wenn es sich nicht um einen Buchstaben handelt.

Vorherige Version (weniger Golf: 47 Bytes):

 s/ //g;s%.%$_=$&;$F[$i++]=~/[A-Z]/?uc:lc%ge

Probieren Sie es online!