İşte zorluk. Bir aralıktaki tüm tam sayıların çıktısını almak için bir miktar kod yazın. Sesler kolay, ama işte zor kısmı. En düşük sayıdan sonra en yüksek numaradan başlayacaktır. Daha sonra dizide olmayan en düşük sayı. O zaman henüz içinde olmayan en yüksek olan.

Örnek:

Başlangıç ​​olarak 1-5

Rakamlar [1, 2, 3, 4, 5].

İlkini biz alıyoruz, yani [1]. Kalan sayılar [2, 3, 4, 5]. Sonuncuyu alıyoruz, yeni dizi [1, 5]. Kalan sayılar [2, 3, 4]. Birinciyi alıyoruz, yeni dizi [1, 5, 2]. Kalan sayılar [3, 4]. Sonuncuyu alıyoruz, yeni dizi [1, 5, 2, 4]. Kalan sayılar [3]. Birinciyi alıyoruz, yeni dizi [1, 5, 2, 4, 3]. Kalan numara yok, bitti. Çıktı [1, 5, 2, 4, 3]

Kurallar:

• Bu kod golf, en az byte, herhangi bir dilde yazınız.
• Standart boşluklar yok.
• Lütfen bir online tercümana link verin, lütfen? (Örneğin, https://tio.run/ )
• Her iki tam sayı olan iki giriş. Düşük aralık sonu ve yüksek aralık sonu.
• Çıktının veri türünün ne olduğu umurumda değil, ancak sayıları doğru sırada göstermesi gerekir.

Örnekler

Düşük: 4 Yüksek: 6 Sonuç: 4 6 5

Düşük: 1 Yüksek: 5 Sonuç: 1 5 2 4 3

Düşük: -1 Yüksek: 1 Sonuç: -1 1 0

Düşük: -1 yüksek: 2 Sonuç: -1 2 0 1

Düşük: -50 Yüksek: 50 Sonuç: -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

Mutlu golf!

R , 38 37 36 bayt

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

Çevrimiçi deneyin!

• @ User2390246 sayesinde -1 bayt
• @Kirill L. sayesinde -1 bayt

R'nin matrisleri sütun şeklinde sakladığı gerçeğini kullanmak

Haskell , 30 bayt

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

Çevrimiçi deneyin!

R , 65 64 61 60 bayt

Robert S. sayesinde -1 bayt

DigEmAll sayesinde -4 daha fazlası

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

Çevrimiçi deneyin!

Haskell , 39 bayt

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

Çevrimiçi deneyin!

Python 2,44 bayt

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

Çevrimiçi deneyin!

PowerShell , 59 48 bayt

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

Çevrimiçi deneyin!

(Uzun görünüyor ...)

Girdiyi alır $ave $baralığı oluşturur 0 .. ($b-$a), onu depolar $z, sonra da o aralıktan geçirir. Bu aralıktaki döngü yalnızca yeterli sayıda yineleme elde etmemizi sağlamak için bir sayaç olarak kullanılır. Her yineleme, biz koymak $ave $bekleme / çıkarma ile boru hattı üzerinde. Bu bize böyle bir şey verir , bu yüzden orjinal dizinin (yani sayısı) ' 1,5,2,4,3,3,4,2,5,1dan 0başlayarak dilime geçmemiz gerekir $b-$a. Bu, boru hattında bırakılan ve çıktının kapalı olduğu.

- Maze sayesinde 11 byte.

05AB1E , 6 bayt

ŸDvć,R

Çevrimiçi deneyin!

açıklama

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

òV
íUs w)c vUl

Çevrimiçi deneyin!

Stax , 7 bayt

É╓ÅìΔà▲

Koş ve hata ayıkla

R , 51 bayt

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

Çevrimiçi deneyin!

Açıklama: Bir x:yuzunluk Ndizisi için, üst satırdaki x: y ve alt satırdaki y: x dizilerinden oluşan iki-N bir matris oluşturun matrix(c(z,rev(z)),2,,T). NMatrisin ilk elemanlarını [seq(z)]seçersek, gerekli çıktıyı veren sütunlar tarafından seçilecektir.

DigEmAll tarafından aşıldı

cQuents , 19 bayt

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

Çevrimiçi deneyin!

