Certains d’entre vous connaissent peut-être la façon dont une moto change de vitesse. Mais pour ceux qui ne le font pas, ça ressemble à ça

6

5

4

3

2

N

1

Maintenant, je veux savoir dans quel équipement je me trouve après avoir effectué quelques montées et descentes. Le programme devrait fonctionner de manière neutre.

Exemple de saisie:

V^^

Exemple de sortie:

2

Comme vous pouvez le constater, j'ai rétrogradé une fois de N à 1 et deux fois en deuxième.

Ceci est un code de golf. La réponse la plus courte en octets l'emporte.

Remarque: La saisie peut comporter 2 caractères. Peut être U et D pour monter et descendre ou ce que vous voulez, ce doit être une chaîne . Vous ne pouvez pas passer au-delà du 1er ou du 6ème. Si vous êtes en 6ème et rétrogradez, il restera en 6ème. Bonne chance!

JavaScript (ES6), 49 48 47 46 octets

Attend:

• 1 pour le bas
• 7 pour le haut

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

Formaté et commenté

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

Les engrenages sont cartographiés comme suit:

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)

Ce qui nous permet de vérifier facilement la validité du rapport actuel avec:

(g & 7) != 0

Démo

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 octets

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

Essayez-le en ligne!

Explication

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

5 octets sauvegardés grâce à @Luis

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

Cette solution utilise '2'pour le passage à la vitesse supérieure et'0' descente.

Essayez-le sur MATL Online

Explication

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

:sil!î¬61énÀxVp

Essayez-le en ligne!

L'entrée est une chaîne de caractères h(haut) et l(bas).

Merci à @nmjcman pour avoir économisé 5 octets et m'avoir appris une fonctionnalité de vim dont je n'avais jamais entendu parler!

Si nous pouvions supposer que l'entrée ne sort jamais des limites, ce serait simplement 9 octets:

¬61énÀxVp

Mais malheureusement, ce n'est pas autorisé.

Explication:

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

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

Explication:

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
}

Code de test:

Essayez ici.

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

Sortie:

2
6
1
N

Haskell, 59 53 51 octets

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

Utilisations 0pour le bas et 2pour le haut. Exemple d'utilisation:

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

Merci à @xnor d'avoir supprimé 6 octets! En outre, je n’ai pas besoin d’un nom de fonction ni de parenthèses, c’est donc deux autres octets.

JavaScript (ES6), 48 58 octets

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

Usage

Attribuez-le à une fonction, puis appelez-la. L'entrée est une chaîne contenant un 1pour un passage à la vitesse supérieure et un 0pour une rétrogradation.

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 octets

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

passe $gde -1 à 5, utilise un décalage de chaîne négatif pour la première vitesse.
Exécuter avec -nr, fournit une chaîne de décalage comme argument de ligne de commande.

Gelée , 17 à 14 octets

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

Utilise 6pour et0 descendre.

Essayez-le en ligne!

Comment ça marche

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 octets

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

L'entrée attendue est 'v' pour une rétrogradation et '^' pour une rétrogradation

Traitement de JS (modifié) 121 octets

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

Essayez-le en ligne!

Je suis allé avec PJs depuis que je le connais bien. Le seul problème est que la version que j'utilise est très typée. Je ne peux pas laisser de parenthèses et beaucoup d'autres astuces. C'est assez simple. L'entrée doit aller dans la variable aet cela prend en minuscule u d. Le programme boucle jusqu'à atteindre la fin de la chaîne et à chaque itération, il vérifie si c'est au moins un au. Si c'est le cas, vous n'essaierez pas de "décaler" au-delà de l'endroit où vous le pouvez. À la fin, j'imprime les résultats!

k, 25 octets

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

Il prend les entrées sous forme de chaîne, et utilise [pour rétrograder, et ]pour rétrograder , car elles sont bien situées.

"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

Exemples:

 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 (drapeau r) = 88 octets

Sed n'ayant pas de type entier ni d'opération arithmétique, la solution est obtenue uniquement à l'aide d'expressions régulières.

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

Cela fonctionne en faisant glisser le pointeur x fonction de chaque décalage d'entrée, à gauche (pour Up) ou à droite (pour Dpropre), le long d'une bande non enveloppante qui ne contient que les cellules 65432N1. La réponse à la fin est la valeur dans la cellule à gauche du pointeur.

Exemple de parcours: ou essayez-le en ligne!

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

Explication:

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 octets

Comprend +1 pour -r

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

La sortie est unaire sauf neutre, ce qui est encore N(voir ce consensus ).

