Конец вкладки против космической войны

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

---

Ваша задача - написать полную программу или функцию, которая расширяет все вкладки на четыре области. И затем заменяет серию из n ведущих пробелов на "/ (n - две звезды здесь) /". Вы получите ввод по нескольким строкам в любом приемлемом формате (однострочный массив строк для каждой новой строки. Массив столбцов и т. Д.)

---

Образец ввода бесстыдно украден . Обратите внимание, что поскольку в SE вкладки автоматически расширяются до четырех пробелов, я представляю их как символ «^», но вы также должны обрабатывать вкладки (кодовая точка 0x09). Все символы «^» представляют собой табуляцию.

Calculate the value 256 and test if it's zero
If the interpreter errors on overflow this is where it'll happen
++++++++[>++++++++<-]>[<++++>-]
+<[>-<
    Not zero so multiply by 256 again to get 65536
    [>++++<-]>[<++++++++>-]<[>++++++++<-]
    +>[>
        # Print "32"
        ++++++++++[>+++++<-]>+.-.[-]<
    <[-]<->] <[>>
        # Print "16"
        +++++++[>+++++++<-]>.+++++.[-]<
<<-]] >[>
    # Print "8"
    ++++++++[>+++++++<-]>.[-]<
<-]<
# Print " bit cells\n"
+++++++++++[>+++>+++++++++>+++++++++>+<<<<-]>-.>-.+++++++.+++++++++++.<.
>>.++.+++++++..<-.>>-
Clean up used cells.
[[-]<]l
^this is preceded by a tab
^^two tabs
^^^three tabs etcetera! 

Образец вывода

Calculate the value 256 and test if it's zero
If the interpreter errors on overflow this is where it'll happen
++++++++[>++++++++<-]>[<++++>-]
+<[>-<
/**/Not zero so multiply by 256 again to get 65536
/**/[>++++<-]>[<++++++++>-]<[>++++++++<-]
/**/+>[>
/******/# Print "32"
/******/++++++++++[>+++++<-]>+.-.[-]<
/**/<[-]<->] <[>>
/******/# Print "16"
/******/+++++++[>+++++++<-]>.+++++.[-]<
<<-]] >[>
/**/# Print "8"
/**/++++++++[>+++++++<-]>.[-]<
<-]<
# Print " bit cells\n"
+++++++++++[>+++>+++++++++>+++++++++>+<<<<-]>-.>-.+++++++.+++++++++++.<.
>>.++.+++++++..<-.>>-
Clean up used cells.
[[-]<]l
/**/this is preceded by a tab
/******/two tabs
/**********/three tabs etcetera! 

---

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

отказ

Эта «превосходная» стратегия форматирования была предоставлена ​​Geobits и воспроизводится с его разрешения. Никто из программистов не пострадал во время постановки этой задачи.

V , 21 , 20 байтов

Íô/    
Î^hr/hv0r*r/

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

Это буквально прямой порт моего vim-ответа. Заметные различия:

• Команда Í(Глобальная замена) автоматически заполняет /gфлаг, который сохраняет два байта

• ô идентично \t

• ÎЭто мнемоника для :%norm, и она также заполняет необходимое пространство между :%normнабором нажатий клавиш.

• Задний возврат каретки в конце добавляется неявно.

Vim, 37, 34, 33, 32 байта

:%s/\t/    /g|%norm ^hr/hv0r*r/

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

Обратите внимание, что для этого требуется возврат каретки (ввод) в vim, но не в онлайн-переводчике.

Это использует интерпретатор V, потому что он обратно совместим. Очень простое решение.

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

И вот объяснение того, как это работает:

:%s/\t/    /g           "Replace every tab with 4 spaces
|                       "AND
%norm                   "On every line:
      ^                 "  Move to the first non-whitespace char
       h                "  Move one character to the left. If there is none, the command will end here.
         r/             "  Replace it with a slash
           h            "  Move to the left
            v0          "  Visually select everything until the first column
              r*        "  Replace this selection with asterisks
                r/      "  Replace the first character with a slash

