여러분 중 일부는 오토바이가 변속하는 방식에 익숙 할 것입니다. 하지만 그렇지 않은 사람들에게는

6

5

4

삼

2

엔

1

이제 몇 번의 위아래 이동을 수행 한 후 어떤 장비를 사용하고 있는지 알고 싶습니다. 프로그램은 중립에서 작동해야합니다.

샘플 입력 :

V^^

샘플 출력 :

2

보시다시피 나는 N에서 1로 한 번 다운 시프트하고 두 번째 기어로 두 번 업 시프트했습니다.

이것은 코드 골프입니다. 바이트 단위의 최단 답변이 이깁니다.

참고 : 입력은 2 자일 수 있습니다. 위아래로 U와 D 가 될 수도 있고 원하는 문자열이 될 수도 있습니다 . 1 단 또는 6 단 이상으로 변속 할 수 없습니다. 당신이 6에 있고 다시 변속한다면 그것은 6에 남아있을 것입니다. 행운을 빕니다!

자바 스크립트 (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 바이트

@Luis 덕분에 5 바이트 절약

'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(아래) 문자 의 문자열입니다 .

5 바이트를 절약하고 내가 알지 못했던 vim 기능에 대해 가르쳐 주신 @nmjcman에게 감사드립니다!

입력이 절대 범위를 벗어나지 않는다고 가정 할 수 있다면 단순히 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

자바 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"

6 바이트를 빼낸 @xnor에게 감사합니다! 또한 함수 이름이나 괄호가 필요하지 않으므로 다른 2 바이트입니다.

자바 스크립트 (ES6), 48 58 바이트

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

용법

함수에 할당 한 다음 호출하십시오. 입력은 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), 제 1 기어 오프셋 제외 문자열을 사용한다.
로 실행하고 -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합니다. 프로그램은 문자열의 끝에 도달 할 때까지 반복되며, 모든 반복이 au인지 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

리볼, 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기어가 인쇄됩니다.

자바 스크립트 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

첫 번째는 기어 변속을 처리합니다. 공간 다음에 임의의 수의 기어를 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

powershell codegolf 팁 을 읽어 25 바이트 절약

gt / le 연산자를 뒤집어 2 바이트 절약

펄 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을 사용했지만 언어에 대한 생각이 마음에 들었으므로 시도해야했습니다.

클로저, 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])

매우 간단한 솔루션입니다.

@ovs 덕분에 -4 바이트!