Bugünün meydan okuması için, bir dizenin durumunu değiştiren bir program veya işlev yazmalısınız. Ancak, alfabetik olmayan karakterleri yoksaymalısınız. Bu, her alfabetik karakterin, önceki ve sonraki alfabetik karakterden farklı bir duruma sahip olması gerektiği anlamına gelir . Bu, örneğin diğer tüm harflerin üst harflerinden biraz daha karmaşıktır. Gibi bir dize alırsanız

hello world

ve diğer karakterleri büyük harfe dönüştürerek şunları elde edersiniz:

hElLo wOrLd

Gördüğünüz gibi, küçük harf küçük harf oizler w. Bu geçersiz. Bunun yerine, bize bu sonucu vererek alanı boşvermelisiniz:

hElLo WoRlD

Alfabetik olmayan tüm karakterler aynı bırakılmalıdır. Çıktı, sürekli olarak değiştiği sürece büyük veya küçük harfle başlayabilir. Bu, aşağıdakilerin de kabul edilebilir bir çıktı olacağı anlamına gelir:

HeLlO wOrLd

Programınız giriş durumuna bakılmaksızın çalışmalıdır.

Giriş dizesi yalnızca yazdırılabilir ASCII içerecektir , dolayısıyla yazdırılamayan karakterler, yeni satırlar veya unicode hakkında endişelenmenize gerek yoktur. Gönderiniz tam bir program veya bir işlev olabilir ve giriş ve çıkışları herhangi bir makul formatta alabilirsiniz. Örneğin, fonksiyon argümanları / return değeri, STDIN / STDOUT, bir dosyayı okuma / yazma vb.

Örnekler:

ASCII                                   ->  AsCiI
42                                      ->  42
#include <iostream>                     ->  #InClUdE <iOsTrEaM>
LEAVE_my_symbols#!#&^%_ALONE!!!         ->  lEaVe_My_SyMbOlS#!#&^%_aLoNe!!!
PPCG Rocks!!! For realz.                ->  PpCg RoCkS!!! fOr ReAlZ.
This example will start with lowercase  ->  tHiS eXaMpLe WiLl StArT wItH lOwErCaSe
This example will start with uppercase  ->  ThIs ExAmPlE wIlL sTaRt WiTh UpPeRcAsE
A1B2                                    ->  A1b2

Bu kod golf olduğundan , standart boşluklar uygulanır ve bayt cinsinden en kısa cevap kazanır!

JavaScript (ES6), 66 63 bayt

Büyük harfle başlar.

s=>s.replace(/[a-z]/gi,c=>c[`to${(s=!s)?'Low':'Upp'}erCase`]())

Test durumları

let f =

s=>s.replace(/[a-z]/gi,c=>c[`to${(s=!s)?'Low':'Upp'}erCase`]())

console.log(f("ASCII"))
console.log(f("42"))
console.log(f("#include <iostream>"))
console.log(f("LEAVE_my_symbols#!#&^%_ALONE!!!"))
console.log(f("PPCG Rocks!!! For realz."))
console.log(f("This example will start with lowercase"))
console.log(f("This example will start with uppercase"))
console.log(f("A1B2"))

05AB1E , 11 8 bayt

Kod:

lvyJ¤aiš

05AB1E kodlamasını kullanır . Çevrimiçi deneyin!

Açıklama:

l           # Lowercase the input
 vy         # For each element..
   J        #   Join the entire stack into a single string
    ¤a      #   Check if the last character is alphabetic
      iš    #   If true, swapcase the entire string

GNU Sed, 33

• @TobySpeight sayesinde 5 bayt kaydedildi

Puan -rbayrak sed to için +1 içerir .

s/([a-z])([^a-z]*.?)/\U\1\L\2/gi

Çevrimiçi deneyin .

Jöle , 13 bayt

nŒsTm2
ŒlŒuǦ

Çevrimiçi deneyin!

Nasıl çalışır

ŒlŒsǦ  Main link. Argument: s (string)

Œl      Cast to lowercase.
    Ǧ  At indices returned by the helper link...
  Œu        apply uppercase.


nŒsTm2      Helper link. Argument: s (string)

 Œs         Apply swapcase to s.
n           Perform vectorizing not-equal comparison.
   T        Compute the truthy indices.
    m2      Select every other one, starting with the first.

Japt , 16 14 bayt

r"%l"_m"uv"gT°

Çevrimiçi deneyin!

açıklama

r              // RegEx replace input
 "%l"          // [A-Za-z] as first arg to replace
     _         // created function Z=>Z as second arg to replace
       "uv"gT° // alternates "u" & "v"
      m        // map Z to either "u" upper or "v" lower

Python 3 , 86 76 68 66 63 bayt

