Canard, canard, Josèphe

49

Étant donné un tableau entier:

  1. Commencer à partir du premier numéro
  2. Saut en avant de n positions où n est la valeur de la position actuelle
  3. Supprimer la position actuelle, en faisant de la position suivante la position actuelle.
  4. Aller à l'étape 2 jusqu'à ce qu'il ne reste qu'un numéro
  5. Imprimer ce numéro

Règles

Le tableau est enveloppé (le premier chiffre après le dernier numéro du tableau est le premier).

Un zéro se supprime (évidemment).

Les nombres négatifs ne sont pas autorisés en entrée.

Cas de test

[1] => 1
[1,2] => 1
[1,2,3] => 3
[1,2,2] => 1
[1,2,3,4] => 1
[6,2,3,4] => 4
[1,2,3,4,5] => 5
[0,1] => 1
[0,0,2,0,0] => 0

Exemple pas à pas

[1,4,2,3,5]
 ^          start from the first position
   ^        jump 1 position (value of the position)
[1,  2,3,5] remove number in that position
     ^      take next position of the removed number (the 'new' 'current' position)
         ^  jump 2 positions
[1,  2,3  ] remove number in that position
 ^          take next position (looping on the end of the array)
     ^      jump 1 position
[1,    3  ] remove number in that position
       ^    take next position (looping)
 ^          jump 3 positions (looping on the end of the array)
[      3  ] remove number in that position
print 3

Exemple n ° 2

[4,3,2,1,6,3]
 ^            start from the first position
         ^    jump 4 positions
[4,3,2,1,  3] remove number in that position    
           ^  take next position
     ^        jump 3 positions
[4,3,  1,  3] remove number in that position    
       ^      take next position
           ^  jump 1 positions
[4,3,  1    ] remove number in that position    
 ^            take next position
   ^          jump 4 positions
[4,    1    ] remove number in that position    
       ^      take next position
 ^            jump 1 position
[      1    ] remove number in that position
print 1

C'est code-golf , la réponse la plus courte en octets gagne!

code-golf  array-manipulation 
— flux de travail
source
14
Beau premier challenge!
— Luis Mendo
2
@LuisMendo Oui .. les défis "skip like a ..."
— J42161217 12/12
2
@Jenny_mathy Je ne pensais pas qu'il en existerait un, mais comme l'a dit Luis, le tableau enveloppant constitue un défi intéressant pour le golf. Je pense: /
— workoverflow
3
@EriktheOutgolfer Pas vraiment une dupe. Les éléments y sont indiscernables et le pas est fixe. Le Luis est beaucoup plus proche, mais encore suffisamment différent je pense.
— Martin Ender
3
Doit-il réellement imprimer le nombre final ou peut-il simplement le renvoyer? Doit-il réellement renvoyer le nombre, ou peut-il simplement opérer sur le tableau sur place afin qu'après l'exécution de la fonction, le tableau ne contienne que le nombre?
— Rétablir Monica iamnotmaynard le 12/12/17

Réponses:

9

Coque , 7 octets

Cela renvoie le résultat sous forme de liste de singleton

ΩεSotṙ←

Essayez-le en ligne!

Explication

Ω               Until
 ε              the result is a singleton list
     ṙ          Rotate left by
  S   ←         the first element
   ot           Then remove the first element
— H.PWiz
source
7

Haskell , 54 50 48 octets

f[x]=x
f(x:r)=f$snd<$>zip r(drop(x+1)$cycle$x:r)

Essayez-le en ligne!

Explication:

  • f[x]=x: Si la liste donnée est une liste singleton, retourne son élément.
  • f(x:r)=f$ ...: Sinon, appliquer récursivement fà la liste suivante:
    • Les éléments de la liste en cours ont cyclé infiniment ( cycle$x:r),
    • avec les premiers x+1éléments supprimés ( drop(x+1)$),
    • et tronqué à la longueur de r. ( snd<$>zip rest une alternative plus courte à take(length r)).

Version précédente de 54 octets:

f=(%)=<<head
_%[x]=x
n%(x:r)|n<1=f r|s<-r++[x]=(n-1)%s

Essayez-le en ligne!

— Laikoni
source
6

MATL , 21 octets

