Uzay savaşına karşı sekmeleri sonlandır

Bu nedenle, girintiyi biçimlendirmek / biçimlendirmek için sekmeler veya boşluklar kullanıp kullanmama konusunda çok fazla tartışma yapıldı. İnanılmaz derecede çılgın, eşsiz bir biçimlendirme yöntemine giderek, üniversitenin tartışmayı çözmesine yardımcı olabilir misiniz ?

---

İşiniz, tüm sekmeleri dört alana genişleten tam bir program veya işlev yazmaktır. Ve sonra n / n 'deki boşlukların yerini "/ (n - iki yıldız burada) /" ile değiştirir. Herhangi bir makul formatta birden fazla satırdan girdi alacaksınız (her yeni satır için tek bir dizge dizisi dizisi. Sütun dizisi dizisi vb.)

---

Örnek girişi utanmadan çalındı . Sekmeler otomatik olarak SE'de dört alana genişletildiğinden beri, onu "^" karakteri olarak temsil ediyorum, ancak sekmeleri de kullanmalısınız (kod noktası 0x09). Tüm "^" karakterleri bir tabloyu temsil eder.

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! 

Örnek çıktı

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! 

---

Üniversitenin hem Vim hem de Emacs'ı indirmek için alana ihtiyacı olduğundan, kodunuz için çok az depolama alanına izin verilir. Bu nedenle bu kod golf ve en kısa kod kazanır. Girişin iyi oluşturulduğunu ve dört boşluktan (satırların değiştirilmesinden sonra) satırların tanımsız davranışa yol açabileceğini varsayabilirsiniz.

feragat

Bu "mükemmel" biçimlendirme stratejisi Geobits'in izniyle geldi ve izniyle çoğaltıldı. Bu zorluğun üretimi sırasında hiçbir programcı zarar görmedi.

V , 21 , 20 bayt

Íô/    
Î^hr/hv0r*r/

Çevrimiçi deneyin!

Bu kelimenin tam anlamıyla vim cevabımın doğrudan bir limanı. Önemli farklar:

• Í(Küresel yedek) otomatik olarak doldurur komut /giki bayt kaydeder bayrak,

• ô özdeştir \t

• ÎBunun için bir anımsatıcıdır :%normve aynı zamanda :%normtuş takımları arasındaki gerekli boşluğu doldurur .

• Sondaki izleyen taşıyıcı dönüş örtük olarak eklenir.

Vim, 37, 34, 33, 32 bayt

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

Çevrimiçi deneyin!

Bunun, çevrimiçi tercümana olmasa da vim cinsinden takip eden bir vagon dönüşü (giriş) gerektirdiğini unutmayın.

Bu V yorumlayıcısını kullanır, çünkü geriye doğru uyumludur. Çok basit bir çözüm.

İşte çözümü gerçek zamanlı olarak görmenizi sağlayan bir gif. Bu biraz daha eski bir sürüm kullanıyor ve ne olduğunu görebilmeniz için daha yavaş çalışmasını sağlamak için bazı ek tuş vuruşlarını ekledim:

Ve işte nasıl çalıştığının açıklaması:

:%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 bayt

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

İle koş -pBayrakla , şöyle yap:

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

␉Bir sekmeyle değiştirin (Bash dilinde yazmayı deneyin Control-V Tab.)

Çedar , 60 57 56 bayt

@Conor O'Brien sayesinde 3 bayt kaydedildi

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

Keşke Cheddar daha iyi string formatlama yapsaydı.

Çevrimiçi deneyin!

açıklama

Bu bir fonksiyondur. şunun gibi şeyleri yapmanıza izin veren @işlevli bir özelliği (örn. ruby &:) gösterir: `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
 )

Eğer regex ile aşina değilseniz:

/^ +/gm

bu temelde every ( ) satırının ( ) başında ( ) bulunan bir veya daha fazla ( +) boşlukla ( ) eşleşir .^gm

Mathematica, 97 bayt

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

Anonim işlev Bir dizeyi girdi olarak alır ve dizeyi çıktı olarak döndürür.

Python 3, 124 bayt

İyi bir regex kullanır.

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

Ideone!

Java 210 207 bayt

Bu, saf bir şekilde uygulayan referans çözümdür.

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 bayt

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

\tKodunuzdaki değişmez bir sekmeyle değiştirin .

Java, 185 184 167 152 bayt

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;})

İlk yazıda verilen çok gevşek string dizilimi göz önüne alındığında, Stream<String>bazı bayt tasarrufları için izin verdim .

Aynı hedefe ulaşmak için RI'den farklı teknikler kullandım. Algoritmanın kendisi de aynıdır.

Test ve asılsız :

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);


  }
}

Retina , 25 bayt

\tGerçek bir sekme karakteri (0x09) ile değiştirilmelidir.

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

Çevrimiçi deneyin!

açıklama

\t
4$* 

Her sekmeyi dört boşlukla değiştirin.

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

(Ayrı ayrı hat Transform %eşleştirerek) 2+Nsatır başında boşluk ile değiştirerek /.../burada ...bir Nkopyası *.

Python, 125 111 bayt

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

SED (-r için 56 + 1) 57

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

⇥Sekme nerede
1. sekmeleri boşluklarla değiştirir.
2. ilk ve son ana boşluğu değiştirir /.
3. sonra /ve 0+ *s sonra ilk boşluğu *, bir eşleşme olmayana kadar ile değiştirir .

Üniversite, Emacs Lisp'teki programlar için biraz daha fazla alana izin vermeyi düşünmelidir (ya da varsayılan olarak tabifyve untabifyyalnız), çünkü Java'dan daha ayrıntılı. Ayrıca, boyutlandırma boyutu dörtten küçük olan veya C benzeri olmayan bir dilde kodlayan öğrencilere (veya öğretmenlere) de dikkat etmelidir.

Aşağıdaki çözüm 206 bayt var

(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-widthAçıkça ayarlanması gerekmediğini varsayarsak, 20 tanesini kurtarabiliriz.

(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))))))))

Ve unungolfed versiyonu şöyle görünürdü

(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)))))))))

untabifyBaşlamadan önce ilk önce bölge. Sonra, bir satırın başında boşluk görürken, onu boşluk olarak söylediği kadar uzun bir yorumla değiştiririz. Kesin olarak, eklenecek yorum, tarafından oluşturulur.

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

hangi kendisi 97 byte alır. Bazı dizeleri n kere kopyalamak için daha kısa bir çözüm oldukça takdir edilmektedir.

Ruby, 52 47 + 1 (p bayrağı) = 48 bayt

Düzenleme : Value Ink sayesinde 5 baytın tamamı kaydedildi

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

GNU sed, 66 64 + 1 (r bayrağı) = 65 bayt

Düzenleme: 1 byte az sayesinde Riley'nin önerisi .

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

Çalıştır: sed -rf formatter.sed input_file

\nBaştaki boşluklarla o satırdaki metnin geri kalanından ayrılmasının nedeni , aksi halde, bunun gibi bir yorumla başlayan bir C ++ satırının 4 gibi hatta daha basit bir satırla /* */çevrilmesidir . Sed, her giriş satırı için komut dosyasını yürüttüğünden, okumadaki desen alanında hiçbir şey tanıtılmaz./*****/s,^(/\**) ,\1*,s,^(/\**) ( */),\1*\2,\n