Era solo un bug di input

17

Continuando il mio Era solo un bug sfida di :

Ingresso:

Una stringa composta da caratteri ASCII stampabili senza spazi bianchi né nuove righe.

Produzione:

Innanzitutto trasforma l'input in un palindromo ripristinando l'input e aggiungendolo prima di se stesso, escludendo il carattere medio (ovvero con un input 1234567890 , diventerà0987654321234567890 ).

E quindi emetti questo testo:

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

(Dal centro verso l'esterno in entrambe le direzioni, ogni personaggio è separato da uno spazio in più rispetto alla riga precedente.)

Regole della sfida:

  • È necessario stampare il doppio della lunghezza dell'input, meno 3 righe. Quindi con l'input1234567890 , l'uscita visualizzata sopra è di 17 righe (lunghezza 10 * 2 - 3).
  • L'input conterrà solo ASCII stampabile (esclusi spazio, tabulazione e nuova riga).
  • Gli spazi finali sono opzionali.
  • Una singola nuova riga finale è facoltativa.
  • Non sono consentiti spazi iniziali (aggiuntivi) o nuove righe iniziali.
  • Puoi presumere che l'input avrà sempre una lunghezza di almeno quattro caratteri.
  • A differenza del mio È stata solo una sfida da bug , sia i formati di input che di output sono flessibili. Quindi ti è permesso di produrre il risultato come String-array, String-list, ecc.

Regole generali:

  • Questo è code-golf , quindi vince la risposta più breve in byte.
    Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
  • Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
  • Scappatoie predefiniteSono vietate le .
  • Se possibile, aggiungi un link con un test per il tuo codice.
  • Inoltre, si prega di aggiungere una spiegazione, se necessario.

Casi test:

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
fonte
Una quantità uguale di spazi iniziali su ogni riga è OK?
— Adám,
@ Adám Siamo spiacenti ma no. Qualsiasi numero di spazi finali va bene, ma non gli spazi iniziali. Specifico questa regola nella sfida.
— Kevin Cruijssen,
2
"Devi stampare la lunghezza dell'input meno 3 righe." quindi "(lunghezza 10 * 2 - 3)". La prima frase dice "no double", la seconda dice "double". Quindi che cos'è?
— Olivier Grégoire,
@ OlivierGrégoire Oops, la prima riga avrebbe dovuto contenere il
— doppio

Risposte:

5

Carbone , 14 byte

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

Provalo online!

AST:

Program
├Print
│└Ｅ: Map
│ ├⁻: Difference
│ │├Ｌ: Length
│ ││└θ: Identifier θ
│ │└1: Number 1
│ └⪫: Join
│  ├θ: Identifier θ
│  └×: Product
│   ├' ': String ' '
│   └ι: Identifier ι
└‖Ｏ: Reflect overlap
 └Multidirectional
  ├←: Left
  └↑: Up
— Erik the Outgolfer
fonte
Potrebbe essere 16 punti di codice, ma come UTF-8 Python 3 riporta che è di 41 byte. Quale set di caratteri usi per renderlo 16 byte?
— Janus Troelsen,
@JanusTroelsen È un set di caratteri personalizzato.
— Erik the Outgolfer,
Eh, ⪫ lavora sulle stringhe? Devo ricordare che per la prossima volta ...
— Neil,
@Neil Sì, ha senso vero?
— Erik the Outgolfer,
Tecnicamente la modifica non è competitiva perché il commit pertinente postdatizza la sfida.
— Neil,
7

Japt , 22 21 byte

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

Provalo online!

Spiegazione

I primi 8 byte generano il quadrante in basso a destra del modello:

 ¬ Å  £    ¬ 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.

A questo punto abbiamo una serie di es ["ABCD", "A B C D", "A B C D"]. Sfortunatamente, ci vogliono 13 byte per quadrare questo:

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
— ETHproductions
fonte
Vorrei aver pensato di usare transpose - ben fatto :)
— Shaggy
Posso porre una domanda a cui ho paura di conoscere la risposta? Tu e gli altri qui in realtà lo codifichiamo nella sua versione ridotta?
— gdbj,
Se avete il coraggio. Probabilmente no.
— CalcolatriceFeline
1
@gdbj di solito lo faccio ... è un brutto segno? : P
— ETHproductions
@ETHproductions Stavo dicendo a un amico che questo è simile al vero golf: frustrante da imparare, stranamente avvincente, e dimostrando abilità in esso richiede rispetto.
— gdbj,
5

JavaScript (ES6) , 159 136 129 127 byte

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):''

Provalo online! Spiegazione di seguito

// 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)
  : ''

Primo ingresso a codegolf, mi scuso in anticipo per eventuali errori evidenti.

Grazie a Justin Mariner per aver salvato 23 byte! Grazie a Craig Ayre per aver salvato 11 byte e per la segnalazione dei bug.

