Aquí está el desafío. Escriba un código para generar todos los enteros en un rango. Suena fácil, pero aquí está la parte difícil. Comenzará con el número más bajo, luego el más alto. Luego, el número más bajo que aún no está en la matriz. Entonces el más alto que aún no está en él.

Ejemplo:

Tomemos de 1 a 5 como nuestro comienzo

Los números son [1, 2, 3, 4, 5].

Tomamos el primero, entonces [1]. Los números restantes son [2, 3, 4, 5]. Tomamos el último, la nueva matriz es [1, 5]. Los números restantes son [2, 3, 4]. Tomamos la primera, nueva matriz es [1, 5, 2]. Los números restantes son [3, 4]. Tomamos el último, la nueva matriz es [1, 5, 2, 4]. Los números restantes son [3]. Tomamos la primera, nueva matriz es [1, 5, 2, 4, 3]. No quedan números, hemos terminado. Salida [1, 5, 2, 4, 3]

Reglas:

• Este es el código de golf, escríbalo en la menor cantidad de bytes, en cualquier idioma.
• No hay lagunas estándar.
• Enlaces a un intérprete en línea, por favor? (Por ejemplo, https://tio.run/ )
• Dos entradas, ambos enteros. Extremo bajo del rango y extremo alto del rango.
• No me importa cuál es el tipo de datos de la salida, pero debe mostrar los números en el orden correcto.

Ejemplos

Bajo: 4 Alto: 6 Resultado: 4 6 5

Bajo: 1 Alto: 5 Resultado: 1 5 2 4 3

Bajo: -1 Alto: 1 Resultado: -1 1 0

Bajo: -1 alto: 2 Resultado: -1 2 0 1

Bajo: -50 Alto: 50 Resultado: -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

¡Feliz golf!

R , 38 37 36 bytes

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

Pruébalo en línea!

• -1 byte gracias a @ user2390246
• -1 byte gracias a @Kirill L.

Explotando el hecho de que R almacena matrices en columnas

Haskell , 30 bytes

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

Pruébalo en línea!

R , 65 64 61 60 bytes

-1 byte gracias a Robert S.

-4 más gracias a digEmAll

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

Pruébalo en línea!

Haskell , 39 bytes

a#b|a>b=a:b#(a-1)|a<b=a:b#(a+1)|1>0=[a]

Pruébalo en línea!

Python 2 , 44 bytes

f=lambda a,b:[a]*(a==b)or[a]+f(b,a-cmp(a,b))

Pruébalo en línea!

PowerShell , 59 48 bytes

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

Pruébalo en línea!

(Parece largo ...)

Toma datos $ay $bconstruye el rango 0 .. ($b-$a), los almacena $zy luego recorre ese rango. El bucle a través de ese rango solo se usa como un contador para garantizar que obtengamos suficientes iteraciones. Cada iteración, ponemos $ay $ben la tubería con suma / resta. Eso nos da algo así, 1,5,2,4,3,3,4,2,5,1por lo que debemos dividirlo desde 0hasta el $b-$a(es decir, el recuento) de la matriz original, por lo que solo nos quedan los elementos apropiados. Eso queda en la tubería y la salida es implícita.

-11 bytes gracias a mazzy.

05AB1E , 6 bytes

ŸDvć,R

Pruébalo en línea!

Explicación

Ÿ        # 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

Japt , 14 bytes

òV
íUs w)c vUl

Pruébalo en línea!

Stax , 7 bytes

É╓ÅìΔà▲

Ejecutar y depurarlo

R , 51 bytes

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

Pruébalo en línea!

Explicación: Para una secuencia x:yde longitud N, cree una matriz de dos por N que consista en la secuencia x: y en la fila superior e y: x en la fila inferior matrix(c(z,rev(z)),2,,T). Si seleccionamos los primeros Nelementos de la matriz [seq(z)], se elegirán por columna, dando el resultado requerido.

Superado por digEmAll

cQuents , 19 bytes

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

Pruébalo en línea!

Tenga en cuenta que no funciona en TIO en este momento porque el intérprete de TIO no está actualizado.

Explicación

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

Haskell, 39 bytes

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

Pruébalo en línea!

C # (compilador interactivo de Visual C #) , 46 bytes

a=>b=>{for(;a<=b;Write(a+(b>a++?b--+"":"")));}

¡Guardado 4 bytes gracias a dana!

Pruébalo en línea!

C # (compilador interactivo de Visual C #) , 65 bytes