1`yy)+ynX\[]w(5Mynq]x

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

1        % Push 1: current position in the array
`        % Do...while
  yy     %   Duplicate top two elements in the stack. Takes input implicitly
         %   in the first iteration.
         %   STACK: array, position, array, position
  )      %   Get specified entry in the array
         %   STACK: array, position, selected entry
  +      %   Add
         %   STACK: array, position (updated)
  y      %   Duplicate from below
         %   STACK: array, position, array
  n      %   Number of elements of array
         %   STACK: array, position, number of elements or array
  X\     %   1-based modulus
         %   STACK: array, position (wrapped around)
  []     %   Push empty array
         %   STACK: array, position, []
  w      %   Swap
         %   STACK: array, [], position
  (      %   Write value into specified entry in array. Writing [] removes
         %   the entry
         %   STACK: array (with one entry removed)
  5M     %   Push latest used position. Because of the removal, this now
         %   points to the entry that was after the removed one
         %   STACK: array, position
  y      %   Duplicate from below
         %   STACK: array, position, array
  n      %   Number of elements of array
         %   STACK: array, position, number of elements of array
  q      %   Subtract 1
         %   STACK: array, position, number of elements of array minus 1
]        % End. If top of the stack is nonzero, proceed with next iteration
         % STACK: array (containing 1 entry), position
x        % Delete. Implicitly display
         % STACK: array (containing 1 entry)
— Luis Mendo
source
1
Remarque: utiliser des rotations de liste au lieu de garder un pointeur rendra cela beaucoup plus court.
— Erik l'Outgolfer
1
@ Erik Merci. Mais maintenant que j'ai ajouté l'explication, je pense que je vais le laisser comme ceci
— Luis Mendo
Eh bien, vous pouvez toujours supprimer l'explication, elle sera conservée dans l'historique :)
— Erik the Outgolfer
6

Python 3 , 54 51 octets

f=lambda x:x and f((x+x*x[0])[x[0]:][1:len(x)])or x

La sortie est une liste de singleton.

Essayez-le en ligne!

— Dennis
source
Complètement sans lien, mais j'aime votre chapeau de licorne, Dennis. xD (et bonne réponse bien sûr, comme toujours!)
— Kevin Cruijssen
5

CJam , 15 octets

