задача

Ваша задача - преобразовать строки следующим образом:

abc^d+ef^g + hijk^l - M^NO^P (Ag^+)

Для таких строк:

   d   g       l    N P    +
abc +ef  + hijk  - M O  (Ag )

Что является приближением к abc ^d + ef ^g + hijk ^l - M ^N O ^P (Ag ⁺ )

Словами, поднимите символы непосредственно рядом с символами в верхней строке, один символ на один символ.

Спекуляции

• Допускаются дополнительные конечные пробелы в выводе.
• Никакие цепочки, такие как цепочки, m^n^oне будут введены в качестве входных данных.
• За кареткой не последует сразу пробел или другая каретка.
• Перед кареткой не будет сразу пробела.
• Перед всеми каретками должен стоять хотя бы один символ, а за ним - хотя бы один.
• Входная строка будет содержать только печатные символы ASCII (U + 0020 - U + 007E)
• Вместо двух строк вы можете вывести массив из двух строк.

Для тех, кто говорит регулярное выражение: входная строка будет соответствовать этому регулярному выражению:

/^(?!.*(\^.\^|\^\^|\^ | \^))(?!\^)[ -~]*(?<!\^)$/

Leaderboard

var QUESTION_ID=86647,OVERRIDE_USER=48934;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

V , 15 14 байт

ÄÒ +òf^xxé kPj

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

Довольно простое решение. Идеальный вызов для V!

Объяснение:

Ä                "Duplicate this current line
 Ò               "Replace this line with spaces
   +             "Move to the beginning of the next line
    ò         ò  "Recursively (The second ò is implicit):
     f^          "  Find a caret
       xx        "  Delete two characters. The second will be saved into the main register
         é       "  Insert a space
           k     "  Move up
            P    "  Paste from the main register
             j   "  Move down

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

Чеддер, 77 72 67 байт

l->l.chars.vfuse.replace("^\n"," ").lines.map(j->"%-2s"%j).turn(3)

Нет регулярных выражений!

Мне нравится этот ответ, так как он является прекрасной демонстрацией способностей Чеддера. Главным образом благодаря функции замены, добавленной Conor. PR для dev никогда не создавался, поэтому функция замены существует только в этой ветке (обновление: я сделал PR, и теперь он в последней бета-ветке, с которой вы можете установить npm install -g cheddar-lang)

Я нашел способ игры в гольф, но, к сожалению, недосмотр приводит к тому, что это происходит, когда длина предметов не одинакова:

["   denifednud   denifednug       denifednul    denifednuN denifednuP    denifednu+ ", "abcdenifednu +efdenifednu  + hijkdenifednu  - Mdenifednu Odenifednu  (Agdenifednu )"]

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

объяснение

l->                    // Function take input as `l`
   l.chars             // Get array of chars in input
   .vfuse              // Join with newlines
   .replace("^\n"," ") // Replace `^\n` with a space globally
   .lines              // Get the lines (see below for more details on what this returns)
   .map(j->            // Loop through each "line" `j` is arg
       "%-2s"          // C-like printf format.
                       // think of as: padRight(j, " ", 2)
                       // see below for more details
        % j            // Pass j as the string to insert
   ).turn(3)           // Turn the string 270 degrees (see below)
   .vfuse              // Vertically fuse to get result (this is not needed as we can output an array of the lines)

Чтобы лучше понять. Это то, что .linesвозвращается для1^2

["1", " 2"]

.turnс поворотом этим:

1
 2

в:

 2
1

Еще один пример, который сделает это более понятным:

1
 2
2
 2

будет выглядеть так:

 2 2
1 2

Почему формат?

То, что %-2sделает, довольно просто. %указывает, что мы запускаем «формат», или что переменная будет вставлена ​​в эту строку в этой точке. -означает правую строку, и 2это максимальная длина. По умолчанию он дополняется пробелами. sпросто указывает, что это строка. Чтобы увидеть, что он делает:

"%-2s" % "a"  == "a "
"%-2s" % " a" == " a"

Perl, 21 + 1 = 22 байта

