Дехто з вас може бути знайомий з тим, як рухається мотоцикл. Але для тих, хто цього не робить, це виглядає приблизно так

6

5

4

3

2

N

1

Тепер я хочу знати, в якій передачі я перебуваю після декількох перемикань вгору та вниз. Програма повинна працювати з нейтралітету.

Зразок введення:

V^^

Вибірка зразка:

2

Як ви бачите, я змінив один раз вниз з N на 1 і в два рази перейшов на другу передачу.

Це кодовий гольф. Найкоротша відповідь у байтах виграє.

Примітка. Вхід може бути будь-якими 2 символами. Це можуть бути U і D вгору і вниз, або що завгодно, це повинно бути рядком . Ви не можете переключитися за межі 1-ї або 6-ї передач. Якщо ви перебуваєте в 6-му місці і знову піднімаєтеся вгору, він залишиться в 6-му. Удачі!

JavaScript (ES6), 49 48 47 46 байт

Очікує:

• 1 для пуху
• 7 для вгору

f=([c,...s],g=2)=>c?f(s,g-c&7||g):'1N'[--g]||g

Відформатовано та прокоментовано

f = (                   // f is a recursive function which takes:
  [c,                   // - c = next character in input string
      ...s],            // - s = remaining characters
  g = 2                 // - g = current gear, with default = neutral = 2
) =>                    //
  c ?                   // if there's still a character to process:
    f(                  //   do a recursive call with:
      s,                //     - the remaining characters
      g - c & 7 ||      //     - the updated gear if it is valid
      g                 //       or the previous gear if not
    )                   //
  :                     // else:
    '1N'[--g] ||        //   decrement g and output '1' for g = 0, 'N' for g = 1,
    g                   //   or simply the corresponding digit for other values

Шестірні відображаються так:

g MOD 8 = 0 1 2 3 4 5 6 7
          ---------------
gear    = X 1 N 2 3 4 5 6       (where 'X' is an invalid state)

Що дозволяє нам легко перевірити справність поточної передачі за допомогою:

(g & 7) != 0

Демо

f=([c,...s],g=2)=>c?f(s,g-c&7||g):'1N'[--g]||g

console.log(f(''))
console.log(f('1'))
console.log(f('11'))
console.log(f('17777'))
console.log(f('1777777771'))

05AB1E , 22 20 байт

Îvy<+®‚Z5‚W}6LÀ'N¸ìè

Спробуйте в Інтернеті!

Пояснення

Î                      # push 0 (accumulator) and input
 v         }           # for each in input
  y<+                  # decrement current element and add to accumulator
     ®‚Z               # take maximum of current value and -1
        5‚W            # take minimum of current value and 5
            6L         # push the range [1 ... 6]
              À        # rotate left
               'N¸ì    # prepend the letter "N" producing the list [N, 2, 3, 4, 5, 6, 1]
                   è   # index into this list with the value produced by the loop

MATL, 32 28 23 байт

5 байт збережено завдяки @Luis

'234561N'j!Uq[aA]&Ys0))

Це рішення використовується '2'для зсуву вгору і '0'для зміни вниз.

Спробуйте в MATL Online

Пояснення

'234561N'   % Push the string literal to the stack
j           % Grab the input as a string
!U          % Convert the input to a numeric array based on the characters.
q           % Subtract 1 to turn '2' into 1 and '0' into -1
[aA]        % Push the array [-1 5] to the stack
&Ys         % Compute the cumulative sum using the array [-1, 5] as
            % the upper and lower limits at each point
0)          % Get the last value from the cumulative sum
)           % Use this to index into the initial string literal.
            % Implicitly display the result

V , 20 , 15 байт

:sil!î¬61énÀxVp

Спробуйте в Інтернеті!

Введення - це рядок h(вгору) та l(вниз) символів.

Дякую @nmjcman за збереження 5 байтів та навчання мене про функцію vim, про яку я ніколи не знав!

Якби ми могли припустити, що вхід ніколи не виходить за межі, це було б просто 9 байт:

¬61énÀxVp

Але, на жаль, це не дозволено.

Пояснення:

:sil!           " If the cursor goes out of bounds, ignore it and continue
     î          " Run the following keystrokes as V code, rather than vimscript:
      ¬61       "   Insert the string "654321". This will leave the cursor on the '1'
         én     "   Insert an 'n'
           À    "   Run the first arg as V code. This will move left and right a bunch of times
            x   "   Delete whatever character we ended up on
             V  "   Select this whole line,
              p "   And replace it with the character we just deleted

