465 Композиция


24

Вот проблема. Напишите некоторый код для вывода всех целых чисел в диапазоне. Звучит просто, но вот сложная часть. Это начнется с самого низкого числа, затем самого высокого. Тогда самое низкое число, которого еще нет в массиве. Тогда самое высокое, которого еще нет в нем.

Пример:

Давайте начнем с 1 до 5

Числа: [1, 2, 3, 4, 5].

Возьмем первое, поэтому [1]. Остальные цифры [2, 3, 4, 5]. Мы берем последний, новый массив - [1, 5]. Остальные цифры [2, 3, 4]. Возьмем первый, новый массив - [1, 5, 2]. Остальные цифры [3, 4]. Возьмем последний, новый массив: [1, 5, 2, 4]. Остальные цифры [3]. Возьмем первый, новый массив - [1, 5, 2, 4, 3]. Чисел не осталось, мы сделали. Выход [1, 5, 2, 4, 3]

Правила:

  • Это код гольф, напишите его в наименьшем количестве байтов, на любом языке.
  • Нет стандартных лазеек.
  • Ссылки на онлайн переводчика, пожалуйста? (Например, https://tio.run/ )
  • Два входа, оба целые. Нижний предел диапазона и верхний предел диапазона.
  • Я не против того, что тип данных вывода, но он должен показывать числа в правильном порядке.

Примеры

Низкий: 4 Высокий: 6 Результат: 4 6 5


Низкий: 1 Высокий: 5 Результат: 1 5 2 4 3


Низкий: -1 Высокий: 1 Результат: -1 1 0


Низкий: -1 высокий: 2 Результат: -1 2 0 1


Низкий: -50 Высокий: 50 Результат: -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


Удачного игры в гольф!


2
Почти дубликат (разница в том, что этот требует изменения второй половины перед слиянием).
Питер Тейлор

вход всегда будет в порядке низкого конца, высокого конца?
Sumner18

1
@ Sumner18 да. Сообщество здесь настроено против проверки ввода, и я не просил ввод в обратном порядке, поэтому мы можем предположить, что он всегда будет низким - высоким.
AJFaraday

1
@ Sumner18 Обычно эти проблемы работают так, что нам все равно, как обрабатываются неверные данные. Ваш код оценивается как успешный только по тому, как он обрабатывает действительные входные данные (т.
Е.

1
@AJFaraday: вы должны добавить примечание к основному сообщению, указывающее, что X всегда будет строго ниже Y (то есть X! = Y), я пропустил этот комментарий;)
digEmAll

Ответы:


15

R , 38 37 36 байт

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

Попробуйте онлайн!

  • -1 байт благодаря @ user2390246
  • -1 байт благодаря @Kirill L.

Используя тот факт, что R хранит матрицы по столбцам


Использование rbindнамного лучше, чем мой подход, но вы можете сэкономить 1 байт, используя [seq(a:b)]вместо unique.
user2390246

Вы правы, я пропустил комментарий, где было указано, что a <b (никогда не равно), поэтому мы можем использоватьseq(a:b)
digEmAll

@digEmAll Мое решение было буквальным толкованием головоломки, я никогда бы не подумал сделать что-то подобное. Впечатляет, есть upvote!
Sumner18



8

R , 65 64 61 60 байт

-1 байт благодаря Роберту С.

Еще -4 благодаря digEmAll

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

Попробуйте онлайн!


Вы можете заменить length(z)на, sum(z|1)чтобы сохранить 1 байт :)
Роберт С.

Я не понимаю, как это работает, но я думаю, что это работает. sum (z | 1), похоже, всегда будет иметь значение не менее 1, что приведет к бесконечному циклу цикла while. но, видимо, нет
Sumner18

4
z является вектором. каждый элемент этого вектора имеет значение |1. Это всегда равно 1. Когда вы берете сумму, у вас есть вектор, заполненный TRUEs, так что результат равен длине вектора. Если вектор пустой, вы не имеете ничего общего |с выходным вектором logical(0). Когда вы берете эту сумму, это 0
OganM



5

PowerShell , 59 48 байтов

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

Попробуйте онлайн!

(Кажется долго ...)

Принимает ввод $aи $bсоздает диапазон 0 .. ($b-$a), сохраняет его в $z, а затем перебирает этот диапазон. Цикл этого диапазона просто используется как счетчик, чтобы гарантировать, что мы получим достаточно итераций. Каждую итерацию мы ставим $aи $bна конвейер с сложением / вычитанием. Это дает нам что-то вроде этого, 1,5,2,4,3,3,4,2,5,1поэтому нам нужно нарезать это от0 до$b-$a (то есть, подсчет) исходного массива , так что мы только оставили с соответствующими элементами. Это осталось на конвейере и вывод неявный.

-11 байт благодаря маззи.



@ mazzy Ах, мне нравится этот $b-$aтрюк - это умно!
AdmBorkBork

