Triangulieren von Text

39

Schreiben Sie ein Programm oder eine Funktion, die eine Zeichenfolge enthält, die mit Ausnahme des Leerzeichens garantiert nur druckbare ASCII- Zeichen enthält und eine positive dreieckige Zahl (1, 3, 6, 10, 15, ...) ist.

Die gleiche Zeichenfolge drucken oder zurückgeben, jedoch mit Leerzeichen zu einem Dreieck geformt. Einige Beispiele zeigen am besten, was ich meine:

Wenn der Eingang ist, Rist der Ausgang

R

Wenn der Eingang ist, catist der Ausgang

 c
a t

Wenn der Eingang ist, monk3yist der Ausgang

  m
 o n
k 3 y

Wenn der Eingang ist, meanIngfu1ist der Ausgang

   m
  e a
 n I n
g f u 1

Wenn der Eingang ist, ^/\/|\/[]\ist der Ausgang

   ^
  / \
 / | \
/ [ ] \

Wenn der Eingang ist

Thisrunofcharactersismeanttohavealengththatcanbeexpressedasatriangularnumber.Diditwork?Youtellme,Ican'tcountverywell,ok?

dann wird die Ausgabe sein

              T
             h i
            s r u
           n o f c
          h a r a c
         t e r s i s
        m e a n t t o
       h a v e a l e n
      g t h t h a t c a
     n b e e x p r e s s
    e d a s a t r i a n g
   u l a r n u m b e r . D
  i d i t w o r k ? Y o u t
 e l l m e , I c a n ' t c o
u n t v e r y w e l l , o k ?

Grundsätzlich werden zwischen den dreieckigen Teilzeichenfolgen Zeilenumbrüche eingefügt, zwischen allen Zeichen Leerzeichen eingefügt und jede Zeile mit Leerzeichen eingerückt, um der Dreieckform zu entsprechen.

Eine einzelne nachgestellte Zeile und Zeilen mit nachgestellten Leerzeichen sind optional zulässig, ansonsten sollte Ihre Ausgabe genau mit diesen Beispielen übereinstimmen. Die letzte Zeile des Dreiecks sollte keine führenden Leerzeichen enthalten.

Der kürzeste Code in Bytes gewinnt.

Calvins Hobbys
quelle
Gibt es ein absolutes Maximum, das die Länge der Zeichenkette sein kann?
Geokavel
@geokavel Es sollte für jede Länge der Zeichenkette funktionieren, die Ihre Sprache normalerweise verarbeiten kann.
Calvins Hobbys
11
Hier ist ein Weihnachtsbaum für alle, die noch keinen aufgestellt haben. * / \ / | \ / | o \ / | o | \ / o | o | \ / || o | o \ / o ||| o | \ / o || o ||| \ / || o | || o | \ / | o ||| o || o \
Timmy

Antworten:

9

Pyth, 22 Bytes

jua+L\ GjdHfTczsM._UzY

Probieren Sie es online aus: Demo oder Test Suite

Erläuterung:

jua+L\ GjdHfTczsM._UzY   implicit: z = input string
                   Uz    create the list [0, 1, ..., len(z)-1]
                 ._      all prefixes of this list: [[0], [0,1], [0,1,2], ...]
               sM        sum up each sublist: [0, 1, 3, 6, 10, ...]
             cz          split z at these indices
           fT            remove all the unnecessary empty strings
                         this gives us the list of strings of the triangle
 u                   Y   reduce this list, with the initial value G = []
   +L\ G                    prepend a space to each string in G
        jdH                 join the current string with spaces
  a                         and append it to G
j                        print each string on a separate line
Jakube
quelle
12

Python, 81 Bytes

def f(s,p=''):
 i=-int(len(2*s)**.5)
 if s:f(s[:i],p+' ');print p+' '.join(s[i:])

Eine rekursive Funktion. Geht vom Ende ab s, hackt ab und druckt Zeichen. Die Anzahl der zu verwendenden Zeichen wird aus der Länge von berechnet s. Die Funktion ist so eingerichtet, dass in umgekehrter Reihenfolge der rekursiven Aufrufe gedruckt wird, die enden, wenn sie sleer sind, und dann die Sicherungskopie der Zeile auflösen. Für jede Ebene wird dem Präfix pein zusätzlicher Speicherplatz hinzugefügt.

