Il primo, l'ultimo e tutto il resto

33

Dati due numeri interi, genera i due numeri interi e quindi l'intervallo tra loro (esclusi entrambi).

L'ordine dell'intervallo deve essere lo stesso dell'input.

Esempi:

 Input        Output
 0,  5   ->   [0, 5, 1, 2, 3, 4]
-3,  8   ->   [-3, 8, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7]
 4,  4   ->   [4, 4]
 4,  5   ->   [4, 5]
 8,  2   ->   [8, 2, 7, 6, 5, 4, 3]
-2, -7   ->   [-2, -7, -3, -4, -5, -6]
code-golf 
— TFeld
fonte
Immagino che non possiamo prendere gli input nell'ordine preordinato?
— Kevin Cruijssen,
@KevinCruijssen, no, l'ordine di output dipende dall'ordine di input
— TFeld
@StewieGriffin, l'ordine di output deve essere lo stesso dell'input
— TFeld
E ' questo formato di output accettabile? Nota la newline
— Luis Mendo
2
@KevinCruijssen È accettabile qualsiasi I / O ragionevole.
— TFeld

Risposte:

14

R , 39 33 30 byte

c(a<-scan(),setdiff(a:a[2],a))

Provalo online!

Grazie per i byte salvati su user2390246 e J.Doe.

— Kirill L.
fonte
È possibile salvare alcuni byte prendendo l'input come vettore anziché come due numeri interi separati.
— user2390246
Sì, è ragionevole, e in realtà diventa ancora più breve come programma completo piuttosto che funzione.
— Kirill L.
Puoi abusare del fatto che l' :operatore utilizza il primo elemento di entrambi gli arg per 30 byte
— J.Doe
10

Python 2 (Cython) , 36 35 byte

lambda x:x+range(*x,-cmp(*x)|1)[1:]

Grazie a @nwellnhof per il golf off 1 byte!

Provalo online!

Python 2 , 37 byte

lambda x:x+range(*x+[-cmp(*x)|1])[1:]

Grazie a @JonasAusevicius per il porto su CPython!

Provalo online!

— Dennis
fonte
2
Questo può essere applicato a livello Python 2 a 37 byte, il che rende la risposta più breve ancora: lambda x:x+range(*x+[-cmp(*x)|1])[1:]. Bella soluzione
— Jonas Ausevicius
8

Perl 6 , 26 22 byte

{|@_,|[...^](@_).skip}

Provalo online!

Spiegazione

{                    }
 |@_,   # Slip args a,b into result
      [...^](@_)  # Reduce args a,b with ...^ operator, same as a...^b
                .skip  # Skip first element
     |  # Slip into result
— nwellnhof
fonte
7

Python 2 , 40 byte

lambda x,y:[x,y]+range(x,y,-(y<x)|1)[1:]

Provalo online!

— Erik the Outgolfer
fonte
Piace davvero -(y<x)|1. molto bello ma non riesco a capire perché funzioni! Qualche possibilità che tu possa spiegarlo?
— ElPedro
2
@ElPedro Fondamentalmente, y<xcontrolla se yè strettamente inferiore a x, e restituisce Truese lo è, Falsealtrimenti. Successivamente, -viene applicato unario ad esso, che viene convertito Truein -1e Falsein 0. L'ultimo passo è bit a bit O questo numero con 1. Questo ovviamente lascia 1( 0b1) inalterato, e lascia anche -1( -0b1) inalterato (il bit di segno -1è impostato, quindi è mantenuto come tale). Tuttavia, si converte 0in 1, quindi rangenon mi lamento di me usando un stepdi 0.
— Erik the Outgolfer
È davvero bello e molto intelligente. Se potessi votare due volte lo farei. Mille grazie per la spiegazione.
— ElPedro,
6

Japt, 8 byte

cUr!õ kU

Provalo qui

             :Implicit input of array U
c            :Concatenate
 Ur          :  Reduce U by
   !õ        :   Inclusive range
      kU     :  Remove all elements in original U
— ispido
fonte
6

JavaScript (ES6), 51 byte

Accetta input come (a)(b).

a=>g=(b,c=b)=>(b+=b<a|-(b>a))-a?[...g(b,c),b]:[a,c]

Provalo online!

Commentate