l~_,({_0=m<1>}*

Essayez-le en ligne!

Explication

Au lieu de garder la trace d'un pointeur, je déplace simplement le tableau de manière cyclique afin que l'élément actuel soit toujours au premier plan.

l~     e# Read and evaluate input.
_,(    e# Get its length L and decrement to L-1.
{      e# Run this block L-1 times...
  _0=  e#   Get the first element X.
  m<   e#   Rotate the array left by X positions.
  1>   e#   Discard the first element.
}*
       e# The final element remains on the stack and gets printed implicitly.

Une alternative amusante qui ne sauve malheureusement aucun octet:

l~_{;m<1>_0=}*;
— Martin Ender
source
5

Brain-Flak , 88 octets

([[]]()){({}<(({})){({}<({}<([]){({}{}<>)<>([])}{}>)<>{({}[<>[]])<>}<>>[()])}{}{}>())}{}

Essayez-le en ligne!

Explication

([[]]())                      Push negative N: the stack height - 1
{({}< … >())}{}               Do N times
     (({}))                     Duplicate M: the top of the stack
     {({}< … >[()])}{}          Do M times 
                                  Rotate the stack by 1:
          ({}< … >)               Pop the top of the stack and put it back down after
          ([]){({}{}<>)<>([])}{}  Pushing the rest of the stack on to the other one, in reverse, with the stack height added to each element (to ensure that all are positive)
          <>{({}[<>[]])<>}<>      Push the rest of the stack back, unreversing, and subtracting the stack height from each element
                      {}        Pop the top of stack
— H.PWiz
source
1
Un golf très étrange mais le voici en 88 octets .
— Wheat Wizard
1
@ WheatWizard Nice, étonnamment j'ai essayé quelque chose comme ça plus tôt.
— H.PWiz
Je ne saurai jamais comment les gens peuvent coder comme ça! y a-t-il un traducteur de pseudo-code ou quelque chose?
— workoverflow
1
@ workoverflow non, c'est vraiment plus facile qu'il n'y paraît. C'était très intimidant avant que je commence réellement, mais lorsque les commandes sont aussi simples, il est facile à apprendre.
— H.PWiz
5

Python 2 , 55 octets

def f(a):
 while a[1:]:l=a[0]%len(a);a[:]=a[-~l:]+a[:l]

Essayez-le en ligne!

Sortie sous forme de liste de singleton, comme autorisé par défaut . Sauvegardé quelques octets grâce à Dennis , en me rappelant que la modification de l'argument de la fonction est autorisée.

Comment ça fonctionne

  • def f(a)- Définit une fonction avec un paramètre a.

  • while a[1:]:- Alors aque le premier élément supprimé est la vérité, lancez le bloc de code à suivre. Une liste avec un ou plusieurs éléments est truey, et les listes vides sont faussées en Python, elle s’arrêtera dès lors qu’elle aatteint la longueur 1.

  • l=a[0]%len(a)- Prenez le premier élément et obtenez le reste de sa division par la longueur de a. Attribuer le résultat à l.

  • a[:]=a[-~l:]+a[:l]- Faites pivoter ales léléments vers la gauche et supprimez le premier, tout en l’affectant à la aplace.

Python 2 , 63 octets

f=lambda a,i=0:a[1:]and f(a,a.pop(((a*-~i)[i]+i)%len(a))+1)or a

Essayez-le en ligne!

Bien que plus long, cela semble beaucoup plus élégant. Merci également aux ovs pour avoir aidé à discuter.

— M. Xcoder
source
1
Ne pourriez-vous pas faire quelque chose comme a,*b=input()(python3) et économiser quelques octets? Cependant, je ne suis pas sûr de l'impact que cela pourrait avoir sur lla tranche
— Rod
1
@Rod Je ne pense pas, j'aurais aussi besoin d'évaluer l'entrée en Python 3
— M. Xcoder 12/12/17
4

Gelée , 7 octets

ṙḷ/ḊµḊ¿

Essayez-le en ligne!

Programme complet.

— Erik le golfeur
source
3
C'est ḷ/sacrément intelligent.
— M. Xcoder
Pourriez-vous ajouter une explication, s'il vous plaît? J'ai maintenant regardé les Quicks et les Atomes sur les pages GIT liées, et +1 sur cette base, mais je peux imaginer que tout le monde n'ait pas les patients à faire de même. ;)
— Kevin Cruijssen
4

Gelée , 9 octets

ṙḷ/ḊµL’$¡

Essayez-le en ligne!

-2 octets grâce à user202729

Explication

ṙḷ/ḊµL’$¡  Main Link
     L’$¡  Repeat <length - 1> times
ṙ          Rotate left by
 ḷ/        The first element (from JHT; thanks to user202729)
   Ḋ       Take all but the first element
— HyperNeutrino
source
3

Mathematica, 36 octets

utilise l'algorithme de Martin 

#//.l:{x_,__}:>Rest@RotateLeft[l,x]&

-5 octets de Misha Lavrov && Martin Ender

Essayez-le en ligne!

— J42161217
source
1
Vous pouvez enregistrer deux octets en utilisant le modèle pour sélectionner le premier élément #//.{x_,y__}:>Rest@RotateLeft[{x,y},x]&. (Cela s'arrête quand il n'y a qu'un seul élément parce que {a}ne correspond plus au modèle {x_,y__}.)
— Misha Lavrov
1
@MishaLavrov ne peut pas tester pour le moment, mais vous pouvez probablement le raccourcir davantage en supprimant le y, en appelant la liste complète l, puis en utilisant lplutôt que {x,y}.
— Martin Ender
1
@MartinEnder Vous voulez dire comme ça - #//.l:{x_,__}:>Rest@RotateLeft[l,x]&?
— Misha Lavrov
1
@MishaLavrov yep.
— Martin Ender
3

J , 21 17 octets

-4 octets grâce à FrownyFrog

((1<#)}.{.|.])^:_

Essayez-le en ligne!

Original:

([:}.{.|.])^:(1<#)^:_

Comment ça fonctionne:

^:_ répéter jusqu'à ce que le résultat cesse de changer

^:(1<#) si la longueur de la liste est supérieure à 1

{.|.] faire pivoter la liste vers la gauche ses premiers temps d'élément

[:}. déposer le premier élément et boucher la fourchette

Essayez-le en ligne!

— Galen Ivanov
source
@ FrownyFrog Merci, je n'ai pas essayé - c'est beaucoup mieux!
— Galen Ivanov
3

JavaScript (ES6), 54 60 octets

Enregistré 1 octet grâce à @Shaggy
Version fixe (+6 octets)

Modifie le tableau d'entrée , qui est réduit à un singleton.

f=(a,p=0)=>1/a||f(a,p=(p+a[p%(l=a.length)])%l,a.splice(p,1))

Cas de test

Afficher l'extrait de code

Comment?

Nous appliquons récursivement l'algorithme décrit dans le challenge. Seule la condition d'arrêt 1/apeut sembler un peu bizarre. Lors de l'application d'un opérateur arithmétique:

  • Les tableaux de plusieurs éléments sont forcés NaNet 1/NaNsont également NaN(falsification).
  • Les tableaux d'exactement un entier sont forcés sur cet entier, conduisant à l'un 1/0 = +Infinityou à l'autre 1/N = positive floatpour N> 0 (les deux vrais).
f = (a, p = 0) =>                 // a = input array, p = pointer into this array
  1 / a ||                        // if a is not yet a singleton:
    f(                            //   do a recursive call with:
      a,                          //     a
      p = (                       //     the updated pointer
        p + a[p % (l = a.length)] //
      ) % l,                      //
      a.splice(p, 1)              //     the element at the new position removed
    )                             //   end of recursive call
— Arnauld
source
Vu que splicemodifie le tableau d'origine, vous pourriez le faire f=(a,p=0)=>1/a||f(a,p=p+a[p]%a.length,a.splice(p,1))pour 52 octets
— Shaggy
il semble que cela ne donne pas le bon résultat pour l'exemple de la deuxième étape par étape, f=(a,p=0)=>1/a?a:f(a,p=(p%a.length+a[p%a.length])%a.length,a.splice(p,1))est ok mais peut être optimisé
— Nahuel Fouilleul 12/12
@NahuelFouilleul Oups. J'ai pensé à un moment que les parenthèses autour p+a[p]pourraient être supprimées. Ce qui - bien sûr - n'est pas le cas. Merci d'avoir signalé cela!
— Arnauld
Voir ce consensus que @Neil a porté à mon attention ici .
— Shaggy
@Shaggy Oh, je vois. Je vous remercie! (J'ai raté votre lien TIO la 1ère fois ...)
— Arnauld
3

Java 8, 79 octets

Ce lambda accepte un Stack<Integer>et retourne un intou Integer.

l->{for(int i=0,s=l.size();s>1;)l.remove(i=(i+l.get(i%s))%s--);return l.pop();}

Essayez-le en ligne

Ungolfed

l -> {
    for (
        int i = 0, s = l.size()
        ; s > 1
        ;
    )
        l.remove(
            i = (i + l.get(i % s)) % s--
        );
    return l.pop();
}

Remerciements

  • -2 octets grâce à Nahuel Fouilleul
— Jakob
source
1
i%=speut être enlevé si l.get(i)changé parl.get(i%s)
— Nahuel Fouilleul Le
2

Pyth , 9 octets

.WtHt.<Zh

Essayez-le ici!

Le résultat est affiché sous forme de liste de singleton, comme autorisé par défaut .

Comment ça fonctionne

.WtHt.<Zh ~ Full program.

.W        ~ Functional while. It takes three arguments, two functions: A and B
            and a starting value, which in this case is automatically assigned
            to the input. While A(value) is truthy, value is set to B(value).
            Returns the ending value. A's argument is H and B's is Z.
  tH      ~ A (argument H): Remove the first element of H. A singleton list
            turns into [], which is falsy and thus breaks the loop. Otherwise,
            it is truthy and the loops goes on until the list reaches length 1.
     .<Zh ~ B (argument Z): Cyclically rotate Z by Z[0] places, whereas Z[0]
            represents the first element of Z.
    t     ~ And remove the first element.

Remarque: Si vous ne voulez pas voir ces crochets, ajoutez simplement hou edevant tout le code.

— M. Xcoder
source
2

Rapide , 87 octets

func f(a:inout[Int]){var i=0,c=0;while(c=a.count,c>1).1{i=(i+a[i%c])%c;a.remove(at:i)}}

Renvoie sous forme de liste de singleton en modifiant l'entrée . Essayez-le en ligne!

Explication

func f(a:inout[Int]){
  var i=0,c=0;            // Set the index i to 0
  while(c=a.count,c>1).1{ // While the length of the list > 0:
    i=(i+a[i%c])%c;       //  Add a[i] to i and loop back using modulo
    a.remove(at:i)        //  Remove a[i]
  }
}
— Herman L
source
2

Perl 6 , 46 45 octets

(-1 octet merci à Brad Gilbert)

{($_,{(|$_ xx*)[.[0]+(1..^$_)]}...1)[*-1][0]}

Essayez-le en ligne!

($_, { ... } ... 1)génère une séquence de listes, commençant par la liste d'entrée $_, chaque élément successif étant généré par l'expression d'accolade et se terminant lorsque la liste smart-matches 1-, a une longueur de 1. La fin [* - 1]obtient le dernier élément, et le dernier [0]prend le seul élément de cette liste de singleton.

(|$_ xx *)génère une copie plate, répliquée à l'infini de l'élément en cours. Cette liste est indexée avec la plage .[0] + (1 ..^ $_)pour extraire la prochaine liste finie de la série.

— Sean
source
1
l'esprit soufflé oO
— Adrian
[*-1][0]peut être combiné pour [*-1;0]sauvegarder un octet. Il 1..$_-1est également préférable d’écrire de 1..^$_nouveau pour sauvegarder un octet.
— Brad Gilbert b2gills
@ BradGilbertb2gills j'ai essayé [*-1;0], mais cela ne semble pas être équivalent en quelque sorte. La fonction retourne alors une liste plutôt qu'un nombre.
— Sean
Cela n'empêche pas l' 1..^$_optimisation
— Brad Gilbert b2gills
1

Perl 5 , 47 43 41 + 2 ( -ap) = 43 octets

$\=splice@F,($_+=$F[$_%@F])%@F,1while@F}{

Essayez-le en ligne!

Prend les entrées sous forme de nombres séparés par des espaces.

— Xcali
source
il semble que ce ne soit pas exactement la même chose que l'exemple pas à pas suivant, mais qu'il est plus long$x%=@F,splice@F,$x=($x+$F[$x])%@F,1while$#F;$_="@F"
— Nahuel Fouilleul 12/12
1
wow oO Besoin de jouer mon jeu.
— Adrian
1

Java 8 , 325 octets

Golfé:

static void n(Integer[]j){Integer[]h;int a=0;h=j;for(int i=0;i<j.length-1;i++){if(h.length==a){a=0;}a=(a+h[a])%h.length;h[a]=null;h=m(h);}System.out.print(h[0]);}static Integer[] m(Integer[]array){Integer[]x=new Integer[array.length-1];int z=0;for(int i=0;i<array.length;i++){if(array[i]!=null){x[z]=array[i];z++;}}return x;}

Ungolfed:

 interface ArrayLeapFrog {
static void main(String[] z) throws Exception {
    Integer[] j = {6, 2, 3, 4};
    n(j);
}

static void n(Integer[] j) {
    Integer[] h;
    int a = 0;
    h = j;
    for (int i = 0; i < j.length - 1; i++) {
        if (h.length == a) {
            a = 0;
        }
        a = (a + h[a]) % h.length;
        h[a] = null;
        h = m(h);
    }
    System.out.print(h[0]);
}

static Integer[] m(Integer[] array) {
    Integer[] x = new Integer[array.length - 1];
    int z = 0;
    for (int i = 0; i < array.length; i++) {
        if (array[i] != null) {
            x[z] = array[i];
            z++;
        }
    }
    return x;
  }
}
— DevelopingDeveloper
source
4
Bienvenue! Quelques conseils: inutile de compter les staticmots - clés ici. Généralement, les solutions multi-méthodes sont implémentées en tant que membres non statiques d'une classe et maincréent une instance à tester. De même, si vous le faites de cette manière, vous supportez Java 7 et pouvez soumettre simplement une solution "Java". Pour référence future, le format de saisie a tendance à être assez flexible ici. Vous pouvez par exemple choisir de prendre les entrées en tant que List(ce qui est très utile pour résoudre ce problème).
— Jakob
1

APL + WIN, 36 octets

¯1↑⍎¨(1⌈¯1+⍴v←,⎕)⍴⊂'v←(1<⍴v)↓v[1]⌽v'

Explication:

Invites pour la saisie à l'écran. 

'v←(1<⍴v)↓v[1]⌽v' Loop logic as a string

 (1<⍴v)↓ only drop the first when number of elements n>1

 (1⌈¯1+⍴v←,⎕)⍴⊂ create a nested vector of logic of length 1 max n-1

 ⍎¨ execute each element of the nested vector in turn

¯1↑ take answer from executing final element
— Graham
source
1

Python 2, 61 octets

def f(x):
 while x[1:]:y=x[0]%len(x);x=x[y+1:]+x[:y]
 print x
— Rɪᴋᴇʀ
source
1
Je sais qu'il existe de nombreuses réponses en python, mais je me suis dit que je pourrais aussi bien ajouter les miennes.
— Rɪᴋᴇʀ
1

JavaScript, 58 56 59 octets

let f =

a=>{for(i=0,k=a.length;k>1;)i+=a[i%=k],a.splice(i%=k--,1)}
<h2>Test</h2>
Enter or paste a valid array literal within square brackets and click Run.
<blockquote>
   <input id = "array" type="text" length="20">
   <button type="button" onclick="run()">Run</button>
</blockquote>
Result: <pre id="o"></pre>

<script>
    function run() {
       let a = JSON.parse(array.value);
       f(a);
       o.textContent = a;
    }
</script>
Développer l'extrait

Renvoie le résultat en tant que seul élément restant dans le tableau d'entrée mis à jour sur place.

Deux octets enregistrés en utilisant une instruction séparée par des virgules au lieu d'une instruction block dans le corps de la boucle for! Trois octets perdus pour ignorer un élément supprimé à la fin du tableau (:

Moins joué au golf:

a => {
    for(i=0,k=a.length;k>1;) // once less than array length
        i+=a[i%=k],          // the new index
        a.splice(            // delete an element
           i%=k--,           // ensuring index is within array,
                             // and post decrement loop count
           1
        )
}
— traktor53
source
Cela semble donner la mauvaise réponse pour [3, 5, 7, 9].
— Neil
Mauvais pour [3,5,7,9]. Valeur attendue 5
— edc65
La fonction ne renvoie pas la valeur, je ne suis pas sûr que le nombre d'octets soit correct, gardez-le à l'esprit car il ne peut pas fonctionner seul ...
— Brian H.
@ edc65 et Neil, merci - l'index d'un élément supprimé en fin de tableau n'a pas été ajusté au début du tableau raccourci.
— traktor53
@BrianH. la fonction modifie ses paramètres, il existe un consensus autour de ce codegolf.meta.stackexchange.com/a/4942/21348
— edc65
1

Brain-Flak , 104 octets

H.PWiz a une réponse plus courte ici que j'ai aidé à faire, vous devriez vérifier.

([[]]()){({}()<(({})){({}[()]<({}<(([])<{{}({}<>)<>([])}{}<>>)<>>)<>{({}[()]<({}<>)<>>)}{}<>>)}{}{}>)}{}

Essayez-le en ligne!

Explication

([[]]())   #Push 1 minus stackheight
{({}()<    #N times
 (({}))    #Get a copy of the top
 {({}[()]< #N times
  ({}<(([])<{{}({}<>)<>([])}{}<>>)<>>)<>{({}[()]<({}<>)<>>)}{}<>
           #Roll the top to the bottom (From the wiki)
 >)}{}     #End loop
 {}        #Remove one value
>)}{}      #End loop
— Assistant de blé
source
Je pensais que je serais en compétition . Ensuite, j'ai réalisé que le mien était presque identique au vôtre , mis à part un "top roll" différent
— H.PWiz 12/12
J'ai vu ça ;). Utiliser le fait que tout est non négatif est plutôt malin.
— Wheat Wizard
1

R , 111 117 126 octets

Merci à @Giuseppe pour avoir joué 11 octets en passant à une boucle while, obtenu un autre 4 en supprimant la fonction et en lisant directement les entrées de l'utilisateur.

Je ne me sens pas très bien à propos de ce qu'il fallait pour y arriver - je suis sûr qu'il existe une solution plus élégante.

i=scan();m=1;while((l=sum(i|1))-1){j=i[m];p=`if`(j+m>l,j%%l+!m-1,j+m);p=`if`(!p,m,p);i=i[-p];m=`if`(p-l,p,1)};i

Essayez-le en ligne!

Code non-liquéfié

i=scan()
m=1
while((l=sum(i|1))-1){
  j=i[m]
  p=`if`(j+m>l,j%%l+!m-1,j+m)
  p=`if`(!p,m,p)
  i=i[-p]
  m=`if`(p-l,p,1)
}
i
— marque
source
117 octets - notez que puisqu'il s'agit d'une fonction récursive, le nom f=doit être inclus
— Giuseppe
1
J'ai trouvé ce défi assez difficile avec un langage basé sur 1 index sans rotation des tableaux; c'est potentiellement 1-3 octets plus court avec une whileboucle, je pense.
— Giuseppe
— Giuseppe
mon précédent 115 octets était invalide puisque nous avons tous deux oublié la f=partie de la fonction récursive. :(
— Giuseppe
J'ai mis à jour l'ancien score et le nouveau score afin de refléter la récursivité :) Avec la boucle 'while', j'ai lancé un autre parcours de 4 octets en utilisant scan.
— Marc
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.