Era solo un error de entrada

17

Continuando con mi solo fue un desafío de error :

Entrada:

Una cadena que consta de caracteres ASCII imprimibles sin espacios en blanco ni líneas nuevas.

Salida:

Primero convierta la entrada en un palíndromo al revertir la entrada y agregarla antes de sí misma, excluyendo el carácter del medio (es decir, con una entrada 1234567890, se convertirá 0987654321234567890).

Y luego genera este texto:

0        9        8        7        6        5        4        3        2        1        2        3        4        5        6        7        8        9        0
         0       9       8       7       6       5       4       3       2       1       2       3       4       5       6       7       8       9       0
                  0      9      8      7      6      5      4      3      2      1      2      3      4      5      6      7      8      9      0
                           0     9     8     7     6     5     4     3     2     1     2     3     4     5     6     7     8     9     0
                                    0    9    8    7    6    5    4    3    2    1    2    3    4    5    6    7    8    9    0
                                             0   9   8   7   6   5   4   3   2   1   2   3   4   5   6   7   8   9   0
                                                      0  9  8  7  6  5  4  3  2  1  2  3  4  5  6  7  8  9  0
                                                               0 9 8 7 6 5 4 3 2 1 2 3 4 5 6 7 8 9 0
                                                                        0987654321234567890
                                                               0 9 8 7 6 5 4 3 2 1 2 3 4 5 6 7 8 9 0
                                                      0  9  8  7  6  5  4  3  2  1  2  3  4  5  6  7  8  9  0
                                             0   9   8   7   6   5   4   3   2   1   2   3   4   5   6   7   8   9   0
                                    0    9    8    7    6    5    4    3    2    1    2    3    4    5    6    7    8    9    0
                           0     9     8     7     6     5     4     3     2     1     2     3     4     5     6     7     8     9     0
                  0      9      8      7      6      5      4      3      2      1      2      3      4      5      6      7      8      9      0
         0       9       8       7       6       5       4       3       2       1       2       3       4       5       6       7       8       9       0
0        9        8        7        6        5        4        3        2        1        2        3        4        5        6        7        8        9        0

(Desde el centro hacia afuera en ambas direcciones, cada personaje está separado por un espacio más que la línea anterior).

Reglas de desafío:

  • Debe imprimir el doble de la longitud de la entrada, menos 3 líneas. Entonces, con la entrada 1234567890, la salida que se muestra arriba es de 17 líneas (longitud 10 * 2 - 3).
  • La entrada solo contendrá ASCII imprimible (excluyendo espacio, tabulación y nueva línea).
  • Los espacios finales son opcionales.
  • Una nueva línea final es opcional.
  • No se permiten espacios iniciales (adicionales) o nuevas líneas iniciales.
  • Puede suponer que la entrada siempre tendrá al menos cuatro caracteres de longitud.
  • A diferencia de mi Era solo un desafío de errores , tanto los formatos de entrada como los de salida son flexibles. Por lo tanto, puede generar el resultado como una matriz de cadenas, una lista de cadenas, etc.

Reglas generales:

  • Este es el código de golf , por lo que la respuesta más corta en bytes gana.
    No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de código. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
  • Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
  • Las lagunas predeterminadas están prohibidas.
  • Si es posible, agregue un enlace con una prueba para su código.
  • Además, agregue una explicación si es necesario.

Casos de prueba:

