ASCII Meme Arrow Generator

13

Характеристики

Учитывая число n, выведите ASCII "мем-стрелку" (больше символа >) размера n.

n всегда будет положительным целым числом, больше 0.

Примеры

n = 2

\
 \
 /
/

n = 5

\
 \
  \
   \
    \
    /
   /
  /
 /
/

Образец кода

Вот пример программы, написанной на Crystal, которая возвращает правильные результаты. Запустите это как ./arrow 10.

arrow.cr:

def f(i)
        i.times { |j|
                j.times { print ' ' }
                puts "\\"
        }
        i.times { |j|
                (i-j-1).times { print ' ' }
                puts '/'
        }
end

f(ARGV[0].to_i)

правила

  • Это код-гольф . Самый короткий ответ выигрывает. Однако я не буду выбирать ответ, потому что самый короткий ответ может меняться со временем.
  • Стандартные лазейки не допускаются.
code-golf  ascii-art 
— dkudriavtsev
источник
1
Вы уверены, что это не дубликат? Я думаю, что это может быть, но это почти невозможно найти.
— мое местоимение monicareinstate
1
Может nбыть ноль?
— xnor
6
Я думаю, что довольно глупо называть этот общий символ «мемовой стрелой». Они явно комедийные шевроны.
— разброс
4
@Christian Они на самом деле забавные углы
— dkudriavtsev
1
@ArtemisFowl Я думал, что это были интересные увеличения
— dkudriavtsev

Ответы:

4

C64Mini / C64 BASIC (и другие варианты CBM BASIC), используется 52 токенизированных байта BASIC

 0INPUTN:N=N-1:FORI=0TON:PRINTTAB(I)"\":NEXT:FORI=NTO0STEP-1:PRINTTAB(I)"/":NEXT

Вот необъясненная версия для объяснения:

 0 INPUT N
 1 LET N=N-1
 2 FOR I=0 TO N
 3  PRINT TAB(I);"\"
 4 NEXT I
 5 FOR I=N TO 0 STEP -1
 6  PRINT TAB(I);"/"
 7 NEXT I

То, что число вводится в Nнулевой строке, уменьшается на единицу, поскольку TABкоманда индексируется с нуля; Эти FOR/NEXTпетли в двух строках через четыре и пять до семи , то вывести верхнюю и нижнюю часть , если memeстрелка соответственно (представлены сдвинутым Mи смещенного Nв графическом режиме источником )

Commodore C64 мем стрелка

— Шон Бебберс
источник
1
Знаете ли вы, что в Commodore Basic все ключевые слова могут быть сокращены? Вот ссылка: c64-wiki.com/wiki/BASIC_keyword_abbreviation Например, forможет быть fO( f- shoft o), printесть ?и т. Д.
— gaborsch
1
52 байта вводят в заблуждение в Code Golf, двоичные файлы не учитываются, только исходный код. Это должно быть что-то вроде этого: 0inputn:n=n-1:fOi=0ton:?tA(i)"\":nE:fOi=0ton:?tA(i)"/":nE- это занимает 57 байтов.
— gaborsch
1
Как обсуждено здесь -> codegolf.meta.stackexchange.com/questions/11553/… Я считаю, что используются токены, так как это более точно отражает объем используемой памяти.
— Шон Бебберс
1
О, я этого не знал. Есть ли решение по этому поводу? Даже ответ там не был принят.
— gaborsch
1
Моим первым компьютером был C16, я тоже много собирал на нем, так что без обид, я люблю Commodore. C16 имел Basic 3,5, 80 символов в строке, у меня также была книга с объяснениями списков ROM, поэтому я точно знал, как работает токенизация и листинг,
— gaborsch
4

MarioLANG , 719 677 байт

