Le premier, le dernier, et tout entre

33

Étant donné deux nombres entiers, sortir les deux entiers, puis la plage entre eux (à l'exclusion des deux).

L'ordre de la plage doit être identique à celui de l'entrée.

Exemples:

 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
source
Je suppose que nous ne pouvons pas prendre les entrées dans l'ordre précommandé?
— Kevin Cruijssen
@KevinCruijssen, non, l'ordre de sortie dépend de l'ordre d'entrée
— TFeld
@StewieGriffin, l'ordre de sortie doit être identique à celui de l'entrée
— TFeld
Ce format de sortie est- il acceptable? Notez la nouvelle ligne
— Luis Mendo
2
@KevinCruijssen Toute E / S raisonnable est acceptable.
— TFeld

Réponses:

14

R , 39 33 30 octets

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

Essayez-le en ligne!

Merci pour les octets sauvegardés à user2390246 et à J.Doe.

— Kirill L.
source
Vous pouvez économiser quelques octets en prenant l’entrée comme un vecteur plutôt que comme deux entiers distincts.
— user2390246
Ouais, c'est raisonnable, et en fait, il devient encore plus court en tant que programme complet plutôt que fonctionnel.
— Kirill L.
Vous pouvez abuser du fait que l' :opérateur utilise le premier élément des deux arguments pendant 30 octets
— J.Doe
8

Perl 6 , 26 22 octets

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

Essayez-le en ligne!

Explication

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

Python 2 , 40 octets

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

Essayez-le en ligne!

— Erik le golfeur
source
J'aime vraiment -(y<x)|1. très cool mais je ne peux pas comprendre pourquoi ça marche! Avez-vous une chance de l'expliquer?
— ElPedro
2
@ElPedro En gros, y<xvérifie si yest strictement inférieur à x, et renvoie Truesi c'est le cas, Falsesinon. Après cela, unaire -est appliquée, qui convertit Trueà -1et Falseà 0. La dernière étape consiste à utiliser bitwise OU ce nombre avec 1. Cela laisse évidemment 1( 0b1) inchangé, et également -1( -0b1) inchangé (le bit de signe de -1est défini, il est donc conservé comme tel). Cependant, il se convertit 0en 1, de sorte que rangecela ne se plaint pas de moi en utilisant un stepde 0.
— Erik l'Outgolfer
C'est vraiment cool et très intelligent. Si je pouvais voter deux fois, je le ferais. Merci beaucoup pour l'explication.
— ElPedro
6

Japt, 8 octets

cUr!õ kU

Essayez-le ici

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

JavaScript (ES6), 51 octets

Prend les entrées en tant que (a)(b).

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

Essayez-le en ligne!

Commenté

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
source
6

Python 2 , 47 41 40 octets

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

Essayez-le en ligne!

Voici le mien, maintenant que beaucoup d'autres réponses Python ont été postées

-6 octets, grâce à GB

— TFeld
source
Tirer parti de la plage vide lorsqu'elle est invalide est un moyen astucieux de traiter les listes en avant ou en arrière. Je pourrais voir cela être très utile et est un bon truc pour savoir existe.
— akozi
2
41 octets utilisant une seule plage: plage (a, b, (a <b) * 2-1)
— GB
a<b or-1est plus court pour le paramètre 3ème plage. Le plus court que j'ai eu étaitlambda 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 octets

Utilisation d'une chaîne délimitée par des espaces:

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

Essayez-le en ligne.

Utiliser une liste:

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

Essayez-le en ligne.

( a<b?++a<b:--a>bpeut être ++a<b||(a-=2)>bpour le même nombre d'octets: essayez-le en ligne pour la chaîne ou essayez-le en ligne pour la liste .)

Old ( 109 108 104 102 101 octets) répond en utilisant un tableau:

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 octets grâce à @nwellnhof .

Essayez-le en ligne.

Explication:

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
source
N'y a-t-il rien dans la bibliothèque standard de Java pour créer des plages d'entiers? Ou est-ce trop verbeux à utiliser?
— ousurous
@ Οurous C'est en effet trop bavard: 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 bytes)
— Kevin Cruijssen
Est-ce Java 8 ou Java 10? A cause de "var" ^^ '
— mardi
1
@Neyt Ah, corrigé. Ma version initiale avec le tableau ci-dessous n'a pas été utilisée var, c'est pourquoi je mets généralement celles-ci à 8, et celles qui utilisent var10 (et celles qui utilisent String.repeat11). :) Oublié de le mettre à jour après avoir ajouté les réponses List et String, devrait être corrigé maintenant. Merci.
— Kevin Cruijssen
5

APL (Dyalog Extended) , 5 octets

Fonction infixe anonyme.

,,…~,

Essayez-le en ligne!

, le premier et le dernier (lit. la concaténation des arguments)

, et (lit. concaténé à)

… la gamme

~ sans pour autant

, le premier et le dernier (lit. la concaténation des arguments)

— Adam
source
Bien, alors je suppose que vous allez utiliser cela pour tous vos matchs à partir de maintenant?
— Zacharý
@ Zacharý Probablement seulement si le code est nettement plus court ou plus simple.
— Adám
4

Gelée , 4 octets

,œ|r

Essayez-le en ligne!

Comment ça marche

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

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

J , 26 octets

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

Essayez-le en ligne!

Explication:

Un verbe dyadique (prend l'argument gauche et droit)

                         -    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
source
1
,,[:}.@}:<.+i.@-@(+*)@-pour 23 octets et pas de casse particulière sur l'ordre des arguments relatifs (plutôt: il est caché à l'intérieur du signum *). Je sens que cela pourrait descendre sous 20 ans mais je suis fatigué.
— Jonas
@ Jonah Merci! La solution de Btw FrownyFrog est bien meilleure que la mienne, je ne vais donc pas aller au golf plus loin.
— Galen Ivanov
4