Input: 1234567890
Output:
0        9        8        7        6        5        4        3        2        1        2        3        4        5        6        7        8        9        0
         0       9       8       7       6       5       4       3       2       1       2       3       4       5       6       7       8       9       0
                  0      9      8      7      6      5      4      3      2      1      2      3      4      5      6      7      8      9      0
                           0     9     8     7     6     5     4     3     2     1     2     3     4     5     6     7     8     9     0
                                    0    9    8    7    6    5    4    3    2    1    2    3    4    5    6    7    8    9    0
                                             0   9   8   7   6   5   4   3   2   1   2   3   4   5   6   7   8   9   0
                                                      0  9  8  7  6  5  4  3  2  1  2  3  4  5  6  7  8  9  0
                                                               0 9 8 7 6 5 4 3 2 1 2 3 4 5 6 7 8 9 0
                                                                        0987654321234567890
                                                               0 9 8 7 6 5 4 3 2 1 2 3 4 5 6 7 8 9 0
                                                      0  9  8  7  6  5  4  3  2  1  2  3  4  5  6  7  8  9  0
                                             0   9   8   7   6   5   4   3   2   1   2   3   4   5   6   7   8   9   0
                                    0    9    8    7    6    5    4    3    2    1    2    3    4    5    6    7    8    9    0
                           0     9     8     7     6     5     4     3     2     1     2     3     4     5     6     7     8     9     0
                  0      9      8      7      6      5      4      3      2      1      2      3      4      5      6      7      8      9      0
         0       9       8       7       6       5       4       3       2       1       2       3       4       5       6       7       8       9       0
0        9        8        7        6        5        4        3        2        1        2        3        4        5        6        7        8        9        0

Input: ABCD
Output:
D  C  B  A  B  C  D 
   D C B A B C D
      DCBABCD
   D C B A B C D
D  C  B  A  B  C  D

Input: =>)}]
Output:
]   }   )   >   =   >   )   }   ]
    ]  }  )  >  =  >  )  }  ]
        ] } ) > = > ) } ]
            ]})>=>)}]
        ] } ) > = > ) } ]
    ]  }  )  >  =  >  )  }  ]
]   }   )   >   =   >   )   }   ]

Input: XXxxXX
Output:
X    X    x    x    X    X    X    x    x    X    X
     X   X   x   x   X   X   X   x   x   X   X
          X  X  x  x  X  X  X  x  x  X  X
               X X x x X X X x x X X
                    XXxxXXXxxXX
               X X x x X X X x x X X
          X  X  x  x  X  X  X  x  x  X  X
     X   X   x   x   X   X   X   x   x   X   X
X    X    x    x    X    X    X    x    x    X   X
code-golf  ascii-art 
— Kevin Cruijssen
fuente
¿Hay una cantidad igual de espacios iniciales en cada línea?
— Adám
@ Adám Lo siento pero no. Cualquier cantidad de espacios finales está bien, pero los espacios iniciales no. Especificaré esta regla en el desafío.
— Kevin Cruijssen
2
"Debe imprimir la longitud de la entrada menos 3 líneas". luego "(longitud 10 * 2 - 3)". La primera oración dice "no doble", la segunda dice "doble". Entonces cual es?
— Olivier Grégoire
@ OlivierGrégoire Vaya, la primera línea debería haber contenido 2
— veces

Respuestas:

5

Carbón , 14 bytes

Ｅ⁻Ｌθ¹⪫θ× ι‖Ｏ←↑

Pruébalo en línea!

AST:

Program
├Print
│└Ｅ: Map
│ ├⁻: Difference
│ │├Ｌ: Length
│ ││└θ: Identifier θ
│ │└1: Number 1
│ └⪫: Join
│  ├θ: Identifier θ
│  └×: Product
│   ├' ': String ' '
│   └ι: Identifier ι
└‖Ｏ: Reflect overlap
 └Multidirectional
  ├←: Left
  └↑: Up
— Erik el Outgolfer
fuente
Pueden ser 16 puntos de código, pero como UTF-8 Python 3 informa que son 41 bytes. ¿Qué juego de caracteres utiliza para que sea de 16 bytes?
— Janus Troelsen
@JanusTroelsen Es un juego de caracteres personalizado.
— Erik the Outgolfer
¿Eh, funciona con cuerdas? Debo recordar eso para la próxima vez ...
— Neil
@Neil Sí, tiene sentido, ¿no?
— Erik the Outgolfer
Técnicamente, su edición no es competitiva porque la confirmación relevante es posterior al desafío.
— Neil
7

Japt , 22 21 bytes