Java 7, 106 105 103 байт

char c(String s){int r=1;for(int c:s.toCharArray())r+=c<99?1:-1;return"1N23456".charAt(r<0?0:r>6?6:r);}

Пояснення:

char c(String s){                // Method with String input and character return-type
  int r = 1;                     // Result-index (0-indexed and starting at 1)
  for(int c : s.toCharArray()){  // Loop over all characters in the input String
    r += c < 99 ?                //  If the current character is '^':
           1                     //   Raise the result-index by 1
         :                       //  If it is 'v' instead:
           -1;                   //   Decrease the result-index by 1
  }
  return "1N23456".charAt(       // Return the character based on the return-index:
           r < 0 ?               //  If the result-index is below 0
                  0              //   Use 0 instead
                 : r > 6 ?       //  Else-if the result-index is above 6
                          6      //   Use 6 instead
                         :       //  Else
                          r);    //   Use the result-index
}

Код тесту:

Спробуйте тут.

class M{
  static char c(String s){int r=1;for(int c:s.toCharArray())r+=c<99?1:-1;return"1N23456".charAt(r<0?0:r>6?6:r);}

  public static void main(String[] a){
    System.out.println(c("v^^"));
    System.out.println(c("^^^^^^^^"));
    System.out.println(c("vvvv^^^vvvv"));
    System.out.println(c("^v^v^v^v"));
  }
}

Вихід:

2
6
1
N

Хаскелл, 59 53 51 байт

("1N23456"!!).foldl(\l c->max 0$min 6$l+read[c]-1)1

Використання 0для вниз і 2для вгору Приклад використання:

(("1N23456"!!).foldl(\l c->max 0$min 6$l+read[c]-1)1) "0002"

Дякуємо @xnor за зняття 6 байт! Крім того, виявляється, мені не потрібні ім'я функції або дужки, так що це ще 2 байти.

JavaScript (ES6), 48 58 байт

s=>"1N23456"[[1,...s].reduce((a,b)=>a?a<6?+b?a+1:a-1:6:0)]

Використання

Призначте її функції, а потім зателефонуйте. Введення - це рядок, що містить a 1для швидкого зсуву, а 0для - для зниження.

f=s=>"1N23456"[[1,...s].reduce((a,b)=>a?a<6?+b?++a:a--:6:0)]
f("011")
-> "2"
f("0")
-> "1"
f("01")
-> "N"

PHP 7.1, 71 байт

for(;$c=$argv[1][$i++];))$g=max(-1,min($g+=$c<=>X,5));echo N234561[$g];

змінює $gвід -1 до 5, використовує від'ємне зміщення струни для першої передачі.
Запустіть -nr, надайте рядок зміщення як аргумент командного рядка.

Желе , 17 14 байт

1;r2ị$¥/CỊ¡o”N

Використання 6для вгору і 0для вниз.

Спробуйте в Інтернеті!

Як це працює

1;r2ị$¥/CỊ¡o”N  Main link. Argument: s (string of 6's and 0's)

1;              Prepend a 1 (integer) to the string/character array s.
       /        Reduce the result by the following dyadic link.
                Let's call the arguments x and y.
      ¥           Create a dyadic chain of 2 links:
  r                 Construct the range [x, ..., y] (increasing or decreasing).
                    y will be a character, but 'r' casts both argument to int.
                    This is intended for use with floats, but it works just as well
                    when the argument is a digit.
     $              Create a monadic chain of two links:
   2ị                 Take the second element of the constructed range.
                  When y = 6 > x, this gives x + 1.
                  When y = 0 < x, this gives x - 1.
                  When y = x, the range is a singleton array, so this gives x.
          ¡     Conditional application:
         Ị        If the previous result is insignificant (0 or 1):
        C           Subtract it from 1.
                This swaps 0 and 1 without affecting the other potential outcomes.
           o”N  Logical OR with 'N', replacing 0 with that character.

Рубін, 58 байт

->s{a=1;s.chars{|b|a-=[a<=>0,a<=>6][b<=>?v]};"1N23456"[a]}

Очікуваний вхід - "v" для зниження та "^" для швидкого переходу

Обробка JS (модифікована) 121 байт

var g="1N23456",a="",c=0; for(var i=0;i<a.length;i++){if(a[i]==="d"&&c>0){c--;}else if(c<6&&a[i]==="u"){c++;}}println(g[c]);

