N (e (s (t))) строка

77

Чтобы «вложить» строку, вы должны:

  • Рассматривайте первый символ как функцию, а следующие символы как аргументы этой функции. Например, если входная строка была Hello, то первым шагом будет:

    H(ello)
    
  • Затем повторите этот же шаг для каждой подстроки. Итак, мы получаем:

    H(ello)
    H(e(llo))
    H(e(l(lo)))
    H(e(l(l(o))))
    

Ваша задача - написать программу или функцию, которая "вложит" строку в функцию. Например, если входная строка была Hello world!, то вы должны вывести:

H(e(l(l(o( (w(o(r(l(d(!)))))))))))

Входные данные будут содержать только печатный ASCII , и вы можете принимать входные и выходные данные в любом приемлемом формате. Например, STDIN / STDOUT, аргументы функции и возвращаемое значение, чтение и запись в файл и т. Д.

Для простоты вы можете также предположить, что ввод не будет содержать скобок и не будет пустым.

Input:
Nest a string
Output:
N(e(s(t( (a( (s(t(r(i(n(g))))))))))))

Input:
foobar
Output:
f(o(o(b(a(r)))))

Input:
1234567890
Output:
1(2(3(4(5(6(7(8(9(0)))))))))

Input:
code-golf
Output:
c(o(d(e(-(g(o(l(f))))))))

Input:
a
Output:
a

Input:
42
Output:
4(2)

Как обычно, применяются все наши правила и лазейки по умолчанию, и выигрывает самый короткий ответ в байтах!

DJMcMayhem
источник
21
Гм: Это сообщение как- то связано с проблемой? :-)
wizzwizz4
12
T I L 4 2 = 8
ETHproductions
Какова максимальная длина входной строки? Incase рекурсивных методов
Ferrybig
1
@ kamoroso94 You may take the input and the output in any reasonable format.Список символов кажется мне вполне разумным.
DJMcMayhem
1
Вот так выглядит код на Лиспе
caird coinheringaahing

Ответы:

63

Python, 41 39 34 байта

lambda e:"(".join(e)+")"*~-len(e)

Ideone это

Довольно понятно.

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

Мастер пшеницы
источник
13
Этот трюк - это круто, мне нужно это запомнить.
Скайлер
как работает трюк?
ShadowFlame
1
@ShadowFlame -делает число отрицательным и ~немного переворачивает его. Вы можете прочитать немного больше об этом на странице советов .
Пшеничный волшебник
1
@ShadowFlame. Механика этого, как сказал Уитворд. Он работает в системах, которые используют режим двойного дополнения для хранения отрицательных чисел (что в настоящее время является большинством систем).
Безумный физик
1
@MadPhysicist С Python это работает всегда, потому что ~ определяется как -x-1
Mega Man
45

MS-DOS .com файл, 30 байт

0000   fc be 82 00 b4 02 ac 88 c2 cd 21 ac 3c 0d 74 0d
0010   b2 28 50 cd 21 5a e8 f0 ff b2 29 cd 21 c3

Строка передается в исполняемый файл с помощью командной строки. (Один пробел между именем файла .COM и строкой).

Результат записывается в стандартный вывод.

Разборка здесь:

  fc          cld              ; Make sure DF is not set (lodsb!)
  be 82 00    mov    si,0x82   ; First character of command line args
  b4 02       mov    ah,0x2    ; AH=2 means output for INT 21h
  ac          lodsb            ; Load first character
  88 c2       mov    dl,al     ; Move AL to DL (DL is written to output)
recursiveFunction:
  cd 21       int    0x21      ; Output
  ac          lodsb            ; Get the next character
  3c 0d       cmp    al,0xd    ; If it is "CR" (end of command line) ...
  74 0d       je     doReturn  ; ... return from the recursive function
  b2 28       mov    dl,0x28   ; Output "(" next...
  50          push   ax        ; ... but save character read first
  cd 21       int    0x21      ; (Actual output)
  5a          pop    dx        ; Restore character (but in DL, not in AL)
  e8 f0 ff    call   recursiveFunction  ; Recursively enter the function
