Вызов ogl-edocf

22

вход

Непустая перетасованная строка, состоящая из символов ASCII в диапазоне .[32..126]

Выход

Выход получается путем применения последовательных поворотов к входной строке.

Для каждой буквы ( [a-zA-Z]) во входной строке, идущей слева направо:

  • если буква в верхнем регистре, поверните все символы перед ней на одну позицию влево
  • если буква в нижнем регистре, поверните все символы перед ней на одну позицию вправо

пример

Вход: "Cb-Ad"

  • Первая буква " С ". Мы должны повернуть налево, но перед этим буквой " C " нет символа . Так что вращать нечего.
  • Следующая буква - « б ». Вращаем « С » вправо. Поскольку это один символ, он остается неизменным.
  • Символ « - » не вызывает вращения, так как это не буква.
  • Следующая буква " А ". Поворачиваем « Cb- » влево, что дает « bC Ad»
  • Четвертая и последняя буква - « д ». Поворачиваем « b-CA » вправо, что дает « Ab-C

Следовательно, ожидаемый результат - « Ab-Cd ».

правила

  • Вы можете воспринимать ввод как строку или как массив символов - что может или не может быть одним и тем же, в зависимости от вашего языка.
  • Вы также можете вывести массив символов вместо строки.
  • Это

Контрольные примеры

"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!"
Arnauld
источник

Ответы:

5

Pyth, 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для уменьшения ввода от 2-го значения. Это позволяет отказаться =kот начала и )kконца, поскольку ввод и печать неявны. Полная программа: .U+.>b-}ZG}Zr1GZ- ссылка
Sok
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поступать так же, как ḅ-в этом случае? Кажется, здесь работает , но не в вашем коде. Я немного запутался, почему. Кроме того, есть ли команда, чтобы поместить все списки как отдельные элементы в стек в Jelly (подождите, Jelly не является языком, основанным на стеке, не так ли ...)? В этом случае можно использовать простое вычитание, и вам также не понадобится отрицание, если я не ошибаюсь (аналогично последнему редактированию в моем ответе 05AB1E).
Кевин Круйссен
1
Iдает список - добавить, ŒṘ чтобы увидеть полное представление . Так ØẠŒHċ€IṪN⁸ṙ;ð/будет работать.
Джонатан Аллан
Ах, хорошо, это имеет смысл. Спасибо за объяснение. Хороший ответ, кстати, уже проголосовал вчера. :)
Кевин Круйссен
3

05AB1E , 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

К4 , 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!"

Объяснение:

Выполните итерацию по входной строке, поворачивая предыдущий вывод на 1, -1 или 0 в зависимости от его положения в списке «a-zA-Z».

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

Заметки:

  • -10 байт с вдохновением от решения 05AB1E
streetster
источник
3

> <> , 45 43 байта

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

Haskell , 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

Попробуйте онлайн!

Объяснение / Ungolfed

Оператор (!)берет непустую строку, 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

Haskell , 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гольф в своем представлении , я надеюсь, что вы согласны с этим, в противном случае я переверну мои изменения
მოიმო
@BWO Спасибо за предложения, и вперед!
Кертис Бектел
2

JavaScript (Node.js) , 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 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

Сиеру Асакото
источник
Это, вероятно, короче, eval(`regex`)чем использование конструктора
Downgoat
@ Downgoat Боюсь, что это не так, потому что слеши нужны в случае eval(`regex`), поэтому -2 + 2 = 0, и, следовательно, это не помогает уменьшить количество байтов.
Шиеру Асакото
@Downgoat Стоит использовать, eval()когда используется хотя бы один флаг: eval('/./g')на 3 байта меньше, чем RegExp('.','g').
Арно
@Arnauld Это правда, но я здесь не использую флаги.
Шиеру Асакото,
@ShieruAsakoto (Конечно. Мой комментарий был в первую очередь адресован Downgoat, чтобы объяснить, почему это не стоит делать здесь.)
Арно,
2

Рубин , 51 байт

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

Попробуйте онлайн!

Ввод и вывод - это массивы символов

Трюк:

Код довольно прост, за исключением, возможно, части поворота:

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

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

Japt, 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

Java 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;}

Порт @ShieruAsakoto JavaScript ответ , поэтому обязательно проголосуйте за него.

