To był tylko błąd wejściowy

17

Kontynuując mój To był tylko błąd :

Wejście:

Ciąg składający się z drukowalnych znaków ASCII bez białych spacji ani nowych wierszy.

Wynik:

Najpierw zmień dane wejściowe na palindrom, odwracając dane wejściowe i dodając je przed sobą, z wyłączeniem środkowego znaku (tzn. Z wejściem 1234567890stanie się 0987654321234567890).

A następnie wyślij ten tekst:

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

(Od środka na zewnątrz w obu kierunkach każdy znak jest oddzielony o jedną spację więcej niż poprzedni wiersz).

Zasady konkursu:

  • Musisz wydrukować podwójną długość wejścia, minus 3 linie. Tak więc z wejściem 1234567890, wyjście wyświetlane powyżej to 17 linii (długość 10 * 2 - 3).
  • Dane wejściowe będą zawierały tylko ASCII do wydruku (bez spacji, tabulacji i nowego wiersza).
  • Spacje końcowe są opcjonalne.
  • Pojedyncza nowa linia jest opcjonalna.
  • (Dodatkowe) wiodące spacje lub wiodące nowe linie nie są dozwolone.
  • Możesz założyć, że dane wejściowe zawsze będą miały co najmniej cztery znaki.
  • W przeciwieństwie do mojego To było tylko wyzwanie, zarówno formaty wejściowe, jak i wyjściowe są elastyczne. Zatem możesz wyświetlać wynik jako tablicę łańcuchów, listę łańcuchów itp.

Główne zasady:

  • To jest , więc wygrywa najkrótsza odpowiedź w bajtach.
    Nie pozwól, aby języki gry w golfa zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
  • Do odpowiedzi mają zastosowanie standardowe reguły , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami i zwracanymi typami, pełnych programów. Twoja decyzja.
  • Domyślne luki są zabronione.
  • Jeśli to możliwe, dodaj link z testem swojego kodu.
  • W razie potrzeby dodaj również wyjaśnienie.

Przypadki testowe:

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
Kevin Cruijssen
źródło
Czy równa liczba spacji wiodących w każdej linii jest OK?
Adám
@ Adám Przepraszamy, ale nie. Dowolna liczba końcowych spacji jest w porządku, ale spacje wiodące nie. Sprecyzuję tę regułę w wyzwaniu.
Kevin Cruijssen
2
„Musisz wydrukować długość wejścia minus 3 linie.” następnie „(długość 10 * 2–3)”. Pierwsze zdanie mówi „brak podwójnego”, drugie zdanie „podwójny”. Więc co to jest?
Olivier Grégoire,
@ OlivierGrégoire Ups, pierwsza linia powinna zawierać 2x długość minus 3. Naprawiono
Kevin Cruijssen

Odpowiedzi:

5

Węgiel drzewny , 14 bajtów

E⁻Lθ¹⪫θ× ι‖O←↑

Wypróbuj online!

AST:

Program
├Print
│└E: Map
│ ├⁻: Difference
│ │├L: Length
│ ││└θ: Identifier θ
│ │└1: Number 1
│ └⪫: Join
│  ├θ: Identifier θ
│  └×: Product
│   ├' ': String ' '
│   └ι: Identifier ι
└‖O: Reflect overlap
 └Multidirectional
  ├←: Left
  └↑: Up
Erik the Outgolfer
źródło
Może to być 16 współrzędnych kodowych, ale jak UTF-8 Python 3 zgłasza, że ​​ma 41 bajtów. Jakiego zestawu znaków używasz, aby 16 bajtów?
Janus Troelsen
@JanusTroelsen To niestandardowy zestaw znaków.
Erik the Outgolfer
Huh, ⪫ działa na łańcuchach? Musisz pamiętać, że następnym razem ...
Neil
@Neil Tak, to ma sens, prawda?
Erik the Outgolfer
Z technicznego punktu widzenia Twoja edycja nie jest konkurencyjna, ponieważ odpowiednie zatwierdzenie jest datowane na wyzwanie.
Neil,
7