¬Å£¬qYîÃy w ê y w ê ·

¡Pruébelo en línea!

Explicación

Los primeros 8 bytes generan el cuadrante inferior derecho del patrón:

 ¬ Å  £    ¬ qYîÃ
Uq s1 mXY{Uq qYî} 

Uq                 : Split the input into characters.
   s1              : Slice off the first.
      mXY{      }  : Map each item X and index Y to
          Uq       :   the input split into chars,
             q     :   joined with
              Yî   :     Y spaces.

En este punto tenemos una serie de eg ["ABCD", "A B C D", "A B C D"]. Desafortunadamente, se necesitan 13 bytes para cuadrar esto:

y w ê y w ê ·
y w ê y w ê qR
y                : Pad each line to the same length with spaces and transpose.
  w              : Reverse the array, and
    ê            : palindromize. Now we have the bottom half of the output transposed.
      y          : Transpose back.
        w ê      : Reverse and palindromize again, giving the full output.
            qR   : Join with newlines.
                 : Implicit: output result of last expression
— ETHproducciones
fuente
Ojalá hubiera pensado usar la transposición - bien hecho :)
— Shaggy
¿Puedo hacer una pregunta que me da miedo saber la respuesta? ¿Está usted y el resto aquí realmente codificando esto en su versión reducida?
— gdbj
Si te atreves. Probablemente no.
— CalculatorFeline
1
@gdbj que suelo hacer ... ¿es una mala señal? : P
— ETHproductions
@ETHproductions le estaba diciendo a un amigo que esto es similar al golf real: frustrante de aprender, extrañamente adictivo, y demostrar habilidad en él exige respeto.
— gdbj
5

JavaScript (ES6) , 159 136 129 127 bytes

f=(i,x=1-(l=i.length-1),y=x<0?-x:x,[,...b]=i)=>l>x?''.padEnd(l*(l+~y))+[...b.reverse(),...i].join(''.padEnd(y))+`
`+f(i,x+1):''

Pruébalo en línea! Explicación a continuación

// This is a recursive function
// First, inputs and various variable initializations
// by using defaults
let func = (
  // Text input, will not be modified through recursion
  input,

  // Current line, for the first function call we start from -lines to +lines
  // It's roughly equivalent to lines*2 but this helps us computing the spacing
  // Also computing the total amount of lines
  currentLine = 1 - (totalLines = input.length - 1),

  // Getting the absolute value of the current line (like Math.floor)
  absCurrentLine = currentLine < 0 ? -currentLine : currentLine,

  // Getting the input without it's first letter, useful for the palidrome of the input
  [,...slicedInput] = input

// Base case, stopping the recursion if the current line
// is still below the total amount of lines
) => totalLines > currentLine

  // Leading spacing
  ? ''.padEnd(totalLines * (totalLines + ~absCurrentLine)) + 

  // Putting together the palindrome version and adding spaces between the chars
    [...slicedInput.reverse(), ...input].join(''.padEnd(absCurrentLine)) + `

  // Line return + recursion call
` + f(input, currentLine + 1)
  : ''

Primera entrada a codegolf, pido disculpas de antemano por cualquier error obvio.

¡Gracias a Justin Mariner por guardar 23 bytes! Gracias a Craig Ayre por guardar 11 bytes y por el informe de error.

— Saming
fuente
Buena primera respuesta, +1 de mi parte y bienvenidos a PPCG. No estoy muy familiarizado con Js, pero ¿es posible comenzar xen -2 en lugar de -1 y cambiar x<=la ++x<=lpara que pueda eliminar x++y guardar un byte?
— Kevin Cruijssen
Lo intenté pero no lo logré porque también linesestá enredado con el espaciado, por lo que termina costando más bytes para que todo vuelva a funcionar. Pero estoy bastante seguro de que hay una mejor manera de organizar el código y agregar su sugerencia.
— Saming
1
¡Bienvenido a PPCG, buena primera publicación y explicación! Golfed hasta 133 bytes aquí . Incluye explicación de lo que se cambió.
— Justin Mariner
Desafortunadamente, su salida no parece coincidir con la salida esperada: vea aquí
— Craig Ayre
1
Esto es genial, agregué tu nueva función y actualicé la explicación
— Saming
4