Безумовно

var g=[1,"N",2,3,4,5,6],a="",c=0;
for(var i=0;i<a.length;i++)
{if(a[i]==="d"&&c>0)
{
    c--;

}else if(c<6&&a[i]==="u")
{
    c++;

}

}
println(g[c]);

Спробуйте в Інтернеті!

Я пішов з PJ, оскільки я це добре знаю. Єдина проблема - версія, яку я використовую, дуже суворо набрана. Я не можу залишити дужки і безліч інших хитрощів. Це досить просто. Вхід повинен входити в змінну, aі вона займає малі регістри u d. Програма циклічно, поки не потрапить у кінець рядка, і кожну ітерацію вона перевіряє, чи є вона a чи d. Якщо це так, і він не спробує перенести повз туди, куди ви можете. Наприкінці роздруковую результати!

k, 25 байт

"1N23456"@{6&0|x+y-92}/1,

Він приймає введення як рядок, і використовує як [для зменшення, так і ]для переключення вниз, оскільки вони зручно розташовані.

"1N23456"@                / the numbers 0 to 6 are used for the gears,
                          / this turns them into the correct number/letter
                       1, / prepend 1 because this is our initial gear
          {          }/   / fold the function through the list
                          / x is before, y is the next character
                 y-92     / subtract 92, which is between "[" and "]"
                          / "[" becomes -1 and "]" becomes 1
               x+         / add it to what we had before
           6&0|           / use max and min to set boundaries 6 and 0

Приклади:

 shift:"1N23456"@{6&0|x+y-92}/1,
 shift"[]]"
"2"
 shift"]]]]]]]]"
"6"
 shift"[[[[]]][[[["
"1"
 shift"[][][][]"
"N"
 shift"[[[[[[[[]"
"N"
 shift"]]]]]]]]["
"5"

GNU sed , 89 87 + 1 (r прапор) = 88 байт

Оскільки sed не має цілих типів чи арифметичних операцій, до рішення доходить лише за допомогою регулярних виразів.

s:$:65432Nx1:
:
/6x/!s:^U(.*)(.)x:\1x\2:
s:^D(.*)x(.):\1\2x:
t
s:U|D::
t
s:.*(.)x.*:\1:

Це працює, ковзаючи покажчик xна основі кожного зсуву введення, вліво (для Up) або праворуч (для Dвласного), вздовж не обертаючої стрічки, що містить лише комірки 65432N1. Відповідь в кінці - це значення в комірці зліва від вказівника.

Приклад запуску: або Спробуйте в Інтернеті!

sed -rf gear.sed <<< "UUUUUUD"
5

Пояснення:

s:$:65432Nx1:              # assign initial tape and pointer
:                          # start loop
/6x/!s:^U(.*)(.)x:\1x\2:   # if shift 'U', slide `x` to left, but not past the edge
s:^D(.*)x(.):\1\2x:        # if shift 'D', slide `x` to right, -||-
t                          # repeat
s:U|D::                    # if a shift couldn't be applied, delete it "manually",
t                          # and jump to the start of the loop again
s:.*(.)x.*:\1:             # print value left of pointer `x` (answer)

GNU sed , 76 73 байт

Включає +1 для -r

s/$/1/
:
/1{6}/!s/^U(.*)/\11/
s/^D(.*)1/\1/
t
s/U|D//
t
s/^1$/N/
s/^$/1/

Вихід є не одинаковим, крім нейтрального, який все ще є N (див. Цю консенсус ).

Спробуйте в Інтернеті!

Це в основному рахується вгору і вниз в одинаковому, а потім перетворює 1 в N і 0 в 1.

s/$/1/               # add 1 to the end (the starting value)
:                    # loop start
/1{6}/!s/^U(.*)/\11/ # If the string starts with 'U' and doesn't have 6 ones, increment
s/^D(.*)1/\1/        # If the string starts with 'D' decrement (but not past 0)
t                    # if something changed loop back
s/U|D//              # if the U or D couldn't be applied, remove it.
t                    # if something changed loop back
s/^1$/N/             # replace 1 with N
s/^$/1/              # if "0", replace with 1

Rebol, 96 93 байт

f: func[s][g: next"1N23456"parse s[any["D"(g: back g)|"U"(unless tail? x: next g[g: x])]]g/1]

Безголівки:

f: func [s] [
    g: next "1N23456"
    parse s [
        any [
              "D" (g: back g)
            | "U" (unless tail? x: next g [g: x])
        ]
    ]
    g/1
]

