একটি ogl-edocf চ্যালেঞ্জ

22

ইনপুট

ব্যাপ্তিতে ASCII অক্ষর সমন্বিত একটি খালি খালি শ্যাফলেড স্ট্রিং ।[32..126]

আউটপুট

আউটপুট ইনপুট স্ট্রিংয়ে ধারাবাহিক ঘূর্ণন প্রয়োগ করে প্রাপ্ত হয়।

[a-zA-Z]বাম থেকে ডানে যেতে ইনপুট স্ট্রিংয়ের প্রতিটি অক্ষরের ( ) জন্য:

  • চিঠিটি যদি বড় হাতের অক্ষরে থাকে তবে তার আগে সমস্ত অক্ষর বাম দিকে একটি অবস্থানের সাথে ঘোরান
  • যদি চিঠিটি ছোট ক্ষেত্রে হয় তবে তার আগে সমস্ত অক্ষরকে ডানদিকে এক অবস্থান দিয়ে ঘোরান

উদাহরণ

ইনপুট: "সিবি-অ্যাড"

  • প্রথম অক্ষরটি একটি " সি "। আমাদের বাম দিকে ঘোরানো উচিত, তবে এই " সি " এর আগে কোনও চরিত্র নেই । সুতরাং, ঘোরানোর কিছুই নেই।
  • পরবর্তী অক্ষরটি একটি " খ "। আমরা " সি " ডানদিকে ঘোরান । কারণ এটি একটি একক চরিত্র, এটি অপরিবর্তিত রয়েছে।
  • " - " অক্ষরটি কোনও ঘূর্ণনকে ট্রিগার করে না, কারণ এটি কোনও অক্ষর নয়।
  • পরের চিঠিটি একটি " এ "। আমরা " সিবি- " বাম দিকে ঘোরান , যা " বিসি বিজ্ঞাপন" দেয়
  • চতুর্থ এবং শেষ বর্ণটি একটি " ডি "। আমরা " বি-সিএ " ডানদিকে ঘোরান , যা " আব-সি ডি" দেয়

সুতরাং, প্রত্যাশিত আউটপুটটি " আব-সিডি "।

বিধি

  • আপনি স্ট্রিং হিসাবে বা অক্ষরের অ্যারে হিসাবে ইনপুট নিতে পারেন - যা আপনার ভাষার উপর নির্ভর করে একই জিনিস হতে পারে বা নাও হতে পারে।
  • আপনি স্ট্রিংয়ের পরিবর্তে অক্ষরের একটি অ্যারের আউটপুটও করতে পারেন।
  • এটি ogl-edocf কোড-গল্ফ

পরীক্ষার মামলা

"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!"
code-golf  string  code-golf  string  code-golf  string  parsing  brainfuck  code-challenge  python  hello-world  error-message  code-golf  string  code-golf  number  integer  counting  subsequence  code-golf  string  cipher  code-golf  array-manipulation  arithmetic  integer  matrix  code-golf  math  sequence  code-golf  restricted-source  pi  popularity-contest  cops-and-robbers  polyglot  popularity-contest  cops-and-robbers  polyglot  code-golf  file-system  king-of-the-hill  code-golf  number  sequence  integer  rational-numbers  string  code-challenge  source-layout  code-golf  ascii-art  king-of-the-hill  code-golf  array-manipulation  sorting  code-golf  string  code-golf  restricted-source  source-layout  tips  math  code-challenge  permutations  logic-gates  code-golf  number  random  integer  code-golf  math  code-golf  math  number  decision-problem  king-of-the-hill  python  board-game  code-challenge  brainfuck  busy-beaver  code-golf  number  cops-and-robbers  polyglot  obfuscation  answer-chaining  code-golf  number  integer  conversion  code-golf  string  parsing  code-golf  ascii-art  number  king-of-the-hill  javascript  code-golf  source-layout  radiation-hardening  code-golf  array-manipulation  matrix  code-golf  string  graph-theory  code-golf  array-manipulation  decision-problem  code-golf  string  ascii-art  code-golf  string  code-golf  array-manipulation 
— Arnauld
সূত্র