SOGL V0.12 , 22 18 bytes

ā,⁄H{,čFH@*∑Κ}▓±╬-

Pruébalo aquí!

Explicación:

ā                   push an empty array - canvas
 ,⁄H{        }      input length-1 times do
     ,                push the input
      č               chop it into chars
       FH@*           get the current iteration-1 amount of spaces
           ∑          join the chopped input with the spaces
            Κ         prepend it to the array
              ▓     space to a square
               ±    reverse each string in that list
                ╬-  quad-palindromize with 1 X and 1 Y overlap and without swapping characters
— dzaima
fuente
¿Es ╬-el comando palindromize de cuatro vías? Estaba por aquí deseando que Japt tuviera algo así ...: P
— ETHproductions
@ETHproductions FWIW, ╬es muchas cosas
— dzaima
Lo sé, de ahí por qué lo especifiqué ╬-. Pero gracias, no pude encontrar esa página por alguna razón
— ETHproductions
@ETHproductions Oh. Solo existe en la copia SOGLOnline del intérprete: / En algún momento necesito unir los dos: |
— dzaima
Hmm ... se debe implementar automática Fde ∑si se necesita.
— Erik the Outgolfer
4

Python 3 , 149141 95 bytes

def f(s):l=len(s)-1;[print((' '*abs(i)).join(s[:0:-1]+s).center(2*l*l+1))for i in range(1-l,l)]

Pruébalo en línea!

Gracias a @KevinCruijssen y @ETHproductions por guardar algunos bytes

¡Un agradecimiento especial a @notjagan por guardar 46 bytes!

— Sr. Xcoder
fuente
1
Cambiar l=len(s);a l=len(s)-1;y luego cambiar todos los valores que implican l(es decir, l-1-> l; -l+2-> -l+1; etc.) es de 8 bytes más corto. Pruébalo aquí
— Kevin Cruijssen
1
-l+2-> 2-l:)
— ETHproductions
Gracias @KevinCruijssen, desafortunadamente no puedo editar en este momento, ¿puedes editar?
— Sr. Xcoder
@KevinCruijssen ¡Muchas gracias!
— Sr. Xcoder
3
¡Hasta 95 bytes usando en centerlugar del forbucle!
— notjagan 05 de
4

PHP, 145 131 bytes

Le tomó un poco de tiempo jugar golf ese byte adicional; Pero valió la pena.

