En gribouillant avec des nombres, j'ai trouvé une permutation intéressante que vous pouvez générer à partir d'une liste de nombres. Si vous répétez cette même permutation suffisamment de fois, vous vous retrouverez toujours dans le tableau d'origine. Utilisons la liste suivante:

[1, 2, 3, 4, 5]

par exemple

1. Inversez le tableau. Maintenant, notre tableau est

   [5, 4, 3, 2, 1]
   

2. Réorganisez (échangez) chaque paire. Notre liste comprend 2 paires:, [5, 4]et [3, 2]. Malheureusement, nous ne pouvons pas regrouper le 1en une paire, nous allons donc le laisser seul. Après avoir échangé chaque paire, le nouveau tableau est:

   [4, 5, 2, 3, 1]
   

3. Répétez les étapes 1 et 2 jusqu'à ce que nous revenions au tableau d'origine. Voici les 4 prochaines étapes:

   Step 2:
   Start:          [4, 5, 2, 3, 1]
   Reversed:       [1, 3, 2, 5, 4]
   Pairs Swapped:  [3, 1, 5, 2, 4]
   
   Step 3:
   Start:          [3, 1, 5, 2, 4]
   Reversed:       [4, 2, 5, 1, 3]
   Pairs Swapped:  [2, 4, 1, 5, 3]
   
   Step 4:
   Start:          [2, 4, 1, 5, 3]
   Reversed:       [3, 5, 1, 4, 2]
   Pairs Swapped:  [5, 3, 4, 1, 2]
   
   Step 5:
   Start:          [5, 3, 4, 1, 2]
   Reversed:       [2, 1, 4, 3, 5]
   Pairs Swapped:  [1, 2, 3, 4, 5]
   
   # No more steps needed because we are back to the original array
   

   Si la longueur de la liste, n est impaire, il faudra toujours exactement n étapes pour revenir au tableau d'origine. Si n est pair, il faudra toujours 2 étapes pour revenir au tableau d'origine, à moins que n ne soit 2, auquel cas cela prendra 1 étape (car inverser et permuter est la même chose).

Votre tâche pour aujourd'hui (si vous l'acceptez) est de visualiser cet ensemble d'étapes pour des listes de longueurs arbitraires. Vous devez écrire un programme ou une fonction qui prend en entrée un seul entier positif n et effectue cet ensemble d'étapes pour la liste [1, n]. Vous devez sortir chaque étape intermédiaire en cours de route, que cela signifie imprimer chaque étape ou les renvoyer sous forme de liste d'étapes. Je ne suis pas très pointilleux sur le format de sortie, tant qu'il est clair que vous générez chaque étape. Cela signifie (par exemple) l'un de ces éléments:

• Sortie de chaque étape sous forme de liste dans STDOUT

• Renvoyer une liste de listes

• Renvoyer une liste de représentations de chaîne de chaque étape

• Retour / sortie d'une matrice

serait acceptable.

Vous devez également sortir le tableau d'origine, que cela vienne à la fin ou au début. (techniquement, les deux sont corrects)

Vous devrez gérer le cas de bord de 2 en 1 étape au lieu de 2 , alors assurez-vous que votre solution fonctionne avec une entrée de 2 (et 1 est un autre cas de bord potentiel).

Comme d'habitude, il s'agit de code-golf , donc les lacunes standard s'appliquent et essayez de rendre votre solution plus courte que toute autre dans la langue de votre choix (ou même essayez de battre une autre langue qui est généralement plus courte que la vôtre si vous vous sentez bien) pour un défi).

Test IO

1: 
[1]


2: 
[1, 2]


3: 
[2, 3, 1]
[3, 1, 2]
[1, 2, 3]


4: 
[3, 4, 1, 2]
[1, 2, 3, 4]


5: 
[4, 5, 2, 3, 1]
[3, 1, 5, 2, 4]
[2, 4, 1, 5, 3]
[5, 3, 4, 1, 2]
[1, 2, 3, 4, 5]


7: 
[6, 7, 4, 5, 2, 3, 1]
[3, 1, 5, 2, 7, 4, 6]
[4, 6, 2, 7, 1, 5, 3]
[5, 3, 7, 1, 6, 2, 4]
[2, 4, 1, 6, 3, 7, 5]
[7, 5, 6, 3, 4, 1, 2]
[1, 2, 3, 4, 5, 6, 7]


