Użytkownicy wcięć w przestrzeni, łączcie się ! Musimy walczyć ze wszystkimi małymi użytkownikami kart !

Twoim zadaniem (jeśli zdecydujesz się to zaakceptować) jest napisanie programu lub funkcji, która przyjmuje dwa argumenty:

• Ciąg: To jest dane wejściowe.
• Dodatnia liczba całkowita: liczba spacji na tabulator.

Musisz przejść przez każdą linię łańcucha i zastąpić każdą tabulację używaną do wcięcia podaną liczbą spacji, a każdą tabulację nieużywaną do wcięcia (np. W środku linii) jedną spacją.

Zauważ, że linie takie jak \t \tabcniezdefiniowane zachowanie; zostały one wstawione przez użytkowników karty zła, aby skomplikować twoje programy.

Według Tabs Must Die Society, twój program musi być tak krótki, jak to możliwe, aby uniknąć wykrycia przez złych użytkowników kart.

Przykład

\t służy tutaj do reprezentowania kart.

Ciąg wejściowy:

a
\t\tb\tc
d

Wpisz numer:

4

Wydajność:

a
        b c
d

Środkowa linia była wcięta 8 spacjami, po 4 na tabulację (ponieważ podana liczba to 4).

Ciąg wejściowy:

\ta\t\tb

Wpisz numer:

4

Wydajność:

    a  b

UWAGA: To nie duplikat wyzwanie ekspansji zakładka ; wymaga bardzo innego formatu wejściowego i nieco innych wymagań.

CJam, 30 24 23 bajtów