while($y<=2*$e=strlen($a=$argn)-1)echo($p=str_pad)("
",$e*($e-$d=abs($y++-$e))+1),chunk_split($a.substr(strrev($a),1),1,$p("",$d));

imprime una nueva línea principal. Ejecutar como tubería con -nRo probarlo en línea .

Descompostura

while($y<=2*$e=strlen($a=$argn)-1)  # $e=length-1, loop through rows
                                        # 1. print linebreak and left padding
    echo($p=str_pad)("\n",$e*($e-$d=abs($y++-$e))+1),
        chunk_split(
            $a.substr(strrev($a),1)     # 2. palindromize input
            ,1,$p("",$d));              # 3. insert $e..0..$e spaces between characters

solución alternativa , misma longitud:

for($d=-$e=strlen($a=$argn)-1;$d<$e;)echo($p=str_pad)("
",$e*($e-$b=abs($d++))+1),chunk_split($a.substr(strrev($a),1),1,$p("",$b));
— Tito
fuente
1
Puede guardar 13 bytes con ¡ Pruébelo en línea!
— Jörg Hülsermann
3

APL (Dyalog) , 37 bytes

Requiere ⎕IO←0cuál es el predeterminado en muchos sistemas.

{⍉m(2-d)↓⍉(m←⊖⍪1↓⊢)↑∊¨(1↓⍳d←≢⍵)↑¨¨⊂⍵}

{... } función anónima donde el argumento está representado por ⍵

 (… )↑¨¨⊂⍵ Para cada ( ¨) de los siguientes números tome ( ↑) esa cantidad de caracteres de cada ( ¨) del ⊂argumento completo ( ), rellenando con espacios según sea necesario:

  ≢w el número de caracteres en el argumento

  d← almacenar eso en d

  ⍳ que muchos ɩ nices (0 ... d - 1)

  1↓ soltar uno (el cero)

 ∊¨ ϵ nlist (aplanar) cada

 ↑ elevar el rango (convertir la lista de listas en una matriz)

 (m←… ) Aplique la siguiente función tácita m , definida como:

  ⊖ el argumento al revés

  ⍪ encima de

  1 una fila]

  ↓ caido de

  ⊢ el argumento

 ⍉ transponer

 (... )↓ soltar:

  2-d = - ( d - 2), es decir, d - 2 filas desde abajo

 m aplicar m

 ⍉ transponer

Pruébalo en línea!

— Adán
fuente
3

Java (OpenJDK 8) , 201 196 bytes

s->{for(int l=s.length()-1,i=-l,x=0;++i<l;x+=i<0?l:-l)System.out.printf("%1$"+(x<1?"":x)+"s"+s.join("%1$"+(i<0?-i:i>0?i:"")+"s",(new StringBuffer(s.substring(1)).reverse()+s).split(""))+"%n","");}

Pruébalo en línea!

Es la misma idea que usé para el desafío anterior , excepto que la cadena del generador ahora es un poco más larga y con casos más difíciles de manejar.

%1$Ns0%1$Ns9%1$Ns8%1$Ns7%1$Ns6%1$Ns5%1$Ns4%1$Ns3%1$Ns2%1$Ns1%1$Ns2%1$Ns3%1$Ns4%1$Ns5%1$Ns6%1$Ns7%1$Ns8%1$Ns9%1$Ns0%n
— Olivier Grégoire
fuente
3

Python 3 , 134 124 bytes

f=lambda s:'\n'.join([' '*(len(s)-1)*abs(len(s)-abs(i)-2)+(' '*abs(i)).join(s[::-1]+s[1:]) for i in range(2-len(s),len(s)-1)])

Pruébalo en línea!

Primera publicación en PPCG después de estar al acecho por un tiempo. Buscando alguna sugerencia / consejo!

¡Gracias a @LyricLy y @ Łukasz Rogalski por las mejoras!

— Chase Vogeli
fuente
1
No tiene que imprimir la salida dentro de la función, la salida se puede dar en un valor de retorno. Además, no tiene que contar f=en el bytecount, simplemente proporcionar una función anónima está bien.
— Letra
1
Además, -len(s)+2es solo 2-len(s)un byte menos.
— Łukasz Rogalski
Gracias @ Łukasz Rogalski y @LyricLy; me has guardado 10 bytes!
— Chase Vogeli
3

Haskell, 177 163 bytes

import Data.List
k n=[1..n]>>" "
f s=let n=length s in map(\x->(k(((n-1)*(n-(abs x)))))++(intercalate (k(abs x))$map(\z->[z])$((++)=<<reverse.tail) s))[n,n-1.. -n]

La función f es la función de desafío y devuelve una lista de cadenas ( [String]), su uso unlinesdebe proporcionar la misma salida visual que los casos de prueba ( main = putStr $ unlines $ f "test string"para compilarla).

Pruébalo en línea!

-14 bytes gracias a @nimi

— Mephy
fuente
1
k Puede ser definido como k n=[1..n]>>" " y pcomo p=(++)=<<reverse.tail(incluso esta definición en línea).
— nimi
2

Mathematica, 141 bytes

Column[Join[Reverse@(s=Row/@Table[Riffle[Reverse@Rest@b~Join~b,""<>Table[" ",i]],{i,0,Length[b=Characters@#]-1}]),Rest@s],Alignment->Center]&
— J42161217
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.