উত্তর:

5

পাইথ, 21 20 বাইট

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

এখানে চেষ্টা করুন

ব্যাখ্যা

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.
আপনি .Uদ্বিতীয় মান থেকে ইনপুট হ্রাস করতে ব্যবহার করতে পারেন । এটি আপনাকে =kশুরু থেকে ড্রপ করতে দেয় এবং )kইনপুট এবং প্রিন্টিং উভয়ই অন্তর্নিহিত বলে প্রান্ত থেকে। সম্পূর্ণ প্রোগ্রাম: .U+.>b-}ZG}Zr1GZ- লিঙ্ক
— সাক
3

জেলি , 14 বাইট

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

একটি মোনাডিক লিঙ্ক অক্ষরের একটি তালিকা গ্রহণ করে যা অক্ষরের একটি তালিকা দেয়।

এটি অনলাইন চেষ্টা করুন! অথবা পরীক্ষা-স্যুটটি দেখুন ।

কিভাবে?

ØẠŒ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
— জোনাথন অ্যালান
সূত্র
আমি জেলিকে খুব ভাল করে চিনি না, তবে এই ক্ষেত্রে Iযেমন করা উচিত না তেমন করা উচিত ḅ-? মনে হচ্ছে এটি এখানে কাজ করে তবে আপনার কোডে নয়। আমি কেন কিছুটা বিভ্রান্ত। এছাড়াও, জিলির স্ট্যাকের জন্য পৃথক আইটেম হিসাবে পৃথক তালিকাগুলি ধাক্কা দেওয়ার কোনও আদেশ আছে (অপেক্ষা করুন, জেলি কোনও স্ট্যাক-ভিত্তিক ভাষা নয়, এটি ..)? সেক্ষেত্রে একটি সাধারণ বিয়োগফল ব্যবহার করা যেতে পারে এবং যদি আমার ভুল না হয় তবে আপনাকেও নেগেটের প্রয়োজন হবে না (আমার 05AB1E উত্তরের সর্বশেষ সম্পাদনার মতো)।
— কেভিন ক্রুইজসেন
1
Iএকটি তালিকা দেয় - ŒṘ সম্পূর্ণ উপস্থাপনা দেখতে যোগ করুন । সুতরাং ØẠŒHċ€IṪN⁸ṙ;ð/কাজ করবে।
— জোনাথন অ্যালান
আহ, ঠিক আছে। ব্যাখ্যা করার জন্য ধন্যবাদ. উত্তম উত্তর বিটিডব্লিউ, ইতিমধ্যে এটি গতকাল উত্সাহিত করেছে। :)
— কেভিন ক্রুইজসেন
3

05 এ বি 1 ই , 18 17 16 14 বাইট

õsvy.uy.l-._y«

এটি অনলাইনে চেষ্টা করুন বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

ব্যাখ্যা:

õ            # 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)
— কেভিন ক্রুইজসেন
সূত্র
3

K4 , 43 33 বাইট

সমাধান:

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

উদাহরণ:

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-zA-Z" তালিকার উপরের অবস্থানের উপর নির্ভর করে পূর্ববর্তী আউটপুটটিকে 1, -1 বা 0 দ্বারা আবর্তিত করে ইনপুট স্ট্রিংয়ের উপর ভাগ করুন।

