Snakify a String

35

Una cadena snakified se ve así:

T AnE eOf ifi ing
h s x l A k e r
isI amp Sna dSt

Tu tarea

Tome una cadena sy un tamaño n, luego envíe la cadena snakified. Las entradas ThisIsAnExampleOfaSnakifiedStringy 3producirían el ejemplo anterior.

Presupuesto

  • s solo contendrá caracteres ASCII entre los puntos de código 33 y 126 inclusive (sin espacios ni líneas nuevas).
  • s tendrá entre 1 y 100 caracteres de longitud.
  • nes un número entero que representa el tamaño de cada segmento de cadena de salida. Cada línea de caracteres (arriba / abajo o izquierda / derecha) que forman las curvas en la "serpiente" tiene ncaracteres largos. Vea los casos de prueba para ver ejemplos.
  • n será entre 3 y 10 inclusive.
  • La cadena de salida siempre comienza a apuntar hacia abajo.
  • Se permiten espacios finales en cada línea.
  • Las nuevas líneas al final de la salida también están permitidas.
  • No se permiten espacios iniciales.
  • code-golf significa que el código más corto en bytes gana.

Casos de prueba

a 3

a

----------

Hello,World! 3

H Wor
e , l
llo d!

----------

ProgrammingPuzzlesAndCodeGolf 4

P  ngPu  Code
r  i  z  d  G
o  m  z  n  o
gram  lesA  lf

----------

IHopeYourProgramWorksForInputStringsWhichAre100CharactersLongBecauseThisTestCaseWillFailIfItDoesNot. 5

I   gramW   tStri   100Ch   gBeca   CaseW   DoesN
H   o   o   u   n   e   a   n   u   t   i   t   o
o   r   r   p   g   r   r   o   s   s   l   I   t
p   P   k   n   s   A   a   L   e   e   l   f   .
eYour   sForI   Which   cters   ThisT   FailI

----------

!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ 10