In Python 3 ifkann dies durch Kurzschließen geschehen, obwohl dies keine Zeichen zu sparen scheint:

def f(s,p=''):i=-int(len(2*s)**.5);s and[f(s[:i],p+' '),print(p+' '.join(s[i:]))]

Eine ebenso lange Alternative mit Verkettung von Ungleichungen:

def f(s,p=''):i=-int(len(2*s)**.5);''<s!=f(s[:i],p+' ')!=print(p+' '.join(s[i:]))

Beide printund fzurück None, was schwer zu bedienen ist.

xnor
quelle
1
Das ist ziemlich schlau. Wenn Sie die Zeichenfolge zeilenweise abhacken, erhalten Sie immer noch eine dreieckige Zeichenfolge, mit der Sie die Anzahl der führenden Leerzeichen berechnen können.
xsot
6

Retina , 108 102 94 87 82 64 63 Bytes

Vielen Dank an Sp3000, der mich dazu gebracht hat, meinen ursprünglichen Ansatz zu verfolgen, bei dem die Byteanzahl von 108 auf 82 gesenkt wurde.

Ein großes Dankeschön an Kobi, der eine viel elegantere Lösung gefunden hat, mit der ich zusätzlich noch 19 Bytes einsparen konnte.

S_`(?<=^(?<-1>.)*(?:(?<=\G(.)*).)+)
.
$0 
m+`^(?=( *)\S.*\n\1)
<space>

Wobei <space>ein einzelnes Leerzeichen darstellt (das sonst von SE entfernt würde). Zu Zählzwecken wird jede Zeile in eine separate Datei geschrieben und \nsollte durch ein tatsächliches Zeilenvorschubzeichen ersetzt werden. Der Einfachheit halber können Sie den Code so ausführen, wie er aus einer einzelnen Datei mit dem -sFlag stammt.

Probieren Sie es online aus.

Erläuterung

Naja ... wie immer kann ich hier keine vollständige Einführung in die Bilanzkreise geben. Für einen Primer siehe meine Stack Overflow Antwort .

S_`(?<=^(?<-1>.)*(?:(?<=\G(.)*).)+)

Die erste Stufe ist eine SPlitstufe, die die Eingabe in Zeilen mit zunehmender Länge aufteilt. Das _bedeutet, dass leere Chunks von der Aufteilung ausgeschlossen werden sollten (dies wirkt sich nur auf das Ende aus, da an der letzten Position eine Übereinstimmung vorliegt). Die Regex selbst ist vollständig in einem Look-Around enthalten, sodass keine Zeichen, sondern nur Positionen gefunden werden.

Dieser Teil basiert auf der Lösung von Kobi mit einer zusätzlichen Golfstärke, die ich selbst gefunden habe. Beachten Sie, dass Lookbehinds in .NET von rechts nach links übereinstimmen. Daher sollte die folgende Erklärung am besten von unten nach oben gelesen werden. Ich habe \Gder Klarheit halber auch eine andere in die Erklärung eingefügt , obwohl dies nicht erforderlich ist, damit das Muster funktioniert.

(?<=
  ^         # And we ensure that we can reach the beginning of the stack by doing so.
            # The first time this is possible will be exactly when tri(m-1) == tri(n-1),
            # i.e. when m == n. Exactly what we want!
  (?<-1>.)* # Now we keep matching individual characters while popping from group <1>.
  \G        # We've now matched m characters, while pushing i-1 captures for each i
            # between 1 and m, inclusive. That is, group <1> contains tri(m-1) captures.
  (?:       
    (?<=
      \G    # The \G anchor matches at the position of the last match.
      (.)*  # ...push one capture onto group <1> for each character between here
            # here and the last match.
    )       # Then we use a lookahead to...
    .       # In each iteration we match a single character.
  )+        # This group matches all the characters up to the last match (or the beginning
            # of the string). Call that number m.
)           # If the previous match was at position tri(n-1) then we want this match
            # to happen exactly n characters later.

Ich bewundere immer noch Kobis Arbeit hier. Dies ist noch eleganter als der Prime Testing Regex. :)

Fahren wir mit der nächsten Stufe fort:

.
$0 

Ganz einfach: Fügen Sie nach jedem Zeichen ohne Zeilenvorschub ein Leerzeichen ein.

m+`^(?=( *)\S.*\n\1)
<space>