^{DJMcMayhem sayesinde -2 bayt Cyoce
sayesinde -3 bayt}

x=0
for i in input():print(end=(2*i).title()[x]);x^=i.isalpha()

Çevrimiçi deneyin! veya Tüm test durumlarını deneyin

Alice , 18 bayt

/olZlYuN
@iy.u..//

Çevrimiçi deneyin!

açıklama

Bu program, tamamen sıralı modda çalışan tek uzunluktaki programlar için daha az bilinen bir şablon izler. Bu kodun doğrusallaştırılmış sürümü:

il.l.uN.YuZyo@

Kod açıklaması:

i - push input onto stack            ["Hello world!"]
l - convert to lowercase             ["hello world!"]
. - duplicate                        ["hello world!", "hello world!"]
l - convert to lowercase (should be no-op, but avoids what seems to be a bug in the TIO implementation)
. - duplicate again                  ["hello world!", "hello world!", "hello world!"]
u - convert to uppercase             ["hello world!", "hello world!", "HELLO WORLD!"]
N - difference between sets          ["hello world!", "helloworld"]
. - duplicate reduced string         ["hello world!", "helloworld", "helloworld"]
Y - unzip (extract even positions)   ["hello world!", "helloworld", "hlool", "elwrd"]
u - convert to uppercase             ["hello world!", "helloworld", "hlool", "ELWRD"]
Z - zip evens back into string       ["hello world!", "helloworld", "hElLoWoRlD"]
y - perform substitution             ["hElLo WoRlD!"]
o - output                           []
@ - terminate

Kullanmadan lkopya üzerinde, yığın sonra Nolurdu ["helloworld", "helloworld"]. Bunun bir hata olduğundan şüpheleniyorum.

C (tcc) , 60 57 56 bayt

DigitalTrauma sayesinde bit 5'in farkına vararak ASCII büyük / küçük harf için tek fark.

Üç bayt daha golf oynamak için zch özel teşekkürler.

RJHunter fikrinden bir bayt daha saklayın

l;f(char*s){for(;*s=isalpha(*s)?*s&95|++l%2<<5:*s;s++);}

Çevrimiçi deneyin!

Java 8, 99 bayt

a->{String r="";int i=0;for(int c:a)r+=(char)(c>64&c<91|c>96&c<123?i++%2<1?c|32:c&~32:c);return r;}

Açıklama:

Burada dene.

a->{                          // Lambda with char-array parameter and String return-type
  String r="";                //  Result-String
  int i=0;                    //  Flag for alteration
  for(int c:a)                //  Loop over the characters of the input
    r+=(char)                 //   And append the result-String with the following (converted to char):
      (c>64&c<91|c>96&c<123?  //    If it's a letter:
       i++%2<1?               //     And the flag states it should be lowercase:
        (c|32)                //      Convert it to lowercase
       :                      //     Else (should be uppercase):
        (c&~32)               //      Convert it to uppercase
      :                       //    Else:
       c);                    //     Simply append the non-letter character as is
                              //  End of loop (implicit / single-line body)
  return r;                   //  Return result-String
}                             // End of method

Ruby, 57 55 47 41 bayt

Bayt sayısı, komut satırı seçenekleri için iki bayt içerir.
Örneğin şöyle çalıştırın:$ ruby -p0 alternate_case.rb <<< "some input"

gsub(/\p{L}/){($&.ord&95|32*$.^=1).chr}

Bu p0seçenekle, girişin tamamı tek seferde tüketilir ve büyülü global $.1'e yükseltilir. Bu daha sonra 0 ile 1 arasında değişir ve durumu korumak için kullanılır.

Çok satırlı giriş ile çalışır; Çevrimiçi deneyin!

Harika girdiler için Ventero'ya teşekkürler - ayrıntılar için yorumları kontrol edin.

Brachylog , 25 bayt

{ḷ|ụ}ᵐ.{ḷ∈Ạ&}ˢ¬{s₂{∈Ạ}ᵐ}∧

Çevrimiçi deneyin!

Bu hem uzun hem de yavaş.

açıklama

{   }ᵐ.                       The Output is the result of mapping on each char of the Input:
 ḷ                              Lowecase the char
  |                             Or
   ụ                            Uppercase the char
       {    }ˢ                In the Ouput, select the chars that:
        ḷ∈Ạ&                    when lowercased are in "abc...xyz" (ie are letters)
              ¬{       }∧     In that new string, it is impossible to find:
                s₂              a substring of 2 consecutive chars
                  {∈Ạ}ᵐ         where both of them are in the lowercase alphabet

Matl , 16 15 bayt