""{.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 (/)

নোট:

  • 05AB1E সমাধান থেকে অনুপ্রেরণা সহ -10 বাইট
— streetster
সূত্র
3

> <> , 45 বাইট

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

এটি অনলাইন চেষ্টা করুন!

> <> স্ট্যাকের ঘূর্ণন সাহায্য করে তবে এই চিঠির কেসটি যাচাই করা যায় না।

ব্যাখ্যা:

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
— জো কিং
সূত্র
2

হাস্কেল , 101 91 বাইট

-10 বাইট কার্টিস বেচটেলের উত্তরের দ্বারা অনুপ্রাণিত ( লোয়ার-কেসড অক্ষরের জন্য '@'<c,c<'['ওভার elem c['A'..'Z']এবং সেই অনুযায়ী ব্যাপ্তি ব্যবহার করুন)।

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

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা / অবহেলিত

অপারেটর (!)একটি খালি খালি স্ট্রিং নেয় xযার উপর আমরা প্যাটার্ন-মিল করতে পারি এবং একটি অক্ষর:

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

এখন আমরা ইনপুটটির লেজটি বাম থেকে ডানে হ্রাস করতে পারি, এটি ব্যবহার করে ইনপুটটির প্রথম অক্ষর দিয়ে শুরু করে:

\b a -> b!a ++ [a]
— ბიმო
সূত্র
2

হাস্কেল , 122 92 বাইট

পরামর্শের জন্য BWO ধন্যবাদ! আমি আমার আসল উত্তরের চেয়ে কিছুটা ভিন্ন দৃষ্টিভঙ্গি নিয়েও অনেক কিছু সাশ্রয় করেছি।

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

এটি অনলাইন চেষ্টা করুন!

— কার্টিস বেচটেল
সূত্র
আপনি এর প্যাটার্ন-ম্যাচটি অদলবদল করতে পারবেন (#), ,ওভার &&ব্যবহার [l!!0,c]করতে পারবেন head l:[c], এর 1>0পরিবর্তে True, আপনাকে গণনা করার দরকার নেই f=এবং আপনি খালি খালি ইনপুট ধরে নিতে পারেন যা l==[]গার্ডকে সংরক্ষণ করে - আপনার 13 বাইট সংরক্ষণ করে: অনলাইনে চেষ্টা করে দেখুন!
— ბიმო
BTW। আমি আমার জমাতে isLowerএবং isUpperগল্ফটি ব্যবহার করেছি , আমি আশা করি আপনি এটির সাথে ঠিক আছেন অন্যথায় আমি আমার সম্পাদনাটি বিপরীত করব।
— ბიმო
@ বিডব্লিউও পরামর্শগুলির জন্য ধন্যবাদ, এবং ঠিক এগিয়ে যান!
— কার্টিস বেচটেল
2

জাভাস্ক্রিপ্ট (নোড.জেএস) , 116 102 বাইট

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

এটি অনলাইন চেষ্টা করুন!

আসল ( 116 111 106 বি)

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

— শিয়েরু আসাকোটো
সূত্র
eval(`regex`)কনস্ট্রাক্টর ব্যবহার করার চেয়ে এটি করা সম্ভবত কম
— ডাউনগোট
@ ডাওনগোট আমি আশঙ্কা করি যে এটি কেস নয় কারণ স্ল্যাশগুলির ক্ষেত্রে স্ল্যাশগুলির প্রয়োজন হয় eval(`regex`), সুতরাং -2 + 2 = 0 এবং সুতরাং এটি বাইট গণনা হ্রাস করতে সহায়তা করে না।
— Shieru Asakoto
@Downgoat এটি ব্যবহার মূল্য eval()যখন অন্তত একটি পতাকা ব্যবহার করা হয়: eval('/./g')3 চেয়ে খাটো বাইট RegExp('.','g')।
— আর্নল্ড
@ আরনাউল্ড এটি সত্য, তবে আমি এখানে পতাকা ব্যবহার করি না।
— শিয়ারু আসাকোটো
@ শিেরুআসাকোটো (অবশ্যই। আমার মন্তব্যটি এখানে কেন করা ভাল নয় তা ব্যাখ্যা করার জন্য মূলত ডাওনগোটকে সম্বোধন করা হয়েছিল।)
— আরনাউল্ড
2

রুবি , 51 বাইট

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

এটি অনলাইন চেষ্টা করুন!

ইনপুট এবং আউটপুট হ'ল অক্ষরের অ্যারে

্জগ:

কোডটি বেশ সোজা, সম্ভবত ঘূর্ণন অংশটি বাদে:

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

এক্স একটি অক্ষর, যা একটি চিঠি, প্রথম অভিব্যক্তি হতে পারে x=~/\W/আয় nilযদি এটি একটি চিঠি, এবং 0 অন্যথায়। যদি এটি 0 হয়, আমরা সম্পন্ন করেছি, না হলে লজিকাল orদ্বিতীয় অভিব্যক্তিটি পরীক্ষা করে: ?_<=>xআপার ক্ষেত্রে -1 এবং লোয়ার ক্ষেত্রে 1 প্রদান করে। সুতরাং ঘূর্ণনটি হ'ল:

  • উপরের ক্ষেত্রে -1 (1 বাম দিকে)
  • লোয়ার ক্ষেত্রে +1 (ডানদিকে 1)
  • 0 (কোনও আবর্তন নেই) যদি এটি কোনও চিঠি না থাকে
— গিগাবাইট
সূত্র
2

লাল , 110 বাইট

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]

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা:

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 
]
— গ্যালেন ইভানভ
সূত্র
2

