L'Arrangement 465

24

Voici le défi. Écrivez du code pour sortir tous les entiers d'une plage. Cela semble facile, mais voici la partie délicate. Il commencera par le nombre le plus bas, puis le plus élevé. Ensuite, le nombre le plus bas qui n'est pas encore dans le tableau. Puis le plus haut qui n'y est pas encore.

Exemple:

Prenons 1 à 5 comme point de départ

Les nombres sont [1, 2, 3, 4, 5].

Nous prenons le premier, donc [1]. Les nombres restants sont [2, 3, 4, 5]. Nous prenons le dernier, le nouveau tableau est [1, 5]. Les nombres restants sont [2, 3, 4]. Nous prenons le premier, le nouveau tableau est [1, 5, 2]. Les nombres restants sont [3, 4]. Nous prenons le dernier, le nouveau tableau est [1, 5, 2, 4]. Les nombres restants sont [3]. Nous prenons le premier, le nouveau tableau est [1, 5, 2, 4, 3]. Il ne reste plus de chiffres, nous avons terminé. Sortie [1, 5, 2, 4, 3]

Règles:

  • Il s'agit de code golf, écrivez-le dans le moins d'octets, dans n'importe quelle langue.
  • Pas de failles standard.
  • Liens vers un interprète en ligne, s'il vous plaît? (Par exemple https://tio.run/ )
  • Deux entrées, les deux entiers. Bas de gamme et haut de gamme.
  • Peu m'importe le type de données de la sortie, mais il doit afficher les nombres dans le bon ordre.

Exemples

Faible: 4 Élevé: 6 Résultat: 4 6 5

Faible: 1 Élevé: 5 Résultat: 1 5 2 4 3

Faible: -1 Élevé: 1 Résultat: -1 1 0

Bas: -1 haut: 2 Résultat: -1 2 0 1

Bas: -50 Haut: 50 Résultat: -50 50-49 49-48 48-47 47-46 46-45 45-44 44-43 43-42 42-41 41-40 40-39 39-38 38-37 37-36 36-35 35-34 34-33 33-32 32-31 31-30 30-29 29-28 28-27 27-26 26-25 25-24 24-23 23-22 22-21 21 - 20 20-19 19-18 18-17 17-16 16-15 15-14 14-13 13-12 12-11 11-10 10-9 9-8 8 -7 7 -6 6 -5 5 -4 4 -3 3 -2 2 -1 1 0

Bon golf!