Xktkyy-f2L))5M(

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

açıklama

'Merhaba dünya' girişini düşünün

Xk    % To upper case
      % STACK: 'HELLO WORLD'
t     % Duplicate top element
      % STACK: 'HELLO WORLD', 'HELLO WORLD'
k     % To lower case
      % STACK: 'HELLO WORLD', 'hello word'
yy    % Duplicate top two elements
      % STACK: 'HELLO WORLD', 'hello word', 'HELLO WORLD', 'hello word'
-     % Difference (of code points; element-wise)
      % STACK: 'HELLO WORLD', 'hello word', [-32 -32 -32 -32 -32 0 -32 -32 -32 -32 -32]
f     % Indices of nonzeros
      % STACK: 'HELLO WORLD', 'hello word', [1 2 3 4 5 7 8 9 10 11]
2L)   % Keep only even-indexed values (*)
      % STACK: 'HELLO WORLD', 'hello word', [2 4 7 9 11]
)     % Reference indexing (get values at indices)
      % STACK: 'HELLO WORLD', 'elwrd'
5M    % Push (*) again
      % STACK: 'HELLO WORLD', 'elwrd', [2 4 7 9 11]
(     % Assignment indexing (write values at indices). Implicit display
      % STACK: 'HeLlO wOrLd

'

Perl 6 ,  32  30 bayt

{S:g/<:L><-:L>*<:L>?/$/.tclc()/}

Dene

{S:g{<:L><-:L>*<:L>?}=$/.tclc}

Dene

Expanded:

{  # bare block lambda with implicit parameter ｢$_｣

  S            # string replace (not in-place) implicitly against ｢$_｣

  :global

  {

    <+ :L >    # a letter
    <- :L >*   # any number of non-letters
    <+ :L >?   # an optional letter

  }

  =

  $/.tclc()    # uppercase the first letter, lowercase everything else
}

q / kdb +, 51 42 38 bayt

Çözüm:

{@[x;;upper]1#'2 cut(&)x in .Q.a}lower

Örnek:

q){@[x;;upper]1#'2 cut(&)x in .Q.a}lower"hello world"
"HeLlO wOrLd"

Notlar:

.Q.a        // abcde...xyz lowercase alphabet
(&) x in    // where, returns indices for where x (hello world) is an alpha
2 cut       // splits list into 2-item lists
1#'         // takes first item of each 2-item list; ie the indices to uppercase
@[x;;upper] // apply (@) upper to x at these indices

V , 17 , 13 bayt

VUÍშáü$©/ì&

Çevrimiçi deneyin!

Veya Tüm test durumlarını doğrulayın!

HexDump:

00000000: 5655 cde1 83a8 e1fc 24a9 2fec 26         VU......$./.&

Açıklama:

Bu sıkıştırılmış bir regex ™ ️ kullanır , bu yüzden açıklamadan önce regex'i genişletelim:

:%s/\v\a.{-}(\a|$)/\l&

Her VUşeyi büyük harfe dönüştürür. O zaman şunu çalıştırırız:

:%                      " On every line:
  s/\v                  "   Substitute:
      \a                "     A letter
        .{-}            "     Followed by as few characters as possible
            (\a|$)      "     Followed by either another letter or an EOL
                  /     "   With:
                   \l   "     The next character is lowercased
                     &  "     The whole text we matched

Eski / daha ilginç bir cevap:

:se nows
Vuò~h2/á

PHP, 71 Bayt

for(;a&$c=$argn[$i++];)echo ctype_alpha($c)?(ul[$k++&1].cfirst)($c):$c;

Çevrimiçi deneyin!

CJam , 26 24 bayt

qeu{_'[,65>&,T^:T{el}&}%

Çevrimiçi deneyin!

açıklama

q         e# Read all input.
eu        e# Uppercase it.
{         e# For each character:
 _        e#  Duplicate it.
 '[,65>&  e#  Set intersection with the uppercase alphabet.
 ,        e#  Length (either 0 or 1 in this case).
 T^:T     e#  XOR with T (T is initially 0), then store the result back in T.
 {el}&    e#  If The result of the XOR is true, lowercase the character.
}%        e# (end for)

Pyth, 11 bayt

srR~xZ}dGrZ

Burada dene

açıklama

              # Z = 0; Q = eval(input())
srR~xZ}dGrZQ  # Auto-fill variables
         rZQ  # lowercase the input
 rR           # Apply the r function to each letter of the input with
   ~xZ}dG     # ... this as the other argument
   ~          # use the old value of the variable Z, then update it with the value of ...
    xZ        # Z xor ...
      }dG     # the variable d is a lowercase letter
              # because of how mapping works in pyth, d will contain the current letter
              # This causes Z to flip between 0 and 1, alternately upper and lower casing
              # the current character if it is a letter

PowerShell, 86 bayt

-join($args[0]|%{if($_-match"[a-z]"-and($i=!$i)){"$_".toupper()}else{"$_".tolower()}})