doReturn:
  b2 29       mov    dl,0x29   ; Output ")"
  cd 21       int    0x21
  c3          ret              ; Actually return

Примечание. Вы можете выйти из файла .COM DOS (в отличие от файлов с заголовками EXE), используя инструкцию «RET».

Мартин Розенау
источник
Поскольку я не могу найти какую-либо фактическую документацию или удовлетворительную информацию: почему call 0xfoff? 0Насколько я могу судить, программа загружается в память по адресу (или 0x100в CP / M-DOS, но, похоже, это инструкции x86), почему recursiveFunctionвдруг находится в 0xffof? Кажется, он начинается через 9 байт после начала программы, и в исполняемом файле нет виртуализации или метаданных.
кот
6
DOS загружает файлы .COM для адресации, 0x100однако эта программа будет работать даже на ЛЮБОМ адресе: e8 f0 ffэто относительная инструкция вызова: она переходит на адрес инструкции, следующей за callинструкцией минус 0x10.
Мартин Розенау
32

JavaScript (ES6), 40 34 33 байта

Сохранено 6 байтов благодаря ETHproductions

Рекурсивная функция.

f=([c,...s])=>s+s?c+`(${f(s)})`:c

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

Arnauld
источник
1
Хороший трюк с 1/s.
ETHproductions
Супер хороший трюк с ([c,...s])вами следует написать совет
edc65
@ edc65 Просто для ясности, это было предложено ETHproductions.
Арно
хорошо, кто-то должен написать совет в любом случае
edc65
1
@jmingov спасибо, я знаю. Суть в том, чтобы использовать DA для нарезки строки очень коротким способом (очень короче, чем .slice)
edc65
27

Brainfuck, 42 40 байт

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

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

Ungolfed:

>+[-->+[<]>-]>+     # count to 40 (ASCII for open paren)
>>                  # move to the input holder
,.                  # input the first byte and output it
,                   # input the next byte
[                   # while it's not zero
  <+                # move to the input counter and increment it
  <.                # move to the open paren and output it
  >>.               # move to the input holder and output it
  ,                 # input the next byte
]
<<+                 # move to the open paren and increment it to a close
>                   # move to the input counter
[                   # while it's not zero
  -                 # decrement it
  <.                # move to the close paren and output it
  >                 # move to the input counter
]
Алекс Хованский
источник
1
Обычно есть более короткий способ получить константу, чем очевидное двухфакторное умножение.
Мартин Эндер
Ах, хорошо, спасибо. Это была моя первая подача BF (вообще-то, моя первая BF-программа), так что я уверен, что есть и много других возможных улучшений.
Алекс Ховански
у тебя много пар скобок !?
Vloxxity
Это ставит пустую пару скобок после последнего символа строки. Я не знаю, есть ли способ избежать этого без добавления ",". перед циклом и переключением порядка вывода внутри цикла, что делает программу на два байта длиннее.
user59468 21.10.16
Ах, черт возьми, ты прав. Я не читал достаточно внимательно и сделал последнее письмо вызовом функции, как и другие.
Алекс Ховански
18

Brainfuck, 44 байта

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

Читает байт за раз, ставит перед каждым, кроме первого, открытый символ «парен», в конце ставит одинаковое количество «парэнс».

user59468
источник
+++++[->++++++++<],.,[>.>+<<.,]>+>[-<.>]немного короче.
Тессеракт
17

Haskell, 30 байт

f[x]=[x]
f(a:b)=a:'(':f b++")"

Пример использования: f "Nest a string"-> "N(e(s(t( (a( (s(t(r(i(n(g))))))))))))".

Возьмите следующий символ, за которым следует a (, затем рекурсивный вызов со всеми, кроме первого символа, за которым следует a ).