9: 
[8, 9, 6, 7, 4, 5, 2, 3, 1]
[3, 1, 5, 2, 7, 4, 9, 6, 8]
[6, 8, 4, 9, 2, 7, 1, 5, 3]
[5, 3, 7, 1, 9, 2, 8, 4, 6]
[4, 6, 2, 8, 1, 9, 3, 7, 5]
[7, 5, 9, 3, 8, 1, 6, 2, 4]
[2, 4, 1, 6, 3, 8, 5, 9, 7]
[9, 7, 8, 5, 6, 3, 4, 1, 2]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Et pour faire bonne mesure, voici un cas de test géant:

27: 
[26, 27, 24, 25, 22, 23, 20, 21, 18, 19, 16, 17, 14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 1]
[3, 1, 5, 2, 7, 4, 9, 6, 11, 8, 13, 10, 15, 12, 17, 14, 19, 16, 21, 18, 23, 20, 25, 22, 27, 24, 26]
[24, 26, 22, 27, 20, 25, 18, 23, 16, 21, 14, 19, 12, 17, 10, 15, 8, 13, 6, 11, 4, 9, 2, 7, 1, 5, 3]
[5, 3, 7, 1, 9, 2, 11, 4, 13, 6, 15, 8, 17, 10, 19, 12, 21, 14, 23, 16, 25, 18, 27, 20, 26, 22, 24]
[22, 24, 20, 26, 18, 27, 16, 25, 14, 23, 12, 21, 10, 19, 8, 17, 6, 15, 4, 13, 2, 11, 1, 9, 3, 7, 5]
[7, 5, 9, 3, 11, 1, 13, 2, 15, 4, 17, 6, 19, 8, 21, 10, 23, 12, 25, 14, 27, 16, 26, 18, 24, 20, 22]
[20, 22, 18, 24, 16, 26, 14, 27, 12, 25, 10, 23, 8, 21, 6, 19, 4, 17, 2, 15, 1, 13, 3, 11, 5, 9, 7]
[9, 7, 11, 5, 13, 3, 15, 1, 17, 2, 19, 4, 21, 6, 23, 8, 25, 10, 27, 12, 26, 14, 24, 16, 22, 18, 20]
[18, 20, 16, 22, 14, 24, 12, 26, 10, 27, 8, 25, 6, 23, 4, 21, 2, 19, 1, 17, 3, 15, 5, 13, 7, 11, 9]
[11, 9, 13, 7, 15, 5, 17, 3, 19, 1, 21, 2, 23, 4, 25, 6, 27, 8, 26, 10, 24, 12, 22, 14, 20, 16, 18]
[16, 18, 14, 20, 12, 22, 10, 24, 8, 26, 6, 27, 4, 25, 2, 23, 1, 21, 3, 19, 5, 17, 7, 15, 9, 13, 11]
[13, 11, 15, 9, 17, 7, 19, 5, 21, 3, 23, 1, 25, 2, 27, 4, 26, 6, 24, 8, 22, 10, 20, 12, 18, 14, 16]
[14, 16, 12, 18, 10, 20, 8, 22, 6, 24, 4, 26, 2, 27, 1, 25, 3, 23, 5, 21, 7, 19, 9, 17, 11, 15, 13]
[15, 13, 17, 11, 19, 9, 21, 7, 23, 5, 25, 3, 27, 1, 26, 2, 24, 4, 22, 6, 20, 8, 18, 10, 16, 12, 14]
[12, 14, 10, 16, 8, 18, 6, 20, 4, 22, 2, 24, 1, 26, 3, 27, 5, 25, 7, 23, 9, 21, 11, 19, 13, 17, 15]
[17, 15, 19, 13, 21, 11, 23, 9, 25, 7, 27, 5, 26, 3, 24, 1, 22, 2, 20, 4, 18, 6, 16, 8, 14, 10, 12]
[10, 12, 8, 14, 6, 16, 4, 18, 2, 20, 1, 22, 3, 24, 5, 26, 7, 27, 9, 25, 11, 23, 13, 21, 15, 19, 17]
[19, 17, 21, 15, 23, 13, 25, 11, 27, 9, 26, 7, 24, 5, 22, 3, 20, 1, 18, 2, 16, 4, 14, 6, 12, 8, 10]
[8, 10, 6, 12, 4, 14, 2, 16, 1, 18, 3, 20, 5, 22, 7, 24, 9, 26, 11, 27, 13, 25, 15, 23, 17, 21, 19]
[21, 19, 23, 17, 25, 15, 27, 13, 26, 11, 24, 9, 22, 7, 20, 5, 18, 3, 16, 1, 14, 2, 12, 4, 10, 6, 8]
[6, 8, 4, 10, 2, 12, 1, 14, 3, 16, 5, 18, 7, 20, 9, 22, 11, 24, 13, 26, 15, 27, 17, 25, 19, 23, 21]
[23, 21, 25, 19, 27, 17, 26, 15, 24, 13, 22, 11, 20, 9, 18, 7, 16, 5, 14, 3, 12, 1, 10, 2, 8, 4, 6]
[4, 6, 2, 8, 1, 10, 3, 12, 5, 14, 7, 16, 9, 18, 11, 20, 13, 22, 15, 24, 17, 26, 19, 27, 21, 25, 23]
[25, 23, 27, 21, 26, 19, 24, 17, 22, 15, 20, 13, 18, 11, 16, 9, 14, 7, 12, 5, 10, 3, 8, 1, 6, 2, 4]
[2, 4, 1, 6, 3, 8, 5, 10, 7, 12, 9, 14, 11, 16, 13, 18, 15, 20, 17, 22, 19, 24, 21, 26, 23, 27, 25]
[27, 25, 26, 23, 24, 21, 22, 19, 20, 17, 18, 15, 16, 13, 14, 11, 12, 9, 10, 7, 8, 5, 6, 3, 4, 1, 2]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27]