Giriş bir [char[]]dizidir.

Açıklama kodunda yorumlar

# Join the array of string and char back together.
-join
    # Take the first argument and pass each element ([char]) down the pipe. 
    ($args[0]|%{
        # Check if this is a letter. Second condition is a boolean that changes at every pass 
        # but only if the current element is a letter. If not the condition never fires
        if($_-match"[a-z]"-and($i=!$i)){
            # Change the character to uppercase
            "$_".toupper()
        }else{
            # Output the character to lowercase. 
            # Special characters are not affected by this method
            "$_".tolower()
        }
    })

Haskell, 105 83 + 2 4 + 1 bayt ayırıcı = 108 86 88 Bayt

import Data.Char
f#(x:y)|isLetter x=([toUpper,toLower]!!f)x:(1-f)#y|1>0=x:f#y
_#l=l

İşlev, (1#)küçük harf başlar. Çevrimiçi deneyin!

Üzücü olan şey bunun Java ve C # cevaplarından daha uzun olmasıdır. Üç satırı bir araya getirerek 22 byte tasarruf sağlayan Ørjan Johansen sayesinde!

Google Sayfaları, 264 bayt

=ArrayFormula(JOIN("",IF(REGEXMATCH(MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1),"[A-Za-z]"),CHAR(CODE(UPPER(MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1)))+MOD(LEN(REGEXREPLACE(LEFT(A1,ROW(OFFSET(A1,0,0,LEN(A1)))),"[^A-Za-z]","")),2)*32),MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1))))

Büyük bir karmaşa ama genişletmek biraz daha kolay:

=ArrayFormula(
  JOIN(
    "",
    IF(REGEXMATCH(MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1),"[A-Za-z]"),
      CHAR(
        CODE(UPPER(MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1)))
        +
        MOD(LEN(REGEXREPLACE(LEFT(A1,ROW(OFFSET(A1,0,0,LEN(A1)))),"[^A-Za-z]","")),2)*32
      ),
      MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1)
    )
  )
) 

Sözde mantık şöyle çalışır:

For each character {                                    // ArrayFormula()
  If (character is a letter) {                          // REGEXMATCH(MID())
    Return CHAR(                                        // CHAR()
      CODE(UPPER(letter))                               // CODE(UPPER(MID()))
      +
      If (nth letter found and n is odd) {32} else {0}  // MOD(LEN(REGEXREPLACE(LEFT())))
    )
  } else {
    Return character                                    // MID()
  }
}

Perl 5 , 24 bayt

23 bayt + 1 bayt -p.

-2 bayt için @Dada'ya teşekkürler .

s/\pl/--$|?uc$&:lc$&/eg

Çevrimiçi deneyin!

Retina , 46 bayt

T`L`l
T`l`L`.(?=([^a-z]*|[a-z][^a-z]*[a-z])*$)

Çevrimiçi deneyin! Test durumları içerir.

C 64 bayt

B;R(char *s){for(;*s=isalpha(*s)?(B=!B)?*s|=32:*s&=~32:*s;s++);}

Büyük ve küçük harflerin 0x20 ile dengelendiği yer olan ascii kodlamasından faydalanır.

Retina , 32 bayt

T`l`L
01T`L`l`[A-Z][^A-Z]*[A-Z]?

Çevrimiçi deneyin!

Önce girişi büyük harfe dönüştürür, sonra girişi en fazla iki büyük harf içeren eşleşmelerde gruplandırır. Sadece bir harf içerecek tek zaman, son mektubun bir çifti olmamasıdır. Sonra bu maçların her birinin ilk harfini indirir.

01İkinci aşamada kabaca anlamına: maç sayısına dayanarak bu aşamada davranışını değiştirmek, ancak sadece her maçın ilk karakter değişiklikleri geçerli değildir.

PHP 5, 54 bayt

<?=preg_filter('/\pL/e','($0|" ")^a^aA[$i^=1]',$argn);

C #, 100 bayt

s=>{var r="";int m=0;foreach(var c in s)r+=char.IsLetter(c)?(char)(++m%2>0?c|32:c&~32):c;return r;};

Groovy, 79 bayt

{x=0;it.toUpperCase().collect{(it==~/\w/)?x++%2?it:it.toLowerCase():it}.join()}

Python 3 , 192 bayt

x=list(input())
s=[]
for i in x[1::2]:
 s.append(i)
 x.remove(i)
s.reverse()
while len(x)<len(s):
 x.append("")
while len(x)>len(s):
 s.append("")
for i in range(len(x)):
 print(end=x[i]+s[i])

Çevrimiçi deneyin!

Dışbükey , 16 bayt

¯{_U&,R^:R{¬}&}%

Çevrimiçi deneyin!

@ Business Cat'in cevabının dışbükey limanı .