a =>                // main function, taking a
  g = (             // g = recursive function
    b,              //     taking b
    c = b           // we save a backup of the original value of b into c
  ) =>              //
    (b +=           // add to b:
      b < a |       //   +1 if b is less than a
      -(b > a)      //   -1 if b is greater than a
    )               //   (or 0 if b = a)
    - a ?           // if the updated value of b is not equal to a:
      [             //   generate a new array:
        ...g(b, c), //     prepend all values generated by a recursive call
        b           //     append the current value of b
      ]             //
    :               // else:
      [a, c]        //   stop recursion and return the first 2 values: a and c
— Arnauld
fonte
6

Python 2 , 47 41 40 byte

lambda a,b:[a,b]+range(a,b,a<b or-1)[1:]

Provalo online!

Ecco la mia, ora che sono state postate molte altre risposte di Python

-6 byte, grazie a GB

— TFeld
fonte
Sfruttare l'intervallo vuoto quando non è valido è un modo intelligente per gestire elenchi avanti o indietro. Ho visto che essere molto utile ed è un bel trucco sapere che esiste.
— akozi
2
41 byte utilizzando un singolo intervallo: intervallo (a, b, (a <b) * 2-1)
— GB
a<b or-1è più breve per il parametro del 3o intervallo. Il più corto che ho avuto è statolambda x,y:[x,y]+range(x+(x<y or-1),y,x<y or-1)
— mbomb007,
5

Java 10, 109 108 104 102 93 62 byte

Utilizzando una stringa delimitata da spazi:

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

Provalo online.

Utilizzando un elenco:

b->a->{var r=new java.util.Stack();for(r.add(a),r.add(b);a<b?++a<b:--a>b;)r.add(a);return r;}

Provalo online.

( a<b?++a<b:--a>bpuò essere ++a<b||(a-=2)>bper lo stesso conteggio byte: provalo online per la stringa o provalo online per l'elenco .)

Vecchia ( 109 108 104 102 101 byte) risposta utilizzando un array:

a->b->{int s=a<b?1:-1,i=a!=b?(b-a)*s+1:2,r[]=new int[i];for(r[0]=a,r[1]=b;i>2;)r[--i]=b-=s;return r;}

-7 byte grazie a @nwellnhof .

Provalo online.

Spiegazione:

a->b->{                // Method with 2 int parameters & int-array return-type
  int s=               //  Step integer, starting at:
        a<b?1          //   1 if the first input is smaller than the second
        :-1;           //   -1 otherwise
      i=               //  Array-index integer, starting at:
        a!=b?          //   If the inputs aren't equal:
         (b-a)*s+1     //    Set it to the absolute difference + 1
        :              //   Else:
         2,            //    Set it to 2
      r[]=new int[i];  //  Result-array of that size
  for(r[0]=a,          //  Fill the first value with the first input
      r[1]=b;          //  And the second value with the second input
      i>2;)            //  Loop `i` downwards in the range [`i`,2):
    r[--i]=            //   Decrease `i` by 1 first with `--i`
                       //   Set the `i`'th array-value to:
           b-=s;       //    If the step integer is 1: decrease `b` by 1
                       //    If the step integer is -1: increase `b` by 1
                       //    And set the array-value to this modified `b`
  return r;}           //  Return the result-array
— Kevin Cruijssen
fonte
Non c'è niente nella libreria standard di Java per creare intervalli di numeri interi? O è troppo prolisso per usarlo?
— 1818
@ Οurous È davvero troppo dettagliato: a->b->{var L=java.util.stream.IntStream.range(a,b).boxed().collect(java.util.Collectors.toList());L.add(0,b);L.add(0,a);return L;}(130 byte)
— Kevin Cruijssen
È Java 8 o Java 10? A causa di "var" ^^ '
— Neyt
1
@Neyt Ah, risolto. La mia versione iniziale con l'array di seguito non è stata utilizzata var, motivo per cui di solito li metto a 8 e quelli che usano varcome 10 (e quelli che usano String.repeatcome 11). :) Dimenticato di aggiornarlo dopo aver aggiunto le risposte Elenco e String, ora dovrebbe essere corretto. Grazie.
— Kevin Cruijssen,
5

APL (Dyalog Extended) , 5 byte

Funzione infix anonima.

,,…~,

Provalo online!

, il primo e l'ultimo (lett. la concatenazione degli argomenti)

, e (lett. concatenato a)

… la gamma

~ senza

, il primo e l'ultimo (lett. la concatenazione degli argomenti)

— Adamo
fonte
Bene, quindi suppongo che lo userai per tutto il tuo golf d'ora in poi?
— Zacharý,
@ Zacharý Probabilmente solo se il codice è significativamente più breve o più semplice.
— Adám,
4

Gelatina , 4 byte

,œ|r

Provalo online!

Come funziona

,œ|r  Main link. Left argument: a. Right argument: b

,     Pair; yield [a, b].
   r  Range; yield [a, ..., b].
 œ|   Perform multiset union.
— Dennis
fonte
4

J , 26 byte

,,[|.@]^:(>{.)<.+1}.i.@|@-

Provalo online!

Spiegazione:

Un verbo diadico (prende l'argomento sinistro e destro)

                         -    subtracts the arguments
                       |@     and finds the absolute value
                    i.@       and makes a list 0..absolute difference
                 1}.          drops the fist element
                +             adds to the entire list
              <.              the smaller of the arguments
   |.@]                       reverses the list
       ^:                     only if
  [                           the left argument
         (>{.)                is greater than the first item of the list
 ,                            appends the list to
,                             the right argument appended to the left one
— Galen Ivanov
fonte
1
,,[:}.@}:<.+i.@-@(+*)@-per 23 byte e nessun involucro speciale sull'ordinamento degli argomenti relativi (piuttosto: è nascosto all'interno del signum *). penso che questo potrebbe scendere sotto i 20 anni, ma sono stanco.
— Giona,
@Giona Grazie! A proposito, la soluzione di FrownyFrog è decisamente migliore della mia, quindi non la giocherò più.
— Galen Ivanov,
4

