La disposizione 465

24

Ecco la sfida. Scrivi del codice per generare tutti gli interi in un intervallo. Sembra facile, ma ecco la parte difficile. Inizierà con il numero più basso, quindi il più alto. Quindi il numero più basso che non è ancora nella matrice. Quindi il più alto che non è ancora in esso.

Esempio:

Prendiamo da 1 a 5 come il nostro inizio

I numeri sono [1, 2, 3, 4, 5].

Prendiamo il primo, quindi [1]. I numeri rimanenti sono [2, 3, 4, 5]. Prendiamo l'ultimo, il nuovo array è [1, 5]. I numeri rimanenti sono [2, 3, 4]. Prendiamo il primo, il nuovo array è [1, 5, 2]. I numeri rimanenti sono [3, 4]. Prendiamo l'ultimo, il nuovo array è [1, 5, 2, 4]. I numeri rimanenti sono [3]. Prendiamo il primo, il nuovo array è [1, 5, 2, 4, 3]. Nessun numero rimanente, abbiamo finito. Uscita [1, 5, 2, 4, 3]

Regole:

  • Questo è il golf del codice, scrivilo nel minor numero di byte, in qualsiasi lingua.
  • Nessuna scappatoia standard.
  • Collegamenti a un interprete online, per favore? (Ad esempio https://tio.run/ )
  • Due ingressi, entrambi numeri interi. Fine gamma bassa e fascia alta gamma.
  • Non mi importa quale sia il tipo di dati dell'output, ma deve mostrare i numeri nell'ordine corretto.

Esempi

Basso: 4 Alto: 6 Risultato: 4 6 5

Basso: 1 Alto: 5 Risultato: 1 5 2 4 3

Basso: -1 Alto: 1 Risultato: -1 1 0

Basso: -1 alto: 2 Risultato: -1 2 0 1

Basso: -50 Alto: 50 Risultato: -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-22 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

Buon golf!

code-golf 
— AJFaraday
fonte
2
Quasi duplicato (la differenza è che questo richiede di invertire la seconda metà prima della fusione).
— Peter Taylor,
l'ingresso sarà sempre nell'ordine di fascia bassa, fascia alta?
— Sumner18
1
@ Sumner18 sì. La community qui è messa a confronto con la convalida dell'input e non ho chiesto un input in ordine inverso, quindi possiamo presumere che sarà sempre basso - alto.
— AJFaraday,
1
@ Sumner18 Il modo in cui queste sfide di solito funzionano è che non ci interessa come vengono gestiti gli input non validi. Il tuo codice è giudicato efficace solo dal modo in cui
— gestisce
1
@AJFaraday: dovresti aggiungere una nota al post principale indicando che X sarà sempre rigorosamente inferiore a Y (cioè X! = Y), ho perso questo commento;)
— digEmAll

Risposte:

15

R , 38 37 36 byte

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

Provalo online!

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

Sfruttando il fatto che R memorizza le matrici per colonna

— digEmAll
fonte
Usare rbindè molto meglio del mio approccio, ma puoi salvare 1 byte usando [seq(a:b)]invece di unique.
— user2390246
Hai ragione, ho perso il commento in cui è stato specificato che <b (mai uguale), quindi possiamo usareseq(a:b)
— digEmAll
@digEmAll La mia soluzione era essenzialmente un'interpretazione letterale del puzzle, non avrei mai pensato di fare qualcosa del genere. Impressionante, avere un voto!
— Sumner18
1
— Kirill L.
8

R , 65 64 61 60 byte

-1 byte grazie a Robert S.

-4 in più grazie a digEmAll 

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

Provalo online!

— Sumner18
fonte
È possibile sostituire length(z)con sum(z|1)per salvare 1 byte :)
— Robert S.
Non capisco come funzioni, ma credo che lo faccia. sum (z | 1) sembra che valuterà sempre almeno 1, il che causerebbe un ciclo infinito del ciclo while. ma apparentemente no
— Sumner18
4
z è un vettore. ogni elemento di quel vettore è |edito con 1. Che è sempre uguale a 1. Quando prendi la somma, hai un vettore pieno di TRUEs, quindi il risultato è uguale alla lunghezza del vettore. Se il vettore è vuoto, non c'è niente da fare, |quindi lo è il vettore di output logical(0). Quando prendi quella somma, è 0
— OganM il
5

PowerShell , 59 48 byte

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

Provalo online!

(Sembra lungo ...)

Accetta input $a e $bcostruisce l'intervallo 0 .. ($b-$a), lo memorizza in $z, quindi scorre attraverso quell'intervallo. Il ciclo attraverso tale intervallo viene utilizzato solo come contatore per garantire che si ottengano abbastanza iterazioni. Ogni iterazione, abbiamo messo $ae $bin cantiere con addizione / sottrazione. Questo ci dà qualcosa del genere, 1,5,2,4,3,3,4,2,5,1quindi dobbiamo dividerlo da 0fino al $b-$a(cioè il conteggio) dell'array originale, quindi ci rimangono solo gli elementi appropriati. Rimane in cantiere e l'output è implicito.

-11 byte grazie a mazzy.

— AdmBorkBork
fonte
— mazzy
@mazzy Ah, mi piace quel $b-$atrucco - è intelligente!
— AdmBorkBork,
5

