Einige von Ihnen kennen vielleicht die Art und Weise, wie ein Motorrad schaltet. Aber für diejenigen, die es nicht tun, sieht es so aus

6

5

4

3

2

N

1

Jetzt möchte ich wissen, in welchem ​​Gang ich bin, nachdem ich ein paar Hoch- und Runterschaltungen durchgeführt habe. Das Programm sollte von neutral funktionieren.

Beispieleingabe:

V^^

Beispielausgabe:

2

Wie Sie sehen, habe ich einmal von N auf 1 und zweimal auf den 2. Gang hochgeschaltet.

Dies ist ein Code Golf. Kürzeste Antwort in Bytes gewinnt.

Hinweis: Die Eingabe kann aus 2 beliebigen Zeichen bestehen. Kann U und D für oben und unten sein oder was auch immer Sie wollen, es muss eine Zeichenfolge sein . Sie können nicht über den 1. oder 6. Gang hinaus schalten. Wenn Sie auf dem sechsten Platz sind und wieder hochschalten, bleibt es auf dem sechsten Platz. Viel Glück!

JavaScript (ES6), 49 48 47 46 Bytes

Erwartet:

• 1 für unten
• 7 für bis

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

Formatiert und kommentiert

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

Zahnräder werden wie folgt abgebildet:

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)

So können wir auf einfache Weise die Gültigkeit des aktuellen Zahnrads überprüfen:

(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 Bytes

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

Probieren Sie es online!

Erläuterung

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

5 Bytes gespart dank @Luis

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

Diese Lösung dient '2'zum Hochschalten und '0'zum Herunterschalten.

Probieren Sie es bei MATL Online aus

Erläuterung

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

:sil!î¬61énÀxVp

Probieren Sie es online!

Die Eingabe ist eine Zeichenfolge aus h(Auf) und l(Ab) Zeichen.

Vielen Dank an @nmjcman für das Speichern von 5 Bytes und das Erlernen einer vim-Funktion, von der ich noch nie etwas gewusst habe!

Wenn wir annehmen könnten, dass die Eingabe niemals außerhalb der Grenzen liegt, wären es einfach 9 Bytes:

¬61énÀxVp

Das ist aber leider nicht erlaubt.

Erläuterung:

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

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

Erläuterung:

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
}

Testcode:

Probieren Sie es hier aus.

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

Ausgabe:

2
6
1
N

Haskell, 59 53 51 Bytes

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

Gebrauch 0für unten und 2für oben. Anwendungsbeispiel:

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

Danke an @xnor für die 6 Bytes! Es stellte sich heraus, dass ich keinen Funktionsnamen oder Klammern benötige, das sind also weitere 2 Bytes.

JavaScript (ES6), 48 58 Bytes

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

Verwendung

Weisen Sie es einer Funktion zu und rufen Sie es dann auf. Die Eingabe ist eine Zeichenfolge, die ein 1für ein Hochschalten und ein 0für ein Herunterschalten enthält.

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 Bytes

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

wechselt $gvon -1 auf 5, verwendet negativen Saitenversatz für den ersten Gang.
Führen Sie mit aus -nr, und geben Sie die Umschaltzeichenfolge als Befehlszeilenargument an.

Jelly , 17-14 Bytes

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

Verwendet 6für oben und 0unten.

Probieren Sie es online!

Wie es funktioniert

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 Bytes

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

Die erwartete Eingabe ist 'v' für ein Herunterschalten und '^' für ein Hochschalten

Verarbeitung von JS (geändert) 121 Bytes

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

Ungolfed

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

Probieren Sie es online!

Ich ging mit PJs, da ich es gut kenne. Das einzige Problem ist, dass die Version, die ich verwende, sehr streng getippt ist. Ich kann Klammern und viele andere Tricks nicht auslassen. Das ist ziemlich einfach. Die Eingabe sollte in die Variable gehen aund es dauert Kleinbuchstaben u d. Das Programm durchläuft eine Schleife, bis es das Ende der Zeichenfolge erreicht und bei jeder Iteration überprüft, ob es sich um ein au oder ein d handelt. Wenn es so ist und es nicht versucht, vorbei zu "verlagern", wo Sie können, verlagert es sich. Am Ende drucke ich die Ergebnisse!

k, 25 Bytes

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

Es nimmt Eingaben als Zeichenfolge und wird [zum Herunterschalten und ]Hochschalten verwendet, da sie günstig angeordnet sind.

"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

Beispiele:

 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 Bytes

Da sed keine ganzzahligen Typen oder arithmetischen Operationen hat, wird die Lösung nur mit regulären Ausdrücken erreicht.

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

Bewegen Sie den Zeiger xbei jeder Eingangsverschiebung nach links (für Up) oder rechts (für Down) entlang eines nicht umhüllenden Bands, das nur die Zellen enthält 65432N1. Die Antwort am Ende ist der Wert in der Zelle links vom Zeiger.

Beispiellauf: oder Online ausprobieren!

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

Erläuterung:

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 Bytes

Beinhaltet +1 für -r

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

Die Ausgabe ist unärgerlich, mit Ausnahme der neutralen Ausgabe N(siehe diesen Konsens ).

Probieren Sie es online!

Dies zählt im Grunde genommen unär auf und ab und wandelt dann 1 in N und 0 in 1 um.

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 Bytes

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