5

05AB1E , 6 байтов

ŸDvć,R

Попробуйте онлайн!

объяснение

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

Ÿ2ä`R.ι не итеративно с использованием чередования, но это все же намного лучше.
Волшебная Урна Осьминога

1
@MagicOctopusUrn: Сначала я попробовал не итеративное решение, но это было еще хуже, так как я не знал об этом ;)
Эминья,

Подобно тому, что я имел в виду, так очевидно +1 от меня. Мне также нравится ваш альтернативный 7-байтовый, @MagicOctopusUrn. :)
Кевин Круйссен

1
@KristianWilliams: кажется, работает на меня.
Emigna

1
@KevinCruijssen: Я переключился на пару, так как это было более интуитивным в любом случае :)
равно



4

R , 51 байт

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

Попробуйте онлайн!

Объяснение: Для последовательности x:yдлины Nсоздайте матрицу два на N, состоящую из последовательности x: y в верхней строке и y: x в нижней строке matrix(c(z,rev(z)),2,,T). Если мы выберем первые Nэлементы матрицы[seq(z)] , они будут выбраны по столбцам, что даст требуемый результат.

Перегнан на DigEmAll


1
Я только что опубликовал очень похожий подход за 30 секунд до вас: D
digEmAll

@digEmAll Да, но ваш намного лучше!
user2390246

4

cQuents , 19 байтов

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

Попробуйте онлайн!

Обратите внимание, что он не работает на TIO прямо сейчас, потому что интерпретатор TIO не обновлен.

объяснение

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



4

Байт-код JVM (OpenJDK asmtools JASM), 449 байт

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

Неутолкнутый (и немного чище)

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

Автономная функция, должна вызываться из Java как b.a(num1,num2) .

объяснение

Этот код использует параметры метода в качестве переменных, а также логическое значение в локальной # 3, решающее, какое число вывести. Каждая итерация цикла либо левая, либо правая выводится, и это число увеличивается слева или уменьшается справа. Цикл продолжается до тех пор, пока оба числа не будут равны, затем это число выводится.

... У меня есть отчетливое чувство, что я массово перебил на счет байтов


4

Wolfram Language (Mathematica) , 56 54 байта

Это мой первый раз в гольф!

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

Попробуйте онлайн!

Сохранено 2 байта с использованием инфиксной записи.

Объяснение:

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)

В качестве альтернативы, мы могли бы использовать Take[...,b-a+1]для того же результата.

тесты:

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}

Ссылка «Попробуйте онлайн» возвращает 403. «Извините, у вас нет прав доступа к этому элементу».
Рохит Намёси

@RohitNamjoshi Я обновил ссылку
Кай

обратите внимание, что в TIO вы можете разместить код верхнего и нижнего колонтитула в текстовых полях выше и ниже фактического поля кода. Это делает код более понятным, а также позволяет использовать форматер ответов PPCG (esc-sg). Попробуйте онлайн!
Джо Кинг

@JoKing очень ценится, я никогда не использовал его раньше!
Кай





3

Forth (gforth) , 52 байта

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

Попробуйте онлайн!

объяснение

Цикл от 0 до (Конец - Старт). Поместите Конец и Начните сверху стека.

Каждая итерация:

  • Вывести текущий номер
  • Добавить (или вычесть) 1 из текущего числа
  • Переключите текущий номер с другим номером

Код Объяснение

: 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


3

Haskell, 30 байт

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

Использование: 3%7дает `[3,7,4,6,5]

Для входов l, hфункция вызывает рекурсивно с входами l+1, h-1и добавляет l,hк началу. Вместо любого условия остановки код использует take(h-l)для сокращения последовательности до нужной длины (которая в противном случае была бы бесконечной последовательностью увеличивающихся и уменьшающихся чисел).


3

Брахилог , 15 байт

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

Вход представляет собой 2-элементный список [lo, hi]. Обратите внимание, что подчеркивание используется для отрицательных чисел. Попробуйте онлайн!

объяснение

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

3

MathGolf , 6 байтов

↨_x^─▀

Попробуйте онлайн!

Объяснение с (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]

Причина, по которой это работает, заключается в том, что все элементы в выходных данных должны быть уникальными, поэтому оператор уникальных элементов отфильтровывает вторую половину массива, создавая правильный вывод.






2

Cubix, 16 байтов

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

Попробуй здесь

Cubified

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

объяснение

По сути, это сдвигает две границы ближе друг к другу, пока они не встретятся. Каждый раз в цикле мы sобмениваем границы, Oвыводим, принимаем разницу и увеличиваем )или уменьшаем на (основе знака.


2

Pyth, 10 8 байт

{.iF_B}F

Попробуй здесь

объяснение

{.iF_B}F
      }FQ  Generate the range between the (implicit) inputs.
 .iF_B     Interleave it with its reverse.
{          Deduplicate.
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.