q{_9=NA=Seasi*' ?@?:N}/

Zwykle odmawiam zamieszczania złośliwego kodu w Internecie…

Jest to pełny program, który wczytuje ciąg ze STDIN i liczbę jako argument wiersza poleceń.

Wypróbuj online w interpretatorze CJam .

Jak to działa

q                        Read all input from STDIN.
 {                   }/  For each character C in the input:
  _9=                      Push 1 if C is a tab and 0 otherwise.
     NA=                   See below.
        Seasi*             Push a string of W spaces, where W is the integer from
                           the command-line arguments.
              '            Push a spaces character.
                ?          Select the string if NA= pushed a truthy value, the
                           single space otherwise.
                 @         Rotate C on top of the stack.
                  ?        Select the string of spaces or the single space if _9=
                           pushed 1, the character C otherwise.
                   :N      Save the result in N.

Co NA=robi:

• Dla pierwszego znaku Nbędzie zawierać jego wartość domyślną, tj "\n". Ciąg .

  Dla wszystkich kolejnych znaków Nbędzie zawierał wynik ostatniej iteracji, tj. Ostatni znak z wejścia, znak spacji lub ciąg jednej lub więcej spacji.

• Jeśli Njest łańcuchem, NA=wybiera element o indeksie 10 N (zawijanie). Wynikiem będzie spacja lub znak przesunięcia wiersza. Oba są prawdą.

  Jeśli N jest znakiem, NA=popycha 1, aby przesunąć linię, a 0 w przeciwnym razie.

• Z tego powodu NA=przesunie prawdziwą wartość dla pierwszego znaku, znaku poprzedzonego linią znaków lub znaku poprzedzonego ciągiem spacji (wcięcie, które zostało już zastąpione).

  We wszystkich pozostałych przypadkach (w tym tabulator, który został zastąpić spacją charakteru ), NA=będzie apelować wartość falsy.

K5, 53 45 bajtów

{{,/(b+a&~b:x*&\a:9=y){$[x;x#" ";y]}'y}[x]'y}

W akcji:

  {{,/(b+a&~b:x*&\a:9=y){$[x;x#" ";y]}'y}[x]'y}[4;(,"a";"\t\tb\tc";,"d")]
(,"a"
 "        b c"
 ,"d")

Chcę tylko, aby dokumentacja wykazała, że ​​to pytanie jest moralnie naganne.

Perl, 23 bajty

Kod 22 bajtów + wiersz poleceń 1 bajt

Mam nadzieję, że nie jest zbyt bezczelny, aby przyjąć, że dane liczbowe można podać za pomocą parametru -i! Upewnij się, że \ t w poniższym kodzie zastąpiono rzeczywistym znakiem tabulacji.

s/\G\t/$"x$^I/ge;y/\t/ /

Przykład użycia:

printf "a\n\t\tb\tc\nd" | perl -p entry.pl -i4

Lub dla wygody:

printf "a\n\t\tb\tc\nd" | perl -pe 's/\G\t/$"x$^I/ge;y/\t/ /' -i4

Wyjaśnienie:

Użycie -pargumentu spowoduje wykonanie programu dla każdej linii na wejściu, a następnie wydrukowanie wyniku na końcu.

W powyższym przykładzie podstawienie wyrażenia regularnego zastępuje \G\tsię " "x4(spacja powtórzona czterokrotnie). \Gjest mało znaną konstrukcją wyrażeń regularnych, która pasuje do pozycji pierwszego dopasowania, jeśli pierwsza iteracja, lub z pozycji poprzedniego dopasowania, jeśli nie jest to pierwsza iteracja, co oznacza, że ​​zastąpi tylko wszystkie tabulatory na początku łańcucha i będzie rób to jeden po drugim. Po y/\t/ /prostu zamienia wszystkie pozostałe zakładki spacjami.

Julia, 69 59 bajtów

f(s,n)=(r=replace)(r(s,r"^\t*"m,i->" "^endof(i)n),"\t"," ")

Nie golfowany:

function f(s::String, n::Int)
    # Replace the leading indentation tabs
    r1 = replace(s, r"^\t*"m, i -> " "^endof(i)n)

    # Replace any remaining tabs between words
    r2 = replace(r1, r"\t", " ")

    # Return
    r2
end

Zaoszczędziłem 10 bajtów i naprawiłem problem dzięki Glen O!

Haskell, 82 bajty

n!('\t':x)=([1..n]>>" ")++n!x
n!x=f<$>x
f '\t'=' '
f x=x
g n=unlines.map(n!).lines

Więc g 3 "a\n\t\tb\tc\nd"robi to.

Mathematica, 42 37 bajtów

Dzięki @ LegionMammal978 za wiele sugestii dotyczących oszczędzania kodu. Pierwszy parametr #dotyczy tekstu wejściowego, drugi parametr - #2liczby spacji na tabulatorze.

StringReplace[#,"\t"->" "~Table~{#2}]&

Ruby 49 bajtów

def r s,t;s.gsub! /^\t/,' '*t;s.gsub!"\t",' ';end

JavaScript (ES6), 70

Używając ciągów szablonów, nowa linia jest znacząca i zliczana

(s,n,r=n)=>[...s].map(c=>c<`
`?` `.repeat(r):(r=c<` `?n:1,c)).join``

Przetestuj poniższy fragment kodu w przeglądarce Firefox.

F=(s,n,r=n)=>[...s].map(c=>c<`
`?` `.repeat(r):(r=c<` `?n:1,c)).join``

// TEST
out=x=>O.innerHTML+=x+'\n\n'

out('Input: "A\\n\\t\\tB\\tC\\nD" 4\nOutput:\n'+F('A\n\t\tB\tC\nD',4))

out('Input: "\\tA\\t\\tB" 4\nOutput:\n'+F('\tA\t\tB', 4))

<pre id=O></pre>

CoffeeScript, 72 bajty

(s,n)->s.replace(/^\t+/mg,(m)->" ".repeat(m.length*n)).replace /\t/g," "

(Próbowanie gry w golfa co najmniej 2 kolejne brania, aby pokonać rozwiązanie ES6 ... Pomoc doceniona: D)

Stosowanie:

f=(s,n)->s.replace(/^\t+/mg,(m)->" ".repeat(m.length*n)).replace /\t/g," "
str="""
My nice\tString
\tIndent <--
\t\tDouble
""" #\t is recognized as tab by CS
alert(f(str,4))

Siatkówka, 42 bajty

Wszystkie wystąpienia .są spacjami, wszystkie \tsą literami (1 bajt) i <empty>reprezentują pusty plik. To tylko dla czytelności. Nie jestem też do końca pewien, czy poprawnie wykonuję pętlę, ale tak myślę. Każda linia powinna być umieszczona we własnym pliku. Dodałem 1 bajt dla każdego dodatkowego pliku.

Zakłada się, że wejście ma wartość Unary w swoim własnym wierszu na końcu wejścia.

(1*)$
_$1
m+`(?<!^|\t)\t
.
(`1$
<empty>
)`\t
\t.
\t|_
<empty>

Wyjaśnienie

Dodaję _przed wejściem Unary, aby rozgraniczać je podczas zamiany, aby nie usuwać żadnych ciągów wejściowych z ciągu wejściowego. Następnie zastępuję wszystkie tabulatory nie na początku wiersza pojedynczym odstępem. Następnie zapętlam, usuwając pojedynczy 1i dodając pojedynczą spację po każdej karcie, aż zabraknie danych wejściowych. Na koniec sprzątam usuwając zakładki i podkreślenia.

Python, 72 68 bajtów

Tabulatory to dosłowne tabulatory (1 bajt), więc r'...'nie są potrzebne. Niestety, Python wymaga podglądu / podglądu o stałej szerokości, więc nie mogę go używać (?<!^|\t). Używa prawie tej samej metody, co moje rozwiązanie Retina.

import re
lambda s,n:re.sub('\t',' '*n,re.sub('(?<!^)(?<!\t)\t',' ',s))

Stax , 20 bajtów

ÜR╧█╧╫≡eX,)~σOÜ¢G╩N‼

Uruchom i debuguj

Ten program odczytuje pierwszy wiersz jako szerokość wcięcia, a resztę danych wejściowych jako program.

Japt v2.0a0, 17 bajtów

r/^\t+/m_çVçÃr\tS

Spróbuj

Haskell , 75 bajtów

s#m|let('\t':r)#n=(' '<$[1..n])++r#n;(x:r)#n=x:r#(m^sum[1|x<' ']);e#_=e=s#m

Wypróbuj online! Zakłada się, że dane wejściowe zawierają tylko drukowalne znaki, a także tabulatory i znaki nowej linii, co dopuszcza OP w komentarzach.

Wyjaśnienie:

Funkcja zewnętrzna #pobiera ciąg si liczbę mi wywołuje wewnętrznie zdefiniowaną #funkcję lokalną z tymi samymi argumentami. Odbywa się to w celu śledzenia pierwotnej mwartości, ponieważ #funkcja wewnętrzna zmienia liczbę:

• ('\t':r)#n=(' '<$[1..n])++r#nJeśli napotkasz kartę, zastąp ją nspacjami i pozostaw nbez zmian.
• (x:r)#n=x:r#(m^sum[1|x<' '])Jeśli xnapotkasz kartę, która nie jest kartą, zachowaj ją taką, jaka jest, ale ustaw noryginalną liczbę, mjeśli xjest to nowa linia, lub w 1przeciwnym razie. Odbywa się to poprzez m^sum[1|x<' ']: mprzeniesienie do potęgi, sum[1|x<' ']która ocenia, 1kiedy xjest mniejsza niż spacja (tj. Nowa linia), więc otrzymujemy m^1 = m. W przeciwnym razie jest 0i mamy m^0 = 1.

Java 11, 134 bajty

n->s->{var r="";for(var p:s.split("\n")){for(;p.charAt(0)==9;p=p.substring(1))r+=" ".repeat(n);r+=p+"\n";}return r.replace('\t',' ');}

Wypróbuj online.
UWAGA: Java 11 nie jest jeszcze w TIO, więc " ".repeat(n)została emulowana jako repeat(" ",n)zamiast (z tą samą liczbą bajtów).

Wyjaśnienie:

n->s->{                 // Method with integer & String parameters and String return-type
  var r="";             //  Result-String, starting empty
  for(var p:s.split("\n")){
                        //  Loop over the rows (split by new-lines)
    for(;p.charAt(0)==9;//   Inner loop as long as the current row starts with a tab
       p=p.substring(1))//     After every iteration: remove the first character (tab)
      r+=" ".repeat(n); //    Append `n` amount of spaces to the result-String
    r+=p+"\n";}         //   Append the rest of the row with a newline to the result
  return r.replace('\t',' ');} 
                        //   Replace any remaining tabs with a space, and return the result