In dieser letzten Phase werden alle Linien korrekt eingerückt, um das Dreieck zu bilden. Dies mist nur der übliche mehrzeilige Modus, um eine ^Übereinstimmung mit dem Zeilenanfang herzustellen . Das +weist Retina an, diesen Schritt zu wiederholen, bis sich die Zeichenfolge nicht mehr ändert (was in diesem Fall bedeutet, dass die Regex nicht mehr übereinstimmt).

^      # Match the beginning of a line.
(?=    # A lookahead which checks if the matched line needs another space.
  ( *) # Capture the indent on the current line.
  \S   # Match a non-space character to ensure we've got the entire indent.
  .*\n # Match the remainder of the line, as well as the linefeed.
  \1   # Check that the next line has at least the same indent as this one.
)

Dies entspricht also dem Anfang einer Zeile, die keinen größeren Einzug als die nächste hat. In einer solchen Position fügen wir ein Leerzeichen ein. Dieser Vorgang wird beendet, sobald die Zeilen in einem ordentlichen Dreieck angeordnet sind, da dies das minimale Layout ist, bei dem jede Zeile einen größeren Einzug als die nächste hat.

Martin Ender
quelle
@ _ @ Was zum Teufel macht es?
n̴̖̋h̴̖̋a̷̭̿h̷̭̿d̸̡̅ẗ̵̨́
@ n̴̖̋h̷͉̃ã̷͉h̷̭̿d̷̰̀ĥ̷̳ Jetzt mit 100% mehr Erstaunlichkeit, mit freundlicher Genehmigung von Kobi.
Martin Ender
6

Candy , 67 59 57 Bytes

&iZ1-=yZ1+Z*2/>{0g}0=z@1i&{|.}bYR(" ";=)ZR(=a&{;}" ";)"\n";Y1-=ya1j

&1-8*1+r1-2/=y@1i&{|.}bYR(" ";=)ZR(=a&{;}" ";)"\n";Y1-=ya1j

&8*7-r1-2/=y@1i&{|.}bYR(" ";=)ZR(=a&{;}" ";)"\n";Y1-=ya1j

oder:

          &
         8 *
        7 - r
       1 - 2 /
      = y @ 1 i
     & { | . } b
    Y R ( "   " ;
   = ) Z R ( = a &
  { ; } "   " ; ) "
 \ n " ; Y 1 - = y a
1 j

lange Form:

stackSz
digit8    # Y = (sqrt((numCh - 1) * 8 + 1) - 1) / 2   using pythagorean
mult      # Y = (sqrt(numCh * 8 - 7) - 1) / 2  equivalent but shorter
digit7
sub
root
digit1
sub
digit2
div
popA
YGetsA
label digit1
incrZ
stackSz   # bail if we're out of letters
if
  else
  retSub
endif
stack2
pushY     # print the leading spaces (" " x Y)
range1
while
  " " printChr
  popA
endwhile
pushZ
range1      # output this row of characters (Z of them)
while
  popA
  stack1
  stackSz
  if
    printChr    # bail on unbalanced tree
  endif
  " " printChr
endwhile
"\n" printChr
pushY
digit1
sub
popA
YGetsA
stack1
digit1 jumpSub   # loop using recursion
Dale Johnson
quelle
Ja, ich fühlte Weihnachten-y.
Dale Johnson
5

CJam, 27 26 Bytes

Vielen Dank an Sp3000 für das Speichern von 1 Byte.

