Beberapa dari Anda mungkin terbiasa dengan cara sepeda motor bergeser. Tetapi bagi mereka yang tidak, Sepertinya ini

6

5

4

3

2

N

1

Sekarang saya ingin tahu gigi apa yang saya pakai setelah melakukan beberapa shift naik dan turun. Program harus bekerja dari netral.

Masukan sampel:

V^^

Output sampel:

2

Seperti yang Anda lihat, saya turun satu kali dari N ke 1 dan naik dua kali ke gigi 2.

Ini adalah kode golf. Jawaban terpendek dalam byte menang.

Catatan: Input dapat berupa 2 karakter. Dapat berupa U dan D untuk naik dan turun atau apa pun yang Anda inginkan harus berupa string . Anda tidak dapat bergeser melampaui gigi 1 atau 6. Jika Anda berada di 6 dan naik lagi itu akan tinggal di 6. Semoga berhasil!

JavaScript (ES6), 49 48 47 46 byte

Mengharapkan:

• 1 untuk turun
• 7 untuk naik

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

Diformat dan dikomentari

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

Roda gigi dipetakan sebagai berikut:

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)

Yang memungkinkan kami untuk dengan mudah memeriksa validitas gigi saat ini dengan:

(g & 7) != 0

Demo

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 byte

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

Cobalah online!

Penjelasan

Î                      # 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 byte

5 byte disimpan berkat @Luis

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

Solusi ini digunakan '2'untuk naik dan '0'turun.

Cobalah di MATL Online

Penjelasan

'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 byte

:sil!î¬61énÀxVp

Cobalah online!

Input adalah serangkaian karakter h(atas) dan l(bawah).

Terima kasih kepada @nmjcman karena telah menghemat 5 byte dan mengajari saya tentang fitur vim yang tidak pernah saya ketahui!

Jika kita bisa berasumsi bahwa input tidak pernah keluar dari batas, itu hanya akan menjadi 9 byte:

¬61énÀxVp

Tapi sayangnya itu tidak diperbolehkan.

Penjelasan:

: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 byte

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

Penjelasan:

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
}

Kode uji:

Coba di sini.

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"));
  }
}

Keluaran:

2
6
1
N

Haskell, 59 53 51 Bytes

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

Gunakan 0untuk turun dan 2naik. Contoh penggunaan:

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

Terima kasih kepada @xnor karena melepas 6 byte! Juga, ternyata saya tidak perlu nama fungsi atau tanda kurung jadi itu 2 byte lagi.

JavaScript (ES6), 48 58 byte

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

Pemakaian

Tetapkan ke suatu fungsi, lalu panggil. Input adalah string yang berisi 1untuk upshift, dan 0untuk downshift.

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 byte

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

bergeser $gdari -1 ke 5, menggunakan offset string negatif untuk gigi pertama.
Jalankan dengan -nr, berikan string penggeser sebagai argumen baris perintah.

Jelly , 17 14 byte

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

Penggunaan 6untuk naik dan 0turun.

Cobalah online!

Bagaimana itu bekerja

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.

Ruby, 58 byte

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

Input yang diharapkan adalah 'v' untuk downshift dan '^' untuk upshift

Memproses JS (dimodifikasi) 121 byte

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]);

Tidak disatukan

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]);

Cobalah online!

Saya pergi dengan PJs karena saya tahu betul. Satu-satunya masalah adalah versi yang saya gunakan diketik dengan sangat ketat. Saya tidak bisa meninggalkan tanda kurung dan banyak trik lainnya. Sederhana saja. Input harus masuk ke variabel adan butuh huruf kecil u d. Program loop sampai menyentuh ujung string dan setiap iterasi itu memeriksa untuk melihat apakah itu au atau d. Jika ya dan tidak akan mencoba dan "menggeser" masa lalu di mana Anda bisa, itu bergeser. Pada akhirnya saya mencetak hasilnya!

k, 25 byte

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

Dibutuhkan input sebagai string, dan digunakan [untuk downshift, dan ]untuk upshift, karena mereka berlokasi.

"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

Contoh:

 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 flag) = 88 byte

Karena sed tidak memiliki tipe integer atau operasi aritmatika, solusinya didapat dengan menggunakan ekspresi reguler saja.

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

Ia bekerja dengan menggeser pointer xberdasarkan pada masing-masing shift input, kiri (untuk Up) atau kanan (untuk Dsendiri), sepanjang pita non-pembungkus yang hanya berisi sel-sel 65432N1. Jawaban di akhir adalah nilai di sel sebelah kiri pointer.

Contoh jalankan: atau Coba online!

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

Penjelasan:

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 byte

Termasuk +1 untuk -r

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

Keluaran dalam unary kecuali netral, yang masih N(lihat konsensus ini ).

Cobalah online!