!        <=>?@ABCDE        `abcdefghi
"        ;        F        _        j
#        :        G        ^        k
$        9        H        ]        l
%        8        I        \        m
&        7        J        [        n
'        6        K        Z        o        ~
(        5        L        Y        p        }
)        4        M        X        q        |
*+,-./0123        NOPQRSTUVW        rstuvwxyz{
code-golf string ascii-art code-golf code-golf string balanced-string decision-problem code-golf string geometry grid code-golf tips lisp code-golf quine tips king-of-the-hill code-challenge math code-golf string palindrome math fastest-code code-golf string counting code-golf code-golf internet code-golf quine source-layout hello-world code-golf math number sequence arithmetic code-golf ascii-art grid code-golf number grid code-golf string crossword code-golf code-golf ascii-art grid counting code-golf code-golf math sequence arithmetic number-theory code-golf code-golf graphical-output geometry random code-golf ascii-art grid counting code-golf string ascii-art code-challenge test-battery code-golf string code-golf ascii-art kolmogorov-complexity code-golf interpreter code-golf math sequence code-golf math primes set-partitions code-golf usuario81655
fuente
Supongo que el próximo desafío será convertir una cadena de volver snakified a los 2 parámetros originales ...
abligh
@abligh No tenía más planes, pero en realidad eso suena como una idea decente. Sin embargo, podría haber algún tipo de duplicado, por lo que primero tendré que comprobarlo. ¡Manténganse al tanto!
user81655
el desafío inverso sería más divertido si la serpiente puede ser una forma arbitraria ...
abligh
@abligh ¡Eso es exactamente lo que estaba planeando hacer jaja!
user81655
@abligh ¡Listo!
user81655

Respuestas:

9

Pyth, 48 45 44 43 42 bytes

=Y0juXGZX@G~+Z-!J%/HtQ4q2J~+Y%J2@zHlzm*;lz

Pruébalo en línea.

Este enfoque hace el mismo abuso de espacios en blanco que la respuesta de Ruby.

PurkkaKoodari
fuente
3
Tachado 44 sigue siendo 44 ... todavía.
Arcturus
12

Rubí, 87 bytes

->s,n{p=0
a=(' '*(w=s.size)+$/)*n
w.times{|i|a[p]=s[i];p+=[w+1,1,-w-1,1][i/(n-1)%4]}
a}

Algunos abusos menores de la regla Trailing spaces on each line are allowed.Cada línea de salida tiene wcaracteres largos, más una nueva línea, dondew está la longitud de la cadena original, es decir, lo suficientemente larga como para contener toda la entrada. Por lo tanto, hay una gran cantidad de espacios en blanco innecesarios a la derecha para grandes n.

Sin golf en el programa de prueba

f=->s,n{
  p=0                            #pointer to where the next character must be plotted to
  a=(' '*(w=s.size)+$/)*n        #w=length of input. make a string of n lines of w spaces, newline terminated
  w.times{|i|                    #for each character in the input (index i)
    a[p]=s[i]                    #copy the character to the position of the pointer
    p+=[w+1,1,-w-1,1][i/(n-1)%4] #move down,right,up,right and repeat. change direction every n-1 characters
  }
a}                               #return a

puts $/,f['a',3]

puts $/,f['Hello,World!',3]

puts $/,f['ProgrammingPuzzlesAndCodeGolf',4]

puts $/,f['IHopeYourProgramWorksForInputStringsWhichAre100CharactersLongBecauseThisTestCaseWillFailIfItDoesNot.',5]

puts $/,f['!"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~',10]
Level River St
fuente
7

JavaScript (ES6), 143 bytes

(s,n)=>[...s].map((c,i)=>(a[x][y]=c,i/=n)&1?y++:i&2?x--:x++,a=[...Array(n--)].map(_=>[]),x=y=0)&&a.map(b=>[...b].map(c=>c||' ').join``).join`\n`

Donde \nrepresenta una nueva línea literal. Sin golf:

function snakify(string, width) {
    var i;
    var result = new Array(width);
    for (i = 0; i < width; i++) result[i] = [];
    var x = 0;
    var y = 0;
    for (i = 0; i < string.length; i++) {
       result[x][y] = string[i];
       switch (i / (width - 1) & 3) {
       case 0: x++; break;
       case 1: y++; break;
       case 2: x--; break;
       case 3: y++; break;
    }
    for (i = 0; i < width; i++) {
        for (j = 0; j < r[i].length; j++) {
            if (!r[i][j]) r[i][j] = " ";
        }
        r[i] = r[i].join("");
    }
    return r.join("\n");
}
Neil
fuente
7

Pyth, 85 74 59 bytes

Kl@Q0J0=Y*]d-+*@Q1K@Q1 1FNr1@Q1=XY-+*KNN1b;VK=XYJ@@Q0N=+J@[+K1 1-_K1 1).&3/N-@Q1 1;sY

=G@Q1=H@Q0KlHJ0=Y*]dt+*GKGFNr1G=XYt+*KNNb;VK=XYJ@HN=+J@[hK1t_K1).&3/NtG;sY

Klz=Ym;+*QKQVQ=XYt+*KhNhNb;VK=XYZ@zN=+Z@[hK1_hK1).&3/NtQ;sY

¡Gracias a @FryAmTheEggman por ayudarme mucho!

Golfé tanto como pude. Pruébalo aquí! Por alguna razón, el ajuste de línea hace que la salida sea extraña. Es posible que desee ver el resultado en la página completa

Explicación

Respira un segundo y concéntrate. Esto se puede dividir en tres secciones, como casi cualquier algoritmo "clásico".

La primera sección

Es donde se inicializan las variables. Se puede dividir en dos partes:

Klz=Ym;+*QKQ
Klz                Assign len(input[0]) to K. (length of input String)
   =Ym;+*QKQ       Assign an empty list to Y of length K*input[1]-input[1]-1, where input[1] is the size of the snake 
                   (thus the height of the final string)

la segunda parte :

VQ=XYt+*KhNhNb;
VQ                       For N in range(0, input[1]), where input[1] is the size of the snake 
  =                        Assign to Y. Y is implicit, it is the last variable we used.
   XYt+*KhNhNb               Y[K*N+N-1]="\n". Can be broken down in four parts :
   X                           Replace function. X <A: list> <B: int> <C: any> is A[B]=C
    Y                          A: The array we initialized in the first section.
     t+*KhNhN                  B: K*(N+1)+N+1 (N is the for loop variable)
             b                 C: Newline character ("\n")
              ;          End the loop.

La segunda sección

Contiene la lógica real.

VK=XYZ@zN=+Z@[hK1_hK1).&3/NtQ;
VK                                         For N in range(0, K), where K is the length of the input string (see first section)
  =                                          Assign to Y. Y is implicit, it is the last variable we used.
   XYZ@zN                                    Same as in section 2. This is a replacement function. Y[Z] = input[0][N]. Z is initially 0.
         =+Z@[hK1_hK1).&3/NtQ                Again this can be broken down :
         =+Z                                   Add to Z
             [hK1_hK1)                         Array containing directions. Respectively [K+1, 1, -K-1, 1]
            @         .&3/NtQ                  Lookup in the array, on index .&3/N-@Q1 1:
                      .&3                        Bitwise AND. .& <int> <int>
                         /NtQ                    (input[1]-1)/N, where input[1] is the size of the snake
                             ;             End the loop

La tercera sección

Esta es la parte de salida. No es realmente interesante ...

sY    Join the array Y. Implicitly print.

PRIMA

Escribí el programa pyth de este script python. 

input=["ThisIsAnExampleOfASnakifiedString", 4];
width=len(input[0]);
height=input[1];
pointer=0;
directions = [width+1,1,-width-1,1] #Respectively Down, right, up, right (left is replaced by right because of snake's nature. Doesn't go left).
output=[' ' for i in range(0, width*height+height-1)];
for N in range(1, height):
    output[width*N+N-1]="\n";
for N in range(0, len(input[0])):  
    output[pointer]=input[0][N];
    pointer+=directions[3&(N/(height-1))];
print "".join(output);
FliiFe
fuente
5

JavaScript (ES6), 122 bytes

document.write("<pre>"+(

// --- Solution ---
s=>n=>[...s].map((c,i)=>(a[p]=c,p+=[l+1,1,-l-1,1][i/n%4|0]),p=0,a=[...(" ".repeat(l=s.length)+`
`).repeat(n--)])&&a.join``
// ----------------

)("IHopeYourProgramWorksForInputStringsWhichAre100CharactersLongBecauseThisTestCaseWillFailIfItDoesNot.")(5))
Expandir fragmento

Mismo algoritmo que la respuesta de @ LevelRiverSt.

usuario81655
fuente
4

C, 138 bytes

char*h[]={"\e[B\e[D","","\e[A\e[D",""},t[999];i;main(n){system("clear");for(scanf("%s%d",t,&n),--n;t[i];++i)printf("%c%s",t[i],h[i/n%4]);}

Esto usa escapes ANSI. Funciona en terminal de linux.

Sin golf:

char*h[]={"\e[B\e[D","","\e[A\e[D",""},
    /* cursor movement - h[0] moves the cursor one down and one left,
    h[2] moves the cursor one up and one left. */
t[999];i;
main(n){
    system("clear");
    for(scanf("%s%d",t,&n),--n;t[i];++i)
        printf("%c%s",t[i],h[i/n%4]);
}
MIllIbyte
fuente
1

JavaScript (ES6), 131

Algoritmo: mapeando la posición x,yen la salida al índice en la cadena de entrada, de alguna manera como esta respuesta (no relacionada).

Tomé prestado de @LevelRiverSt el truco de mantener el ancho horizontal igual a la longitud de entrada.

a=>m=>eval('for(--m,t=y=``;y<=m;++y,t+=`\n`)for(x=0;a[x];)t+=a[2*(x-x%m)+((h=x++%(2*m))?h-m?!y&h>m?h:y<m|h>m?NaN:m+h:m-y:y)]||`.`')

Menos golf

Este fue el primer borrador de trabajo antes del golf

f=(a,n)=>{
  l=a.length
  m=n-1
  s=m*2 // horizontal period

  b=-~(~-l/s)*m // total horizontal len, useless in golfed version
  t=''
  for(y=0;y<n;y++)
  {
    for(x=0;x<b;x++)
    {
      k = x / m | 0
      h = x % s
      if (h ==0 )
        c=k*s+y
      else if (h == m)
        c=k*s+m-y
      else if (y == 0 && h>m)
        c=k*s+h
      else if (y == m && h<m)
        c=k*s+m+h
      else
        c=-1
      t+=a[c]||' '
    }
    t+='\n'
  }
  return t
}

Prueba

F=a=>m=>eval('for(--m,t=y=``;y<=m;++y,t+=`\n`)for(x=0;a[x];)t+=a[2*(x-x%m)+((h=x++%(2*m))?h-m?!y&h>m?h:y<m|h>m?NaN:m+h:m-y:y)]||` `')

function test()
{
  var n=+N.value
  var s=S.value
  O.textContent=F(s)(n)
}  

test()
#S {width:80%}
#N {width:5%}
<input id=N value=5 type=number oninput='test()'>
<input id=S 5 oninput='test()'
value='IHopeYourProgramWorksForInputStringsWhichAre100CharactersLongBecauseThisTestCaseWillFailIfItDoesNot.'>
<pre id=O></pre>
Expandir fragmento

edc65
fuente
0

Pyth, 122 bytes

=k@Q0J-@Q1 1K*4J=T*@Q1[*lkd;Vlk=Z+*%NJ/%N*J2J*/N*J2J=Y.a-+**/%N*J2J!/%NK*J2J*%NJ!/%N*J2J**!/%N*J2J/%NK*J2J XTYX@TYZ@kN;jbT

Hice una fórmula para calcular las posiciones x, y de cada carácter en función del tamaño / módulo del segmento, pero se hicieron más grandes de lo que esperaba: c

Explicación:

=k@Q0                                                                                                                     # Initialize var with the text
     J-@Q1 1                                                                                                              # Initialize var with the segment size (minus 1)
            K*4J                                                                                                          # Initialize var with the "block" size (where the pattern start to repeat)
                =T*@Q1[*lkd;                                                                                              # Initialize output var with an empty array of strings
                            Vlk                                                                                           # Interate over the text
                               =Z+*%NJ/%N*J2J*/N*J2J                                                                      # Matemagics to calculate X position
                                                    =Y.a-+**/%N*J2J!/%NK*J2J*%NJ!/%N*J2J**!/%N*J2J/%NK*J2J                # Matemagics to calculate Y position
                                                                                                          XTYX@TYZ@kN;    # Assign the letter being iterated at x,y in the output
                                                                                                                      jbT # Join with newlines and print the output

Prueba aquí

Para las fórmulas matemáticas, utilicé mod para generar indicadores 0/1 y luego lo multipliqué por un factor basado en la entrada n, agregué la hoja de cálculo con cada paso en el fragmento debajo

Mostrar fragmento de código

Barra
fuente
¿Puedes explicar los Matemagics? es decir, escribirlos de una manera más humana?
FliiFe
@FliiFe hecho c:
Rod
0

PHP, 127 126 124 120 119 118 117 110 106 bytes

Utiliza la codificación ISO-8859-1.

for(;($q=&$o[$y+=$d]||$q=~ÿ)&&~Ï^$q[$x+=!$d]=$argv[1][$a];$a++%($argv[2]-1)?:$d-=-!$y?:1)?><?=join(~õ,$o);

Ejecutar así ( -dagregado solo por estética):

php -r 'for(;($q=&$o[$y+=$d]||$q=~ÿ)&&~Ï^$q[$x+=!$d]=$argv[1][$a];$a++%($argv[2]-1)?:$d-=-!$y?:1)?><?=join(~õ,$o);' "Hello W0rld!" 3 2>/dev/null;echo

Sin golf:

// Iterate over ...
for (
    ;
    // ... the characters of the input string. Prepend `0` so a 0 in the input
    // becomes truthy.
    0 . $char = $argv[1][$a];

    // Use modulo to determine the end of a stretch (where direction is
    // changed).
    // Change direction (`0` is right, `-1` is up and `1` is down). When
    // y coordinate is `0`, increment the direction, else decrement.
    $a++ % ($argv[2] - 1) ?: $direction += $y ? -1 : 1
)

    (
        // Increase or decrease y coordinate for direction -1 or 1 respectively.
        // Check whether the array index at new y coordinate is already set.
        $reference =& $output[$y += $direction] ||
        // If not, create it as a string (otherwise would be array of chars).
        // Null byte, won't be printed to prevent leading char.
        $reference = ~ÿ;

        // Increment x coordinate for direction 0. Set the output char at the
        // current coordinates to the char of the current iteration.
    ) & $reference[$x += !$direction] = $char;

// Output all lines, separated by a newline.
echo join(~õ, $output);

Ajustes

  • Guardado un byte usando en <lugar de!=
  • Ahorré 2 bytes configurando la cadena al 0principio, por lo que no tengo que anteponer otro 0(en caso de que la primera salida en una línea fuera a 0), produciendo verdad 00.
  • Guardado 4 bytes usando una referencia en lugar de repetir $o[$y]
  • Se guardó un byte usando el módulo en lugar de ==comparar la dirección con 1 para cambiar la coordenada x
  • Se guardó un byte al eliminar el tipo de conversión nullaint de desplazamiento de cadena, como se echa a compensar int todos modos cuerdas
  • Guardado un byte mediante el uso de etiqueta de impresión corta
  • Ahorró 7 bytes al mejorar la lógica de dirección
  • Se guardaron 4 bytes asignando directamente el carácter para evitar intermedios $c
aross
fuente