code-golf AJFaraday
la source
2
Presque en double (la différence étant que celle-ci nécessite d'inverser la seconde moitié avant de fusionner).
Peter Taylor
l'entrée sera-t-elle toujours de l'ordre de bas de gamme, haut de gamme?
Sumner18
1
@ Sumner18 oui. La communauté ici est bloquée contre la validation des entrées, et je n'ai pas demandé d'entrée inversée, nous pouvons donc supposer que ce sera toujours bas - haut.
AJFaraday
1
@ Sumner18 Comment ces défis fonctionnent généralement, c'est que nous ne nous soucions pas de la façon dont les entrées invalides sont gérées. Votre code n'est jugé efficace que par la façon dont il traite les entrées valides (c'est-à-dire que les deux sont des entiers, le premier est inférieur au second)
AJFaraday
1
@AJFaraday: vous devriez ajouter une note au message principal indiquant que X sera toujours strictement inférieur à Y (c'est-à-dire X! = Y), j'ai raté ce commentaire;)
digEmAll

Réponses:

15

R , 38 37 36 octets

function(a,b)rbind(a:b,b:a)[a:b-a+1]

Essayez-le en ligne!

  • -1 octet grâce à @ user2390246
  • -1 octet grâce à @Kirill L.

Exploiter le fait que R stocke les matrices colonne par colonne

digEmAll
la source
L'utilisation rbindest bien meilleure que mon approche, mais vous pouvez économiser 1 octet en utilisant [seq(a:b)]au lieu de unique.
user2390246
Vous avez raison, j'ai raté le commentaire où il a été spécifié qu'un <b (jamais égal), afin que nous puissions utiliserseq(a:b)
digEmAll
@digEmAll Ma solution était essentiellement une interprétation littérale du puzzle, je n'aurais jamais pensé à faire quelque chose comme ça. Impressionnant, ayez un vote positif!
Sumner18
1
-1 de plus
Kirill L.
11

Haskell , 30 octets

a%b=a:take(b-a)(b:(a+1)%(b-1))

Essayez-le en ligne!

xnor
la source
Bon sang! Je viens de trouver exactement la même solution.
Eh
8

R , 65 64 61 60 octets

-1 octet grâce à Robert S.

-4 de plus grâce à digEmAll 

x=scan();z=x:x[2];while(sum(z|1)){cat(z[1],"");z=rev(z[-1])}

Essayez-le en ligne!

Sumner18
la source
Vous pouvez remplacer length(z)par sum(z|1)pour économiser 1 octet :)
Robert S.
Je ne comprends pas comment cela fonctionne, mais je suppose que oui. sum (z | 1) semble s'évaluer toujours à au moins 1, ce qui ferait que la boucle while se boucle indéfiniment. mais apparemment pas
Sumner18
4
z est un vecteur. chaque élément de ce vecteur est |édité par 1. Ce qui est toujours égal à 1. Lorsque vous prenez la somme, vous avez un vecteur rempli de TRUEs donc le résultat est égal à la longueur du vecteur. Si le vecteur est vide, vous n'avez rien à voir |avec le vecteur de sortie logical(0). Quand vous prenez cette somme, c'est 0
OganM
5

PowerShell , 59 48 octets

param($a,$b)(($z=0..($b-$a))|%{$a+$_;$b-$_})[$z]

Essayez-le en ligne!

(Semble long ...)

Prend des entrées $aet $bconstruit la plage 0 .. ($b-$a), les stocke dans $z, puis parcourt cette plage. Le bouclage à travers cette plage est juste utilisé comme compteur pour garantir que nous obtenons suffisamment d'itérations. Chaque itération, nous mettons $aet $bsur le pipeline avec addition / soustraction. Cela nous donne quelque chose comme 1,5,2,4,3,3,4,2,5,1ça, nous devons donc le découper 0jusqu'au $b-$a(c'est-à-dire le nombre) du tableau d'origine, de sorte qu'il ne nous reste que les éléments appropriés. Cela reste sur le pipeline et la sortie est implicite.

-11 octets grâce à mazzy.

AdmBorkBork
la source
48 octets
mazzy
@mazzy Ah, j'aime cette $b-$aastuce - c'est intelligent!
AdmBorkBork
5

05AB1E , 6 octets

ŸDvć,R

Essayez-le en ligne!

Explication

Ÿ        # push range [min ... max]
 D       # duplicate
  v      # for each element in the copy
   ć,    # extract and print the head of the original list
     R   # and then reverse it
Emigna
la source
Ÿ2ä`R.ι non itératif utilisant l'entrelacement, mais c'est encore mieux.
Urne de poulpe magique le
1
@MagicOctopusUrn: J'ai d'abord essayé une solution non itérative, mais c'était encore pire car je ne le savais pas .ι;)
Emigna
Similaire à ce que j'avais en tête, si évident +1 de ma part. J'aime aussi votre alternative à 7 octets via @MagicOctopusUrn. :)
Kevin Cruijssen
1
@KristianWilliams: Semble travailler pour moi.
Emigna
1
@KevinCruijssen: Je suis passé à une paire à la place car cela semblait de toute façon plus intuitif :)
Emigna
4

R , 51 octets

function(x,y,z=x:y)matrix(c(z,rev(z)),2,,T)[seq(z)]

Essayez-le en ligne!

Explication: pour une séquence x:yde longueur N, créez une matrice deux par N composée de la séquence x: y dans la ligne supérieure et y: x dans la ligne inférieure matrix(c(z,rev(z)),2,,T). Si nous sélectionnons les premiers Néléments de la matrice [seq(z)], ils seront choisis par colonne, donnant la sortie requise.

Outgolfed par digEmAll

user2390246
la source
1
Je viens de poster une approche très similaire 30 secondes avant vous: D
digEmAll
@digEmAll Oui, mais le vôtre est bien meilleur!
user2390246
4

cQuents , 19 octets

#|B-A+1&A+k-1,B-k+1

Essayez-le en ligne!

Notez qu'il ne fonctionne pas sur TIO pour le moment car l'interpréteur de TIO n'est pas à jour.

Explication

#|B-A+1&A+k-1,B-k+1
                      A is the first input, B is the second input
#|B-A+1               n = B - A + 1
       &              Print the first n terms of the sequence
                      k starts at 1 and increments whenever we return to the first term
        A+k-1,         Terms alternate between A + k - 1 and
              B-k+1     B - k + 1
                       increment k
Stephen
la source
4

Haskell, 39 octets

f(a:b)=a:f(reverse b)
f x=x
a#b=f[a..b]

Essayez-le en ligne!

nimi
la source
4

Bytecode JVM (OpenJDK asmtools JASM), 449 octets

enum b{const #1=Method java/io/PrintStream.print:(I)V;static Method a:(II)V stack 2 locals 4{getstatic java/lang/System.out:"Ljava/io/PrintStream;";astore 3;ldc 0;istore 2;l:iload 2;ldc 1;if_icmpeq t;aload 3;iload 0;invokevirtual #1;iinc 0,1;iinc 2,1;goto c;t:aload 3;iload 1;invokevirtual #1;iinc 1,-1;iinc 2,-1;c:aload 3;ldc 32;i2c;invokevirtual java/io/PrintStream.print:(C)V;iload 0;iload 1;if_icmpne l;aload 3;iload 0;invokevirtual #1;return;}}

Non golfée (et légèrement plus propre)

 enum b {    
    public static Method "a":(II)V stack 5 locals 4 {
        getstatic "java/lang/System"."out":"Ljava/io/PrintStream;";
        astore 3;
        ldc 0;
        istore 2;
    loop:
        iload 2;
        ldc 1;
        if_icmpeq true;
    false:
        aload 3;
        iload 0;
        invokevirtual "java/io/PrintStream"."print":"(I)V";
        iinc 0,1;
        iinc 2,1;
        goto cond;
    true:
        aload 3;
        iload 1;
        invokevirtual "java/io/PrintStream"."print":"(I)V";
        iinc 1,-1;
        iinc 2,-1;
        goto cond;
    cond:
        iload 0;
        iload 1;
        if_icmpne loop;
        aload 3;
        iload 0;
        invokevirtual "java/io/PrintStream"."print":"(I)V";
        return;
    }
}

Fonction autonome, doit être appelée à partir de Java en tant que b.a(num1,num2).

Explication

Ce code utilise les paramètres de la méthode comme variables, ainsi qu'un booléen dans le local # 3 pour décider du nombre à afficher. Chaque itération de boucle à gauche ou à droite est sortie, et ce nombre est incrémenté pour la gauche ou décrémenté pour la droite. La boucle continue jusqu'à ce que les deux nombres soient égaux, puis ce nombre est sorti.

... J'ai un sentiment distinct que je suis massivement dépassé par le nombre d'octets

Chaton
la source
4

Wolfram Language (Mathematica) , 56 54 octets

C'est ma première fois au golf!

f[a_,b_]:=(c=a~Range~b;Drop[c~Riffle~Reverse@c,a-b-1])

Essayez-le en ligne!

Enregistré 2 octets en utilisant la notation infixe.

Explication:

f[a_,b_]:=                                   \function of two variables
c=a~Range~b;                                 \list of integers from a to b 
                           Reverse@c         \same list in reverse
                  c~Riffle~Reverse@c         \interleave the two lists
             Drop[c~Riffle~Reverse@c,a-b-1]  \drop last |a-b-1| elements (note a-b-1 < 0)

Alternativement, nous pourrions utiliser Take[...,b-a+1]pour le même résultat.

Tests:

f[4, 6]
f[1, 5]
f[-1, 1]
f[-1, 2]

Sortie:

{4, 6, 5}
{1, 5, 2, 4, 3}
{-1, 1, 0}
{-1, 2, 0, 1}
Kai
la source
Le lien "Essayez-le en ligne" renvoie un 403. "Désolé, vous n'êtes pas autorisé à accéder à cet élément."
Rohit Namjoshi
@RohitNamjoshi J'ai mis à jour le lien
Kai
notez que sur TIO, vous pouvez placer le code d'en-tête et de pied de page dans les zones de texte au-dessus et en dessous de la zone de code réelle. Cela rend le code plus propre et vous permet de profiter du formateur de réponse PPCG (esc-sg). Essayez-le en ligne!
Jo King
@JoKing très apprécié, je ne l'avais jamais utilisé auparavant!
Kai
3

Japt, 7 octets

Prend l'entrée comme un tableau.

rõ
ÊÆÔv

Essayez-le ou exécutez tous les cas de test

         :Implicit input of array U=[low,high]
r        :Reduce by
 õ       :  Inclusive, reversed range (giving the range [high,low])
\n       :Reassign to U
Ê        :Length
 Æ       :Map the range [0,Ê)
  Ô      :  Reverse U
   v     :  Remove the first element
Hirsute
la source
3

MATL , 8 octets

&:t"1&)P

Essayez-le en ligne!

Explication

&:      % Take two inputs (implicit). Two-input range
t       % Duplicate
"       % For each
  1&)   %   Push first element, then an array with the rest
  P     %   Reverse array
        % End (implicit). Display (implicit)
Luis Mendo
la source
3

Forth (gforth) , 52 octets

: f 2dup - 1+ 0 do dup . i 2 mod 2* 1- - swap loop ;

Essayez-le en ligne!

Explication

Boucle de 0 à (Fin - Début). Placez End et Start sur le dessus de la pile.

Chaque itération:

  • Afficher le numéro actuel
  • Ajouter (ou soustraire) 1 du nombre actuel
  • Changer le numéro actuel avec l'autre numéro

Explication du code

: f           \ start new word definition
  2dup -      \ get the size of the range (total number of integers)
  1+ 0        \ add 1 to the size because forth loops are [Inclusive, Exclusive) 
  do          \ start counted loop from 0 to size+1
    dup .     \ output the current top of the stack
    i 2 mod   \ get the index of the loop modulus 2
    2* 1-     \ convert from 0,1 to -1,1
    -         \ subtract result from top of stack (adds 1 to lower bound and subtracts 1 from upper)
    swap      \ swap the top two stack numbers 
  loop        \ end the counted loop
;             \ end the word definition
reffu
la source
3

Haskell, 30 octets

l%h=l:take(h-l)(h:(l+1)%(h-1))

Utilisation: 3%7donne `[3,7,4,6,5]

Pour les entrées, l, hla fonction appelle récursivement avec les entrées l+1, h-1et ajoute l,hau début. Au lieu de toute condition d'arrêt, le code utilise take(h-l)pour raccourcir la séquence à la bonne longueur (qui serait sinon une séquence infinie de nombres croissants et décroissants).

fier haskeller
la source
3

Brachylog , 15 octets

⟦₂{∅|b↔↰T&hg,T}

L'entrée est une liste à 2 éléments [lo, hi]. Notez que le soulignement est utilisé pour les nombres négatifs. Essayez-le en ligne!

Explication

⟦₂               2-argument inclusive range: [1,5] -> [1,2,3,4,5]
  {           }  Call this recursive predicate to calculate the output:
   ∅               Base case: the input is empty list; nothing to do
    |              Otherwise (recursive case):      [1,2,3,4,5]
     b             Behead the input list            [2,3,4,5]
      ↔            Reverse                          [5,4,3,2]
       ↰           Call the predicate recursively   [5,2,4,3]
        T          Label the result T
         &         Also, with the input list,
          h        Take the head                    1
           g       Wrap it in a list                [1]
            ,T     Append T from earlier            [1,5,2,4,3]
DLosc
la source
3

MathGolf , 6 octets

↨_x^─▀

Essayez-le en ligne!

Explication avec (1, 5)

↨        inclusive range from a to b    [1, 2, 3, 4, 5]
 _       duplicate TOS                  [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]
  x      reverse int/array/string       [1, 2, 3, 4, 5], [5, 4, 3, 2, 1]
   ^     zip top two elements on stack  [[1, 5], [2, 4], [3, 3], [4, 2], [5, 1]]
    ─    flatten array                  [1, 5, 2, 4, 3, 3, 4, 2, 5, 1]
     ▀   unique elements of string/list [1, 5, 2, 4, 3]

La raison pour laquelle cela fonctionne est due au fait que tous les éléments de la sortie doivent être uniques, de sorte que l'opérateur des éléments uniques filtrera la seconde moitié du tableau, produisant la sortie correcte.

maxb
la source
2

Cubix, 16 octets

;w(.II>sO-?@;)^/

Essayez-le ici

Cubifié

    ; w
    ( .
I I > s O - ? @
; ) ^ / . . . .
    . .
    . .

Explication

Fondamentalement, cela rapproche les deux limites l'une après l'autre jusqu'à ce qu'elles se rencontrent. Chaque fois que nous parcourons la boucle, nous sinversons les limites, Osaisissons, prenons la différence et incrémentons )ou décrémentons avec en (fonction du signe.


la source
2

Pyth, 10 8 octets

{.iF_B}F

Essayez-le ici

Explication

{.iF_B}F
      }FQ  Generate the range between the (implicit) inputs.
 .iF_B     Interleave it with its reverse.
{          Deduplicate.

la source