Ungolfed:

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

Anwendungsbeispiel (in der Rebol-Konsole):

>> print f "DUU"         
2

>> print f "DDDUU"
2

>> print f "UUUUUUUUU"  
6

>> print f "UUUUUUUUUD"
5

> <> , 35 Bytes

Ein begeisterter Code, der Sie ermutigt, über das Tempolimit hinaus zu fahren.

Akzeptiert alle zwei Eingängen , dessen Code modulo 3 sind 0 und 2 beispielsweise 0und 2.
Für zusätzliche Fischigkeit empfehle ich die Verwendung von <und >.

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

Erklärung:

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

Sie können es hier ausprobieren !

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)

Verschiebt den Index des Strings abhängig von der Eingabe und druckt das entsprechende Zeichen.

Pyth, 32 Bytes

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

Benutzt Leerzeichen und Zeilenvorschub für Ab und Auf.

Erläuterung

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

Es gibt mit ziemlicher Sicherheit eine bessere Möglichkeit, das Inkrementieren und die Ausgabe durchzuführen.

CJam , 24 22 Bytes

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

Gebrauch (für unten und )für oben.

Probieren Sie es online!

Erläuterung

"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 Bytes

@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

Übernimmt die Eingabe in STDIN, 0um in einen niedrigeren und 6in einen höheren Gang zu schalten. Diese Nummern wurden gewählt, um das Ignorieren des aktuellen Gangs zu vereinfachen. Schließlich, wenn das Zahnrad 1dann Ngedruckt wird, wird anderweitig 0konvertiert 1und das Zahnrad gedruckt.

Javascript ES6 uneingeschränkt, 136 120 Zeichen

136 Zeichen für 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 Zeichen für -+

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

Netzhaut , 65 Bytes

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

Verwendet uund dfür auf und ab.

Probieren Sie es online!

Erläuterung

Dieses Programm arbeitet so, dass 1N23456die Reihenfolge der Anweisungen eingehalten wird. Es verfolgt den aktuellen Gang, indem es ein Leerzeichen dahinter hat. Dann dauert es eine Anweisung nach der anderen, bis es keine mehr gibt.

^
1 N23456

Beginnen Sie mit dem Setzen 1 N23456vor der Eingabe. Das vorangestellte Leerzeichen Nzeigt an, dass Nes sich um den aktuellen Gang handelt.

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

Hierbei handelt es sich um zwei Ersetzungsstufen, die in Gruppen zusammengefasst sind und so lange ausgeführt werden, bis die Zeichenfolge nicht mehr geändert wird:

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

Der erste befasst sich mit dem Hochschalten des Gangs. Nach dem Leerzeichen wird nach einer beliebigen Anzahl von Gängen gesucht, gefolgt von einem 6, gefolgt von u( uzeigt die Anweisung zum Hochschalten an). Wenn sich vor der 6 Zeichen befanden, wird das Leerzeichen mit dem Zeichen unmittelbar danach vertauscht u, das Zeichen gelöscht und der Rest der Zeichenfolge bleibt erhalten. Da das 6im Match obligatorisch ist, wird nur das Leerzeichen mit einem Zeichen vor dem ausgetauscht 6. Es wird nie mit dem tauschen 6.

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

Die zweite Stufe übernimmt das Herunterschalten und funktioniert ähnlich. Es wird optional nach einem Zeichen vor dem Leerzeichen gesucht, danach nach einigen anderen Gängen, die auf enden 6, gefolgt von d. Es tauscht das Leerzeichen mit dem Zeichen davor aus, löscht das dund lässt den Rest intakt. Wenn sich das Leerzeichen am Anfang der Zeichenfolge befand, gab es keine Übereinstimmung für ein Zeichen vor dem Leerzeichen, sodass kein Auslagerungsvorgang stattfindet.

.* (.).*
$1

Nachdem keiner der oben genannten Austauschvorgänge mehr ausgeführt werden kann, sind alle Schaltvorgänge abgeschlossen. Die Linie wird sofort nach dem Leerzeichen von allem außer dem Zahnrad befreit. Dies ist der letzte Gang.

Powershell, 112 87 85 Bytes

$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

25 Bytes gespart, indem die Tipps zum Powershell-Codegolf gelesen wurden

sparte 2 Bytes durch Spiegeln der gt / le Operatoren

Perl 6, 144 Bytes

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

Funktioniert wie es sollte, glaube ich. Verbesserungen sind willkommen. Das erste Mal mit Perl, aber ich mochte den Gedanken an die Sprache, also musste ich es versuchen.

Clojure, 74 Bytes

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

Faltet den Shift-String um und behält einen Index als Akkumulator bei. Bei jeder Iteration wird der Index entweder vergrößert oder verkleinert und dann auf den Bereich 0-6 geklemmt. Schließlich wird ein String mit den Zahnrädern indiziert und zurückgegeben.

Gibt ein Clojure-Zeichen zurück, das den aktuellen Gang darstellt. Gang 1 wird zurückgegeben als \1und Gang 'N' wird zurückgegeben als \N.

Pre-Golf Erklärung. Befolgen Sie die Zahlen, da sie von oben nach unten nicht gut lesbar sind.

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

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

Ziemlich einfache Lösung.

-4 Bytes dank @ovs!