Попробуйте онлайн.

Объяснение:

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

Stax , 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

Большая замена стека, что, вероятно, не нужно. Я действительно хотел бы получить это больше, но я боролся с упорядочением стека. Может быть, кто-то может понять это, если им скучно. Будет продолжать работать над этим.

много
источник
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 байтов

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

Попробуйте онлайн! Ссылка на подробную версию кода. Объяснение:

FS

Зацикливайте вводимые символы.

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

Сопоставьте строку собранных символов до настоящего времени, циклически индексируя до собранных символов до сих пор с индексом, увеличиваемым или уменьшающимся, если текущий символ является прописным или строчным соответственно. Это завершает вращение. Затем следующий символ объединяется, и результат присваивается обратно строке.

ω

Распечатайте результат.

Нил
источник
1

R , 107 102 100 байт

Массивный, потому что манипуляции с R громоздки. Кто-нибудь может получить его под 100?

-5 байт, используя трюк «установить переменные цикла в F, чтобы избежать инициализации».

-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
Присоединяйтесь к нам (это только я прямо сейчас ...) в чате R Golf, чтобы поделиться идеями! Я предполагаю, что часть перестановки настолько коротка, насколько это возможно при таком подходе, но я не пробовал сам, я не могу сказать наверняка.
Джузеппе
1

Japt , 25 23 байта

Я сдаюсь, не могу сделать это короче

-2 байта из @ETHproductions

£=¯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это :-( Вы можете сохранить два байта, изменив двойной пробел на a )и удалив ©(неявная запятая означает, что Uон все еще выводится)
ETHproductions
Сохраните еще 2 байта, опустив ÃUи используя -hфлаг.
Лохматый
1

Сетчатка , 67 64 58 байт

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

-9 байт благодаря @Neil удалив три ненужных ? я добавил, а также ненужные (.*)в остальном случае.

Попробуйте онлайн или проверьте все тесты . (ПРИМЕЧАНИЕ: выходы с завершающим символом новой строки. Заголовок в наборе тестов предназначен для проверки каждой строки ввода как отдельного тестового примера, а нижний колонтитул должен удалить этот завершающий перевод строки для более компактного вывода.)

Объяснение:

Добавить новую строку перед вводом:

^
¶

Продолжайте замену, пока мы можем найти соответствие:

+`

Все остальное - это три разные проверки, объединенные вместе:

Если символ сразу после новой строки является строчной буквой: поверните все до новой строки один раз вправо, а затем добавьте этот символ и новую строку:

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

Если символ после новой строки является заглавной буквой: поверните все до новой строки один раз влево, а затем добавьте этот символ и новую строку:

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

Иначе (ни строчные, ни прописные буквы): просто сдвиньте новую строку один раз вправо для следующей «итерации»:

¶(.)
$1¶

Эти три проверки, приведенные выше, объединены с операторами регулярных выражений OR ( |) и более крупными групповыми заменами, чтобы заставить его действовать как if(lowercase) ... elseif(uppercase) ... else ...:

Кевин Круйссен
источник
Я не думаю, что вам нужны ?s - если нечего вращать, не имеет значения, есть ли письмо.
Нил
1
Кроме того, замена (.*)¶(.)на $1$2¶может быть упрощена заменой ¶(.)на, $1¶поскольку другой захват не влияет на результат.
Нил
@ Нил А, конечно, спасибо. -9 байт прямо там! :)
Кевин Круйссен
1

MATL , 20 байтов

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

Попробуйте онлайн!

-4 байта благодаря Луису Мендо.

Преобразует прописные / строчные / не буквы в [-1,0,1] (первая половина программы). Применяет круговое смещение последовательно (вторая половина). Я ломаю свой мозг, если есть лучший способ отобразить прописные / строчные буквы на [-1,0,1] (см. Вторую версию), и, возможно, способ сразу перевернуть строку, чтобы избавиться от двух wнужно для &).

Sanchises
источник
1

С (лязг) , 168 159 153 119 байт

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

Попробуйте онлайн!

Logern
источник
Предлагаю g=a[j=i++];islower(a[i])?bcopy(a,a+1,j)вместоa[j=i++];islower(a[i])?g=a[j],bcopy(a,a+1,j)
floorcat
0

Pyth, 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.
Стивен Х.
источник