Giriş

aralığında ASCII karakterlerinden oluşan boş olmayan karıştırılmış bir dize .$[32..126]$

Çıktı

Çıktı, giriş dizgisine art arda dönüşler uygulanarak elde edilir.

[a-zA-Z]Giriş dizesindeki her harf ( ) için, soldan sağa gitme:

• Harf büyükse, önce tüm karakterleri bir konum sola döndür
• harf küçükse, önce tüm karakterleri sağdaki bir konumla döndürün

Örnek

Giriş: "Cb-Ad"

• İlk harf " C " dir. Sola dönmeliyiz, ama bu " C " den önce karakter yok . Yani, döndürecek bir şey yok.
• Bir sonraki harf bir " b " dir. " C " yi sağa döndürüyoruz. Tek bir karakter olduğu için değişmeden kalır.
• " - " karakteri , bir harf olmadığı için herhangi bir dönme tetiklemez.
• Bir sonraki harf bir " A " dır . Sola, " bC Reklamı" veren " Cb- " yi döndürürüz.
• Dördüncü ve son harf bir " d " dir. " B-CA " yı sağa döndürüyoruz , " Ab-C d" veriyor

Bu nedenle, beklenen çıktı " Ab-Cd " dir.

kurallar

• Girişinize dize veya karakter dizisi olarak - dilinize bağlı olarak aynı şey olabilir veya olmayabilir.
• Ayrıca dize yerine bir karakter dizisi de çıkarabilirsiniz.
• Bu ogl-edocf kod golfü

Test durumları

"cbad" -> "abcd"
"ACBD" -> "ABCD"
"Cb-Ad" -> "Ab-Cd"
"caeBDF" -> "aBcDeF"
"aEcbDF" -> "abcDEF"
"ogl-edocf" -> "code-golf"
"W o,ollelrHd!" -> "Hello, World!"
"ti HIs SSta ET!" -> "tHis IS a tEST!"

Pyth, 21 20 bayt

VQ=k+.>k-}NG}Nr1GN)k

Burada dene

açıklama

VQ=k+.>k-}NG}Nr1GN)k
VQ                )      For each N in the input...
     .>k                 ... rotate k (initially '')...
        -}NG}Nr1G        ... by (N is lowercase) - (N is uppercase)...
    +            N       ... then append N...
  =k                     ... and update k.
                   k     Output the result.

Piton 2 , 100 98 95 bayt

f=lambda s,p='':s and f(s[1:],[p[x:]+p[:x]+s[0]for x in[s[0].isupper()-s[0].islower()]][0])or p

Çevrimiçi deneyin!

Jöle , 14 bayt

ØẠŒHċ€ḅ-N⁸ṙ;ð/

Bir karakter listesi veren bir karakter listesini kabul eden bir monadik bağlantı.

Çevrimiçi deneyin!Veya test odasına bakın .

Nasıl?

ØẠŒHċ€ḅ-N⁸ṙ;ð/ - Link - list of characters
             / - reduce by:
            ð  -   a dyadic chain:  1st call is f(L=1stCharacter, R=2ndCharacter)
               -                    ...then calls are f(L=previousResult, R=nextCharacter)
ØẠ             -     alphabet characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
  ŒH           -     split in half = ["ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz"]
     €         -     for each:
    ċ          -       count occurrences (of R)
               -                          e.g.: 'W' -> [1,0]; 'c' -> [0,1]; '@' -> [0,0]
      ḅ-       -     convert from base -1             -1             1             0
        N      -     negate                            1            -1             0
         ⁸     -     chain's left argument (i.e. L)
          ṙ    -     rotate left by (the negate result)
           ;   -     concatenate R

05AB1E , 18 17 16 14 bayt

õsvy.uy.l-._y«

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

Açıklama:

õ            # Start with an empty string
 sv          # Loop over the characters `y` of the input
   y.u       #  Check if `y` is an uppercase letter (1 if truthy; 0 if falsey)
   y.l       #  Check if `y` is a lowercase letter (1 if truthy; 0 if falsey)
      -      #  Subtract them from each other
       ._    #  Rotate the string that many times (-1, 0, or 1) toward the left
   y«        #  Append the current character `y` to the string
             # (And implicitly output the string after the loop)