say'';s/\^(.)/♥[A\1↓/

Беги с -pфлагом. Замените ♥необработанным ESCбайтом ( 0x1b) и ↓вертикальной вкладкой ( 0x0b).

Вертикальная вкладка - идея Мартина Эндера. Это спасло два байта! Спасибо.

JavaScript (ES6), 56 55 байт

s=>[/.(\^(.))?/g,/\^.(())/g].map(r=>s.replace(r,' $2'))

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

Редактирование: 1 байт сохранен благодаря @Lynn, который разработал способ повторного использования строки замены для второй замены, позволяющей отображать замену в массиве регулярных выражений.

Python 3, 157 101 98 85 83 74 байта

Это решение отслеживает, был ли предыдущий символ ^, а затем решает, выводить ли в первую или вторую строку, основываясь на этом.

Выходы в виде массива ['firstline', 'secondline'].

a=['']*2
l=0
for c in input():x=c=='^';a[l]+=c*x;a[~l]+=' '*x;l=x
print(a)

Сохранено 13 15 байт благодаря @LeakyNun!

Сохранено 7 байтов благодаря @Joffan!

Python 2, 73 байта

l=['']*2;p=1
for c in input():b=c!='^';l[p]+=c*b;l[~p]+=' '*b;p=b
print l

Нет регулярных выражений Помнит, был ли предыдущий символ ^, и поместите текущий символ в верхнюю или нижнюю строку, основываясь на этом, и пробел в другом.

Pyth, 17 байт

CcsmX~Z1j;d;cQ\^2

             Q      input string
            c \^    split on '^'
   m                map for sections d:
    X      ;          insert a space at index:
     ~Z1                the old value of Z (initially 0), before setting Z to 1
                      into:
        j;d             the section joined on spaces
  s                 concatenate
 c              2   chop into groups of 2
C                   transpose

Возвращает массив из 2 строк. (Готовьтесь jприсоединиться к ним с новой строкой.)

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

MATL , 18 байт

94=t1YSt~&vG*cw~Z)

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

94=    % Take input implicitly. Create logical array of the same size that contains
       % true for carets, false otherwise
t      % Push a copy of this array
1YS    % Circularly shift 1 unit to the right. This gives an array that contains true
       % for the elements right after a caret (superindices), and false for the rest 
t~     % Push a copy and negate
&v     % Concatenate vertically. This gives a 2D, 2-row array
G*     % Push the input again, multiply with broadcast. This gives a 2D array in
       % which the first row contains the superindices (characters after a caret)
       % and 0 for the rest; and the second row contains the non-superindices and
       % 0 for the superindices
c      % Convert to char
w      % Swap. Brings to top the array containing true for carets and false otherwise
~      % Negate
Z)     % Use as logical index to remove rows that contain carets. Display implicitly

Рубин, 47 + 1 ( -nфлаг) = 48 байт

puts$_.gsub(/\^(.)|./){$1||" "},gsub(/\^./," ")

Запустите это так: ruby -ne 'puts$_.gsub(/\^(.)|./){$1||" "},gsub(/\^./," ")'

Питон (2), 76 68 67 байт

-5 байт благодаря @LeakyNun

-3 байта благодаря @ KevinLau-notKenny

-1 байт благодаря @ValueInk

-0 байт благодаря @DrGreenEggsandIronMan

import re
lambda i,s=re.sub:[s("(?<!\^).\^?"," ",i),s("\^."," ",i)]

Эта анонимная лямбда-функция принимает входную строку в качестве единственного аргумента и возвращает две выходные строки, разделенные новой строкой. Чтобы назвать его, дайте ему имя, написав перед ним "f =".

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

Выпуклый, 24 байта

®(?<!\^).\^?"SòNê®\^."Sò

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

Сетчатка, 16 байт