Amusez-vous au golf!

TI-Basic (série 83), 58 57 54 octets (104 caractères)

:seq(I,I,1,Ans→A
:Ans→B
:Repeat prod(Ans=ᶫB
:ᶫB→C
:int(⁻Ans/2→D
:SortD(ᶫC,ᶫA
:SortD(ᶫD,ᶫA
:Pause ᶫA
:End

Explication

Prend entrée Ans(par exemple, écrire 5:prgmNAMEpour utiliser des listes de taille cinq).

Crée trois listes auxiliaires de la taille donnée (qui sont recréées à partir ᶫBde chaque étape): ᶫB = ᶫC = {1,2,3,4,5,...}et ᶫD = {-1,-1,-2,-2,-3,...}. À chaque étape, trie ᶫCet ᶫDen ordre décroissant, en appliquant la même permutation à ᶫA. Dans le cas de ᶫC, cela inverse ᶫA, et dans le cas de ᶫD, cela permute les paires adjacentes car TI-Basic utilise une implémentation de tri de sélection vraiment stupide pour SortD(laquelle réorganise autant d'éléments identiques que possible. Quand ᶫAest égal à ᶫBnouveau, nous nous arrêtons.

Non, sérieusement, leur algorithme de tri intégré est ma deuxième plus grande plainte avec l'interpréteur TI-Basic. (Ma plus grande plainte est de savoir comment de nombreuses boucles imbriquées ralentissent l'interpréteur, car les données de la boucle sont stockées dans une pile, mais la pile est agrandie du mauvais côté, de sorte que la calculatrice doit déplacer la pile entière chaque fois qu'un élément est poussé ou sauté.) Mais cette fois, c'est pratique.

-1 octet: Pausestocke la valeur à laquelle il imprime Ans, qui est plus courte à référencer que ᶫA.

-3 octets: prendre en entrée Ans

Gelée , 10 octets

RµUs2UFµÐĿ

Essayez-le en ligne!

Explication

RµUs2UFµÐĿ  Main link
R           Generate the range
        ÐĿ  While the results are unique (collecting results)
 µUs2UFµ    Reverse and reorder
  U         Reverse
   s        Slice non-overlapping into length
    2       2
     U      Reverse (automatically vectorizes to depth 1)
      F     Flatten

Remarque

Si la plage d'origine doit être à la fin, ajoutez ṙ1au code pour 12 octets.

05AB1E , 13 11 octets

LIGÂ2ôí˜})Ù

Essayez-le en ligne!

Explication

L             # range [1 ... input]
 IG           # input-1 times do:
   Â          # bifurcate
    2ô        # split into pieces of 2
      í       # reverse each
       ˜      # flatten
        }     # end loop
         )    # wrap stack in a list
          Ù   # remove duplicates

JavaScript (ES6), 89 85

Modifier 4 octets enregistrés thx @JustinMariner

En utilisant le fait que lorsqu'un élément est au bon endroit, tous les éléments le sont.

n=>{for(l=[];n;l[n-1]=n--);while(alert(l=l.reverse().map((x,i)=>l[i^1]||x)),l[0]-1);}

Moins golfé

n => {
  for(l=[], i=0; i<n; l[i] = ++i);
  while( alert(l=l.reverse().map( (x,i) => l[i^1] || x)),
         l[0]-1);
}

Tester

var F=
n=>{for(l=[];n;l[n-1]=n--);while(alert(l=l.reverse().map((x,i)=>l[i^1]||x)),l[0]-1);}

alert=x=>console.log(x+'') // to avoid popup stress

function update() {
  F(+I.value);
} 

update()

<input type=number id=I value=1 min=1 oninput='update()'>

Mathematica, 142 octets

(h=Range@#;W={};For[i=1,i<=#,i++,s=Reverse@h;AppendTo[W,h=Join[f=Flatten[Reverse/@Partition[s,{2}]],s~Complement~f]];s=h];DeleteDuplicates@W)&

JavaScript (ES6), 79 octets

f=(n,a=[...Array(n)],b=a.map((x,i)=>n-((x?x-1:i)^1)||1))=>b[0]>1?b+`
`+f(n,b):b

Affiche une liste pour chaque étape.

Notez que nous n'avons pas besoin d'initialiser le tableau pour lancer la balle. S'il xn'est pas initialisé ( n'est pas défini), nous pouvons utiliser les indices (paramètres i) du tableau pour effectuer la première étape:

b=a.map((x,i)=>n-((x?x-1:i)^1)||1)

Cas de test:

f=(n,a=[...Array(n)],b=a.map((x,i)=>n-((x?x-1:i)^1)||1))=>b[0]>1?b+`
`+f(n,b):b

console.log(f(1));
console.log(f(2));
console.log(f(3));
console.log(f(4));
console.log(f(5));
console.log(f(7));
console.log(f(27));

R, 109 95 94 79 74 62 octets

Si le fait que le code envoie des avertissements au-dessus de la solution réelle (aucun avertissement si nest 1, 3 avertissements si nest pair et navertissements si nest impair) n'est pas un problème, alors ce qui suit fonctionne de manière similaire à la solution précédente, grâce au vecteur recyclage:

n=scan();m=1:n;w=0:n+2*1:0;while(print(m<-rev(m)[w[w<=n]])-1)n

Essayez-le en ligne!

Merci encore à @Giuseppe pour 12 octets supplémentaires!

Solution précédente sans avertissement à 94 octets:

n=scan();m=s=1:n;while(any(print(m<-rev(m)[c(if(n>1)2:1+rep(seq(0,n-2,2),e=2),n[n%%2])])!=s))n

Essayez-le en ligne!

Solution originale à 109 octets :

n=scan();m=s=1:n;repeat{cat(m<-rev(m)[c(t(embed(s,min(n,2))[!!s[-n]%%2,]),n[n%%2])],"\n");if(all(m==s))break}

Essayez-le en ligne!

Japt , 20 18 15 12 octets

õ
£=ò2n)ÔcÃâ

Essayez-le ( -Rindicateur à des fins de visualisation uniquement)

1 octet économisé grâce à ETHproductions.

               :Implicit input of integer U
õ              :Range [1,U]
\n             :Reassign to U
£              :Map
  ò            :  Partitions
   2           :    Of length 2
    n          :    Starting from the end
     )         :  End partition
      Ô        :  Reverse
       c       :  Flatten
 =             :  Reassign to U
        Ã      :End map
         â     :Deduplicate

Coque , 9 octets

U¡ȯṁ↔C2↔ḣ

Essayez-le en ligne!

            -- implicit input N                 |  3
         ḣ  -- list [1..N]                      | [1,2,3]
 ¡(     )   -- iterate the following function,  | [[1,2,3],[2,3,1],[3,1,2],[1,2,3],...
U           -- until the first repetition:      | [[1,2,3],[2,3,1],[3,1,2]]
       ↔    --   reverse                        |   [3,2,1]
     C2     --   cut into two                   |   [[3,2],[1]]
   ṁ↔       --   reverse each pair & flatten    |   [2,3,1]

Rubis , 64 57 52 50 octets

->x{(s=*w=1..x).map{s=w.map{|y|s[-y^1]||s[0]}}|[]}

Essayez-le en ligne!

Comment ça marche:

Créez d'abord la plage, puis répétez la permutation x fois: utilisez un indice négatif, mais inversez le dernier bit, nous obtenons donc la séquence -2, -1, -4, -3 ... si x est pair, cela se terminera sinon, nous ajouterons l'élément restant à la fin. Dernière étape: filtrer les tableaux répétés (nous couvrons donc tous les cas: x = 1, x = 2, nombres pairs et impairs)

Haskell, 75 74 octets

g(a:b:c)=b:a:g c
g x=x
h=g.reverse
0!x|x<[2]=[x]|1<2=x:0!h x
p n=0!h[1..n]

Essayez-le en ligne!

geffectue les échanges par paire, hune seule étape (inverse + réorganiser), !s'applique à plusieurs reprises h(et recueille les résultats intermédiaires) jusqu'à ce que l'ordre soit restauré. Remarque: !prend le paramètre supplémentaire supplémentaire mais inutilisé 0juste pour en faire un opérateur d'infixe. La fonction principale le pdémarre.

Edit: Merci à @Angs pour un octet.

Java 8, 215 214 octets

import java.util.*;n->{Stack a=new Stack(),t;int i=0;for(;i<n;a.add(++i));t=(Stack)a.clone();Collections x=null;for(i=0;i<1|!a.equals(t);System.out.println(t))for(x.reverse(t),i=0;i<n;i++)if(i<n-1)x.swap(t,i,++i);}

J'ai essayé de jouer au golf en utilisant des tableaux réels au lieu d'une liste, mais inverser et échanger prendrait trop d'octets .. Peut-être qu'il peut être combiné dans une boucle (au lieu d'inverser d'abord, puis d'échanger), mais je n'ai pas encore comprendre cela.
Cela peut certainement être joué un peu plus, cependant.

Explication:

Essayez ici.

import java.util.*;           // Required import for Stack and Collections

n->{                          // Method with integer parameter and no return-type
  Stack a=new Stack(),        //  Original List
        t;                    //  Copy-List
  int i=0;                    //  Index-integer, starting at 0
  for(;i<n;a.add(++i));       //  Fill the original list with the integers
  t=(Stack)a.clone();         //  Make a copy of the List
  Collections x=null;         //  Static `Collections` to reduce bytes
  for(i=0;                    //  Reset index `i` to 0
      i<1                     //  Loop (1) as long as `i` is 0 (the first iteration),
      |!a.equals(t);          //  or the input array is not equal to the copy
      System.out.println(t))  //    After every iteration: print the modified List
    for(x.reverse(t),         //   Reverse the copied List
        i=0;                  //   Reset `i` to 0
        i<n;                  //   Inner loop (2) over the List
        i++)                  //     After every iteration: increase `i` by 1 again
      if(i<n-1)               //    Unless it's the last item in the List:
        x.swap(t,i,++i);      //     Swap the items at indexes `i` and `i+1` 
                              //     (by increasing `i` by 1 first with `++i`)
                              //   End of inner loop (2) (implicit / single-line body)
                              //  End of loop (1) (implicit / single-line body)
}                             // End of method

Java (OpenJDK 8) , 257 245 243 226 206 205 octets

n->{int i=0,k,t[]=new int[n];while(i<n)t[i]=++i;do{for(i=0;i<n/2;t[i]=t[n+~i],t[n+~i++]=k)k=t[i];for(k=1;k<n;t[k]=t[--k],t[k]=i,k+=3)i=t[k];System.out.println(java.util.Arrays.toString(t));}while(t[0]>1);}

Essayez-le en ligne!

MATL , 17 octets

:`tP2ePXz!tG:-a]x

Essayez-le en ligne!

Explication

:       % Implicit input: n. Push [1 2 ... n]
`       % Do...while
  t     %   Duplicate
  P     %   Reverse
  2e    %   Reshape into a 2-row matrix. A final 0 is added if needed
  P     %   Reverse each column
  Xz    %   Nonzero entries (i.e. remove final 0 if present). Gives a column vector
  !     %   Transpose into a row
  t     %   Duplicate
  G:    %   Push [1 2 ... n] again
  -     %   Subtract element-wise
  a     %   Any. Gives true if there is at least a nonzero value
]       % End. Go to next iteration if top of the stack is true.  So the loop ends
        % when [1 2 ... n] has been found again
x       % Delete top of the stack (which is [1 2  ... n]). Implicit display

Stax , 17 octets

âΩÄ─g╫B♥C╛♠ƒ?|πcD

Exécuter et déboguer

Explication

RX~Wr2/{r+}Fc|uPcx=C      # Full program, unpacked, implicit input
RX~                       # Create range, save to X register, pop back to input stack
   W                      # Start while loop until truthy value
    r                     # reverse array
     2/                   # Split into groups of 2
      {r+}F               # Loop through each set and reverse each
           c              # Copy top value
            |u            # Convert to string representation of array
              P           # Pop top value off
               cx=        # Copy top value, get value of x register, compare to top value
                  C       # If top value is truthy, cancel block and end

Surpris, il fonctionne aussi vite qu'il le fait, testé jusqu'à 399 avant de ne plus vouloir tempérer mon navigateur.

JavaScript (ES6), 122 octets

f=(n,a=[...Array(n)].map((_,i)=>i+1),r=[],b=a.map((_,i)=>a[n+~(i^1)]||a[0]))=>b.some((e,i)=>e>b[i+1],r.push(b))?f(n,b,r):r

r.push(a)pourrait être utilisé au lieu de r.push(b)mettre la permutation d'origine à l'avant.

Haskell , 97 octets

Cela semble un peu long :(

f n|x<-[1..n]=x:takeWhile(/=x)(tail$iterate((r=<<).g.r)x)
r=reverse
g[]=[]
g x=take 2x:g(drop 2x)

Essayez-le en ligne!

Explication / Non golfé

-- starting with x, accumulate the results of repeatedly
-- applying the function permute
f n = x : takeWhile (/=x) (tail $ iterate permute x)
  where x = [1..n]
        -- reverse, cut2, reverse each pair & flatten
        permute = concatMap reverse . cut2 . reverse

-- recursively transform a list into groups of 2
cut2 [] = []
cut2 xs = take 2 xs : g (drop 2 xs)

Empilé , 42 octets

[~>[rev 2#<$revflatmap]periodsteps behead]

Essayez-le en ligne!

Effectue la transformation donnée à l'aide de la fonction periodstepsintégrée. Cependant, cette fonction intégrée renvoie tous les éléments, ce qui inclut la plage d'entrée en tant que premier et dernier élément. Nous décapitons donc la liste, renvoyant tout sauf le premier élément.

AWK , 123 octets

Pas très serré, mais c'est le mieux que j'ai pu trouver.

{for(N=$1;N>$i=++i;);for(;n++<(i%2?i:i>2?2:1);){for(k=0;k++<i;)K[k]=(z=i-k+(k-1)%2*2)?$z:$1;for(k=0;k++<N;){$k=K[k]}print}}

Essayez-le en ligne!

Python 2 , 165 159 138 81 bytes

x=input()+1
b=a=range(1,x)
while b:b=[b[x-min(x,i+1^1)]for i in a];print b;b*=a<b

Essayez-le en ligne!

-20 octets grâce à @ChasBrown . (Soupir, j'ai fait tout un défi sur la syntaxe de découpage étendue)

Whoa! GolfStorm (-57 octets)! Merci à Ian Gödel, tsh et Jonathan Frech.

JavaScript, 136 octets

(n)=>{for(a=[],i=0;i<n;a[i]=++i);for(j=0;j<(n&1?n:2);j++){a.reverse();for(i=0;i<a.length-1;i += 2)m=a[i],a[i]=a[i+1],a[i+1]=m;alert(a)}}