Ними
источник
2
Если мы интерпретируем ответы как Haskell, мы можем решить их просто f=Data.List.intersperse '$'! Это дает нам f "Nest a string"-> "N$e$s$t$ $a$ $s$t$r$i$n$g".
porglezomp
Просто хотел сообщить, что @fornit (у него недостаточно представителей, чтобы комментировать) предложил использовать f[]=[]в качестве базового варианта вместо вашего f[x]=[x]. Я не знаком с Хаскеллом, поэтому не знаю, законно это или нет, я позволю тебе судить.
Дада
@ Дада: это не сработает, потому что это добавило бы дополнительную ()букву после последней буквы, например f "abc"-> "a(b(c()))".
Ними
Это также не обрабатывает пустой ввод. Кратчайший правильный вариант я мог придумать 44, с другой техникой: f=(++).intersperse '('<*>drop 1.map(\_->')').
Джон Перди
@JonPurdy: нам не нужно обрабатывать пустой ввод. intersperseтребуется import Data.Listеще 17 байтов.
Ними
16

Желе , 9 8 байт

-1 байт благодаря @Dennis (используйте пресс-форму вместо длины Lи повторите x)

j”(³”)ṁṖ

TryItOnline

Как?

j”(³”)ṁṖ - Main link: s     e.g. "code-golf"           printed output:
j        - join s with
 ”(      - literal '('           "c(o(d(e(-(g(o(l(f"
    ”)   - literal ')'
      ṁ  - mould like
   ³     - first input, s        ")))))))))"
         - causes print with no newline of z:          c(o(d(e(-(g(o(l(f
       Ṗ - pop (z[:-1])          "))))))))"            c(o(d(e(-(g(o(l(f
         - implicit print                              c(o(d(e(-(g(o(l(f))))))))
Джонатан Аллан
источник
3
Кстати, ³фактически заставляет Jelly печатать текущее возвращаемое значение, поэтому у вас никогда не будет двух списков символов.
Деннис
13

Сетчатка , 22 17 байт

\1>`.
($&
T`(p`)_

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

В качестве альтернативы:

S_`
\`¶
(
T`(p`)_

объяснение

Я всегда забываю, что можно печатать вещи по пути, вместо того, чтобы преобразовывать все в конечный результат и выводить его за один раз ...

\1>`.
($&

Здесь \говорится, что Retina печатает результат этого этапа без завершающего перевода строки. Это 1>предел, который означает, что первое совпадение регулярного выражения следует игнорировать. Что касается самой стадии, она просто заменяет каждый символ ( .), за исключением первого, (за которым следует этот символ. Другими словами, он вставляет (между каждой парой символов. Для ввода abcэто преобразует его в (и печатает)

a(b(c

Осталось только напечатать закрывающие скобки:

T`(p`)_

Это делается с помощью транслитерации , которая заменяет (с )и удаляет все другие печатные символы ASCII из строки.

Мартин Эндер
источник
Dangit. Так быстро ...
mbomb007
@ mbomb007 ... и далеко не оптимально. ;)
Мартин Эндер
13

> <> , 19 18 байт

io8i:&0(.')('o&!
o

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

объяснение

Первая строка представляет собой цикл ввода, который печатает все до последнего символа ввода (включая все () и оставляет нужное количество )в стеке:

io                 Read and print the first character.
  8                Push an 8 (the x-coordinate of the . in the program).
   i               Read a character. Pushes -1 at EOF.
    :&             Put a copy in the register.
      0(           Check if negative. Gives 1 at EOF, 0 otherwise.
        .          Jump to (8, EOF?). As long as we're not at EOF, this is
                   a no-op (apart from popping the two coordinates). At EOF
                   it takes us to the second line.
         ')('      Push both characters.
             o     Output the '('.
              &    Push the input character from the register.
               !   Skip the 'i' at the beginning of the line, so that the next
                   iteration starts with 'o', printing the last character.

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

Мартин Эндер
источник
12

J, 13 байт

(,'(',,&')')/

J выполняется справа налево, поэтому, используя наречие вставки /, можно использовать глагол, чтобы уменьшить буквы входной строки.

использование

   f =: (,'(',,&')')/
   f 'Nest a string'
N(e(s(t( (a( (s(t(r(i(n(g))))))))))))
   f 'foobar'
f(o(o(b(a(r)))))
   f '1234567890'
1(2(3(4(5(6(7(8(9(0)))))))))
   f 'code-golf'
c(o(d(e(-(g(o(l(f))))))))

Вы можете наблюдать частичные выходы между каждой редукцией.

   |. f\. 'Hello'
o            
l(o)         
l(l(o))      
e(l(l(o)))   
H(e(l(l(o))))

объяснение

(,'(',,&')')/  Input: string S
(          )/  Insert this verb between each char and execute (right-to-left)
      ,&')'      Append a ')' to the right char
  '(',           Prepend a '(' to that
 ,               Append to the left char
миль
источник
12

C #, 32 байта

F=s=>*s+++(0<*s?$"({F(s)})":"");

Эта лямбда должна быть статическим методом, нужно ли мне подсчитывать дополнительные байты для этого требования? Обычно я не использовал бы лямбду для рекурсии в C #, но тогда я думаю, что было бы короче не использовать рекурсию.

/*unsafe delegate string Function(char* s);*/ // Lambda signature
/*static unsafe Function*/ F = s =>
    *s++                               // Take first char and increment pointer to next one
    + (0 < *s                          // Check if any chars left
        ? $"({F(s)})"                  // If so concat surrounding parens around recursion
        : ""                           // Otherwise done
    )
;
молоко
источник
определение должно работать так, как заявлено и засчитано
кошка
9

R 61 байт

cat(gsub("(?<=.)(?=.)","(",x,F,T),rep(")",nchar(x)-1),sep="")

Regex находит и заменяет пробелы между символами на "(". Затем catи repдобавляет ")" n-1 раз в конце.

jmartindill
источник
На самом деле можно вычесть здесь 1 байт, исключив F, например, потому , что каждая запись уже имеет настройку по умолчанию, поэтому оставление пустого символа между запятыми приведет к тому, что опция ignore.case будет использовать значение по умолчанию. Но вы, вероятно, знали, что ... Хорошо выполненная работа!
Sumner18
9

Java 7,81 79 байт

Сохраненный 1байт. Спасибо Кевину.

String f(char[]a,String b,int l){return l<a.length?f(a,b+'('+a[l],++l)+')':b;}
Numberknot
источник
Хороший рекурсивный подход. Короче, чем цикл, который я собирался опубликовать. +1 Две вещи, которые вы можете l!=a.lengthl<a.lengthb=b+'('+a[l],++l)+')'b+="("+a[l],++l)+")"
играть в
@KevinCruijssen b+="("+a[l],++l)+")"дает вам 144141148))), и, кстати b+"("+a[l],++l)+")", правильно. и это была моя очень глупая ошибка ( !=).
Numberknot
Нет, b+='('+a[l],++l)+')'дает 144141148, но b+="("+a[l],++l)+")"не делает. Скобки заключены в кавычки вместо строковых кавычек.
Кевин Круйссен
Я публикую свою версию (82 байта в Java 7), используя только входную строку в качестве параметра. Многословно, но не так плохо;) Если вы найдете что-то для изменения: codegolf.stackexchange.com/a/96745/59739
AxelH
8

PowerShell v2 +, 46 байт

param([char[]]$a)($a-join'(')+')'*($a.count-1)

Принимает входную строку, char-array's it, -joinмассив вместе с открытыми паренами (, затем объединяет соответствующее количество закрытых паренов ).

AdmBorkBork
источник
8

APL, 19 байт

{∊('(',¨⍵),')'⍴⍨⍴⍵}

Объяснение:

{
  ('(',¨⍵)          ⍝ join a ( to each character in ⍵          
          ,')'⍴⍨⍴⍵  ⍝ for each character in ⍵, add an ) to the end
 ∊                  ⍝ flatten the list 
                   }

Альтернативное решение, также 19 байтов:

{⊃{∊'('⍺⍵')'}/⍵,⊂⍬}

Объяснение:

{              
              ⍵,⊂⍬  ⍝ add an empty list behind ⍵ (as a base case)
  {         }/      ⍝ reduce with this function:
    '('⍺⍵')'        ⍝   put braces around input
   ∊                ⍝   flatten the list
 ⊃                  ⍝ take first item from resulting list
                   }
Мэринус
источник
6
Где купить клавиатуру для такого языка !!!
Ронан Дейхеро
@RonanDejhero Возможно просто переназначение клавиш с помощью cltr, shift, alt, capslock, numlock и т. Д.
Ариана
8

MATL , 16 байт

t~40+v3L)7MQ3L)h

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

объяснение

t     % Implicit input. Duplicate
      % STACK: 'foobar', 'foobar'
~     % Negate. Transforms into an array of zeros
      % STACK: 'foobar', [0 0 0 0 0 0]
40+   % Add 40, element-wise. Gives array containing 40 repeated
      % STACK: 'foobar', [40 40 40 40 40 40]
v     % Concatenate vertically. Gives a two-row char array, with 40 cast into '('
      % STACK: ['foobar'; '((((((']
3L)   % Remove last element. Converts to row vector
      % STACK: 'f(o(o(b(a(r'
7M    % Push array containing 40 again
      % STACK: 'f(o(o(b(a(r', [40 40 40 40 40 40]
Q     % Add 1, element-wise 
      % STACK: 'f(o(o(b(a(r', [41 41 41 41 41 41]
h     % Concatenate horizontally, with 41 cast into ')'
      % STACK: 'f(o(o(b(a(r)))))'
      % Implicit display
Луис Мендо
источник
8

Точность !! 129 байтов

Неплохо для довольно многословного тарпита Тьюринга ...

N
Count i while _%128-9 {
Count x while _/128%2 {
Write 40
_+128
}
Write _%128
_+128-_%128+N
}
Count j while _/256-j {
Write 41
}

(Да, все эти пробелы являются обязательными.)

Примечание: из-за ограничений ввода Acc! , невозможно прочитать произвольную строку символов без некоторого конечного разделителя. Поэтому эта программа ожидает ввода (в stdin) в виде строки, за которой следует символ табуляции.

Точность !! ?

Это язык, который я создал, который кажется непригодным для использования . Единственным типом данных являются целые числа, единственной конструкцией потока управления является Count x while yцикл, а единственным способом хранения данных является один аккумулятор _. Ввод и вывод выполняются по одному символу за раз, используя специальное значение Nи Writeоператор. Несмотря на эти ограничения, я вполне уверен, что Acc !! завершена по Тьюрингу.

объяснение

Основная стратегия в Acc !! программирование заключается в использовании модового %и целочисленного деления /для концептуального разбиения аккумулятора, что позволяет ему хранить несколько значений одновременно. В этой программе мы используем три таких раздела: семь битов младшего порядка ( _%128) хранят код ASCII из ввода; следующий бит ( _/128%2) хранит значение флага; а оставшиеся биты ( _/256) подсчитывают количество близких паренов, которые нам понадобятся.

Вход в Acc !! происходит от специального значения N, которое считывает один символ и оценивает его код ASCII. Любой оператор, который состоит исключительно из выражения, присваивает результат этого выражения аккумулятору. Итак, начнем с хранения кода первого символа в аккумуляторе.

_%128будет хранить последний прочитанный символ Таким образом, первый цикл выполняется, пока он не _%128-9равен нулю, то есть до тех пор, пока текущий символ не станет вкладкой.

Внутри цикла мы хотим печатать, ( если не будем на первой итерации. С Акк !! не имеет оператора if, мы должны использовать циклы для условных выражений. Мы используем 128-разрядный бит аккумулятора _/128%2как значение флага. На первом проходе единственное, что в аккумуляторе - это значение ASCII <128, поэтому флаг равен 0 и цикл пропускается. На каждом последующем проходе мы будем следить за тем, чтобы флаг был равен 1.

Внутри Count xцикла (всякий раз, когда флаг равен 1), мы записываем открытый код (ASCII 40) и добавляем 128 к аккумулятору, тем самым устанавливая флаг в 0 и выходя из цикла. Это также происходит, чтобы _/256увеличить значение , которое мы будем использовать в качестве нашего подсчета близких паренов, которые будут выведены.

Независимо от значения флага мы пишем самый последний входной символ, который просто _%128.

Следующее присваивание ( _+128-_%128+N) делает две вещи. Сначала, добавив 128, он устанавливает флаг в следующий раз в цикле. Во-вторых, он обнуляет _%128слот, читает другой символ и сохраняет его там. Затем мы делаем петлю.

Когда Count iцикл завершается, мы только что прочитали символ табуляции, и значение аккумулятора распадается следующим образом:

  • _%128: 9(символ табуляции)
  • _/128%2: 1(флаг)
  • _/256: количество прочитанных символов, минус 1

(Минус 1 в том, что мы добавляем 128 к аккумулятору только один раз во время первого прохода через главный цикл.) Все, что нам сейчас нужно, это близкие скобки. Count j while _/256-jзацикливание _/256раз, запись близкого парня (ASCII 41) каждый раз. Вуаля!

DLosc
источник
7

Perl, 25 байт

Спасибо @Ton Hospel за 4 байта в гольфе.

24 байта кода + -F.

$"="(";say"@F".")"x$#F

Нужды -Fи -Eфлаги:

echo -n "I love lisp" | perl -F -E '$"="(";say"@F".")"x$#F'

Обратите внимание, что если вы попробуете это на старой версии Perl, вам может понадобиться добавить -aфлаг.


Еще один интересный способ (хотя и немного дольше: 28 байт):
Спасибо Тону Хоспелу за то, что он помог мне сделать это правильно.

#!/usr/bin/perl -p
s/.(?=.)/s%\Q$'%($&)%/reg

(Чтобы использовать его, поместите код в файл и вызовите его с помощью echo -n "Hello" | perl nest.pl)

папа
источник
Вам не нужно ""после -F. Вам также не нужно -lвводить строку ввода без заключительного перевода строки:echo -n Hello | program
Ton Hospel
@TonHospel Правильно, я забыл (или не знал, не уверен) об этом -F, спасибо. (Мне было интересно, как получить ввод без последнего перевода строки, спасибо за это тоже)
Dada
perl -F -E '$"="(";say"@F".")"x$#F'
Тон Хоспел
Вы можете заставить свою другую идею работать с чем-то вроде этого s/.(?=.)/s%$'%($&)%/reg, но она, конечно, не поддерживает строки, содержащие метасимволы регулярных выражений
Ton Hospel
@TonHospel Большое спасибо за все это! (О втором я добавил \Qдля поддержки метасимволов регулярных выражений) :-)
Dada
6

Рубин, 27 байт

->s{s.chars*?(+?)*~-s.size}

объяснение

->s{                       # Declare anonymous lambda taking argument s
    s.chars                # Get the array of chars representing s
           *?(             # Join the elements back into a string using "("s as separators
              +?)*~-s.size # Append (s.size - 1) ")"s to the end
м-chrzan
источник
6

Perl, 24 23 байта

Включает +1 для -p

Дать строку на STDIN без новой строки (или добавить -lопцию в программу)

echo -n Hello | nest.pl

nest.pl:

#!/usr/bin/perl -p
$\=")"x s/.(?=.)/$&(/g
Тон Хоспел
источник
6

PHP, 63 байта

<?=str_pad(join("(",$s=str_split($argv[1])),count($s)*3-2,")‌​");

Предыдущая версия 64 байта

<?=join("(",$s=str_split($argv[1])).str_pad("",count($s)-1,")");
Йорг Хюльсерманн
источник
1
Вы можете сохранить два байта, используя <?=вместо, echo и еще один, если вы установите $ s для результата str_splitвызова вместо $argv[1], а затем используете count($s)вместоstrlen($s)
Alex Howansky
2
63 байта: <?=str_pad(join("(",$s=str_split($argv[1])),count($s)*3-2,")");- wordwrapпревзойдет комбинацию split / join, но, к сожалению, не удастся, если вход содержит пробел.
Тит
1
@Titus хорошая альтернатива Спасибо
Йорг Хюльсерманн
6

GNU sed, 37 35 31 байт (30 +1 для -rаргумента)

Чистый Linux lin решение

:;s/([^(])([^()].*)$/\1(\2)/;t
  1. Наименование подстановки :; затем вызывая это рекурсивно сt
  2. Создание 2 групп регулярных выражений:
    • Первая группа - это первый символ из двух последовательных символов, которые не являются скобками
    • Вторая группа - второй последовательный символ и остальная часть строки до конца строки.
  3. Добавьте скобки вокруг второй группы \1 ( \2 )

Редактировать : Спасибо @manatwork за помощь в удалении 4 символов!

Онлайн тестер

Конец света
источник
2
Использование только 2 групп, кажется, достаточно. Захват 2-го и 3-го вместе.
manatwork
Да, и извините, но параметры командной строки, необходимые для изменения поведения интерпретатора по умолчанию, чтобы ваш код работал, должны быть включены в счетчик размеров. Вряд ли необходимо -eпередать код переводчику бесплатно. (Хорошо, sedбез этого тоже счастлив.) Так что для sed -re '…'вас считается +1.
manatwork
1
Пустые метки - это особенность / ошибка GNU sed, поэтому, возможно, заголовок должен быть GNU sed.
Райли
6

Медуза , 19 18 байт

P
,+>`
_  {I
/'␁'(

Символ является непечатаемым управляющим символом с байтовым значением 0x1. Попробуйте онлайн!

объяснение

Это довольно сложная программа Jellyfish, так как многие значения используются в разных местах.

  • I является необработанным вводом, читаемым из STDIN в виде строки.
  • '(это буквальный символ (.
  • {(Левая идентичность) принимает '(и в Iкачестве входных данных и возвращает '(. Возвращаемое значение фактически никогда не используется.
  • `это нить. Он модифицируется так, {чтобы возвращать символ (для каждого символа I, в результате чего получается строка (s такой же длины, что и I.
  • >хвост; он принимает строку (s в качестве входных данных и отсекает первый символ.
  • +принимает в качестве аргументов строку (s и непечатаемый байт и добавляет значение байта (1) к каждому символу. Это дает строку одинаковой длины )s. Использование символа гарантирует, что возвращаемое значение является строкой, а не списком целых чисел.
  • В левом нижнем углу /берет непечатаемый байт и возвращает функцию, которая принимает два аргумента, и объединяет второй аргумент с первым один раз (поскольку значение байта равно 1).
  • _берет эту функцию, захватывает аргументы нижнего {(которые были '(и I) и вызывает функцию с ними. Это вставляет символ (между каждой парой символов в I.
  • ,объединяет эту строку со строкой )s и Pпечатает результат.
Zgarb
источник
5

05AB1E , 22 21 19 18 байт

¤Ug<©FN¹è'(}X®')×J

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

Объяснение:

¤Ug<©FN¹è'(}X®')×J #implicit input, call it A                                 
¤U                 #push the last letter of A, save it to X
  g<©              #push the length of A, subtract 1, call it B and save it to register_c
     F     }       #repeat B times
      N¹è          #push the Nth char of A
         '(        #push '('
            X      #push X
             ®')×  #push ')' repeated B times
                 J #join together
                   #implicit print
Люк
источник
5

Vim, 17 байт

$qqha(<Esc>A)<Esc>%h@qq@q

Идет от конца к началу, потому что в противном случае вы запутаетесь в )уже написанном. Использует haвместо iпровала, когда достигает начала.

Обычно вы бы не делали две отдельные вставки, подобные этой; Вы бы сделали что-то вроде, C()<Esc>Pчтобы сохранить удар. Но на этот раз позиционирование не работает.

udioica
источник
Вы можете использовать <End>ключ в режиме вставки вместо того, чтобы выходить из режима вставки и делатьA
BlackCap
@ BlackCap Это не байт. Мне нужно считать штрихи вместо байтов. (И Vimgolf - лучшая игра, когда вы запрещаете клавиши курсора, хотя разница здесь тривиальна.)
udioica
4

> <> , 37 байт

i:0(?\'('
$,2l~/~
/?(2:<-1$')'
>~ror:

Ряд за рядом

  1. Отталкивает каждый символ от ввода с открывающей скобкой после каждого
  2. Удаляет EOF и последнюю открывающую скобку и увеличивает длину стека
  3. Использует сравнение с половиной длины стека, чтобы вставить закрывающую скобку
  4. Печатает содержимое стека

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

Emigna
источник
4

Brain-Flak 103 97 Bytes

Включает +3 для -c

{({}<><(((((()()){}()){}){}){})>)<>}<>({}<([][()]){({}[()()]<(({})()<>)<>>)}{}>){({}<>)<>}<>{}

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


Объяснение:

#reverse the stack and put a 40 between every number
{({}<><(((((()()){}()){}){}){})>)<>}<>
{                                  }   #repeat this until the stack is empty
 ({}                            )      #pop the top and push it after
    <>                                 #switching stacks and
      <(((((()()){}()){}){}){})>       #pushing a 40 (evaluated as 0) 
                                 <>    #switch back to the first stack
                                    <> #switch to the stack that everything is on now    

#put as many )s on the other stack as needed
({}                                      ) #pop the top letter and put it  back
                                           #after doing the following
                                           #This leaves ( on the top
   <                                    >  #evalute this part as 0
    ([][()])                               #push the height of the stack minus one
            {                        }    #repeat until the "height" is 0
             ({}[()()]              )     #pop the "height" and push is minus two
                      <            >      #evaluate to 0
                       (        )         #push:
                        ({})              #the top of the stack (putting it back on)
                            ()            #plus one onto
                              <>          #the other stack
                                 <>       #switch back to the other stack

                                      {}  #pop what was the height of the stack

#move the string of letters and (s back, reversing the order again
{        }     # repeat until all elements are moved
 (    )        # push:
  {}           # the top of the stack after
    <>         # switching stacks
       <>      # switch back to the other stack
          <>   # switch to the stack with the final string
            {} #pop the extra (
Райли
источник
Ударь меня к этому. +1
DJMcMayhem
Хм. Я думал, что повторное использование 40, чтобы избежать повторения большого целого числа, сэкономит вам много байтов, но лучшее, что я могу придумать, это то, {({}<><(((((()()){}()){}){}){})>)<>}<>({}<(({})<>())><>)([]){({}[()()]<(<>({})<>)>)}{}{}{({}<>)<>}<>{}что на два байта больше ...
DJMcMayhem
Спасибо, что дали мне идею повторно использовать 40. Я получил его до 95 + 3. Почему -aв Brain-Flak все равно 3 байта ?
Райли
О, хорошая работа! +3Байт является стандартным для специальных флагов командной строки . К сожалению, но я могу с этим смириться. Я на самом деле думал о том, чтобы сократить это, но я не совсем уверен, как это сделать.
DJMcMayhem
Разве это обычно не 2 байта? один за -и один за флаг? Вы можете иметь флаг для нормального выполнения, как это делает Perl -e. Таким образом, это будет только 1 дополнительный байт.
Райли
4

Фактор, 81 байт

[ [ >array [ 1string ] map "("join ] [ length 1 - [ 40 ] replicate >string ] bi ]       
кошка
источник