J , 13 byte

,,<.+i.@-~-.=

Provalo online!

     i.@-~       range [0 .. |difference|-1], reverse if the difference is positive
          -.=    remove the zero (either "=" is 0 or there’s nothing to remove)
  <.+            to each element add the smaller of the args
,,               prepend args
— FrownyFrog
fonte
Bella soluzione! Mi sono completamente dimenticato i.con un argomento negativo.
— Galen Ivanov,
1
è stupendo!
— Giona,
3

Lotto, 107 byte

@echo %1
@echo %2
@for %%s in (1 -1)do @for /l %%i in (%1,%%s,%2)do @if %1 neq %%i if %%i neq %2 echo %%i

Accetta input come argomenti della riga di comando. Spiegazione:

@echo %1
@echo %2

Emette i due numeri interi.

@for %%s in (1 -1)do

Prova entrambi gli intervalli crescente e decrescente.

@for /l %%i in (%1,%%s,%2)do

Passa attraverso l'intervallo compreso.

@if %1 neq %%i if %%i neq %2

Escludere i due numeri interi.

echo %%i

Emette il valore corrente.

— Neil
fonte
3

Pyth , 5 byte

+QtrF

Ingresso è una lista a due elementi, [input 1, input 2]. Provalo online qui o verifica tutti i casi di test contemporaneamente qui .

+QtrFQ   Implicit: Q=eval(input())
         Trailing Q inferred
   rFQ   Generate range [input 1 - input 2)
  t      Discard first element
+Q       Prepend Q
— Sok
fonte
Usare al Fposto delle .*liste a 2 elementi è un trucco geniale che userò assolutamente da qui in poi.
— hakr14,
3

Rubino , 33 40 byte

->a,b{[a,b]+[*a..b,*a.downto(b)][1..-2]}

Provalo online!

Correzione temporanea, cercando di trovare un'idea migliore

— GB
fonte
3
Per [4,4]questo ne dà solo uno[4]
— Kirill L.
Hai ragione, l'ho risolto.
— GB
3

Python 2 , 52 47 41 byte

lambda i,j:[i,j]+range(i,j,(i<j)*2-1)[1:]

Provalo online!

-5 grazie a @JoKing

-6 tagliando il primo elemento dell'intervallo (idea rubata da e con credito a @TFeld)

Versione non lambda ...

Python 2 , 51 49 47 byte

i,j=input();print[i,j]+range(i,j,(i<j)*2-1)[1:]

Provalo online!

-2 grazie a @JoKing