S`^
\^(.)
♥[A$1↓

Порт моего Perl-ответа, на который указал Мартин Эндер. Заменить ♥на необработанный ESCbyte ( 0x1b) и ↓вертикальную табуляцию ( 0x0b).

shell + TeX + catdvi, 51 43 байта

tex '\empty$'$1'$\end'>n;catdvi *i|head -n2

Использует texнабор красивой математики, а затем использует catdviдля создания текстового представления. Команда head удаляет ненужную информацию (нумерацию страниц, завершающие символы новой строки), которая в противном случае присутствует.

Изменить: Зачем долго, правильно, вещь и перенаправление, /dev/nullкогда вы можете игнорировать побочные эффекты и писать в один файл письма?

пример

Входные данные: abc^d+ef^g + hijk^l - M^NO^P (Ag^+)

Вывод TeX (обрезается до уравнения): Окончательный вывод:

   d   g     l  N P   +
abc +ef +hijk -M O (Ag )

Допущения: начинайте с пустого dir (или, в частности, dir без имени, оканчивающегося на «i»). Ввод - это единственный аргумент скрипта оболочки. Ввод не является пустой строкой.

Кто-то скажет мне, особенно если это нарушение правил catdvi.

Haskell, 74 56 55 байт

g('^':c:r)=(c,' '):g r
g(c:r)=(' ',c):g r
g x=x
unzip.g

Возвращает пару строк. Пример использования: unzip.g $ "abc^d+e:qf^g + hijk^l - M^NO^P: (Ag^+)"->(" d g l N P + ","abc +e:qf + hijk - M O : (Ag )")

g создает список пар, где первый элемент - это символ в верхней строке, а второй элемент - это символ в нижней строке. unzipпревращает его в пару списков.

Редактировать: @xnor предложил unzipсохранить 18 байтов. @Laikoni нашел еще один байт для сохранения. Благодарность!

Perl, 35 байт

34 байтов код + 1 для -p

$_=s/\^(.)|./$1||$"/ger.s/\^./ /gr

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

perl -pe '$_=s/\^(.)|./$1||$"/ger.s/\^./ /gr' <<< 'abc^d+ef^g + hijk^l - M^NO^P (Ag^+)'
   d   g       l    N P    + 
abc +ef  + hijk  - M O  (Ag )

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

Java 8 лямбда, 132 128 112 символов

i->{String[]r={"",""};for(char j=0,c;j<i.length();j++){c=i[j];r[0]+=c==94?i[++j]:32;r[1]+=c==94?32:c;}return r;}

Версия без гольфа выглядит так:

public class Q86647 {

    static String[] printExponents(char[] input) {
        String[] result = {"",""};
        for (char j = 0, c; j < input.length(); j++) {
            c = input[j];
            result[0] += c == 94 ? input[++j] : 32;
            result[1] += c == 94 ? 32 : c;
        }
        return result;
    }
}

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

Обновления

Заменены символы с их значениями ascii, чтобы сохранить 4 символа.

Спасибо @LeakyLun за указание использовать вместо него массив символов.

Также благодаря @KevinCruijssen для переключения intна , charчтобы сохранить еще несколько символов.

Кокос , 122 114 96 байт

Изменить: 8 26 байтов вниз с помощью Leaky Nun.

def e(s,l)=''==l and s or"^"==l[0]and l[1]+e(s+' ',l[2:])or' '+e(s+l[0],l[1:])
f=print..e$('\n')

Итак, как я узнал сегодня, у python есть троичный условный оператор, или фактически два из них: <true_expr> if <condition> else <false_expr>и <condition> and <true_expr> or <false_expr>последний из них идет с одним символом меньше.
Версия, соответствующая Python, может быть идеально .

Первая попытка:

def e(s,l):
 case l:
  match['^',c]+r:return c+e(s+' ',r)
  match[c]+r:return' '+e(s+c,r)
 else:return s
f=print..e$('\n')

Звонок с f("abc^d+ef^g + hijk^l - M^NO^P (Ag^+)")принтами

   d   g       l    N P    +
abc +ef  + hijk  - M O  (Ag )

Кто-нибудь пробовал еще играть в кокос? Он обогащает Python более функциональными концепциями программирования, такими как сопоставление с образцом и конкатенация функций (с ..), использованными выше. Поскольку это моя первая попытка кокосового ореха, любые советы будут оценены.

Это, безусловно, может быть сокращено, так как любой допустимый код Python также является допустимым, и более короткие ответы Python были опубликованы, однако я попытался найти чисто функциональное решение.

Дьялог АПЛ, 34 байта

{(0 1=⊂b/¯1⌽b){⍺\⍺/⍵}¨⊂⍵/⍨b←⍵≠'∧'}

Возвращает двухэлементный вектор с двумя строками

Пробный прогон (вверху - форматирование двухэлементного вектора для потребления человеком):

      ↑{(0 1=⊂b/¯1⌽b){⍺\⍺/⍵}¨⊂⍵/⍨b←⍵≠'∧'}'abc∧d+ef∧g + hijk∧l - M∧NO∧P (Ag∧+)'
   d   g       l    N P    + 
abc +ef  + hijk  - M O  (Ag )

PowerShell v2 +, 88 83 байта

-join([char[]]$args[0]|%{if($c){$_;$b+=' '}elseif($_-94){$b+=$_;' '}$c=$_-eq94});$b

Немного дольше, чем другие, но демонстрирует немного магии PowerShell и немного другую логику.

По сути, та же концепция, что и в Python, - мы перебираем вводимую букву за символом, помним, был ли предыдущая каретка ( $c), и помещаем текущий символ в соответствующее место. Однако логика и метод определения, куда выводить, обрабатываются немного по-другому и без кортежа или отдельных переменных - мы проверяем, был ли предыдущий символ кареткой, и если да, выводим символ в конвейер и объединяем пробел в $b, В противном случае мы проверяем, является ли текущий символ символом каретки, elseif($_-94)и, если это не так, мы объединяем текущий символ $bи выводим пробел в конвейер. Наконец, мы устанавливаем, является ли текущий персонаж кареткой для следующего раунда.

Мы собираем эти символы из конвейера вместе в паранах, инкапсулируем их в a, -joinчто превращает их в строку, и оставляем это вместе с$b конвейером. Вывод в конце неявный с новой строкой между ними.

Для сравнения вот прямой порт ответа Python @ xnor , 85 байтов :

$a=,''*2;[char[]]$args[($l=0)]|%{$a[!$l]+="$_"*($c=$_-ne94);$a[$l]+=' '*$c;$l=!$c};$a

Гема, 42 41 персонажа

\^?=?@set{s;$s }
?=\ @append{s;?}
\Z=\n$s

Gema обрабатывает ввод как поток, поэтому вы должны решить его за один проход: первая строка записывается сразу после обработки, вторая строка собирается в переменную $ s, а затем выводится в конце.

Образец прогона:

bash-4.3$ gema '\^?=?@set{s;$s };?=\ @append{s;?};\Z=\n$s' <<< 'abc^d+ef^g + hijk^l - M^NO^P (Ag^+)'
   d   g       l    N P    +  
abc +ef  + hijk  - M O  (Ag )

Корица, 21 байт

0000000: 5306 6533 bd92 d1db 8899 8381 a2f8 8f8c  S.e3............
0000010: 1230 249e a1                             .0$..

Неконкурирующий. Попробуйте онлайн.

объяснение

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

Строка распаковывается в:

S(?<!\^)[^^]& &\^&`S\^.& 