পার্ল 6 , 47 বাইট

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

এটি অনলাইন চেষ্টা করুন!

অক্ষরের অ্যারে নিয়ে কাজ করে।

— nwellnhof
সূত্র
আহা, আমি সিএমপি এবং ইউসি / এলসি ব্যবহার করতে যেতাম, তবে এটি 49 বাইটে
— জো কিং
1
ডার্ন, 48 বাইট প্রায় ধরা পড়েছে
— জো কিং
2

জাপট, 17 16 14 বাইট

অক্ষরের অ্যারে হিসাবে ইনপুট নেয়, একটি স্ট্রিং আউটপুট দেয়

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

চেষ্টা করে দেখুন

ব্যাখ্যা

 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?
— রোমশ
সূত্র
1

জাভা 10, 149 119 বাইট

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

@ শিরুআসাকোটো জাভাস্ক্রিপ্টের উত্তরটির পোর্ট , সুতরাং তাকে উর্ধ্বমুখী করা নিশ্চিত করুন।

এটি অনলাইনে চেষ্টা করুন।

ব্যাখ্যা:

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
— কেভিন ক্রুইজসেন
সূত্র
1

স্ট্যাক্স , 32 বাইট

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

এটি চালান এবং এটি ডিবাগ করুন

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

প্রচুর স্ট্যাক অদলবদল যা সম্ভবত অপ্রয়োজনীয়। আমি এটি আরও নিচে নামাতে চাই তবে আমি স্ট্যাকের ক্রম দিয়ে লড়াই করছি strug উদাস হয়ে থাকলে হয়তো কেউ তা বুঝতে পারে। এতে কাজ চালিয়ে যাবেন।

— মাল্টি
সূত্র
1

সংযুক্তি , 69 বাইট

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

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

সাধারণ আকার

ফাংশনটি সাধারণত এটির মতো দেখায়:

~Fold[{...}]#Iota

যা {...}প্রতিটি সদস্যের উপর থেকে পরিসীমাটিতে ভাঁজ 0হয়#input - 1 ( Iota), একটি বীজ হিসাবে ইনপুট থেকে শুরু।

অভ্যন্তরীণ ফাংশন

নিম্নলিখিত ফাংশন হিসাবে বলা হয় f[building, index]এবং প্রতিটি সূচক থেকে একচেটিয়া কল 0করা #inputহয়। ইনপুট স্ট্রিংটি বিভক্ত করে এই যুক্তিগুলিতে @SplitAtকল SplitAtকরে index।