05AB1E , 6 byte

ŸDvć,R

Provalo online!

Spiegazione

Ÿ        # 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.ι non iterativo usando interleave, ma questo è ancora molto meglio.
— Magic Octopus Urn
1
@MagicOctopusUrn: ho provato prima una soluzione non iterativa, ma era anche peggio dato che non ne ero a conoscenza .ι;)
— Emigna,
Simile a quello che avevo in mente, +1 così evidente da parte mia. Mi piace anche la tua alternativa a 7 byter, @MagicOctopusUrn. :)
— Kevin Cruijssen,
1
@KristianWilliams: sembra funzionare per me.
— Emigna,
1
@KevinCruijssen: invece sono passato a una coppia perché mi sembrava comunque più intuitivo :)
— Emigna
4

R , 51 byte

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

Provalo online!

Spiegazione: Per una sequenza x:ydi lunghezza N, creare una matrice due per N composta dalla sequenza x: y nella riga superiore e y: x nella riga inferiorematrix(c(z,rev(z)),2,,T) . Se selezioniamo i primi Nelementi della matrice[seq(z)] , saranno scelti per colonna, fornendo l'output richiesto.

Superato da digEmAll

— user2390246
fonte
1
Ho appena pubblicato un approccio molto simile 30 secondi prima di te: D
— digEmAll
@digEmAll Sì, ma il tuo è molto meglio!
— user2390246
4

cQuents , 19 byte

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

Provalo online!

Si noti che al momento non funziona su TIO perché l'interprete di TIO non è aggiornato.

Spiegazione

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

Bytecode JVM (OpenJDK asmtools JASM), 449 byte

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 leggermente più pulito)

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

Funzione autonoma, deve essere chiamata da Java come b.a(num1,num2) .

Spiegazione

Questo codice utilizza i parametri del metodo come variabili, nonché un valore booleano nel locale n. 3 che decide quale numero emettere. Ogni iterazione del loop viene emessa a sinistra oa destra e quel numero viene incrementato per la sinistra o decrementato per la destra. Il ciclo continua fino a quando entrambi i numeri sono uguali, quindi quel numero viene emesso.

... Ho la netta sensazione di essere massicciamente superato nel conteggio dei byte

— Gattino
fonte
4

Wolfram Language (Mathematica) , 56 54 byte

Questa è la mia prima volta a giocare a golf!

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

Provalo online!

Salvato 2 byte usando la notazione infissa.

Spiegazione:

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)

In alternativa, potremmo usare Take[...,b-a+1]per lo stesso risultato.

test:

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
Il link "Provalo online" restituisce un 403. "Spiacenti, non sei autorizzato ad accedere a questo elemento."
— Rohit Namjoshi,
@RohitNamjoshi Ho aggiornato il link
— Kai il
si noti che su TIO è possibile inserire il codice di intestazione e piè di pagina nelle caselle di testo sopra e sotto la casella del codice reale. Ciò rende il codice più pulito e consente di sfruttare il formattatore di risposte PPCG (esc-sg). Provalo online!
— Jo King,
@JoKing molto apprezzato, non l'avevo mai usato prima!
— Kai,
3

Japt, 7 byte

Accetta input come un array.

rõ
ÊÆÔv

Provalo o esegui tutti i casi di 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
— ispido
fonte
3

MATL , 8 byte

&:t"1&)P

Provalo online!

Spiegazione

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

Forth (gforth) , 52 byte

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

Provalo online!

Spiegazione

Ripeti da 0 a (Fine - Inizio). Posiziona End e Start in cima alla pila.

Ogni iterazione:

  • Emette il numero corrente
  • Aggiungi (o sottrai) 1 dal numero corrente
  • Cambia il numero corrente con l'altro numero

Spiegazione del codice

: 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 byte

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

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

Per gli ingressi, l, hla funzione chiama in modo ricorsivo con gli ingressi l+1, h-1e aggiunge l,hl'inizio. Invece di qualsiasi condizione di arresto, il codice utilizza take(h-l)per abbreviare la sequenza alla giusta lunghezza (che altrimenti sarebbe una sequenza infinita di numeri crescenti e decrescenti).

— haskeller orgoglioso
fonte
3

Brachylog , 15 byte

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

L'input è un elenco di 2 elementi [lo, hi]. Si noti che il trattino basso viene utilizzato per i numeri negativi. Provalo online!

Spiegazione

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

↨_x^─▀

Provalo online!

Spiegazione 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]

Il motivo per cui questo funziona è dovuto al fatto che tutti gli elementi nell'output devono essere univoci, quindi l'operatore degli elementi univoci filtrerà la seconda metà dell'array, producendo l'output corretto.

— maxb
fonte
2

Cubix, 16 byte

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

Provalo qui

Cubified

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

Spiegazione

Fondamentalmente, questo sposta i due limiti più vicini di un passo alla volta fino a quando si incontrano. Ogni volta che eseguiamo il ciclo, eseguiamo il swap dei limiti, Odell'output, prendiamo la differenza e incrementiamo con )o diminuiamo con in (base al segno.

2

Pyth, 10 8 byte

{.iF_B}F

Provalo qui

Spiegazione

{.iF_B}F
      }FQ  Generate the range between the (implicit) inputs.
 .iF_B     Interleave it with its reverse.
{          Deduplicate.
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.