O arranjo 465

24

Aqui está o desafio. Escreva algum código para gerar todos os números inteiros em um intervalo. Parece fácil, mas aqui está a parte complicada. Começará com o número mais baixo e depois o mais alto. Em seguida, o número mais baixo que ainda não está no array. Então o mais alto que ainda não está nele.

Exemplo:

Vamos levar de 1 a 5 como o nosso começo

Os números são [1, 2, 3, 4, 5].

Nós pegamos o primeiro, então [1]. Os números restantes são [2, 3, 4, 5]. Tomamos o último, novo array é [1, 5]. Os números restantes são [2, 3, 4]. Tomamos o primeiro, novo array é [1, 5, 2]. Os números restantes são [3, 4]. Tomamos o último, novo array é [1, 5, 2, 4]. Os números restantes são [3]. Tomamos o primeiro, novo array é [1, 5, 2, 4, 3]. Sem números restantes, terminamos. Saída [1, 5, 2, 4, 3]

Regras:

  • Isso é código de golfe, escreva no menor número de bytes, em qualquer idioma.
  • Sem brechas padrão.
  • Links para um intérprete online, por favor? (Por exemplo, https://tio.run/ )
  • Duas entradas, ambos inteiros. Fim baixo do intervalo e fim alto do intervalo.
  • Não me importo qual é o tipo de dado da saída, mas ele deve mostrar os números na ordem correta.

Exemplos

Baixa: 4 Alta: 6 Resultado: 4 6 5

Baixa: 1 Alta: 5 Resultado: 1 5 2 4 3

Baixa: -1 Alta: 1 Resultado: -1 1 0

Baixa: -1 alta: 2 Resultado: -1 2 0 1

Baixa: -50 Alta: 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 golfe!

code-golf AJFaraday
fonte
2
Quase duplicado (a diferença é que este requer reverter a segunda metade antes da fusão).
Peter Taylor
a entrada sempre será da ordem de baixa, alta?
Sumner18
1
@ Sumner18 sim. A comunidade aqui é definida contra a validação de entrada, e eu não pedi uma entrada de ordem inversa, para que possamos assumir que sempre será baixa - alta.
AJFaraday
1
@ Sumner18 Como esses desafios geralmente funcionam é que não nos importamos com o tratamento de entradas inválidas. Seu código só é julgado para ser bem sucedido pela forma como ele lida com entradas válidas (ou seja, ambos são inteiros, a primeira é menor do que o segundo)
AJFaraday
1
@AJFaraday: você deve adicionar uma nota ao post principal indicando que X sempre será estritamente menor que Y (ou seja, X! = Y), eu perdi esse comentário;)
digEmAll

Respostas:

15

R , 38 37 36 bytes

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

Experimente online!

  • -1 byte graças a @ user2390246
  • -1 byte graças a @Kirill L.

Explorando o fato de que R armazena matrizes em colunas

digEmAll
fonte
Usar rbindé muito melhor do que minha abordagem, mas você pode salvar 1 byte usando em [seq(a:b)]vez de unique.
user2390246
Você está certo, eu perdi o comentário onde foi especificado que a <b (nunca igual), para que possamos usarseq(a:b)
digEmAll
@digEmAll Minha solução foi essencialmente uma interpretação literal do quebra-cabeça, eu nunca teria pensado em fazer algo assim. Impressionante, tenha um voto positivo!
Sumner18
1
-1 mais
Kirill L.
11

Haskell , 30 bytes

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

Experimente online!

xnor
fonte
Droga! Acabei de encontrar exatamente a mesma solução. Oh well
proud haskeller 14/02
8

R , 65 64 61 60 bytes

-1 byte graças a Robert S.

-4 mais graças a digEmAll 

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

Experimente online!

Sumner18
fonte
Você pode substituir length(z)por sum(z|1)para salvar 1 byte :)
Robert S.
Não entendo como isso funciona, mas acho que sim. sum (z | 1) parece que sempre avaliaria pelo menos 1, o que faria com que o loop while repetisse sem parar. mas aparentemente não
Sumner18
4
z é um vetor. cada elemento desse vetor é |editado com 1. O que é sempre igual a 1. Quando você pega a soma, você tem um vetor preenchido com TRUEs, de modo que o resultado é igual ao comprimento do vetor. Se o vetor estiver vazio, você não tem nada a ver |com o vetor de saída logical(0). Quando você recebe essa soma, é 0
OganM
5

PowerShell , 59 48 bytes

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

Experimente online!

(Parece longo ...)

Pega entrada $ae $b, constrói o intervalo 0 .. ($b-$a), armazena-o $ze depois passa por esse intervalo. O loop desse intervalo é usado apenas como um contador para garantir que recebemos iterações suficientes. Cada iteração, nós colocamos $ae $bno gasoduto com adição / subtração. Isso nos dá algo 1,5,2,4,3,3,4,2,5,1assim, precisamos dividir isso 0até a $b-$a(ou seja, a contagem) da matriz original, para que só fiquemos com os elementos apropriados. Isso é deixado no pipeline e a produção está implícita.

-11 bytes graças ao mazzy.