{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

মূলত, এই ফাংশনটি ডান অংশের প্রথম অক্ষর অনুযায়ী স্ট্রিংয়ের বাম অংশটি ঘোরান।

— কনর ও ব্রায়ান
সূত্র
1

কাঠকয়লা , 20 বাইট

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

এটি অনলাইন চেষ্টা করুন! লিঙ্কটি কোডটির ভার্জোজ সংস্করণ। ব্যাখ্যা:

ＦＳ

ইনপুট অক্ষরের উপর লুপ করুন।

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

সংগৃহীত অক্ষরগুলির স্ট্রিংয়ের উপরে মানচিত্র, এখন পর্যন্ত সংগ্রহ করা অক্ষরগুলিতে চক্রাকারে সূচক অনুসারে সূচকটি বর্ধিত বা হ্রাস পেয়েছে যদি বর্তমান অক্ষর যথাক্রমে উপরের বা নিম্নতর হয়। এটি ঘূর্ণন সম্পূর্ণ করে। তারপরে পরবর্তী অক্ষরটি সংক্ষিপ্ত হয়ে যায় এবং ফলাফলটি আবার স্ট্রিংয়ে দেওয়া হয়।

ω

ফলাফল মুদ্রণ করুন।

— নিল
সূত্র
1

আর , 107 102 100 বাইট

বিশাল কারণ আর এর স্ট্রিং ম্যানিপটি বিশাল ky কেউ কি এটি 100 এর নিচে পেতে পারেন?

"আরম্ভকরণ এড়াতে" এফটিতে লুপ ভেরিয়েবল সেট করুন "-বাইটগুলি।

-2 বাইটগুলি সমস্ত অক্ষর মুদ্রণযোগ্য এবং অপারেটর নজির ব্যবহার করে লোয়ার কেসটি পরীক্ষা করার 2*!k%%97>25পরিবর্তে ব্যবহারযোগ্য বলে ধরে নেওয়া হয় 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)}

এটি অনলাইন চেষ্টা করুন!

— J.Doe
সূত্র
1
আশেপাশে কিছু ধারণা বাউন্ড করার জন্য আর গল্ফ চ্যাটরুমে আমাদের সাথে যোগ দিন (এখনই এটি ঠিক আমার সাথে ...) আসুন ! আমার অনুমান যে পারমিটেশন টুকরোটি এই পদ্ধতির সাথে যতটা সংক্ষিপ্ত হতে পারে তবে এটি নিজে চেষ্টা করে দেখিনি, আমি নিশ্চিত করে বলতে পারি না।
— জিউসেপ
1

জাপট , 25 23 বাইট

আমি হাল ছেড়ে দিচ্ছি, এটিকে ছোট করে তুলতে পারি না

@ETH প্রোডাকশনগুলি থেকে -2 বাইট

£=¯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

এটি অনলাইন চেষ্টা করুন!