Приклад використання (у консолі Rebol):

>> print f "DUU"         
2

>> print f "DDDUU"
2

>> print f "UUUUUUUUU"  
6

>> print f "UUUUUUUUUD"
5

> <> , 35 байт

Захоплений фрагмент коду, який спонукає вас їхати понад обмеження швидкості.

Приймає будь-які два входи, кодовим модулем 3 яких є 0 і 2, наприклад 0і 2.
Для додаткової рибності рекомендую використовувати <та >.

1i:0(?;3%1-+:0(?0:6)?6:1go!
1N23456

Пояснення:

1i:0(?;3%1-+:0(?0:6)?6:1go!
1                             # initial position
 i                            # read the next char
  :0(?;                       # copies it, test copy against 0, if lower stops (EOF detection)
       3%1-                   # map the char to -1 or 1
           +                  # add it to the position
            :0(?0             # if the new position is lower than 0, set to 0
                 :6)?6        # if the new position is greater than 6, set to 6
                      :1go    # output a character from line 1 at the position
                          !   # loops and skip the position initialisation

Ви можете спробувати тут !

SpecBAS - 102

1 g=2: INPUT s$
2 FOR i=1 TO LEN s$
3 g+=(s$(i)="^" AND g<7)-(s$(i)="v" AND g>1)
4 NEXT i
5  ?"1N23456"(g)

Переміщує індекс рядка залежно від введення та друкує відповідний символ.

Pyth, 32 байти

J1VQ=JhtS[06+J-qNbqNd;?qJ1\N?JJ1

Використовує простір та нову лінію для вниз та вгору.

Пояснення

J1VQ=JhtS[06+J-qNbqNd;?qJ1\N?JJ1
J1                                 Initialize J to 1
  VQ                 ;             For each character in the input
            +J-qNbqNd              Increment or decrement J
      htS[06                       Get the middle sorted value of [0,6,J]
    =J                             Assign it to J
                      ?qJ1\N?JJ1   Change 1 to 'N' and 0 to 1

Майже напевно є кращий спосіб зробити збільшення і вихід.

CJam , 24 22 байти

"1N23456"1q{~0e>6e<}/=

Використання (для вниз і )для вгору

Спробуйте в Інтернеті!

Пояснення

"1N23456"               e# Push the string containing all gears
         1              e# Push 1, the initial index
          q             e# Push the input
           {            e# For each character in the input
            ~           e#   Eval that character. ( is decrement and ) is increment.
             0e>        e#   Take the maximum of (0, index)
                6e<     e#   Take the minimum of (6, index)
                   }/   e# (end of block)
                     =  e# Take that index of the string

Пакет, 144 байти

@set/ps=
@set g=1
:l
@if %g% neq %s:~,1% set/ag+=%s:~,1%/3-1
@set s=%s:~1%
@if not "%s%"=="" goto l
@if %g%==1 (echo N)else cmd/cset/ag+!g

Здійснює вхід на STDIN, використовуючи 0для переходу на нижчу передачу та 6переходу на більш високу передачу. Ці цифри були вибрані для полегшення ігнорування поточної передачі. Нарешті, якщо шестерня 1потім Nдрукується інакше 0, перетворюється на 1та передачу.

Javascript ES6 необмежений, 136 120 символів

136 годин за V^

with({get x(){return Math.max(0,Math.min(y,6))},set x(v){y=v}})f=s=>eval(s.replace(/(V)|./g,(m,v)=>`x${"-+"[+!v]}=1,`,y=1)+'"1N"[x]||x')

with({get x(){return Math.max(0,Math.min(y,6))},set x(v){y=v}})
f=s=>eval(s.replace(/(V)|./g,(m,v)=>`x${"-+"[+!v]}=1,`,y=1)+'"1N"[x]||x')
console.log(f("V^^"))

120 символів для -+

with({get x(){return Math.max(0,Math.min(y,6))},set x(v){y=v}})f=s=>eval(s.replace(/./g,m=>`x${m}=1,`,y=1)+'"1N"[x]||x')

with({get x(){return Math.max(0,Math.min(y,6))},set x(v){y=v}})
f=s=>eval(s.replace(/./g,m=>`x${m}=1,`,y=1)+'"1N"[x]||x')
console.log(f("-++"))

Сітківка , 65 байт

^
1 N23456
+(` (.)?(\w*6)u
$1 $2
)`(.)? (\w*6)d
 $1$2
.* (.).*
$1

Використання uі dдля вгору і вниз.

Спробуйте в Інтернеті!

Пояснення

Ця програма працює, дотримуючись 1N23456послідовності інструкцій. Він відстежує поточну передачу, маючи за собою пробіл. Потім потрібна одна інструкція за раз, поки не буде більше.

^
1 N23456

Почніть з введення 1 N23456перед введенням. Пробіл раніше Nвказує, що Nце поточна передача.

+(` (.)?(\w*6)u
$1 $2
)`(.)? (\w*6)d
 $1$2

Це два етапи заміни, згруповані разом і виконуються до тих пір, поки вони не перестануть змінювати рядок:

 (.)?(\w*6)u
$1 $2

Перша ручка перемикає передачу вгору. Він буде шукати будь-яку кількість передач після пробілу, а потім a 6, а потім слідує u( uвказує інструкцію щодо перемикання передач вгору). Якщо до 6 були символи, він замінює пробіл символом відразу після нього, видаляє uта залишає решту рядка недоторканою. Оскільки значення 6є обов'язковим у поєдинку, воно буде змінювати місця лише будь-яким символом перед символом 6. Він ніколи не буде мінятися на 6.

(.)? (\w*6)d
 $1$2

Другий етап обробляє перемикання передач вниз і працює аналогічно. Необов'язково виглядає персонаж перед пробілом, потім деякі інші передачі після закінчення 6, а потім d. Він міняє простір символом перед ним, видаляє d, а решту залишає недоторканими. Якщо пробіл знаходився на початку рядка, перед символом пробілу не було відповідності символу, тому не відбувається жодного підміна.

.* (.).*
$1

Після того, як жодна з перерахованих вище замін більше не може бути виконана, всі зміни шестерень завершені. Лінія очищається від усього, крім шестірні, відразу після пробілу. Це заключна передача.

Powershell, 112 87 85 байт

$i=1;switch([char[]]$args[0]){'^'{if(5-gt$i){$i++}}'v'{if(1-le$i){$i--}}}'1N2345'[$i]

неозорий

$i=1;                                # index which gear we are in
switch([char[]]$args[0]){            # loop over all elements using a switch
  '^'{if(5-gt$i){$i++}}             # if there is a ^ and we are not in sixth yet, shift up
  'v'{if(1-le$i){$i--}}             # if there is a v and we are not in first, shift down
}
'1N2345'[$i]                         # print the output

врятувало 25 байт, прочитавши поради з кодексу гольфу на честь коду

збережено 2 байти, перевернувши оператори gt / le

Perl 6, 144 байти

my enum C <1 N 2 3 4 5 6>;my $n=prompt("");my $p=1;for split("",$n) ->$l {$l eq "u" && $p < 6 ?? ++$p !! 0;$l eq"d"&&$p>0 ?? --$p!!0};say C($p);

Працює як слід, я вважаю. Поліпшення вітаються. Перший раз використовував Perl ні для чого, але мені сподобалася думка про мову, тому мені довелося спробувати.

Clojure, 74 байти

#((vec "1N23456")(reduce(fn[c s](max 0(min 6((if(= s \^)inc dec)c))))1 %))

Складається над рядком зсуву, підтримуючи індекс як акумулятор. Кожну ітерацію вона або збільшує, або зменшує індекс, а потім затискає до діапазону 0-6. Нарешті, рядок, що тримає передачі, індексується та повертається.

Повертає символ Clojure, що представляє поточну передачу. Шестірня 1 повертається як \1, а передача 'N' повертається як \N.

Попереднє пояснення гольфу. Слідкуйте за номерами, оскільки він не добре читається зверху вниз.

; Expects ^ for shift-up, and V (or anything else) for shift down
; Returns a character representing the current gear
(defn shift [shift-str]
  ((vec "1N23456") ; 4. Then index the gear list with the calculated index, and return
   (reduce (fn [current-gear s] ; 1. Fold over the shift symbols
             (max 0 (min 6 ; 3. Clamp it to the range 0-6 so we don't overflow
                      ((if (= s \^) inc dec) ; 2. If the shift is up, increase, else decrease
                       current-gear))))
           1
           shift-str)))

Пітон 3, 67 63 байт

k=1
for i in input():k+=[k<6,-(k>0)][i<'1']
print('1N23456'[k])

Досить просте рішення.

-4 байти завдяки @ovs!