Perl, 41 байт

s,␉,    ,g;s,^  ( +),/@{[$1=~y| |*|r]}/,

Запустите с -pфлагом, вот так:

perl -pe 's,␉,    ,g;s,^  ( +),/@{[$1=~y| |*|r]}/,'
#     ↑   └───────────────────┬───────────────────┘
#     1 byte               40 bytes

Заменить ␉на вкладку (в Bash попробуйте набрать Control-V Tab.)

Чеддер , 60 57 56 байт

Сохранено 3 байта благодаря @Conor O'Brien

@.sub(/\t/g," "*4).sub(/^ +/gm,i->"/"+"*"*(i.len-2)+"/")

Я бы хотел, чтобы у Чеддера было лучшее форматирование строк.

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

объяснение

Это функция. @является функционализированным свойством представляет (например, ruby's &:), позволяя вам делать такие вещи, как: `ar.map (@. head (-1))

@                      // Input
 .sub( /\t/g, " "*4)   // Replace tabs with four spaces
 .sub(
   /^ +/gm,            // Regex matches leading spaces
   i ->                // i is the matched leading spaces
     "/"+              // The / at the beginning
     "*"*(i.len-2)+    // Repeat *s i-2 times
     "/"                // The / at the end
 )

Если вы не знакомы с регулярным выражением:

/^ +/gm

это в основном соответствует одному или нескольким ( +) пробелам ( ) в начале ( ^) каждой ( g) строки ( m).

Mathematica, 97 байт

a=StringReplace;a[a[#,"\t"->"    "],StartOfLine~~b:" "..:>"/"<>Table["*",StringLength@b-2]<>"/"]&

Анонимная функция. Принимает строку в качестве ввода и возвращает строку в качестве вывода.

Python 3, 124 байта

Использует доброе старое регулярное выражение.

import re
lambda I:re.sub('^\s*(?m)',lambda m:'/'+'*'*len(m.group()[:-2])+'/',re.sub('\t+',lambda g:' '*4*len(g.group()),I))

Идео это!

Java 210 207 байт

Это эталонное решение, которое реализует его наивно.

void a(String[]a){for(String s:a){s=s.replaceAll("\t", "    ");String x,y="";int j,i=s.length()-(x=s.replaceAll("^\\s+", "")).length();if(i>3){y="/";for(j=0;j++<i-1;)y+="*";y+="/";}System.out.println(y+x);}}

JavaScript ES6, 75 байт

s=>s.replace(/\t/g,"    ").replace(/^ +/gm,k=>`/${"*".repeat(k.length-2)}/`)

Замените \tна буквальную вкладку в вашем коде.

Ява, 185 184 167 152 байта

S->S.map(s->{s=s.replace("\t","    ");String t=s.replaceAll("^ +","");int n=s.length()-t.length();if(n>3){s="/";for(;n-->2;)s+="*";s+="/"+t;}return s;})

Учитывая очень слабое определение массива строк, данное в первоначальном посте, я использовал его, Stream<String>что позволяет сэкономить некоторые байты.

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

Тестирование и ungolfed :

import java.util.Arrays;
import java.util.stream.Stream;

public class Main {

  public static void main(String[] args) {
    StringStreamTransformer sst = lines -> lines.map(line -> {
      line = line.replace("\t","    ");
      String trimmed = line.replaceAll("^ +", "");
      int startingSpaces = line.length() - trimmed.length();
      if (startingSpaces > 3) {
        line = "/";
        for(;startingSpaces > 2; startingSpaces--) {
          line += "*";
        }
        line += "/" + trimmed;
      }
      return line;
    });


    Stream<String> lines = Arrays.stream(new String[]{
      "lots of spaces and tabs after\t\t    \t\t         \t\t\t\t\t",
      "no space",
      " 1 space",
      "  2 spaces",
      "   3 spaces",
      "    4 spaces",
      "     5 spaces",
      "      6 spaces",
      "       7 spaces",
      "        8 spaces",
      "\t1 tab",
      "\t\t2 tabs",
      "\t\t\t3 tabs"
    });
    sst.map(lines).map(s -> s.replace(" ", ".").replace("\t","-")).forEach(System.out::println);


  }
}

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

Символ \tдолжен быть заменен реальным символом табуляции (0x09).

\t
4$* 
%`^  ( +)
/$.1$**/

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

объяснение

\t
4$* 

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

%`^  ( +)
/$.1$**/

Transform каждой строки отдельно ( %) путем сопоставления 2+Nпробелов в начале строки и заменить его , /.../где ...это Nкопия *.

Python, 125 111 байт

lambda s:'\n'.join(('/'+(len(L.replace('\t',' '*4))-len(L.strip())-2)*'*'+'/'+L.strip(),L)[L[0]>' ']for L in s)

https://repl.it/DGyh/2

САС (56 + 1 для -r) 57

s/⇥/    /g;tr;:r;s,^ ( *) ,/\1/,;T;:l;s,^(/\**) ,\1*,;tl

Где ⇥находится вкладка
1. заменяет вкладки пробелами.
2. заменяет первый и последний начальный пробел на /.
3. заменяет первый пробел после /и 0+ *s на, *пока не будет совпадения.

Университет должен рассмотреть возможность предоставления немного больше места для программ в Emacs Lisp (или по умолчанию tabifyи untabifyтолько), поскольку они становятся еще более многословными, чем Java. Следует также обратить пристальное внимание на учеников (или учителей), чей размер инактивации меньше четырех или которые случайно пишут на не-C-подобном языке.

Следующее решение имеет 206 байтов

(lambda (b e)(let((tab-width 4))(untabify b e)(goto-char b)(while(re-search-forward"^ +"e t)(replace-match(format"/%s/"(apply'concat(mapcar(lambda(x)"*")(number-sequence 1(-(length(match-string 0))2)))))))))

Предполагая, что это tab-widthне должно быть явно установлено, мы можем сохранить 20 из них.

(lambda(b e)(untabify b e)(goto-char b)(while(re-search-forward"^ +"e t)(replace-match(format"/%s/"(apply'concat(mapcar(lambda(x)"*")(number-sequence 1(-(length(match-string 0))2))))))))

И негольфированная версия будет выглядеть так

(defun end-tab-war (beg end)
  (let ((tab-width 4))
    (untabify beg end)
    (goto-char beg)
    (while (re-search-forward "^ +" end t)
      (replace-match
       (format
        "/%s/"
        (apply 'concat
               (mapcar (lambda(x) "*")
                       (number-sequence 1
                                        (- (length (match-string 0))
                                           2)))))))))

Мы сначала untabifyрегион, прежде чем прыгать к его началу. Затем, пока мы видим пробел в начале строки, мы заменяем его комментарием, который равен указанному пробелу. Чтобы быть точным, комментарий для вставки построен

 (format"/%s/"(apply'concat(mapcar(lambda(x)"*")(number-sequence 1(-(length(match-string 0))2)))))

что само по себе занимает 97 байт. Более короткое решение для копирования строки n раз высоко ценится.

Ruby, 52 47 + 1 (флаг p) = 48 байт

Редактировать : сохранено целых 5 байтов, благодаря Value Ink

ruby -pe 'gsub ?\t," "*4;sub(/^ +/){?/+?**($&.size-2)+?/}'

GNU sed, 66 64 + 1 (флаг r) = 65 байт

Изменить: на 1 байт меньше по предложению Райли .

s/\t/    /g
s,^ ( *) ,/\1\n,
:
s,^(/\**) ( *\n),\1*\2,
t
s,\n,/,

Запустите: sed -rf formatter.sed input_file

Причина разделения с \nведущими пробелами от остального текста в этой строке заключается в том, что в противном случае строка C ++, начинающаяся с комментария, подобного этому, /* */превратилась бы в /*****/более простую строку типа 4 s,^(/\**) ,\1*,или даже s,^(/\**) ( */),\1*\2,. Поскольку sed выполняет сценарий для каждой строки ввода, \nпри чтении в пространство шаблона не вводится no .