— লুইস ফিলিপে দে জেসুস মুনোজ
সূত্র
দুঃখের বিষয়, আমি এর মধ্যে আর একটি ছোট উপায় খুঁজে পাচ্ছি না éXè\a -Xè\A:-( আপনি ডাবল স্পেস এ এ পরিবর্তন করে )এবং মুছে ফেলার মাধ্যমে দুটি বাইট সংরক্ষণ করতে পারেন ©(অন্তর্নিহিত কমা মানে যে Uএখনও
— আউটপুট করা আছে
পতাকাটি ফেলে ÃUএবং ব্যবহার করে আরও 2 টি বাইট সংরক্ষণ করুন -h।
— শেগি
1

রেটিনা , 67 64 58 বাইট

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

-9 বাইটস @ নীলকে ?আমি যোগ করা অপ্রয়োজনীয় তিনটি অপসারণের পাশাপাশি অপ্রয়োজনীয়কে ধন্যবাদ জানায় thanks(.*) অন্য ক্ষেত্রে ।

এটি অনলাইনে চেষ্টা করুন বা সমস্ত পরীক্ষার কেস যাচাই করুন । (দ্রষ্টব্য: একটি ট্রেলিং করা নতুন লাইনের সাথে আউটপুট test

ব্যাখ্যা:

ইনপুট এর আগে একটি নতুন লাইন প্রস্তুত করুন:

^
¶

যতক্ষণ না আমরা কোনও মিল খুঁজে পাই ততক্ষণ প্রতিস্থাপন চালিয়ে যান:

+`

সমস্ত কিছুই তিনটি পৃথক চেক একত্রিত করা হয়েছে:

যদি নিউলাইনের ঠিক পরে অক্ষরটি ছোট হাতের অক্ষর হয়: নিউলাইনের আগে সমস্ত কিছু একবার ডানের দিকে ঘোরান, এবং তারপরে সেই অক্ষরটি এবং নিউলাইনটি যুক্ত করুন:

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

যদি নিউলাইনের ঠিক পরে অক্ষরটি একটি বড় হাতের অক্ষর হয়: নিউলাইনের আগে সমস্ত কিছু একবার বাম দিকে ঘোরান, এবং তারপরে সেই অক্ষরটি এবং নিউলাইনটি যুক্ত করুন:

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

অন্যথায় (ছোট হাতের না বড় হাতের অক্ষর নয়): পরের 'পুনরাবৃত্তির' জন্য ডানদিকে একবার সরাসরি নিউলাইনটি স্থানান্তর করুন:

¶(.)
$1¶

উপরের এই তিনটি চেকটিকে রেজেক্স অর স্টেটমেন্টগুলি ( |) এবং বৃহত্তর গ্রুপ-প্রতিস্থাপনের সাথে একত্রিত করা হয়েছে যাতে এটি এর মতো কাজ করে if(lowercase) ... elseif(uppercase) ... else ...:

— কেভিন ক্রুইজসেন
সূত্র
আমি মনে করি না যে আপনার দরকার ?- যদি এখনও ঘোরার মতো কিছু না থাকে তবে কোনও চিঠি আছে কিনা তা বিবেচ্য নয়।
— নিল
1
এছাড়াও, প্রতিস্থাপন (.*)¶(.)সঙ্গে $1$2¶প্রতিস্থাপন সরলীকৃত করা যেতে পারে ¶(.)সঙ্গে $1¶হিসাবে অন্যান্য ক্যাপচার ফলাফলের প্রভাব ফেলে না।
— নিল
@ নীল আহ, অবশ্যই ধন্যবাদ। -9 বাইট ঠিক আছে! :)
— কেভিন ক্রুইজসেন
1

MATL , 20 বাইট

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

এটি অনলাইন চেষ্টা করুন!

লুই মেন্ডো -4 বাইট ধন্যবাদ।

বড় হাতের অক্ষর / ছোট হাতের অক্ষর / নন-লেটারকে [-1,0,1] (প্রোগ্রামের প্রথমার্ধে) রূপান্তর করে। পরপর (দ্বিতীয়ার্ধে) সার্কিট শিফট প্রয়োগ করে। আমি বড় মাপের সাথে / ছোট হাতের মানচিত্রের [-1,0,1] (দ্বিতীয় সংস্করণ দেখুন) ম্যাপ করার আরও ভাল উপায় থাকলে এবং সম্ভবত দুটি উপায় থেকে রেহাই পাওয়ার জন্য সম্ভবত স্ট্রিংটিকে বিপরীত করার কোনও উপায় যদি আমি আমার মস্তিষ্ককে ডেকে আছি wএর জন্য দরকার &)।

— Sanchises
সূত্র
0

পাইথ, 16 বাইট

em=+.>k-F}RGrBd2

এখানে চেষ্টা করুন!

ব্যাখ্যা:

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.
— স্টিভেন এইচ।
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.