Japt , 22 21 bajtów

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

Przetestuj online!

Wyjaśnienie

Pierwsze 8 bajtów generuje prawą dolną ćwiartkę wzoru:

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

W tym momencie mamy tablicę np ["ABCD", "A B C D", "A B C D"]. Niestety kwadrat zajmuje 13 bajtów:

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
ETHprodukcje
źródło
Szkoda, że ​​nie pomyślałem o transpozycji - ładnie zrobione :)
Kudłaty
Czy mogę zadać pytanie, na które boję się poznać odpowiedź? Czy ty i reszta tutaj kodujecie to w jej zminimalizowanej wersji?
gdbj
Jeśli się odważysz. Prawdopodobnie nie.
CalculatorFeline,
1
@gdbj Zwykle robię ... czy to zły znak? : P
ETHproductions
@ETHproductions Mówiłem tylko kumplowi, że jest to podobne do prawdziwego golfa: frustracja w nauce, dziwne uzależnienie i demonstrowanie umiejętności w tym zakresie budzi szacunek.
gdbj
5

05AB1E , 17 bajtów

g<F¹RSðN×ýû})Rû.c

Wypróbuj online!

-1 dzięki kalsowerus .

Erik the Outgolfer
źródło
Można zapisać jeden bajt zastępując .c.∊zû.c
kalsowerus
@kalsowerus I wiedziałem, że będzie jakiś sposób na wykorzystanie û... dzięki!
Erik the Outgolfer,
5

JavaScript (ES6) , 159 136 129 127 bajtów

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

Wypróbuj online! Objaśnienie poniżej

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

Pierwsze wejście do codegolf, z góry przepraszam za oczywiste błędy.

Dzięki Justin Mariner za oszczędność 23 bajtów! Dzięki Craig Ayre za zapisanie 11 bajtów i zgłoszenie błędu.

Saming
źródło
Ładna pierwsza odpowiedź, +1 ode mnie i witamy w PPCG. Nie znam się zbytnio na Js, ale czy można zacząć xod -2 zamiast -1 i zmienić x<=lna ++x<=l, abyś mógł usunąć x++i zapisać bajt?
Kevin Cruijssen
Próbowałem, ale nie udało mi się, ponieważ linesjest również uwikłany w odstępy, więc kosztuje to więcej bajtów, aby wszystko znów działało. Ale jestem całkiem pewien, że istnieje lepszy sposób na uporządkowanie kodu i dodanie swojej sugestii.
Saming,
1
Witamy w PPCG, fajny pierwszy post i wyjaśnienie! Grał tutaj w golfa do 133 bajtów . Zawiera wyjaśnienie tego, co zostało zmienione.
Justin Mariner,
Niestety, wyniki nie wydają się być zgodne z oczekiwanymi: patrz tutaj
Craig Ayre,
1
To wspaniale, dodałem twoją nową funkcję i zaktualizowałem wyjaśnienie
Saming
4

SOGL V0.12 , 22 18 bajtów

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

Wypróbuj tutaj!

Wyjaśnienie:

ā                   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
źródło
Czy ╬-czterokierunkowe polecenie palindromize? Właśnie tu chciałem, żeby Japt miał coś takiego ...: P
ETHproductions
@ETHproductions FWIW, jest wiele rzeczy
dzaima
Wiem, dlatego podałem ╬-. Ale dzięki, nie mogłem znaleźć tej strony z jakiegoś powodu
ETHprodukcje
@ETHproductions Oh. Istnieje tylko w kopii interpretera SOGLOnline: / W pewnym momencie muszę połączyć te dwa elementy: |
dzaima
Hmm ... trzeba wdrożyć automatyczny Fdla jeśli jest to potrzebne.
Erik the Outgolfer
4

Python 3 , 149 141 95 bajtów

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

Wypróbuj online!

Dzięki @KevinCruijssen i @ETHproductions za zaoszczędzenie niektórych bajtów