Şu an TIO'da çalışmadığını, çünkü TIO'nun yorumlayıcısının güncel olmadığını unutmayın.

açıklama

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

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

Çevrimiçi deneyin!

C # (Visual C # Etkileşimli Derleyici) , 46 bayt

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

Dana sayesinde 4 byte kurtarıldı!

Çevrimiçi deneyin!

C # (Visual C # Etkileşimli Derleyici) , 65 bayt

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

Çevrimiçi deneyin!

JVM bayt kodu (OpenJDK asmtools JASM), 449 bayt

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 (ve biraz daha temiz)

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

Bağımsız işlev, Java'dan çağrılması gerekir b.a(num1,num2).

açıklama

Bu kod, metod parametrelerini değişkenler olarak kullanır, ayrıca yerel # 3'te bir boolenin hangi sayıya çıkacağına karar verir. Her döngü, sol veya sağ yinelemenin çıktısıdır ve bu sayı sola doğru artırılır veya sağa doğru azalır. Her iki sayı da eşit oluncaya kadar döngü devam eder, ardından bu sayı çıkar.

... bayt sayısında büyük bir hastayım.

Wolfram Dili (Mathematica) , 56 54 bayt

Bu benim ilk defa golf oynamak!

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

Çevrimiçi deneyin!

İnfix notasyonu kullanılarak 2 bayt kaydedildi.

Açıklama:

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)

Alternatif olarak, Take[...,b-a+1]aynı sonuç için kullanabiliriz .

Testler:

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

Çıkışı:

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

APL (dzaima / APL) , 21 bayt

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

Çevrimiçi deneyin!

Japt, 7 bayt

Diziyi girdi olarak alır.

rõ
ÊÆÔv

Deneyin veya tüm test durumlarını çalıştırın

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

&:t"1&)P

Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi Deneyin!

İleri (gforth) , 52 bayt

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

Çevrimiçi deneyin!

açıklama

0 ila (Son - Başlatma) arasında döngü. Sonu ve Başlat'ı yığının üstüne yerleştirin.

Her Yineleme:

• Mevcut numarayı çıktı
• Geçerli numaradan 1 ekleyin (veya çıkarın)
• Mevcut numarayı diğer numara ile değiştirin

Kod Açıklaması

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

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

Çevrimiçi deneyin!

Haskell, 30 bayt

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

Kullanımı: 3%7`[3,7,4,6,5] verir

Girişler l, hiçin fonksiyon girişler ile tekrar tekrar çağırır l+1, h-1ve başlangıçtakileri ekler l,h. Herhangi bir durma koşulu yerine, kod take(h-l)diziyi doğru uzunlukta kısaltmak için kullanılır (aksi halde sayıları artan ve azalan sayılar dizisi olur).

Brachylog , 15 bayt

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

Giriş 2 elemanlı bir listedir [lo, hi]. Alt çizgi negatif sayılar için kullanıldığını unutmayın. Çevrimiçi deneyin!

açıklama

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

↨_x^─▀

Çevrimiçi deneyin!

İle açıklama (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]

Bunun çalışmasının nedeni, çıktıdaki tüm öğelerin benzersiz olması gerekmesinden kaynaklanmaktadır, bu nedenle benzersiz öğeler operatörü dizinin ikinci yarısını filtreleyerek doğru çıktıyı üretecektir.

Perl 5 -ln , 37 bayt

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

Çevrimiçi deneyin!

Java (JDK) , 52 bayt

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

Çevrimiçi deneyin!

Temiz , 48 bayt

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

Çevrimiçi deneyin!

Ruby , 37 36 33 bayt

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

Çevrimiçi deneyin!

G B. tarafından kaydedilen 3 bayt ile özyineli versiyonu

Ruby , 38 bayt

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

Çevrimiçi deneyin!

Özyinelemeli olmayan versiyonu.

Cubix, 16 bayt

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

Burada dene

Cubified

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

açıklama

Temel olarak, bu iki sınır bir araya gelinceye kadar bir adımda bir adım daha yaklaştırılır. Döngü boyunca her seferinde ssınırları değiştiririz, Osıkarız, farkı alırız ve işareti temel alarak arttırır )veya azaltırız (.

Pyth, 10 8 bayt

{.iF_B}F

Burada dene

açıklama

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