+
+
+
+
+
+         ((((+)+++++)))<
+>======================"
+)++++++)+++++++++++((-[!)
========================#=-
) ![-    <+;)+++)---)++++)<
)=#======"=================
) >)+)+((!
+ "======#
         <))))).(((((((<
 ========">============"
>)+)+((-[!+))        -[!((((((((.)).))))+(-[!)
"========#=============#====================#<
!)                                          <
#==========================================="
                  >(((((.)))>
                  "========<"========
 ![-)).))).(((((((![-    ))+![-((+)+)<((![<
 #================#=========#========"==#="===
 >                                   !  >-!
 "===================================#  "=#

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

Это было сложнее, чем ожидалось ...

— Чарли
источник
4

брейкфук 125 байтов

++++++++++[->+>+++++++++>+++<<<]>>++>++>,[->[->+<<<.>>]<<<.<.>>>>>[-<+>]<+<]<<[--<<+>>]<<+>>>>>[-[-<+<.>>]<<<<<.>.>>>[->+<]>]

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

++++++++++[->+>+++++++++>+++<<<]>>++>++>    ; Initialize with " \"
,                                           ; Get input
[->                                         ; loop and decrement n 
    [->+<<<.>>]                             ; output number of spaces, copy n
    <<<.                                    ; output \
    <.                                      ; output newline
    >>>>                                    
    >[-<+>]<+                               ; copy copy of n back to original place 
<]
<<[--<<+>>]<<+>>                            ; change "\" to "/"
>>>                             
[                                           ; second loop for bottom half
 -                                          ; decrement n
 [-<+<.>>]                                  ; output n spaces
 <<<<<.>.                                   ; output \ and newline
 >>>[->+<]>                                 ; copy n back
]
— Елена
источник
4

Рубин , 111 99 77 73 68 64 57 56 байт

-12 байтов благодаря Бенджамину Уркварту , -43 благодаря ручной работе и -2 байта благодаря Value Ink .

->i{s=[];puts (0...i).map{|j|s=(p=' '*j)+?/,*s;p+?\\},s}

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

Объяснение:

f=->i{                      # instead of a function, use a lambda
  s=[]                      # needs a helper variable *now*, for scope
  puts(                     # puts takes arbitrary num of args; \n after each
    (0...i).map{|j|         # not from 0 to i but from 0 to i-1 (*three* dots)
      s=(
        p=' '*j             # p will remain in scope inside of .map,
      )
      +?/                   # character literal instead of string
      ,*s                   # essentially appending to the array

      p+?\\                 # p is what's returned by .map, not s!

    },                      # up until here, 1st arg to display
    s                       # NOW, as the *2nd* arg, s is displayed
  )
}

Альтернативные (но более длинные) решения

Друг прочитал этот ответ, а затем попытался придумать еще пару подходов. Выкладываю их и здесь, чтобы они не потерялись для огромных сетей.

ввод и выгрузка, 72 байта

->n{puts (0...n).inject([]){|s,i|i=' '*(n-1-i);s.unshift i+?\\;s<<i+?/}}

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

вниз, вводить и не сдвигаться, 80 байтов

->n{puts n.downto(1).map{|i|' '*(i-1)}.inject([]){|s,i|s<<i+?/;s.unshift i+?\\}}

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

интригующий, два не вложенных цикла, 127 байт

->n{
r=->s,c{s[0..-(c+1)],s[-c..-1]=s[c..-1],s[0..c-1];s};
n.times{|i|puts r[' '*n+?\\,n-i]}
n.times{|i|puts r[' '*n+?/,i+1]}
}

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

— шестьдесят пять
источник
Не может ли быть удалено много этого пробела?
— Бенджамин Уркхарт
1
Да, всего 12 байт, спасибо! Это был первый раз, когда я отправил что-нибудь в кодовую игру в гольф ...
— шестьдесят пятого
Тогда вы можете найти интересные советы по игре в гольф на Ruby или даже советы по игре в гольф на <все языки> .
— Манатворк
Вы можете заменить внутренние петли для заполнения String#rjust( попробуйте онлайн! ).
— Манатворк
Здесь я применил некоторые советы из вышеупомянутых 2 коллекций, чтобы уменьшить его до 57 символов: Попробуйте онлайн!
— Манатворк
3

Код T-SQL, 80 байт

DECLARE @ INT=3

,@z INT=0
x:PRINT
space(@-abs(@-@z-.5))+char(92-@z/@*45)SET
@z+=1IF @z<@*2GOTO x

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

Запрос T-SQL, 96 байт

Чтобы сделать эту работу онлайн, мне пришлось внести некоторые незначительные изменения. Пробелы в начале строки не отображаются в онлайн-фрагменте. Поэтому я использую Ascii 160 вместо. При работе в Management Studio можно изменить настройки, чтобы отобразить результат в виде текста, что приведет к правильным пробелам в этом опубликованном скрипте.

DECLARE @ INT=3
SELECT space(@-abs(@-number-.5))+char(92-number/@*45)FROM
spt_values WHERE number<@*2and'p'=type

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

— t-clausen.dk
источник
2

APL (NARS), 40 символов, 80 байтов

{f←{⍺,⍨⍵⍴' '}⋄⊃('\'f¨k),('/'f¨⌽k←¯1+⍳⍵)}

тестовое задание:

  h←{f←{⍺,⍨⍵⍴' '}⋄⊃('\'f¨k),('/'f¨⌽k←¯1+⍳⍵)}
  h 2
\ 
 \
 /
/ 
  h 5
\    
 \   
  \  
   \ 
    \
    /
   / 
  /  
 /   
/
— RosLuP
источник
1

PowerShell , 50 байт

param($n)0..--$n|%{' '*$_+'\'}
$n..0|%{' '*$_+'/'}

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

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

— Veskah
источник
1

Веточка, 115 байт

Строит строку в обратном направлении, «возвращая» ее в конце.

Использует макрос для генерации всех результатов.

{%macro a(N,s="")%}{%for i in N..1%}{%set s=('%'~i~'s
'~s~'%'~i~'s
')|format('\\','/')%}{%endfor%}{{s}}{%endmacro%}

Этот макрос должен быть в файле и импортирован так:

{% import 'macro.twig' as a %}

{{ a.a(<value>) }}

Вы можете попробовать его на https://twigfiddle.com/5hzlpz (нажмите «Показать необработанный результат»).

— Исмаэль Мигель
источник
1

Haskell , 52 49 байт

-3 байта благодаря сриотчизму О'Зайку .

unlines.g
g 0=[]
g n="\\":map(' ':)(g$n-1)++["/"]

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

— Джозеф Сибл-Восстановить Монику
источник
1
Вы можете сохранить байт g$n-1вместо g(n-1). Вам также не нужно считать, f=так как на него fникогда не ссылаются.
— Пост Рок Гарф Хантер
1

MATL, 14 13 12 байт

Xy92*t45-Pvc

1 байт сохранен благодаря @LuisMendo

объяснение

        % Implicitly grab the input as an integer
Xy      % Create an identity matrix this size
92*     % Multiply by 92 (ASCII for '\')
t       % Duplicate the matrix
45-     % Subtract 45 from every element yielding 47 (ASCII for '/') on the diagonal
        % and -45 everywhere else
P       % Vertically flip this matrix
v       % Vertically concatenate the two matrices
c       % Convert to characters (negative numbers are replaced with a space)
        % Implicitly display the result

Попробуйте это в MATL Online

— Suever
источник
@ LuisMendo Обновлено! Благодарность!
— Suever
1

Python 3 , 90 83 байта

lambda n:'\n'.join([' '*i+'\\'for i in range(n)]+[' '*(n+~i)+'/'for i in range(n)])

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

-7 байт благодаря @squid

— Артемида все еще не доверяет ЮВ
источник
83 байта , но я чувствую, что это все еще может уменьшиться
— Восстановите Монику
1
Я хотел бы, чтобы это было возможно.
— Артемида до сих пор не доверяет SE
— Восстановить Монику
О да, я забыл об этом. Может быть, вы должны представить его!
— Артемида по-прежнему не доверяет SE
1

Rockstar, 133 байта

Попробуйте онлайн здесь !

F takes N,S
If N is 0
Give back N

Say S+"\"
Let T be S+" "
Let M be N-1
F taking M,T
Say S+"/"

Listen to X
F taking X,""

Поскольку Rockstar не славится строковыми операциями, для его выполнения требуется сравнительно много кода (рекурсивно - даже дольше).

Размер стрелки берется как ввод.

— gaborsch
источник
1

\ / \ /> 74 байта

jp100o
-84*}!o:?!x1
@+:q:p=?x:o~$:0(pa"\/"q?$~}}:
x2-:p$1-y$:0(?
.{suh?!;2

Пояснение: (линии повернуты в зависимости от начальной точки)

jp100o                        //setup
:?!x1-84*}!                   //add leading spaces, loop and decrement until 0
~$:0(pa"\/"q?$~}}:@+:q:p=?x:o //add correct slash, go back to loop or switch sides
$:0(?x2-:p$1-y                //flip direction state or continue to print
{suh?!;2.                     //remove extra data and print stack
— torcado
источник
1
\/\/> (pronounced wɜrm)Спасибо, я ненавижу это. (JK, я с нетерпением жду, чтобы попробовать)
— Джо Кинг
@JoKing хахаха, должен носить мое вдохновение на моем рукаве. (спасибо!)
— торкадо
0

SimpleTemplate , 100 байт

Это было довольно забавное испытание, но некоторые ошибки в языке затрудняли его оптимизацию.

{@set_ argv.0}{@while_}{@callstr_repeat intoS" ",_}{@setO S,"\\\n",O,S,"/\n"}{@incby-1_}{@/}{@echoO}

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

Каким должен быть ответ

Из-за ошибок код не был правильно интерпретирован.

Вот как будет выглядеть код, если бы в компиляторе не было ошибки (86 байт):

{@forfrom argv.0to0step-1}{@callrepeat intoS" ",_}{@setO S,"\\
",O,S,"/
"}{@/}{@echoO}

Ох, ну, по крайней мере, решение работает: x

— Исмаэль Мигель
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.