void z(int a,int b){if(a<=b){Write(a+(b>a?b+"":""));z(a+1,b-1);}}

Pruébalo en línea!

Código de bytes JVM (OpenJDK asmtools JASM), 449 bytes

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

Sin golf (y un poco más limpio)

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

Función independiente, debe llamarse desde Java como b.a(num1,num2) .

Explicación

Este código utiliza los parámetros del método como variables, así como un booleano en el local # 3 que decide qué número generar. Se genera cada iteración de bucle, ya sea la izquierda o la derecha, y ese número se incrementa para la izquierda o disminuye para la derecha. El bucle continúa hasta que ambos números sean iguales, luego se emite ese número.

... Tengo el presentimiento de que me han superado enormemente en el recuento de bytes

Wolfram Language (Mathematica) , 56 54 bytes

Esta es mi primera vez jugando al golf!

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

Pruébalo en línea!

Guardado 2 bytes usando notación infija.

Explicación:

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)

Alternativamente, podríamos usar Take[...,b-a+1]para el mismo resultado.

Pruebas:

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

Ouput:

{4, 6, 5}
{1, 5, 2, 4, 3}
{-1, 1, 0}
{-1, 2, 0, 1}

APL (dzaima / APL) , 21 bytes

⌈⊢+.5×-+∘(⌽ׯ1*)∘⍳1+-

Pruébalo en línea!

Japt, 7 bytes

Toma la entrada como una matriz.

rõ
ÊÆÔv

Pruébalo o ejecuta todos los casos de prueba

         :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

MATL , 8 bytes

&:t"1&)P

Pruébalo en línea!

Explicación

&:      % 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)

JavaScript, 40 bytes

l=>g=h=>h>l?[l++,h--,...g(h)]:h<l?[]:[l]

¡Pruébelo en línea!

Adelante (gforth) , 52 bytes

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

Pruébalo en línea!

Explicación

Bucle de 0 a (Fin - Inicio). Coloque Fin e Inicio en la parte superior de la pila.

Cada iteración:

• Dar salida al número actual
• Suma (o resta) 1 del número actual
• Cambiar el número actual con el otro número

Explicación del código

: 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

Julia 0.7 , 29 bytes

f(a,b)=[a:b b:-1:a]'[1:1+b-a]

Pruébalo en línea!

Haskell, 30 bytes

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

Uso: 3%7da `[3,7,4,6,5]

Para las entradas, l, hla función llama recursivamente con las entradas l+1, h-1y se suma l,hal comienzo. En lugar de cualquier condición de detención, el código usa take(h-l)para acortar la secuencia a la longitud correcta (que de lo contrario sería una secuencia infinita de números crecientes y decrecientes).

Brachylog , 15 bytes

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

La entrada es una lista de 2 elementos [lo, hi]. Tenga en cuenta que el subrayado se usa para números negativos. Pruébalo en línea!

Explicación

⟦₂               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]

MathGolf , 6 bytes

↨_x^─▀

Pruébalo en línea!

Explicación con (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 razón por la que esto funciona se debe al hecho de que todos los elementos en la salida deben ser únicos, por lo que el operador de elementos únicos filtrará la segunda mitad de la matriz, produciendo la salida correcta.

Perl 5 -ln , 37 bytes

@.=$_..<>;say shift@.,$/,pop@.while@.

Pruébalo en línea!

Java (JDK) , 52 bytes

(l,h,o)->{for(int i=0;l<=h;i^=1)o.add(i<1?l++:h--);}

Pruébalo en línea!

Limpio , 48 bytes

import StdEnv
$a b|a<>b=[a: $b(a+sign(b-a))]=[a]

Pruébalo en línea!

Ruby , 37 36 33 bytes

f=->a,b{a>b ?[]:[a,b]|f[a+1,b-1]}

Pruébalo en línea!

Versión recursiva con 3 bytes guardados por G B.

Rubí , 38 bytes.

->a,b{d=*c=a..b;c.map{d.reverse!.pop}}

Pruébalo en línea!

Versión no recursiva.

Cubix, 16 bytes

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

Pruébalo aquí

Cubified

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

Explicación

Básicamente, esto mueve los dos límites más cerca uno por uno hasta que se encuentran. Cada vez a través del ciclo, nosotross los límites, Outilizamos, tomamos la diferencia e incrementamos )o disminuimos (según el signo.

Pyth, 10 8 bytes

{.iF_B}F

Pruébalo aquí

Explicación

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