J , 13 octets

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

Essayez-le en ligne!

     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
source
Belle solution! J'ai totalement oublié l' i.argument négatif.
— Galen Ivanov
1
c'est magnifique!
— Jonas
3

Lot, 107 octets

@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

Prend l'entrée en tant qu'argument de ligne de commande. Explication:

@echo %1
@echo %2

Affiche les deux entiers.

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

Essayez les deux gammes ascendantes et descendantes.

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

Boucle sur la plage inclusive.

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

Exclure les deux entiers.

echo %%i

Affiche la valeur actuelle.

— Neil
source
3

Pyth , 5 octets

+QtrF

L'entrée est une liste à deux éléments [input 1, input 2]. Essayez-le en ligne ici ou vérifiez tous les cas de test en même temps ici .

+QtrFQ   Implicit: Q=eval(input())
         Trailing Q inferred
   rFQ   Generate range [input 1 - input 2)
  t      Discard first element
+Q       Prepend Q
— Sok
source
Utiliser Fau lieu de .*sur des listes à 2 éléments est un truc génial que je vais absolument utiliser à partir de maintenant.
— hakr14
3

Ruby , 33 40 octets

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

Essayez-le en ligne!

Solution temporaire, essayant de trouver une meilleure idée

— GB
source
3
Pour [4,4]cela ne donne qu'un seul[4]
— Kirill L.
Vous avez raison, je l'ai corrigé.
— GB
3

Python 2 , 52 47 41 octets

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

Essayez-le en ligne!

-5 grâce à @JoKing

-6 en coupant le premier élément de la gamme (idée volée de et avec crédit à @TFeld)

Version non lambda ...

Python 2 , 51 49 47 octets

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

Essayez-le en ligne!

-2 grâce à @JoKing

— ElPedro
source
3

PHP (102 octets)

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

bac à sable

Malheureusement (pour le golf), PHP a des noms de fonction plutôt verbeux, qui contribuent beaucoup à la longueur. Mais l’idée de base est de créer une plage, puis d’extraire le dernier élément et de le réassembler au décalage 1. Par 4,4exemple, j’ai dû ajouter count($r=range($a,$b))>1?...:$r=[$a,$b];ce qui ajoute un peu, et malheureusement, array_splice()c’est par référence qui m’a frappé pendant un peu plus. octets ( $r= and a ;). Tout ça à cause de ce "cas de bord", lol.

Eh bien en tout cas profiter!

— ArtistiquePhoenix
source
Je ne pense pas que ce soit une bonne approche pour le code golf. Vérifiez celui-ci function t($a,$b){$o=array($a,$b);for($i=$a+1;$i<$b;$i++)$o[]=$i;print_r($o);}
— th3pirat3
Ou quelque chose comme çafunction t($a,$b){echo $a.$b;for($i=$a+1;$i<$b;$i++)echo $i};
— th3pirat3
1
Ce doit être une fonction et il doit sortir un tableau. Si vous avez une meilleure réponse à votre question, n'hésitez pas à la poster.
— ArtisticPhoenix
Je l'ai édité, est-ce une soumission valide maintenant? Dois-je le mettre comme une nouvelle réponse ou quoi?
— Th3pirat3
C'est à vous de décider, je voulais juste le faire sans boucle ... lol
— ArtisticPhoenix
3

Clojure , 61 octets

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

Une fonction anonyme qui prend un vecteur 2 en entrée et retourne une liste.

Essayez-le en ligne!

Explication

(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
source
3

D , 85 octets

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

Essayez-le en ligne!

Un portage de la réponse C ++ de @ HatsuPointerKun en D.

— Zacharý
source
3

TI-BASIC, 35 à 34 octets

-1 octet de Misha Lavrov

Prompt A,B
Disp A,B
cos(π(A>B
For(I,A+Ans,B-Ans,Ans
Disp I
End
— kamoroso94
source
2
Et encore un octet en remplaçant 1-2(A>Bpar cos(π(A>B.
— Misha Lavrov
@MishaLavrov seq(ne fonctionnerait pas pour les entrées où Aet Bsont les mêmes, malheureusement :(
— kamoroso94
C'est vrai - j'ai également laissé de côté un argument de seq(, alors je ne suis plus convaincu qu'il est même plus petit. Pourtant, le cos(truc devrait aider.
— Misha Lavrov
2

Charbon de bois , 15 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

ＩＥ²Ｎ

Imprimer les entrées sur des lignes séparées.

Ｉ…⊕θη

Imprimer la plage ascendante, le cas échéant.

Ｉ⮌…⊕ηθ

Imprimer la plage inverse inverse inverse, le cas échéant.

— Neil
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.