Essayez-le en ligne!

Cela compte essentiellement de haut en bas dans unary, puis convertit 1 en N et 0 en 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 octets

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
]

Exemple d'utilisation (dans la console Rebol):

>> print f "DUU"         
2

>> print f "DDDUU"
2

>> print f "UUUUUUUUU"  
6

>> print f "UUUUUUUUUD"
5

> <> , 35 octets

Un morceau de code enthousiaste qui vous encourage à conduire au-dessus de la limite de vitesse.

Accepte deux entrées dont le code modulo 3 est 0 et 2, par exemple 0et 2.
Pour plus de poisson, je recommande l’utilisation de <et >.

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

Explication:

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

Vous pouvez l' essayer ici !

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)

Déplace l'index de la chaîne en fonction de l'entrée et imprime le caractère approprié.

Pyth, 32 octets

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

Utilise l’espace et la nouvelle ligne pour le haut et le bas.

Explication

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

Il y a presque certainement une meilleure façon de faire l'incrémentation et la sortie.

CJam , 24 22 octets

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

Utilisations (pour le bas et )pour le haut.

Essayez-le en ligne!

Explication

"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

Lot, 144 octets

@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

Prend une entrée sur STDIN, en utilisant 0pour passer à une vitesse inférieure et 6pour passer à une vitesse supérieure. Ces chiffres ont été choisis pour qu'il soit facile d'ignorer le rapport actuel. Enfin si l'engin est 1alors Nimprimé autrement 0est converti en 1et l'engin est imprimé.

Javascript ES6 sans restriction, 136 120 caractères

136 caractères pour 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 caractères pour -+

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 octets

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

Usages uet dpour monter et descendre.

Essayez-le en ligne!

Explication

Ce programme fonctionne en gardant 1N23456derrière la séquence d'instructions. Il garde une trace du matériel actuel en laissant un espace derrière lui. Ensuite, cela prend une instruction à la fois jusqu'à ce qu'il n'y en ait plus.

^
1 N23456

Commencez par mettre 1 N23456avant l'entrée. L'espace avant Nindique qu'il Ns'agit du rapport actuel.

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

Ce sont deux étapes de remplacement, regroupées et exécutées jusqu'à ce qu'elles ne modifient plus la chaîne:

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

Le premier s'occupe de passer la vitesse supérieure. Il recherchera un nombre quelconque d'engrenages après l'espace, suivi d'un a 6, suivi de u( uindique l'instruction de passer à la vitesse supérieure). S'il y avait des caractères avant le 6, il remplace l'espace par le caractère immédiatement après, supprime le uet laisse le reste de la chaîne intact. Etant donné que le 6est obligatoire dans le match, il n’échangera l’espace avec aucun caractère avant le 6. Il ne sera jamais échanger avec le 6.

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

La deuxième étape gère le changement de vitesse et fonctionne de manière similaire. Il recherche éventuellement un caractère avant l'espace, puis quelques autres engrenages après la fin 6, suivis de d. Il échange l'espace avec le caractère qui le précède, le supprime det laisse le reste intact. Si l'espace était au début de la chaîne, il n'y a pas de correspondance pour un caractère avant l'espace, aucun échange n'est donc effectué.

.* (.).*
$1

Quand aucun des remplacements ci-dessus ne peut plus être effectué, tous les changements de vitesse sont terminés. La ligne est débarrassée de tout sauf de l'équipement immédiatement après l'espace. Ceci est le rapport final.

Powershell, 112 87 85 octets

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

non-golfé

$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

économisé 25 octets en lisant les astuces sur le code de jeu powershell

sauvé 2 octets en retournant les opérateurs gt / le

Perl 6, 144 octets

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

Fonctionne comme il se doit, je crois. Les améliorations sont les bienvenues. Première utilisation de Perl pour n'importe quoi, mais j'ai adoré l'idée de la langue, donc j'ai dû essayer.

Clojure, 74 octets

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

Se plie sur la chaîne de décalage, en maintenant un index en tant qu'accumulateur. Chaque itération augmente ou diminue l'index, puis le fixe dans la plage 0-6. Enfin, une chaîne contenant les engrenages est indexée et renvoyée.

Renvoie un caractère Clojure représentant le rapport actuel. La vitesse 1 est renvoyée en tant que \1et la vitesse 'N' est renvoyée en tant que\N .

Explication pré-golfée. Suivez les chiffres, car cela ne se lit pas bien de haut en bas.

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

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

Solution assez simple.

-4 octets grâce à @ovs!