Specjalne podziękowania dla @notjagan za uratowanie 46 bajtów!

Pan Xcoder
źródło
1
Zmieniających l=len(s);się l=len(s)-1;, a następnie zmieniając wszystkie wartości udziałem l(tj l-1-> l; -l+2-> -l+1; itd.) Wynosi 8 bajtów krótszy. Wypróbuj tutaj.
Kevin Cruijssen
1
-l+2-> 2-l:)
ETHprodukcje
Dzięki @KevinCruijssen, niestety nie mogę teraz edytować, czy możesz edytować?
Pan Xcoder,
@KevinCruijssen Wielkie dzięki!
Pan Xcoder,
3
W dół do 95 bajtów używając centerzamiast forpętli!
notjagan
4

PHP, 145 131 bajtów

Gra w ten dodatkowy bajt wymagała trochę myślenia; ale było warto.

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

wypisuje wiodącą nową linię. Uruchom jako potok z -nRlub spróbuj online .

awaria

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

alternatywne rozwiązanie o tej samej długości:

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));
Tytus
źródło
1
Możesz zapisać 13 bajtów dzięki Wypróbuj online!
Jörg Hülsermann
3

APL (Dyalog) , 37 bajtów

Wymaga ⎕IO←0ustawienia domyślnego w wielu systemach.

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

{} Anonimowa funkcja, w której argument jest reprezentowany przez

()↑¨¨⊂⍵ Dla każdej ( ¨) z poniższych liczb bierze ( ) tyle znaków z każdego ( ¨) całego ( argumentu ), dopełniając spacjami, jeśli to konieczne:

  ≢w liczba znaków w argumencie

  d← przechowuj w d

   że wiele znaków (0… d - 1)

  1↓ upuść jeden (zero)

∊¨ϵ nlist (spłaszczyć) każde

 podnieść rangę (przekształcić listę list w macierz)

(m←) Zastosuj następującą funkcję ukrytą m , zdefiniowaną jako:

   argument do góry nogami

   na szczycie

  1 jeden rząd]

   spadł z

   argument

 transponować

()↓ Upuść:

  2-d = - ( d - 2), tj. D - 2 rzędy od dołu

m zastosuj m

 transponować

Wypróbuj online!

Adám
źródło
3

Java (OpenJDK 8) , 201 196 bajtów

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

Wypróbuj online!

To ten sam pomysł, który użyłem w poprzednim wyzwaniu , z tym wyjątkiem, że ciąg generatora jest teraz odrobinę dłuższy i trudniejszy w obsłudze.

%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
źródło
3

Python 3 , 134 124 bajty

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

Wypróbuj online!

Pierwszy post do PPCG po chwilowym czyhaniu. Szukasz jakichkolwiek sugestii / porad!


Dzięki @LyricLy i @ Łukasz Rogalski za ulepszenia!

Chase Vogeli
źródło
1
Nie musisz drukować danych wyjściowych wewnątrz funkcji, dane wyjściowe można podać w postaci wartości zwracanej. Ponadto nie musisz liczyć liczby f=bajtowej, po prostu zapewnienie anonimowej funkcji jest w porządku.
LyricLy,
1
Ponadto -len(s)+2jest tylko 2-len(s)jeden bajt mniej.
Łukasz Rogalski,
Dziękuję @ Łukasz Rogalski i @LyricLy; zapisałeś mi 10 bajtów!
Chase Vogeli
3

Haskell, 177 163 bajtów

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]

Ta funkcja fjest funkcją wyzwania i zwraca listę łańcuchów ( [String]), użycie unlinesjej powinno zapewnić taki sam efekt wizualny jak przypadki testowe (main = putStr $ unlines $ f "test string" aby ją skompilować).

Wypróbuj online!

-14 bajtów dzięki @nimi

Mefia
źródło
1
kmożna zdefiniować jako k n=[1..n]>>" "i pjako p=(++)=<<reverse.tail(możesz nawet wstawić tę definicję).
nimi
2

Mathematica, 141 bajtów

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
źródło