AdmBorkBork
fonte
48 bytes
mazzy
@mazzy Ah, eu gosto desse $b-$atruque - isso é inteligente!
AdmBorkBork
5

05AB1E , 6 bytes

ŸDvć,R

Experimente online!

Explicação

Ÿ        # 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
fonte
Ÿ2ä`R.ι não iterativo usando intercalação, mas isso ainda é muito melhor.
Magic Octopus Urn
1
@MagicOctopusUrn: Tentei primeiro uma solução não iterativa, mas foi ainda pior porque não sabia .ι;)
Emigna 14/02
Semelhante ao que eu tinha em mente, um sinal tão óbvio de mim. Também gosto do seu 7-byter alternativo, @MagicOctopusUrn. :)
Kevin Cruijssen 14/02
1
@KristianWilliams: Parece estar trabalhando para mim.
Emigna 14/02
1
@KevinCruijssen: Em vez disso, mudei para um par, pois isso parecia mais intuitivo :)
Emigna 14/02
4

R , 51 bytes

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

Experimente online!

Explicação: Para uma sequência x:yde comprimento N, crie uma matriz dois por N consistindo na sequência x: y na linha superior e y: x na linha inferior matrix(c(z,rev(z)),2,,T). Se selecionarmos os primeiros Nelementos da matriz [seq(z)], eles serão escolhidos por coluna, fornecendo a saída necessária.

Superado por digEmAll

user2390246
fonte
1
Acabei de publicar uma abordagem muito semelhante 30 segundos antes de você: D
digEmAll
@digEmAll Sim, mas o seu é muito melhor!
user2390246
4

cQuents , 19 bytes

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

Experimente online!

Observe que ele não funciona no TIO no momento porque o intérprete do TIO não está atualizado.

Explicação

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

Haskell, 39 bytes

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

Experimente online!

nimi
fonte
4

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

Ungolfed (e um pouco mais limpo)

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

Função autônoma, precisa ser chamada de Java como b.a(num1,num2).

Explicação

Esse código usa os parâmetros do método como variáveis, bem como um booleano no local # 3, decidindo qual número deve ser produzido. Cada iteração de loop, esquerda ou direita, é exibida e esse número é incrementado para a esquerda ou decrementado para a direita. O loop continua até que os dois números sejam iguais, e esse número é emitido.

... Tenho uma sensação distinta de que sou massivamente superado com a contagem de bytes

Gatinho
fonte
4

Wolfram Language (Mathematica) , 56 54 bytes

Esta é a minha primeira vez jogando golfe!

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

Experimente online!

2 bytes salvos usando a notação infix.

Explicação:

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)

Como alternativa, poderíamos usar Take[...,b-a+1]o mesmo resultado.

Testes:

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}
Kai
fonte
O link "Experimente online" retorna um 403. "Desculpe, você não tem permissão para acessar este item."
Rohit Namjoshi
@RohitNamjoshi Atualizei o link
Kai
Observe que no TIO você pode colocar o código do cabeçalho e rodapé nas caixas de texto acima e abaixo da caixa de código real. Isso torna o código mais limpo, além de permitir que você aproveite o formatador de respostas PPCG (esc-sg). Experimente online!
Jo King
@JoKing muito apreciado, eu nunca tinha usado antes!
Kai
3

Japonês, 7 bytes

Recebe entrada como uma matriz.

rõ
ÊÆÔv

Experimente ou execute todos os casos de teste

         :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
Shaggy
fonte
3

MATL , 8 bytes

&:t"1&)P

Experimente online!

Explicação

&:      % 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
fonte
3

Quarto (gforth) , 52 bytes

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

Experimente online!

Explicação

Loop de 0 a (Fim - Início). Coloque Fim e Início no topo da pilha.

Cada iteração:

  • Emite o número atual
  • Adicione (ou subtraia) 1 do número atual
  • Alterne o número atual com o outro número

Código Explicação

: 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
fonte
3

Haskell, 30 bytes

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

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

Para as entradas, l, ha função chama recursivamente com as entradas l+1, h-1e adiciona l,hao início. Em vez de qualquer condição de parada, o código usa take(h-l)para encurtar a sequência para o comprimento correto (que seria uma sequência infinita de números crescentes e decrescentes).

orgulhoso haskeller
fonte
3

Braquilog , 15 bytes

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

Entrada é uma lista de 2 elementos [lo, hi]. Observe que o sublinhado é usado para números negativos. Experimente online!

Explicação

⟦₂               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
fonte
3

MathGolf , 6 bytes

↨_x^─▀

Experimente online!

Explicação com (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]

A razão pela qual isso funciona é devido ao fato de que todos os elementos na saída devem ser exclusivos, portanto o operador de elementos exclusivos filtrará a segunda metade da matriz, produzindo a saída correta.

maxb
fonte
2

Cubix, 16 bytes

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

Experimente aqui

Cubificado

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

Explicação

Basicamente, isso aproxima os dois limites um passo de cada vez até que eles se encontrem. Cada vez que percorremos o loop, alteramos sos limites, a Oquantidade, a diferença e aumentamos )ou diminuímos com (base no sinal.


fonte
2

Pitão, 10 8 bytes

{.iF_B}F

Experimente aqui

Explicação

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

fonte