Ini pada dasarnya menghitung naik dan turun di unary kemudian mengkonversi 1 ke N dan 0 ke 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 byte

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

Tidak Disatukan:

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

Contoh penggunaan (dalam konsol Rebol):

>> print f "DUU"         
2

>> print f "DDDUU"
2

>> print f "UUUUUUUUU"  
6

>> print f "UUUUUUUUUD"
5

> <> , 35 byte

Sepotong kode antusias yang mendorong Anda untuk mengemudi di atas batas kecepatan.

Menerima setiap dua input yang kode kodenya 3 adalah 0 dan 2, misalnya 0dan 2.
Untuk lebih mencurigakan, saya merekomendasikan penggunaan <dan >.

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

Penjelasan:

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

Anda bisa mencobanya di sini !

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)

Memindahkan indeks string tergantung pada input dan mencetak karakter yang relevan.

Pyth, 32 byte

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

Menggunakan ruang dan baris baru untuk turun dan naik.

Penjelasan

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

Hampir pasti ada cara yang lebih baik untuk melakukan peningkatan dan output.

CJam , 24 22 byte

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

Gunakan (untuk turun dan )naik.

Cobalah online!

Penjelasan

"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

Batch, 144 byte

@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

Mengambil input pada STDIN, gunakan 0untuk pergi ke gigi yang lebih rendah dan 6untuk pergi ke gigi yang lebih tinggi. Angka-angka ini dipilih untuk memudahkan mengabaikan gigi saat ini. Akhirnya jika roda gigi dicetak 1maka Njika 0tidak dikonversi menjadi 1dan roda gigi dicetak.

Javascript ES6 nonstrict, 136 120 karakter

136 karakter untuk 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 karakter untuk -+

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("-++"))

Retina , 65 byte

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

Penggunaan u dan duntuk naik turun.

Cobalah online!

Penjelasan

Program ini bekerja dengan menjaga 1N23456urutan instruksi. Ini melacak gigi saat ini dengan memiliki ruang di belakangnya. Kemudian dibutuhkan satu instruksi pada satu waktu sampai tidak ada lagi.

^
1 N23456

Mulailah dengan meletakkan 1 N23456sebelum input. Ruang sebelumnya Nmenunjukkan bahwa itu Nadalah gigi saat ini.

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

Ini adalah dua tahap penggantian, dikelompokkan bersama, dan dijalankan hingga berhenti mengubah string:

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

Yang pertama menangani menggeser gigi ke atas. Ini akan mencari sejumlah roda gigi setelah ruang, diikuti oleh 6, kemudian diikuti oleh u( umenunjukkan instruksi untuk perpindahan gigi ke atas). Jika ada karakter sebelum 6, itu menukar ruang dengan karakter segera setelah itu, menghapus u, dan meninggalkan sisa string. Karena 6itu wajib dalam pertandingan, itu hanya akan menukar ruang dengan karakter apa pun sebelum 6. Itu tidak akan pernah bertukar dengan 6.

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

Tahap kedua menangani perpindahan gigi ke bawah, dan bekerja dengan cara yang sama. Itu terlihat opsional untuk karakter sebelum ruang, kemudian beberapa gigi lain setelah berakhir 6, diikuti oleh d. Ini menukar ruang dengan karakter di depannya, menghapus d, dan membiarkan sisanya tetap utuh. Jika spasi di awal string, tidak ada kecocokan untuk karakter sebelum spasi, jadi tidak ada swap terjadi.

.* (.).*
$1

Setelah penggantian di atas tidak dapat dilakukan lagi, semua perpindahan gigi telah selesai. Garis dibersihkan dari segala sesuatu kecuali roda gigi segera setelah ruang. Ini adalah gigi terakhir.

Powershell, 112 87 85 byte

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

ungolfed

$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

menghemat 25 byte dengan membaca tips codegolf PowerShell

disimpan 2 byte dengan membalik operator gt / le

Perl 6, 144 byte

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);

Bekerja sebagaimana mestinya, saya percaya. Perbaikan dipersilahkan. Pertama kali menggunakan Perl untuk apa pun, tetapi saya menyukai pemikiran bahasanya, jadi saya harus mencoba.

Clojure, 74 byte

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

Lipat pada string shift, mempertahankan indeks sebagai akumulator. Setiap iterasi meningkatkan atau menurunkan indeks, kemudian menjepitnya ke kisaran 0-6. Akhirnya, sebuah string yang menahan persneling diindeks dan dikembalikan.

Mengembalikan karakter Clojure yang mewakili gir saat ini. Gear 1 dikembalikan sebagai \1, dan gear 'N' dikembalikan sebagai \N.

Penjelasan pra-golf. Ikuti angkanya, karena tidak membaca dari atas ke bawah dengan baik

; 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)))

Python 3, 67 63 byte

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

Solusi yang sangat mudah.

-4 byte terima kasih kepada @ovs!