K4 , 43 33 bayt

Çözüm:

""{.q.rotate[-/y in'.Q`A`a;x],y}/

Örnekler:

q)k)""{.q.rotate[-/y in'.Q`A`a;x],y}/"Cb-Ad"
"Ab-Cd"
q)k)""{.q.rotate[-/y in'.Q`A`a;x],y}/"ogl-edocf"
"code-golf"
q)k)""{.q.rotate[-/y in'.Q`A`a;x],y}/"ti HIs SSta ET!"
"tHis IS a tEST!"

Açıklama:

"A-zA-Z" listesindeki konumuna bağlı olarak önceki çıktısını 1, -1 veya 0 döndürerek giriş dizgisini yineleyin.

""{.q.rotate[-/y in'.Q`A`a;x],y}/ / the solution
""{                            }/ / iterate (/) over, starting x as ""
                             ,y   / append y to
   .q.rotate[             ;x]     / rotate x by ...
                    .Q`A`a        / the lists "a..z" and "A..Z"
               y in'              / y in each (') alphabet?
             -/                   / subtract (-) over (/)

Notlar:

• -AB 05E1E çözümünden ilham alan 10 bayt

> <> , 45 43 bayt

ii:2+7$.::&"`{"@)@(*?}"@["&::&@)@(*?{&!
ror

Çevrimiçi deneyin!

> <> 'İn yığın rotasyonu olduğu gerçeği yardımcı olur, ancak harfin durumunu kontrol etmek zorunda değildir.

Açıklama:

i    Get first inputted character
 i   Get second. This is to prevent errors from rotating an empty stack
  :2+7$.      Jump to the second line if that was EOF
        ::&   Create copies of the input and store one in the register
           "`{"@)@(*     Check if the char is lower case
                    ?}   If so rotate the stack
                      "@["&::&@)@(*?{   Rotate the other way if uppercase
                                     &  Push the new char
                                      ! Skip the first i instruction
Skip to the second line on EOF
ro      Reverse the stack and output
r r     Cancel out the first reverse
 o      Output the rest of the stack

Haskell , 101 91 bayt

^{Curtis Bechtel'in cevabından ilham alan -10 bayt ( daha düşük harfli harfler için '@'<c,c<'['üzerini elem c['A'..'Z']ve aralığını kullanın ).}

g(x:y)=foldl((<>pure).(!))[x]y
x@(a:b)!c|'`'<c,c<'{'=last x:init x|'@'<c,c<'['=b++[a]|0<1=x

Çevrimiçi deneyin!

Açıklama / Ungolfed

Operatör üzerinde kalıp eşleştirebileceğimiz (!)boş olmayan xbir karakter ve bir karakter alır:

x@(a:b) ! c
  | '`' < c, c < '{' = last x : init x  -- rotate x to the right by one
  | '@' < c, c < '[' = b ++ [a]         -- rotate x to the left by one
  | otherwise = x                       -- keep x as is

Artık girişin ilk karakterinden başlayarak girişin kuyruğunu soldan sağa düşürebiliriz:

\b a -> b!a ++ [a]

Haskell , 122 92 bayt

Önerileriniz için BWO'ya teşekkürler! Ayrıca orijinal cevabımdan biraz farklı bir yaklaşım benimseyerek çok şey kurtardım.

l@(a:b)!c|'`'<c,c<'{'=last l:init l++[c]|'@'<c,c<'['=b++[a,c]|0<1=l++[c]
f(c:s)=foldl(!)[c]s

Çevrimiçi deneyin!

JavaScript (Node.js) , 116 102 bayt

f=(s,i=1)=>s[i]?f(s.replace(RegExp(`^(.)(.{${i}})(?=[A-Z])|^(.{${i}})(.)(?=[a-z])`),"$4$3$2$1"),i+1):s

Çevrimiçi deneyin!

Orijinal ( 116 111 106B)

s=>Buffer(s).map((x,i)=>s=(t=s[S="slice"](i),i<2)?s:x>64&x<91?s[S](1,i)+s[0]+t:x>96&x<123?s[i-1]+s[S](0,i-1)+t:s)&&s

s=>Buffer(s).map((x,i)=>i<2|--x%32>25|x<64?s:s=[s[S="slice"](1,i)+s[0],s[i-1]+s[S](0,i-1)][+(x>95)]+s[S](i))&&s

s=>Buffer(s).map((x,i)=>!i|--x%32>25|x<64?s:s=(w=x>95,t=s.slice(1-w,i-w),w?s[i-1]+t:t+s[0])+s.slice(i))&&s

Ruby , 51 bayt

->s{w=[];s.map{|x|w.rotate!(x=~/\W/||?_<=>x)<<x};w}

Çevrimiçi deneyin!

Giriş ve çıkış, karakter dizileridir

Numara:

Kod, belki de rotasyon bölümü hariç oldukça basittir:

(x=~/\W/||?_<=>x)

x bir harf olabilen tek bir karakterdir, ilk ifade bir harf ise x=~/\W/döndürür nil, aksi takdirde 0 olur. Eğer 0 ise, bittikten sonra, mantıksal orise ikinci ifadeyi kontrol eder: ?_<=>xbüyük harf için -1, küçük harf için 1 döndürür. Yani dönme:

• Büyük harf için -1 (1 sola)
• Küçük harf için +1 (sağa 1)
• 0 (döndürme yok) bir harf değilse

Kırmızı , 110 bayt

func[s][p: s forall s[if all[(a: first s)>#"@"a < #"["][move p back s]if all[a >#"`"a <#"{"][move back s p]]p]

Çevrimiçi deneyin!

Açıklama:

f: func [ s ] [
    p: s                                ; store the starting position of the string in p
    forall s [                          ; iterate through the entire string
        a: first s                      ; store the current character in a
        if all [ a > #"@" a < #"[" ] [  ; if `a` is a uppercase letter
            move p back s               ; move the starting char to the position before current
        ]
        if all [ a > #"`" a < #"{" ] [  ; if `a` is a lowercase letter
            move back s p               ; move the character before the current one to the start
        ]
    ]
    p                                   ; return the string 
]

Perl 6 , 47 bayt

*.reduce:{|@$^a.rotate($^b~~/\w/&&'_'leg$b),$b}

Çevrimiçi deneyin!

Bir dizi karakter üzerinde çalışır.

Japt, 17 16 14 bayt

Girdiyi karakter dizisi olarak alır, dizge çıktılar

;rÏiXéCøY -BøY

Dene

açıklama

 rÏ                :Reduce by passing the current result (X) & the current element (Y) through a function
   i               :  Prepend to Y
    Xé             :  X rotated right by
;     B            :    Uppercase alphabet
       øY          :    Contains Y?
          -        :    Subtract
;          C       :    Lowercase alphabet
            øY     :    Contains Y?

Jöle , 19 bayt

W€ḷṙ01ŒlƑ?-ŒuƑ?};ʋ/

Çevrimiçi deneyin!

Java 10, 149 119 bayt

s->{for(int i=1;i<s.length();)s=s.replaceAll("^(.)(.{"+i+"})(?=[A-Z])|^(.{"+i+++"})(.)(?=[a-z])","$4$3$2$1");return s;}

@ShieruAsakoto Bağlantı Noktası JavaScript cevap , bu yüzden onu oyladığına emin ol.

Çevrimiçi deneyin.

Açıklama:

s->{                          // Method with String as both parameter and return-type
  for(int i=1;i<s.length();)  //  Loop `i` in the range [1, length)
    s=s.replaceAll("^(.)(.{"+i+"})(?=[A-Z])|^(.{"+i+++"})(.)(?=[a-z])","$4$3$2$1");
                              //   Rotate the substring of [0, i] either left or right
  return s;}                  //  Return the modified input-String as result

Stax , 32 bayt

éG7[Æ┐äZ▬Θε♫∙~╞ÉH╔u╬←J╛ü╢(┼▒uX)Ü

Koş ve hata ayıkla

B]s{c97 123:bsaa|)sc65 91:bsaa|(s+c}fd  #Full program, unpacked, implicit input
B]s                                     #Unons-left, singleton, swap top 2 of stack
   {c                                   #Copy iterative letter
     97 123                             #Put 97 and 123 on stack(lower case)
           :bsaa                        #Check if iterative letter is between range, swap orientation back to proper order
                |)                      #Rotate if the letter is within range
                  sc                    #Swap top 2 and copy top
                    65 91               #Put 65 and 91 on stack (Capitals)
                         :bsaa          #Check if iterative letter is between range, swap orientation back to proper order
                              |(        #Rotate if the letter is within range
                                s+c     #swap, concat and copy
                                   }fd  #remove duplicate of original answer after loop and implicitly print

Muhtemelen gereksiz olan birçok yığın takas. Bunu gerçekten daha fazla azaltmak istiyorum, ancak yığının siparişi ile mücadele ediyordum. Belki biri sıkılırsa çözebilir. Üzerinde çalışmaya devam edecek.

Ataşesi , 69 bayt

~Fold[{s'r.=_'sp;Rotate[s,&`-!Has&r[0]=>ALPHA'alpha]+r}@SplitAt]#Iota

Çevrimiçi deneyin!

açıklama

Genel şekli

İşlev genellikle şöyle görünür:

~Fold[{...}]#Iota

Hangi kıvrımlar {...}aralığında her üyesinin üzerine 0için #input - 1(Iota ), bir tohum gibi girişi ile başlanarak hazırlandı.

İç fonksiyon

Aşağıdaki fonksiyon, f[building, index]her bir indeks 0ile #inputözel arasında çağrılır ve çağrılır . giriş dizisini bölerek bu argümanları @SplitAtçağırır .SplitAtindex

{s'r.=_'sp;Rotate[s,&`-!Has&r[0]=>ALPHA'alpha]+r}
{                                               }    anonymous function taking the split string
                                                     e.g.: ["cd-", "Adf!"]
      _'sp                                           concat the input with a space
                                                     e.g.: ["cd-", "Adf!", " "]
                                                     (this is to handle index = 0)
 s'r.=                                               `s` is the first member, and `r` is the second
           Rotate[s,                         ]       rotate `s` by:
                                  ALPHA'alpha          over uppercase and lowercase alphabets:
                        Has&r[0]=>                       test if r[0] is in each alphabet
                                                       e.g.: [true, false]
                    &`-!                               subtract the second from the first
                                                       e.g.: (true - false) = 1 - 0 = 1
                                                     s is rotated according to the following map:
                                                       uppercase =>  1
                                                       symbol    =>  0
                                                       lowercase => -1
                                              +r     append the right portion of the string

Temel olarak, bu işlev dizginin sol kısmını, sağ bölümün ilk karakterine göre döndürür.

Kömür , 20 bayt

ＦＳ≔⁺⭆ω§ω⁻⁺λ№αι№βιιωω

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

ＦＳ

Giriş karakterleri üzerinde döngü yapın.

≔⁺⭆ω§ω⁻⁺λ№αι№βιιω

Şimdiye kadar toplanan karakterlerin dizgisini eşleştirin, şu anki karakter büyük veya küçük harf ise, dizine artmış veya azalmış olarak toplanan karakterlere çevrimsel olarak indeksleyin. Bu dönüşü tamamlar. Ardından bir sonraki karakter birleştirilir ve sonuç dizeye geri atanır.

ω

Sonucu yazdırın.

R , 107 102 100 bayt

Masif, çünkü R'nin karakter dizgisi hantal. 100'ün altında biri alabilir mi?

"Başlatmaktan kaçınmak için döngü değişkenlerini F olarak ayarlayın" numarasını kullanarak -5 bayt.

Tüm karakterlerin yazdırılabilir olduğunu ve kullanıcı önceliğini kullanarak küçük harfleri sınamak 2*!k%%97>25yerine kullandıklarını varsayarak -2 bayt 2*k%in%97:122.

function(x){for(k in u<-utf8ToInt(x))u[1:F-1]=u[(1:(F=F+1)+k%in%65:90-2*!k%%97>25)%%F];intToUtf8(u)}

Çevrimiçi deneyin!

Japt , 25 23 bayt

Pes ediyorum, kısaltamam

@ETHproductions'tan -2 bayt

£=¯Y éXè\a -Xè\A)+UsYÃU

£=¯Y éXè\a -Xè\A)+UsYÃU     Full program. Implicit input U
£                           map each char
 =                          set U equal to:
  ¯Y                        U sliced to current mapped value
    éXè\a -Xè\A)            and rotated left or right 1 char
                +UsY        append the non-sliced U value
                      ÃU    Output U    

Çevrimiçi deneyin!

Retina , 67 64 58 bayt

^
¶
+`(.*)(.)¶([a-z])|(.)(.*)¶([A-Z])|¶(.)
$2$1$3$5$4$6$7¶

-9 bayt @ Neil ?eklediğim gereksiz üç yanı sıra gereksiz kaldırma(.*) başka durumda .

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın . (NOT: Sondaki yeni satırlı çıkışlar. Test takımındaki başlık, her giriş satırını ayrı bir sınama durumu olarak test etmek içindir ve altbilgi, daha kompakt bir çıktı için bu sondaki yeni satırı kaldırmaktır.)

Açıklama:

Girişten önce yeni bir satıra öncelik verin:

^
¶

Bir eşleşme bulabildiğimiz sürece değiştirmeye devam edin:

+`

Geriye kalan her şey bir araya getirilen üç farklı kontrol:

Newline'dan sonraki karakter küçük harf ise: newline'den önceki her şeyi bir kez sağa döndürün ve ardından o karakteri ve newline ekleyin:

(.*)(.)¶([a-z])
$2$1$3¶

Newline'dan sonraki karakter büyük harf ise: newline'dan önceki her şeyi bir kez sola doğru döndürün ve ardından o karakteri ve newline'ı ekleyin:

(.)(.*)¶([A-Z])
$2$1$3¶

Başka (ne küçük harf ne de büyük harf): yeni satırı bir sonraki 'yineleme' için bir kez sağa kaydırın:

¶(.)
$1¶

Yukarıdaki üç kontrol, regex OR deyimleri ( |) ve aşağıdaki gibi davranması için daha büyük grup değiştirmeleri ile birleştirilir if(lowercase) ... elseif(uppercase) ... else ...:

MATL , 20 bayt

ttYo-ZS"X@q:&)w@YSwh

Çevrimiçi deneyin!

Luis Mendo sayesinde -4 bayt.

Büyük / küçük harf / harf olmayanları [-1,0,1] (programın ilk yarısı) değerine dönüştürür. Art arda geçişi uygular (ikinci yarı). Büyük / küçük harfleri [-1,0,1] ile eşleştirmenin daha iyi bir yolu varsa (ve ikinci versiyona bakınız) beynimi mahvederim ve belki ikiye geri dönmek için dizgiyi derhal tersine çevirebiliriz wiçin gerekli &).

C (clang) , 168 159 153 119 bayt

g,i,j;f(char*a){for(i=0;a[j=i++];islower(a[i])?g=a[j],bcopy(a,a+1,j),*a=g:isupper(a[i])?g=*a,bcopy(a+1,a,j),a[j]=g:0);}

-26 @ceilingcat sayesinde

Çevrimiçi deneyin!

Pyth, 16 bayt

em=+.>k-F}RGrBd2

Burada dene!

Açıklama:

em=+.>k-F}RGrBd2dQ    Autofill variables
 m               Q    for each d in Q (the input):
            rBd2       Take [d, swapcase(d)]
         }RG           Figure out which are in the lowercase alphabet (returns [1,0] for lowercase, [0,1] for uppercase, [0,0] for non-letters)
       -F              Fold on subtraction (1 for lowercase, -1 for uppercase, 0 for non-letter)
    .>k                Cycle the processed part (k) of the input right by ^ steps
   +            d      Add in the new character at the end
  =   k                Store new process step back into k (k starts as an empty string)
e                     Get the (e)nd step's output.