Lq{' @f+_,)@/(S*N+a@\+\s}h

Überraschenderweise in der Nähe von Pyth, lassen Sie uns sehen, ob dies Golf spielen kann ...

Teste es hier.

Erläuterung

L        e# Push an empty array to build up the lines in.
q        e# Read input.
{        e# While the top of the stack is truthy (non-empty)...
  ' @f+  e#   Prepend a space to each line we already have.
  _,)    e#   Get the number of lines we already have and increment.
  @/     e#   Split the input into chunks of that size.
  (S*    e#   Pull off the first chunk (the next line) and join with spaces.
  N+     e#   Append a linefeed.
  a@\+   e#   Append it to our list of lines.
  \s     e#   Pull up the other chunks of the input and join them back into one string.
}h
Martin Ender
quelle
Warum es nicht funktioniert , wenn ich ändern ' zu S???
Geokavel
@geokavel Da Ses sich um eine Zeichenfolge und nicht um ein Zeichen handelt, fwird diese Zeichenfolge anstelle der Zeilenliste zugeordnet .
Martin Ender
Das war meine Vermutung. Haben Sie eine Idee, warum S eine Saite ist?
Geokavel
@geokavel Nein, tue ich nicht.
Martin Ender
5

Ruby, 84 77 73 Bytes

->v{1.upto(n=v.size**0.5*1.4){|i|puts" "*(n-i)+v[i*(i-1)/2,i].chars*" "}}

77 Bytes

->v{0.upto(n=(v.size*2)**0.5-1){|i|puts" "*(n-i)+v[i*(i+1)/2,i+1].chars*" "}}

Reduziert einige Bytes mehr durch Entfernen der Variablen, rwie von steveverrill vorgeschlagen.

84 Bytes

->v{n=(v.size*2)**0.5-1;0.upto(n){|i|puts" "*(n-i)+v[(r=i*(i+1)/2)..r+i].chars*" "}}

Ungolfed:

->v {
  1.upto(n=v.size**0.5*1.4) { |i|
    puts" "*(n-i)+v[i*(i-1)/2,i].chars*" "
  }
}

Erste Berechnung der Dreieckszahl aus der Eingabezeichenfolge

n=v.size**0.5*1.4

dh zum Beispiel ist die Größe der Eingabezeichenfolge 120 und unsere Dreieckszahl n ist 15.

puts" "*(n-i)+v[i*(i-1)/2,i].chars*" "

In der obigen Zeile werden Leerzeichen gefolgt von einer Reihe von Zeichenfolgen gedruckt, die anhand des folgenden Musters aus der Eingabezeichenfolge abgerufen werden

[[0,0],[1,2],[3,5],[6,9]]

Verwendungszweck:

f=->v{1.upto(n=v.size**0.5*1.4){|i|puts" "*(n-i)+v[i*(i-1)/2,i].chars*" "}}
f["Thisrunofcharactersismeanttohavealengththatcanbeexpressesasatriangularnumber.Diditwork?Youtellme,Ican'tcountverywell,ok?"]
              T
             h i
            s r u
           n o f c
          h a r a c
         t e r s i s
        m e a n t t o
       h a v e a l e n
      g t h t h a t c a
     n b e e x p r e s s
    e s a s a t r i a n g
   u l a r n u m b e r . D
  i d i t w o r k ? Y o u t
 e l l m e , I c a n ' t c o
u n t v e r y w e l l , o k ?
Vasu Adari
quelle
Wow, unsere Ansätze sind sehr ähnlich, aber wir scheinen komplementäre Golfkenntnisse zu haben. Ich wusste nicht, dass ich uptokein ganzzahliges Argument benötige (mit timesSicherheit auch). Ich habe einige Ihrer Syntaxangaben in eine Überarbeitung meiner Antwort einbezogen. Der größte Tipp, den ich für Sie habe, ist, dass Sie diese Variable nicht benötigen r. Verwenden Sie einfach ein ,statt ..und die Zahl nach dem Komma ist die Gesamtzahl der zurückzugebenden Elemente und nicht das Ende des Bereichs.
Level River St
Wahr. Danke für den Tipp, ich aktualisiere meine Antwort sofort :)
Vasu Adari
4

Pyth, 27 Bytes

Js.IsSGlzWz+*-J=hZdjd<~>zZZ

                               z = input()
                               Z = 0
                               d = ' '
    sSG                        G -> tri(G)
  .I   lz                      Find the (float) input whose output is len(z).
 s                             Convert to int.
J                              Save as J.
         Wz                    while z:
               =hZ             Z += 1
            *-J  Zd            Generate J-Z spaces.
                      ~>zZ     Remove the first Z characters from z.
                     <    Z    Generate those first Z characters.
                   jd          Join on spaces.
           +                   Add the two together and print.

Test Suite

Ein interessanter Ansatz - unerlässlich und nützlich .I. Wahrscheinlich golfen.

isaacg
quelle
4

C 138, 136, 134 Bytes