— ElPedro
fonte
3

APL (Dyalog Classic) , 29 byte

{⍺,⍵,(⌽⍣(⍺>⍵))(⍺⌊⍵)+¯1↓⍳|⍺-⍵}

Provalo online!

Una porta della mia Jsoluzione

— Galen Ivanov
fonte
Wow, sono sorpreso che sia così lungo per un compito apparentemente semplice.
— Quintec,
@Quintec Probabilmente può essere giocato a golf, o forse un altro algoritmo si tradurrà in una soluzione molto più breve.
— Galen Ivanov,
3

PHP (102 byte)

function t($a,$b){count($r=range($a,$b))>1?array_splice($r,1,0,array_pop($r)):$r=[$a,$b];print_r($r);}

sandbox

Sfortunatamente (per il golf) PHP ha nomi di funzioni piuttosto prolissi, che contribuiscono molto alla lunghezza. Ma l'idea di base è creare un intervallo, quindi estrarre l'ultimo elemento e ricucirlo all'offset 1. Per l' 4,4esempio ho dovuto aggiungere il count($r=range($a,$b))>1?...:$r=[$a,$b];che aggiunge un bel po ', e sfortunatamente array_splice()è per riferimento che mi ha colpito per qualche altro byte ( $r= and a ;). Tutto a causa di quel "caso limite", lol.

Bene comunque divertiti!

— ArtisticPhoenix
fonte
Non penso che questo sia un approccio giusto per il golf del codice. function t($a,$b){$o=array($a,$b);for($i=$a+1;$i<$b;$i++)$o[]=$i;print_r($o);}
— Dai un'occhiata a
O qualcosa del generefunction t($a,$b){echo $a.$b;for($i=$a+1;$i<$b;$i++)echo $i};
— th3pirat3
1
Deve essere una funzione e deve generare un array. Se hai una risposta migliore, allora ti invitiamo a pubblicarla.
— ArtisticPhoenix,
L'ho modificato, è un invio valido ora? Devo metterlo come una nuova risposta o cosa?
— th3pirat3,
Dipende solo da te, volevo solo farlo senza un loop ... lol
— ArtisticPhoenix
3

Clojure , 61 byte

(fn[[a b]](def s(if(> a b)-1 1))(list* a b(range(+ a s)b s)))

Una funzione anonima che accetta un 2-vettore come input e restituisce un elenco.

Provalo online!

Spiegazione

(fn [[a b]] ; An anonymous function that accepts a 2-vector as input, and destructures it to a and b
  (def s (if (> a b) -1 1)) ; If a > b assigns -1 to s and assigns 1 to s otherwise. This determines the order of the elements of the output list.
  (list* a b ; Creates a list with a and b as the first two elements. The remaining elements will be appended from the following range:
    (range (+ a s) b s))) ; A range starting at a+s and ending at b with step s
— TheGreatGeek
fonte
3

D , 85 byte

T[]f(T)(T a,T b){T[]v=[a,b];T c=2*(b>a)-1;for(T i=a+c;a!=b&&b!=i;i+=c)v~=i;return v;}

Provalo online!

Una porta della risposta C ++ di @ HatsuPointerKun in D.

— Zaccaria
fonte
3

TI-BASIC, 35 34 byte

-1 byte da Misha Lavrov

Prompt A,B
Disp A,B
cos(π(A>B
For(I,A+Ans,B-Ans,Ans
Disp I
End
— kamoroso94
fonte
2
E un altro byte sostituendo 1-2(A>Bcon cos(π(A>B.
— Misha Lavrov,
@MishaLavrov seq(non funzionerebbe per input dove Ae Bsono uguali, purtroppo :(
— kamoroso94
È vero, inoltre, ho lasciato fuori un argomento di seq(, quindi non sono più convinto che sia anche più piccolo. Tuttavia, il cos(trucco dovrebbe aiutare.
— Misha Lavrov,
2

Carbone , 15 byte

ＩＥ²ＮＩ…⊕θηＩ⮌…⊕ηθ

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

ＩＥ²Ｎ

Stampa gli input su righe separate.

Ｉ…⊕θη

Stampa l'intervallo crescente, se presente.

Ｉ⮌…⊕ηθ

Stampa l'intervallo inverso crescente inverso, se presente.

— Neil
fonte
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.