— Saming
fonte
Bella prima risposta, +1 da parte mia e benvenuto in PPCG. Non ho troppa familiarità con Js, ma è possibile iniziare xda -2 invece di -1 e passare x<=la in ++x<=lmodo da poter rimuovere x++e salvare un byte?
— Kevin Cruijssen,
Ci ho provato ma non ci sono riuscito perché linesè coinvolto anche nella spaziatura, quindi finisce per costare più byte per far funzionare di nuovo tutto. Ma sono abbastanza certo che esiste sia un modo migliore per organizzare il codice e aggiungere il tuo suggerimento.
— Saming,
1
Benvenuto in PPCG, bel primo post e spiegazione! Golfato fino a 133 byte qui . Include la spiegazione di ciò che è stato modificato.
— Justin Mariner,
Sfortunatamente il tuo output non sembra corrispondere perfettamente a quello atteso: vedi qui
— Craig Ayre,
1
Questo è fantastico, ho aggiunto la tua nuova funzione e aggiornato la spiegazione
— Saming
4

SOGL V0.12 , 22 18 byte

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

Provalo qui!

Spiegazione:

ā                   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
fonte
Il ╬-comando palindromize a quattro vie è? Ero proprio qui che desideravo che Japt avesse qualcosa del genere ...: P
— ETHproductions
@ETHproductions FWIW, ╬sono molte cose
— dzaima,
Lo so, quindi perché ho specificato ╬-. Ma grazie, non ho trovato quella pagina per qualche motivo
— ETHproductions,
@ETHproductions Oh. Esiste solo nella copia SOGLOnline dell'interprete: / Ad un certo punto devo unire le due cose: |
— dzaima,
Hmm ... dovresti implementare automatico Fper ∑se è necessario.
— Erik the Outgolfer,
4

Python 3 , 149 141 95 byte

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

Provalo online!

Grazie a @KevinCruijssen e @ETHproductions per aver salvato alcuni byte

Un ringraziamento speciale a @notjagan per aver salvato 46 byte!

— Mr. Xcoder
fonte
1
Cambiando l=len(s);per l=len(s)-1;poi cambiare tutti i valori che coinvolgono l(ie l-1-> l; -l+2-> -l+1; ecc) è di 8 byte più breve. Provalo qui.
— Kevin Cruijssen,
1
-l+2-> 2-l:)
— ETHproductions
Grazie @KevinCruijssen, sfortunatamente non posso modificare adesso, puoi modificarlo?
— Mr. Xcoder,
@KevinCruijssen Grazie mille!
— Mr. Xcoder,
3
Fino a 95 byte usando al centerposto del forloop!
— notjagan,
4

PHP, 145 131 byte

Ci è voluto un po 'di tempo per pensare a quel byte aggiuntivo; ma ne è valsa 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));

stampa una nuova riga principale. Esegui come pipe -nRo provalo online .

abbattersi

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

soluzione alternativa , stessa lunghezza:

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));
— Titus
fonte
1
Puoi salvare 13 byte con Provalo online!
— Jörg Hülsermann,
3

APL (Dyalog) , 37 byte

Richiede il ⎕IO←0valore predefinito su molti sistemi.

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

{... } funzione anonima in cui l'argomento è rappresentato da ⍵

 (... )↑¨¨⊂⍵ per ciascuno ( ¨) dei seguenti numeri prende ( ↑) che molti caratteri di ciascuno ( ¨) dell'intero ⊂argomento ( ), riempiendo gli spazi se necessario:

  ≢w il numero di caratteri nell'argomento

  d← memorizzalo in d

  ⍳ che molti d ndices (0… d - 1)

  1↓ rilasciare uno (lo zero)

 ∊¨ ϵ nlist (appiattisci) ciascuno

 ↑ aumentare il grado (convertire l'elenco di elenchi in una matrice)

 (m←... ) applica la seguente funzione tacita m , definita come:

  ⊖ l'argomento capovolto

  ⍪ sopra

  1 una [riga]

  ↓ caduto da

  ⊢ l'argomento

 ⍉ trasporre

 (...)↓  rilasciare:

  2-d = - ( d - 2), ovvero d - 2 file dal basso

 m applicare m

 ⍉ trasporre

Provalo online!

— Adamo
fonte
3

Java (OpenJDK 8) , 201 196 byte

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

Provalo online!

È la stessa idea di quella che ho usato per la sfida precedente , tranne per il fatto che la stringa del generatore è ora un po 'più lunga e con custodie più difficili da gestire.

%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
fonte
3

Python 3 , 134 124 byte

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

Provalo online!

Primo post su PPCG dopo un po 'in agguato. In cerca di suggerimenti / consigli!

Grazie a @LyricLy e @ Łukasz Rogalski per i miglioramenti!

— Chase Vogeli
fonte
1
Non è necessario stampare l'output all'interno della funzione, l'output può essere fornito con un valore di ritorno. Inoltre, non devi contare ilf= nel bytecount, semplicemente fornendo una funzione anonima va bene.
— Lirico, il
1
Inoltre, -len(s)+2è solo 2-len(s)un byte in meno.
— Łukasz Rogalski,
Grazie @ Łukasz Rogalski e @LyricLy; mi hai salvato 10 byte!
— Chase Vogeli,
3

Haskell, 177 163 byte

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 funzione fè la funzione challenge e restituisce un elenco di stringhe ( [String]), usando unlinessu di essa dovrebbe fornire lo stesso output visivo dei casi di test (main = putStr $ unlines $ f "test string" per compilarlo).

Provalo online!

-14 byte grazie a @nimi

— Mephy
fonte
1
kpuò essere definito come k n=[1..n]>>" "e pcome p=(++)=<<reverse.tail(puoi anche incorporare questa definizione).
— nimi,
2

Mathematica, 141 byte

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
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.