Nimmt einen String als Eingabe:

j,r,k,a;f(char*s){j=strlen(s);r=k=sqrt(1+8*j)/2;for(;r--;printf("\n")){for(j=r;j--;)printf(" ");for(j=k-r;j--;)printf("%c ",s[a++]);}}
Sahil Arora
quelle
Sie haben anscheinend JavaScript mit C um 1 Byte
Mark K Cowan
@ MarkKCowan ja, anscheinend. Ich hoffe ich mache es noch kleiner! :)
Sahil Arora
@SahilArora - Sie können printf(" ")und printf("\n")durch puts(" ")und ersetzen puts("\n"). Jede Ersetzung spart Ihnen 2 Bytes. :)
Enhzflep
@enhzflep Ich habe es bereits versucht, es gab eine mehrdeutige Ausgabe!
Sahil Arora
Oh. :( Funktioniert hier auf win7 gut mit gcc 4.7.1 - Ich denke, es hängt damit zusammen, wie die printf-Ausgabe auf stdout. +1
geleert wird,
4

Ruby Ansatz 2 rev 1, 76 Bytes

->s{s=s.chars*' '
0.upto(w=s.size**0.5-1){|i|puts' '*(w-i)+s[i*i+i,i*2+2]}}

Optimiert mit Syntax-Ideen aus Vasu Adaris Antwort und einigen eigenen Wendungen.

Ruby Ansatz 2 rev 0, 93 Bytes

->s{s=s.chars.to_a.join(' ')
w=(s.size**0.5).to_i
w.times{|i|puts' '*(w-i-1)+s[i*i+i,i*2+2]}}

Ganz andere Herangehensweise. Zuerst fügen wir Leerzeichen zwischen den Zeichen der Eingabe ein. Dann drucken wir die Zeilen zeilenweise aus.

Ruby-Ansatz 1, 94 Bytes

->s{n=-1;w=((s.size*2)**0.5).to_i
(w*w).times{|i|print i/w+i%w<w-1?'':s[n+=1],-i%w==1?$/:' '}}

das endete viel länger als erwartet.

w Enthält die Anzahl der druckbaren Zeichen in der unteren Zeile oder entsprechend die Anzahl der Zeilen.

Jede Zeile enthält wWhitespace-Zeichen (die letzte Zeile ist die neue Zeile). Sie sollten diese Whitespace-Zeichen also drucken und die druckbaren Zeichen bei Bedarf einfügen.

Level River St
quelle
3

Minkolang 0,14 , 42 Bytes

(xid2;$I2*`,)1-[i1+[" "o]lrx" "$ii-1-D$O].

Probieren Sie es hier aus.

Erläuterung

(                Open while loop
 x               Dump top of stack
  i              Loop counter (i)
   d2;           Duplicate and square
      $I2*       Length of input times two
          `,     Push (i^2) <= (length of input)
            )    Close for loop; pop top of stack and exit when it's 0

1-[                              Open for loop that repeats sqrt(len(input))-1 times
   i1+[                          Open for loop that repeats (loop counter + 1) times
       " "o                      Push a space then read in character from input
           ]                     Close for loop
            l                    Push 10 (newline)
             r                   Reverse stack
              x                  Dump top of stack
               " "               Push a space
                  $i             Push the max iterations of for loop
                    i-           Subtract loop counter
                      1-         Subtract 1
                        D        Pop n and duplicate top of stack n times
                         $O      Output whole stack as characters
                           ].    Close for loop and stop.
El'endia Starman
quelle
2
So eine perfekte Byteanzahl! Gut gemacht!
TanMath
1
@ TanMath aber 42 ist keine Dreieckszahl!
Paŭlo Ebermann
3

Python 2, 88-85 Bytes

s=t=raw_input()
i=1
while s:print' '*int(len(t*2)**.5-i)+' '.join(s[:i]);s=s[i:];i+=1

Danke xnor für das Speichern von 3 Bytes.

xsot
quelle
Verdirbt eine Verkürzung nicht sdie Berechnung der Anzahl der Räume?
30.
Oh, richtig. Ich habe vor dem Absenden eine temporäre Variable entfernt, aber nicht bemerkt, dass sie den Code ungültig macht.
xsot
Was ist, wenn Sie es vorher mögen, aber ein Backup speichern S=s=raw_input()?
30.
Guter Vorschlag. Ich denke, es gibt wahrscheinlich eine kürzere Gesamtstrategie.
xsot
Durchgestrichen 88 sieht lustig aus
pinkfloydx33
3

CJam, 50 Bytes

q:QQ,1>{,{),:+}%:RQ,#:IR2ew<{~Q<>:LS*L,I+(Se[N}%}&

Probieren Sie es hier aus.

Erläuterung

q:QQ,1>{  e# Only proceed if string length > 1, otherwise just print.
,{),:}%:R e# Generates a list of sums from 0 to k, where k goes from 0 to the length of the string [0,1,3,6,10,15,21,...]
Q,#:I     e# Find the index of the length of the string in the list
R2ew<     e# Make a list that looks like [[0,1],[1,3],[3,6],...,[?,n] ]where n is the length of the string 
{~Q<>:L   e# Use that list to get substrings of the string using the pairs as start and end indices
S*        e# Put spaces between the substrings
L,I+(Se[N e# (Length of the substring + Index of string length in sum array -1) is the length the line should be padded with spaces to. Add a new line at the end.
%}& 
Geokavel
quelle
2

JavaScript (ES6), 135 Byte

w=>{r='';for(s=j=0;j<w.length;j+=s++);for(i=j=0;w[j+i];j+=++i)r+=Array(s-i-1).join` `+w.slice(j,i+j+1).split``.join` `+'<br>';return r}

De-Golf + Demo:

function t(w) {
    r = '';
    for (s = j = 0; j < w.length; j += s++);
    for (i = j = 0; w[j + i]; j += ++i) r += Array(s - i - 1).join` ` + w.slice(j, i + j + 1).split``.join` ` + '<br>';
    return r;
}

document.write('<pre>' + t(prompt()));

nicael
quelle
Was ist das Ziel von for (s = j = 0; j < w.length; j += s++);? Auch im Inneren ein <pre>, können Sie \nstatt <br>. Außerdem haben Sie vergessen zu erwähnen, dass es sich um ES6 handelt.
Ismael Miguel
Das Ziel der ersten Schleife ist es, die Länge der letzten Zeile zu zählen, um jede Zeile richtig einzurücken.
nicael
2

Java, 258 194

Golf gespielt:

String f(String a){String r="";int t=(((int)Math.sqrt(8*a.length()+1))-1)/2-1;int i=0,n=0;while(n++<=t){for(int s=-1;s<t-n;++s)r+=" ";for(int j=0;j<n;++j)r+=a.charAt(i++)+" ";r+="\n";}return r;}

Ungolfed:

public class TriangulatingText {

  public static void main(String[] a) {
    // @formatter:off
    String[] testData = new String[] {
      "R",
      "cat",
      "monk3y",
      "meanIngfu1",
      "^/\\/|\\/[]\\",
      "Thisrunofcharactersismeanttohavealengththatcanbeexpressedasatriangularnumber.Diditwork?Youtellme,Ican'tcountverywell,ok?",
    };
    // @formatter:on

    for (String data : testData) {
      System.out.println("f(\"" + data + "\")");
      System.out.println(new TriangulatingText().f(data));
    }
  }

  // Begin golf
  String f(String a) {
    String r = "";
    int t = (((int) Math.sqrt(8 * a.length() + 1)) - 1) / 2 - 1;
    int i = 0, n = 0;
    while (n++ <= t) {
      for (int s = -1; s < t - n; ++s)
        r += " ";
      for (int j = 0; j < n; ++j)
        r += a.charAt(i++) + " ";
      r += "\n";
    }
    return r;
  }
  // End golf
}

Programmausgabe:

f("R")
R 

f("cat")
 c 
a t 

f("monk3y")
  m 
 o n 
k 3 y 

f("meanIngfu1")
   m 
  e a 
 n I n 
g f u 1 

f("^/\/|\/[]\")
   ^ 
  / \ 
 / | \ 
/ [ ] \ 

f("Thisrunofcharactersismeanttohavealengththatcanbeexpressedasatriangularnumber.Diditwork?Youtellme,Ican'tcountverywell,ok?")
              T 
             h i 
            s r u 
           n o f c 
          h a r a c 
         t e r s i s 
        m e a n t t o 
       h a v e a l e n 
      g t h t h a t c a 
     n b e e x p r e s s 
    e d a s a t r i a n g 
   u l a r n u m b e r . D 
  i d i t w o r k ? Y o u t 
 e l l m e , I c a n ' t c o 
u n t v e r y w e l l , o k ? 

quelle
Sie könnten wahrscheinlich System.out statisch importieren, um einige Bytes zu sparen.
RAnders00
import static System.out;beträgt 25 Bytes und System.7 Bytes. Es wird dreimal verwendet und 21 <25, sodass die Größe tatsächlich um 4 Byte erhöht wird. Gutes Blei, statische Importe können jedoch Platz sparen, und nicht jeder kennt sie.
1
Ich habe alte Antworten durchgesehen, als ich diese fand: "Schreibe ein Programm oder eine Funktion ", die ich zuerst nicht erkannte. Das Klassenzeug platzsparend ausziehen. Ich habe es zu einer richtigen Funktion gemacht und ein paar weitere Bytes zum Abschneiden gefunden.
1

JavaScript (ES6), 106 Byte

a=>(y=z=0,(f=p=>p?" ".repeat(--p)+a.split``.slice(y,y+=++z).join` `+`
`+f(p):"")(Math.sqrt(2*a.length)|0))

Verwendet eine Rekursion anstelle einer for-Schleife, um die Zeichenfolge zu erstellen.

Um die Länge der längsten Zeile zu finden, verwendet die Formel für die n - te Dreieckszahl T_nist T_n = (n^2 + n)/2. nFür die T_nVerwendung der quadratischen Formel haben wir gegeben und gelöst :

1/2 * n^2 + 1/2 * n - T_n = 0

a = 1/2, b = 1/2, c = -T_n

-1/2 + sqrt(1/2^2 - 4*1/2*-T_n)   
------------------------------- = sqrt(1/4 + 2*T_n) - 1/2
             2*1/2

Es stellt sich heraus, dass das Hinzufügen von 1/4 innerhalb der Quadratwurzel nach dem Bodenbelag das Ergebnis nicht ändert, daher lautet die Formel für die längste Reihe Math.sqrt(2*a.length)|0.

unerschrockener Kodierer
quelle
1

TeaScript , 44 Bytes

r(m=$s(2*xn)|0)ßp.R(m-i)+x·.S(v,v+=Æw)jø+§)µ

Dies verwendet die gleiche Methode wie meine JavaScript-Antwort , ist jedoch viel kürzer.

Ungolfed

r(m=$s(2*xn)|0)m(#p.R(m-i)+xs``.S(v,v+=++w)j` `+`
`)j``
unerschrockener Kodierer
quelle
1

Powershell, 69 Bytes

($args|% t*y|?{$r+="$_ ";++$p-gt$l}|%{$r;rv r,p;$l++})|%{' '*--$l+$_}

Weniger Golf-Testskript:

$f = {

(
    $args|% t*y|?{  # test predicate for each char in a argument string 
        $r+="$_ "   # add current char to the result string
        ++$p-gt$l   # return predicate value: current char posision is greater then line num
    }|%{            # if predicate is True
        $r          # push the result string to a pipe
        rv r,p      # Remove-Variable r,p. This variables will be undefined after it.
        $l++        # increment line number
    }

)|%{                # new loop after processing all characters and calculating $l
    ' '*--$l+$_     # add spaces to the start of lines
}                   # and push a result to a pipe

}

@(
    ,("R",
    "R ")

    ,("cat",
    " c ",
    "a t ")

    ,("monk3y",
    "  m ",
    " o n ",
    "k 3 y ")

    ,("meanIngfu1",
    "   m ",
    "  e a ",
    " n I n ",
    "g f u 1 ")

    ,("^/\/|\/[]\",
    "   ^ ",
    "  / \ ",
    " / | \ ",
    "/ [ ] \ ")

    ,("Thisrunofcharactersismeanttohavealengththatcanbeexpressedasatriangularnumber.Diditwork?Youtellme,Ican'tcountverywell,ok?",
    "              T ",
    "             h i ",
    "            s r u ",
    "           n o f c ",
    "          h a r a c ",
    "         t e r s i s ",
    "        m e a n t t o ",
    "       h a v e a l e n ",
    "      g t h t h a t c a ",
    "     n b e e x p r e s s ",
    "    e d a s a t r i a n g ",
    "   u l a r n u m b e r . D ",
    "  i d i t w o r k ? Y o u t ",
    " e l l m e , I c a n ' t c o ",
    "u n t v e r y w e l l , o k ? ")

    ,("*/\/|\/|o\/|o|\/o|o|\/||o|o\/o|||o|\/o||o|||\/||o|||o|\/|o|||o||o\",
    "          * ",
    "         / \ ",
    "        / | \ ",
    "       / | o \ ",
    "      / | o | \ ",
    "     / o | o | \ ",
    "    / | | o | o \ ",
    "   / o | | | o | \ ",
    "  / o | | o | | | \ ",
    " / | | o | | | o | \ ",
    "/ | o | | | o | | o \ ")

) | % {
    $s,$expected = $_
    $result = &$f $s
    "$result"-eq"$expected"
    $result
}

Ausgabe:

True
R
True
 c
a t
True
  m
 o n
k 3 y
True
   m
  e a
 n I n
g f u 1
True
   ^
  / \
 / | \
/ [ ] \
True
              T
             h i
            s r u
           n o f c
          h a r a c
         t e r s i s
        m e a n t t o
       h a v e a l e n
      g t h t h a t c a
     n b e e x p r e s s
    e d a s a t r i a n g
   u l a r n u m b e r . D
  i d i t w o r k ? Y o u t
 e l l m e , I c a n ' t c o
u n t v e r y w e l l , o k ?
True
          *
         / \
        / | \
       / | o \
      / | o | \
     / o | o | \
    / | | o | o \
   / o | | | o | \
  / o | | o | | | \
 / | | o | | | o | \
/ | o | | | o | | o \
mazzy
quelle
0

C # 202

string r(string s,List<string> o,int i=1){o=o.Select(p=>" "+p).ToList();o.Add(String.Join(" ",s.Substring(0,i).ToCharArray()));return s.Length==i?String.Join("\n",o):r(s.Substring(i,s.Length-i),o,i+1);}

Ich weiß nicht, ob dies im Code-Golf erlaubt ist, aber zählt das Übergeben einer Liste in der Funktion? Ich kann keine Möglichkeit finden, dies zu wiederholen, ohne eine List <string>, die außerhalb der Funktion deklariert ist. Deshalb habe ich sie als Parameter angegeben.

Verwendungszweck:

 r("1",new List<string>());
 r("123", new List<string>());
 r("123456", new List<string>());
 r("Thisrunofcharactersismeanttohavealengththatcanbeexpressedasatriangularnumber.Diditwork?Youtellme,Icanstcountverywell,ok?",new List<string>());
noisyass2
quelle
0

C 102 Bytes

i,j;main(n,s){for(n=sqrt(strlen(gets(s))*2);j<n;printf("%*.1s",i>1?2:i*(n-j),i++>j?i=!++j,"\n":s++));}
xsot
quelle
0

Bash + Sed, 87

for((;i<${#1};i+=j));{
a+=(${1:i:++j})
}
printf %${j}s\\n ${a[@]}|sed 's/\S/ &/g;s/.//'
Digitales Trauma
quelle
0

R, 142 Bytes

Ich bin mir ziemlich sicher, dass ich das noch besser hinbekomme. Ich arbeite aber immer noch daran. Ich habe das Gefühl, dass mir eine einfache Rekursion fehlt - aber ich konnte sie nicht richtig verkürzen.

f=function(a){n=nchar(a);l=which(cumsum(1:n)==n);w=strsplit(a,c())[[1]];for(i in 1:l){cat(rep(" ",l-i),sep="");cat(w[1:i],"\n");w=w[-(1:i)]}}

ungolfed

f=function(a){
    n = nchar(a)                 #number of characters
    l= which(cumsum(1:n)==n)     #which triangle number
    w= strsplit(a,c())[[1]]      #Splits string into vector of characters
    for (i in 1:l) {
        cat(rep(" ",l-i),sep="") #preceeding spaces
        cat(w[1:i],"\n")         #Letters
        w=w[-(1:i)]              #Shifts removes letters (simplifies indexing)
    }
}
user5957401
quelle