(обратите внимание на завершающий пробел)

Первый Sэтап получает входные данные и использует отрицательный вид сзади, чтобы заменить все символы, кроме кареток, без предшествующей каретки пробелом, а затем удаляет все каретки. Затем он немедленно выводит измененную входную строку с новой строкой и удаляет этот Sэтап. Так как STDIN теперь исчерпан, и предыдущий этап не предоставил никакой информации, следующийS этап снова получает последнюю строку STDIN, а затем заменяет все символы вставки, за которыми следует любой символ, пробелом и выводит их.

В Perl псевдо-код:

$first_stage_sub_1 = ($input =~ s/(?<!\^)[^^]/ /gr);
$first_stage_sub_2 = ($first_stage_sub_1 =~ s/\^//gr);
print $first_stage_sub_2, "\n";

$second_stage_sub = ($input =~ s/\^./ /gr);
print $second_stage_sub, "\n";

J , 28 27 байт

0|:t#]{."0~_1-_1|.t=.'^'~:]

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

                  t=.'^'~:]    0 for ^, 1 for the rest, define t
              _1|.             Shift right, now zeroes are for superscripts         
     ]{."0~_1-                 Prepend that many spaces to each character
   t#                          Remove the rows with carets
0|:                            Transpose

Должен быть лучший способ ...