Generuj Wordenticons


54

Identikony to wizualne przedstawienie wartości skrótu, często wykonane z symetrycznych układów geometrycznych kształtów. Domyślnym awatarem Stack Exchange jest identyfikator. Wyzwanie polega na tworzeniu „wordenticonów” , prostych tekstowych wersji identyfikatorów, które mają zastosowanie do ciągów małych liter, tj. Słów.

Wyzwanie

Napisz program lub funkcję, która pobiera ciąg S i wyprowadza swój wordenticon. S jest gwarantowane, że jest niepuste i zawiera tylko małe litery alfabetu angielskiego az. Możesz opcjonalnie założyć, że S ma końcowy znak nowej linii.

Wordenticon z S będzie kwadratową siatką tekstu o długości boków 2*length(S)złożonej ze spacji ( ), pionowych pasków, ( |) i poziomych pasków ( ).

Aby wygenerować słowo S, utwórz kwadratową siatkę, w której każda kolumna odpowiada literze S (w normalnej kolejności od lewej do prawej), a każdy wiersz odpowiada literze S (w normalnej kolejności od góry do dołu) ).

Na przykład, jeśli S jest foodnaszą początkową siatką, wygląda

 food
f....
o....
o....
d....

gdzie .jest tylko symbolem zastępczym.

Dla każdego pustego punktu (każdego .) w siatce:

  1. Jeśli kolumna list przychodzi przed literą rzędu alfabetycznie wymienić .z |.
  2. Jeśli kolumna list przychodzi po literze rzędu alfabetycznie wymienić .z .
  3. Jeśli litery kolumn i wierszy są takie same, wymienić .z (przestrzeni).

Oto foodprzykład po każdym z tych kroków:

  1. Dodawanie |:

     food
    f...|
    o|..|
    o|..|
    d....
    
  2. Dodawanie :

     food
    f.――|
    o|..|
    o|..|
    d―――.
    
  3. Dodawanie :

     food
    f ――|
    o|  |
    o|  |
    d――― 
    

Aby uzupełnić wordenticon, usuń zbędny wiersz i kolumnę zawierającą słowa

 ――|
|  |
|  |
――― 

następnie odbij wszystko w poziomie

 ――||―― 
|  ||  |
|  ||  |
―――  ―――

i wreszcie lustro ponownie w pionie

 ――||―― 
|  ||  |
|  ||  |
―――  ―――
―――  ―――
|  ||  |
|  ||  |
 ――||―― 

w wyniku czego powstaje 2*length(S)siatka tekstowa o długości boku, która jest końcowym słowem.

Przykłady

Oto kilka dodatkowych przykładów Wordenticon. Zauważ, że różne słowa mogą mieć identyczne słowa, a niektóre słowa mogą być całkowicie wykonane ze spacji (niestety markdown nie chce ich renderować).

food

 ――||―― 
|  ||  |
|  ||  |
―――  ―――
―――  ―――
|  ||  |
|  ||  |
 ――||―― 

mood

 ――||―― 
|  ||  |
|  ||  |
―――  ―――
―――  ―――
|  ||  |
|  ||  |
 ――||―― 

foof

 ――  ―― 
|  ||  |
|  ||  |
 ――  ―― 
 ――  ―― 
|  ||  |
|  ||  |
 ――  ―― 

fool

 ―――――― 
|  ||  |
|  ||  |
|――  ――|
|――  ――|
|  ||  |
|  ||  |
 ―――――― 

a [2*2 grid of spaces]




to

 || 
―  ―
―  ―
 || 

it

 ―― 
|  |
|  |
 ―― 

tt [4*4 grid of spaces]






abc

 ―――― 
| ―― |
||  ||
||  ||
| ―― |
 ―――― 

and

 ―――― 
| || |
|―  ―|
|―  ―|
| || |
 ―――― 

but

 ―――― 
| || |
|―  ―|
|―  ―|
| || |
 ―――― 

you

 |||| 
― ―― ―
―|  |―
―|  |―
― ―― ―
 |||| 

bob

 ―  ― 
| || |
 ―  ― 
 ―  ― 
| || |
 ―  ― 

cat

 |――| 
― ―― ―
||  ||
||  ||
― ―― ―
 |――| 

cart

 |――――| 
― ―――― ―
|| ―― ||
|||  |||
|||  |||
|| ―― ||
― ―――― ―
 |――――| 

todo

 |||||| 
― |  | ―
―― ―― ――
― |  | ―
― |  | ―
―― ―― ――
― |  | ―
 |||||| 

mice

 |||||| 
― |||| ―
―― ―― ――
――|  |――
――|  |――
―― ―― ――
― |||| ―
 |||||| 

zyxw

 |||||| 
― |||| ―
―― || ――
―――  ―――
―――  ―――
―― || ――
― |||| ―
 |||||| 

banana

 |―|―||―|―| 
― ― ―  ― ― ―
|| | || | ||
― ― ―  ― ― ―
|| | || | ||
― ― ―  ― ― ―
― ― ―  ― ― ―
|| | || | ||
― ― ―  ― ― ―
|| | || | ||
― ― ―  ― ― ―
 |―|―||―|―| 

codegolf

 ―――――――――――――― 
| ||| |||| ||| |
|― ―――――――――― ―|
|―| ―――――――― |―|
|―|| ――||―― ||―|
| ||| |||| ||| |
|―|||― || ―|||―|
|―||―――  ―――||―|
|―||―――  ―――||―|
|―|||― || ―|||―|
| ||| |||| ||| |
|―|| ――||―― ||―|
|―| ―――――――― |―|
|― ―――――――――― ―|
| ||| |||| ||| |
 ―――――――――――――― 

programming

 ―||―||||||||||||―||― 
| || |||||||||||| || |
―― |―||||||||||||―| ――
――― ―|――――  ――――|― ―――
| || |||||||||||| || |
――――― ―――――――――― ―――――
―――|―|  |―||―|  |―|―――
―――|―|  |―||―|  |―|―――
―――|―|―― ―||― ――|―|―――
―――|―|||| || ||||―|―――
――― ―|――――  ――――|― ―――
――― ―|――――  ――――|― ―――
―――|―|||| || ||||―|―――
―――|―|―― ―||― ――|―|―――
―――|―|  |―||―|  |―|―――
―――|―|  |―||―|  |―|―――
――――― ―――――――――― ―――――
| || |||||||||||| || |
――― ―|――――  ――――|― ―――
―― |―||||||||||||―| ――
| || |||||||||||| || |
 ―||―||||||||||||―||― 

abcdefghijklm

 ―――――――――――――――――――――――― 
| ―――――――――――――――――――――― |
|| ―――――――――――――――――――― ||
||| ―――――――――――――――――― |||
|||| ―――――――――――――――― ||||
||||| ―――――――――――――― |||||
|||||| ―――――――――――― ||||||
||||||| ―――――――――― |||||||
|||||||| ―――――――― ||||||||
||||||||| ―――――― |||||||||
|||||||||| ―――― ||||||||||
||||||||||| ―― |||||||||||
||||||||||||  ||||||||||||
||||||||||||  ||||||||||||
||||||||||| ―― |||||||||||
|||||||||| ―――― ||||||||||
||||||||| ―――――― |||||||||
|||||||| ―――――――― ||||||||
||||||| ―――――――――― |||||||
|||||| ―――――――――――― ||||||
||||| ―――――――――――――― |||||
|||| ―――――――――――――――― ||||
||| ―――――――――――――――――― |||
|| ―――――――――――――――――――― ||
| ―――――――――――――――――――――― |
 ―――――――――――――――――――――――― 

Punktacja

To jest , wygrywa najkrótszy kod w bajtach. Tiebreaker przechodzi do wcześniejszej odpowiedzi.

Notatki

  • Każde wystąpienie poziomego paska ( ) w kodzie może być liczone jako 1 bajt zamiast 3 bajtów UTF-8, które faktycznie zajmuje. (Do dziesięciu instancji.)
  • W razie potrzeby możesz użyć zwykłych myślników ( -) zamiast poziomych pasków ( ).
  • Usuwanie lub dodawanie końcowych spacji w wierszach wyrazu jest niedozwolone (nawet jeśli kształt pozostaje niezmieniony). Powinien to być 2*length(S)kwadratowy tekst o dokładnej długości boku.
  • Wyjściowy wordenticon może opcjonalnie mieć pojedynczą nową linię.

Czy możemy traktować dane wejściowe jako tablicę znaków?
Downgoat

@Downgoat Nie, powinien być normalnym ciągiem znaków, chyba że absolutnie nie ma innego sposobu na twój język.
Calvin's Hobbies

2
Masz przykłady programming, anda codegolfjednak zapomniałeś puzzles...
Neil

Czy możesz dodać tabelę wyników?
Leaky Nun

W końcu dowiedzieliśmy się, dlaczego pytasz o portmanteaus na czacie :)
gcampbell

Odpowiedzi:


21

MATL, 20 15 bajtów

'-| 'jtPht!-ZS)

Wypróbuj w MATL Online

Wyjaśnienie

'-| '       % String literal defining the replacement characters
j           % Explicitly grab the input as a string
tP          % Duplicate and reverse the input string (row vector of chars)
h           % Horizontally concatenate the input and it's inverse
t!          % Duplicate and turn into a column vector
-           % Subtract the two vectors (converts to ASCII codes) and we automatically
            % broadcast to create a (2N x 2N) matrix where if the column is
            % later in the alphabet (higher ASCII) we get a positive number, if the 
            % column was earlier (lower ASCII) we get a negative number, and if they are
            % the same letter (same ASCII) we get a 0.
ZS          % sign function which yields -1 for negative, 1 for positive, and 0 for 0;
)           % Use this to index (modulus) into the string literal '-| '. MATL uses 1-based
            % indexing so 0 yields ' ', -1 replaced by '|', and 1 replaced by '-'
            % Implicitly display the result

9
: O, rozgromiłeś Dennisa!
Downgoat

@Downgoat To jedna z tych rzadkich okazji, że MATL jest krótszy niż Jelly!
Suever

Dobry pomysł na użycie funkcji znaku!
Luis Mendo

18

Java, 329 305 264 259 192 bajtów

Dzięki:

  • @ Bálint za sugerowanie użycia operatorów trójskładnikowych.
  • @ user902383 za zasugerowanie, aby samodzielnie odwrócić ciąg
  • @Frozn i @ user902383 za sugerowanie zastąpić StringBuilderz String.

Gra w golfa:

String g(String w){char[]a=w.toCharArray();String s="";for(int i=a.length-1;i>=0;s=s+a[i--]);w+=s;a=w.toCharArray();s="";for(char x:a){for(char y:a)s+=(x>y?'|':x<y?'-':' ');s+='\n';}return s;}

Nie golfowany:

String g(String w) {
    char[] a = w.toCharArray();
    String s = "";
    for (int i = a.length - 1; i >= 0; s = s + a[i--]);
    w += s;
    a = w.toCharArray();
    s = "";// To keep the output pure (ie. without the input string as well)
    for (char x : a) {
        for (char y : a)
            s += (x > y ? '|' : x < y ? '-' : ' ');
        s += '\n';
    }
    return s;
}

Zdecydowanie fajna. Pierwsza próba była funkcją, która O(n)jednak została zastąpiona tą prostszą formą po tym, jak byłem zbyt sfrustrowany.

I do przetestowania:

supercalifragilisticexpialidocious
 -|||||||||||||| -|||-||||||||||-  -||||||||||-|||- ||||||||||||||- 
| |||||||||||||||||||-|||||||||| || ||||||||||-||||||||||||||||||| |
-- |-|||||-|||||--|||- |||||||||----||||||||| -|||--|||||-|||||-| --
--- -||----|-------| ---|--|-|--------|-|--|--- |-------|----||- ---
--|| ||||| |||||--|||-||||||||||----||||||||||-|||--||||| ||||| ||--
----- |----|------- ----|---- -------- ----|---- -------|----| -----
------ ---- ------------ ------------------ ------------ ---- ------
---|-|| ||-||| |--|||--|| ||-||------||-|| ||--|||--| |||-|| ||-|---
---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
---|-||-- -|-------||---|--|-|--------|-|--|---||-------|- --||-|---
--|| ||||| |||||--|||-||||||||||----||||||||||-|||--||||| ||||| ||--
------ ---- ------------ ------------------ ------------ ---- ------
---|-||--|-| ------||---|--|-|--------|-|--|---||------ |-|--||-|---
---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
---|-|| ||-||| |--|||--|| ||-||------||-|| ||--|||--| |||-|| ||-|---
---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
 -|||||||||||||| -|||-||||||||||-  -||||||||||-|||- ||||||||||||||- 
|-||||||||||||||| |||-||||||||||-||-||||||||||-||| |||||||||||||||-|
---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
----- |----|------- ----|---- -------- ----|---- -------|----| -----
--- -||----|-------| ---|--|-|--------|-|--|--- |-------|----||- ---
||||||||||||||||||||| |||||||||||||||||||||||| |||||||||||||||||||||
-- |-|||||-|||||--|||- |||||||||----||||||||| -|||--|||||-|||||-| --
---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
------ ---- ------------ ------------------ ------------ ---- ------
---|-|| ||-||| |--|||--|| ||-||------||-|| ||--|||--| |||-|| ||-|---
---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
-----||----|-------|----|-- -|--------|- --|----|-------|----||-----
---|-|||||-|||||--|||--||||| || ---- || |||||--|||--|||||-|||||-|---
----- |----|------- ----|---- -------- ----|---- -------|----| -----
---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
---|-|||||-|||||--|||--||||| || ---- || |||||--|||--|||||-|||||-|---
| |||||||||||||||||||-|||||||||| || ||||||||||-||||||||||||||||||| |
 -|||||||||||||| -|||-||||||||||-  -||||||||||-|||- ||||||||||||||- 
 -|||||||||||||| -|||-||||||||||-  -||||||||||-|||- ||||||||||||||- 
| |||||||||||||||||||-|||||||||| || ||||||||||-||||||||||||||||||| |
---|-|||||-|||||--|||--||||| || ---- || |||||--|||--|||||-|||||-|---
---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
----- |----|------- ----|---- -------- ----|---- -------|----| -----
---|-|||||-|||||--|||--||||| || ---- || |||||--|||--|||||-|||||-|---
-----||----|-------|----|-- -|--------|- --|----|-------|----||-----
---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
---|-|| ||-||| |--|||--|| ||-||------||-|| ||--|||--| |||-|| ||-|---
------ ---- ------------ ------------------ ------------ ---- ------
---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
-- |-|||||-|||||--|||- |||||||||----||||||||| -|||--|||||-|||||-| --
||||||||||||||||||||| |||||||||||||||||||||||| |||||||||||||||||||||
--- -||----|-------| ---|--|-|--------|-|--|--- |-------|----||- ---
----- |----|------- ----|---- -------- ----|---- -------|----| -----
---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
|-||||||||||||||| |||-||||||||||-||-||||||||||-||| |||||||||||||||-|
 -|||||||||||||| -|||-||||||||||-  -||||||||||-|||- ||||||||||||||- 
---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
---|-|| ||-||| |--|||--|| ||-||------||-|| ||--|||--| |||-|| ||-|---
---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
---|-||--|-| ------||---|--|-|--------|-|--|---||------ |-|--||-|---
------ ---- ------------ ------------------ ------------ ---- ------
--|| ||||| |||||--|||-||||||||||----||||||||||-|||--||||| ||||| ||--
---|-||-- -|-------||---|--|-|--------|-|--|---||-------|- --||-|---
---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
---|-|| ||-||| |--|||--|| ||-||------||-|| ||--|||--| |||-|| ||-|---
------ ---- ------------ ------------------ ------------ ---- ------
----- |----|------- ----|---- -------- ----|---- -------|----| -----
--|| ||||| |||||--|||-||||||||||----||||||||||-|||--||||| ||||| ||--
--- -||----|-------| ---|--|-|--------|-|--|--- |-------|----||- ---
-- |-|||||-|||||--|||- |||||||||----||||||||| -|||--|||||-|||||-| --
| |||||||||||||||||||-|||||||||| || ||||||||||-||||||||||||||||||| |
 -|||||||||||||| -|||-||||||||||-  -||||||||||-|||- ||||||||||||||-  

2
Witamy w Programowaniu Puzzle i Code Golf! To bardzo miła pierwsza odpowiedź. :)
Alex A.

1
Pamiętaj, że nie musisz używać \u2015. Użycie poziomego paska (lub po prostu kreski) w surowym kodzie jest w porządku.
Calvin's Hobbies

Jestem prawie pewien, że jeśli użyjesz normalnego Stringzamiast StringBuilderodpowiedzi, może być znacznie krótszy ... (nawet jeśli może zająć o wiele więcej pamięci)
Leaky Nun

Możesz wygrać kilka bajtów, deklarując wszystkie ints na tej samej linii:int i,j,l=m.length();for(i=0;i<l;i++){...
Aaron

Myślę, że możesz dużo zaoszczędzić, jeśli zmienisz pętle for na dla każdej pętli. Nie potrzebujesz indeksów do niczego innego niż uzyskanie char.
Frozn

11

Haskell, 93 bajty

r=reverse
h x=unlines$(++)<*>r$zipWith(++)<*>map r$(<$>x).((("- |"!!).fromEnum).).compare<$>x

Przykład użycia:

*Main> putStr $ h "food"
 --||-- 
|  ||  |
|  ||  |
---  ---
---  ---
|  ||  |
|  ||  |
 --||-- 

Jak to działa (uwaga: (f <*> g) xjest zdefiniowane jako f x (g x)):

((("- |"!!).fromEnum).).compare       -- a function that finds the replacement char
                                      -- for two given chars
   (<$>x).(    )<$>x                  -- map this function for every char in the
                                      -- input over each char. Now we have the
                                      -- first quadrant as a list of strings
zipWith(++) <*> map r                 -- append to each line a reversed copy of itself
(++) <*> r                            -- append a reversed copy of the whole list
unlines                               -- turn into a single string

Alternatywna wersja: funkcję „znajdź zamiennik” ((("- |"!!).fromEnum).).comparemożna również zapisać jako a#b|a<b='-'|a>b='|'|1<2=' 'i wywołać za pomocą (#)tej samej liczby bajtów.


8

Galaretka , 16 bajtów

Om©0_'®Ṡị“-| ”j⁷

Wypróbuj online!

Jak to działa

Om©0_'®Ṡị“-| ”j⁷  Main link. Argument: s (string)

O                 Ordinal; replace the characters of s with their code points.
 m 0              Concatenate the result with a reversed copy.
  ©               Copy the result to the register.
      ®           Yield the list in the register.
    _'            Perform spawned difference of the character codes.
       Ṡ          Apply the sign function.
        ị“-| ”    Index into that string (indices 1, -1, 0).
              j⁷  Join, separating by linefeeds.

8

JavaScript (ES6), 94 bajty

s=>[...s,s].reverse().join``.replace(/./g,(c,_,t)=>t.replace(/./g,d=>d<c?`|`:d>c?`-`:` `)+`
`)

Używam myślnika, ponieważ zwykle uruchamiam powłokę SpiderSonkey JS w systemie Windows, a Unicode nie działa, jeśli to zrobię.


Genialny pomysł z [...s,s].reverse()+1
Downgoat

5

Pyth 31 30

js_BsM_BMclQsm@" |―"._-FCMd*QQ

Pakiet testowy

Niestety nie można upuścić litery QS z powodu kilku rozwidleń. Do tej pory dość prosty algorytm, liczenie traktuje poziomy pasek jako 1 bajt.


do diabła, 2 sekundy przed opublikowaniem mojego rozwiązania 31 char; P
Maltysen

1
@Maltysen Zmęczyło mnie wyjście z FGITWed;) W każdym razie jestem pewien, że może być krótszy ...
FryAmTheEggman

5

Haskell, 66 bajtów

u s|e<-s++reverse s=unlines[["- |"!!min(length[a..b])2|a<-e]|b<-e]

4

JavaScript ES6, 138 126 123 bajtów

s=>(a=(p=[...s]).map(l=>(b=p.map(i=>i<l?"|":i>l?"-":" ").join``)+[...b].reverse().join``)).concat([...a].reverse()).join`
`

większość kodu to odbijanie / przerzucanie


4

J, 26 20 bajtów

6 bajtów dzięki @Zgarb .

' |-'{~3*@-/~@u:[,|.

Poprzednia 26-bajtowa odpowiedź

({&' |-')@*@-/~@(3&u:)@,|.

Używa tego samego algorytmu, co odpowiedź Dennisa.

Stosowanie:

>> f =: ' |-'{~3*@-/~@u:[,|.
>> f 'food'
<<  --||-- 
   |  ||  |
   |  ||  |
   ---  ---
   ---  ---
   |  ||  |
   |  ||  |
    --||-- 

>> f 'supercalifragilisticexpialidocious'
<<  -|||||||||||||| -|||-||||||||||-  -||||||||||-|||- ||||||||||||||- 
   | |||||||||||||||||||-|||||||||| || ||||||||||-||||||||||||||||||| |
   -- |-|||||-|||||--|||- |||||||||----||||||||| -|||--|||||-|||||-| --
   --- -||----|-------| ---|--|-|--------|-|--|--- |-------|----||- ---
   --|| ||||| |||||--|||-||||||||||----||||||||||-|||--||||| ||||| ||--
   ----- |----|------- ----|---- -------- ----|---- -------|----| -----
   ------ ---- ------------ ------------------ ------------ ---- ------
   ---|-|| ||-||| |--|||--|| ||-||------||-|| ||--|||--| |||-|| ||-|---
   ---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
   ---|-||-- -|-------||---|--|-|--------|-|--|---||-------|- --||-|---
   --|| ||||| |||||--|||-||||||||||----||||||||||-|||--||||| ||||| ||--
   ------ ---- ------------ ------------------ ------------ ---- ------
   ---|-||--|-| ------||---|--|-|--------|-|--|---||------ |-|--||-|---
   ---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
   ---|-|| ||-||| |--|||--|| ||-||------||-|| ||--|||--| |||-|| ||-|---
   ---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
    -|||||||||||||| -|||-||||||||||-  -||||||||||-|||- ||||||||||||||- 
   |-||||||||||||||| |||-||||||||||-||-||||||||||-||| |||||||||||||||-|
   ---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
   ----- |----|------- ----|---- -------- ----|---- -------|----| -----
   --- -||----|-------| ---|--|-|--------|-|--|--- |-------|----||- ---
   ||||||||||||||||||||| |||||||||||||||||||||||| |||||||||||||||||||||
   -- |-|||||-|||||--|||- |||||||||----||||||||| -|||--|||||-|||||-| --
   ---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
   ------ ---- ------------ ------------------ ------------ ---- ------
   ---|-|| ||-||| |--|||--|| ||-||------||-|| ||--|||--| |||-|| ||-|---
   ---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
   -----||----|-------|----|-- -|--------|- --|----|-------|----||-----
   ---|-|||||-|||||--|||--||||| || ---- || |||||--|||--|||||-|||||-|---
   ----- |----|------- ----|---- -------- ----|---- -------|----| -----
   ---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
   ---|-|||||-|||||--|||--||||| || ---- || |||||--|||--|||||-|||||-|---
   | |||||||||||||||||||-|||||||||| || ||||||||||-||||||||||||||||||| |
    -|||||||||||||| -|||-||||||||||-  -||||||||||-|||- ||||||||||||||- 
    -|||||||||||||| -|||-||||||||||-  -||||||||||-|||- ||||||||||||||- 
   | |||||||||||||||||||-|||||||||| || ||||||||||-||||||||||||||||||| |
   ---|-|||||-|||||--|||--||||| || ---- || |||||--|||--|||||-|||||-|---
   ---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
   ----- |----|------- ----|---- -------- ----|---- -------|----| -----
   ---|-|||||-|||||--|||--||||| || ---- || |||||--|||--|||||-|||||-|---
   -----||----|-------|----|-- -|--------|- --|----|-------|----||-----
   ---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
   ---|-|| ||-||| |--|||--|| ||-||------||-|| ||--|||--| |||-|| ||-|---
   ------ ---- ------------ ------------------ ------------ ---- ------
   ---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
   -- |-|||||-|||||--|||- |||||||||----||||||||| -|||--|||||-|||||-| --
   ||||||||||||||||||||| |||||||||||||||||||||||| |||||||||||||||||||||
   --- -||----|-------| ---|--|-|--------|-|--|--- |-------|----||- ---
   ----- |----|------- ----|---- -------- ----|---- -------|----| -----
   ---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
   |-||||||||||||||| |||-||||||||||-||-||||||||||-||| |||||||||||||||-|
    -|||||||||||||| -|||-||||||||||-  -||||||||||-|||- ||||||||||||||- 
   ---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
   ---|-|| ||-||| |--|||--|| ||-||------||-|| ||--|||--| |||-|| ||-|---
   ---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
   ---|-||--|-| ------||---|--|-|--------|-|--|---||------ |-|--||-|---
   ------ ---- ------------ ------------------ ------------ ---- ------
   --|| ||||| |||||--|||-||||||||||----||||||||||-|||--||||| ||||| ||--
   ---|-||-- -|-------||---|--|-|--------|-|--|---||-------|- --||-|---
   ---|-||- |-|| - -- ||-- |- |-| ------ |-| -| --|| -- - ||-| -||-|---
   ---|-|| ||-||| |--|||--|| ||-||------||-|| ||--|||--| |||-|| ||-|---
   ------ ---- ------------ ------------------ ------------ ---- ------
   ----- |----|------- ----|---- -------- ----|---- -------|----| -----
   --|| ||||| |||||--|||-||||||||||----||||||||||-|||--||||| ||||| ||--
   --- -||----|-------| ---|--|-|--------|-|--|--- |-------|----||- ---
   -- |-|||||-|||||--|||- |||||||||----||||||||| -|||--|||||-|||||-| --
   | |||||||||||||||||||-|||||||||| || ||||||||||-||||||||||||||||||| |
    -|||||||||||||| -|||-||||||||||-  -||||||||||-|||- ||||||||||||||- 

( >>znaczenie wejścia (STDIN), <<znaczenie wyjścia (STDOUT))


1
Z pewną restrukturyzacją możesz dostać się do 20 bajtów:' |-'{~3*@-/~@u:[,|.
Zgarb

To miłe użycie widelców ...
Leaky Nun

3

Mathematica, 124 110 104 102 bajtów

a=Join[#,Reverse@#]&;#<>"
"&/@a@a@Table[{"|"," ","-"}[[c~Order~d+2]],{c,b=Characters@#},{d,b}]<>""&

Funkcja anonimowa. Znak Unicode to U + F3C7 dla \[Transpose].


3

JavaScript 146 142 132 130 124 bajtów

n=>(e=(a=[...n]).map(b=>(d=a.map(c=>c<b?"|":c>b?"-":" ")).concat([...d].reverse()).join``)).concat([...e].reverse()).join`
`

Zestaw testowy:

f=n=>{a=n.split``;e=a.map(b=>a.map(c=>c<b?"|":c>b?"-":" ")).map(d=>d.concat([...d].reverse()).join``);alert(e.concat([...e].reverse()).join`
`)}

f(prompt("Enter string!"));

Dzięki za @HelkaHomba, za pomoc w usunięciu co najmniej 50 bajtów, i @Downgoat za 3 bajty!


1
zwykle możesz zamienić => {...} na => (...) i zastąpić wszystkie średniki w tym czasie przecinkami
Downgoat

Ta odpowiedź jest prawie identyczna z odpowiedzią Downgoata, przysięgam, nie spojrzałam na jego odpowiedź.
Bálint

3

Właściwie 53 bajty

;l╗;∙`♂O♂ii-s3@%" |-"E`MW╜`d@`nkd@Σ'.o@WX'.@s;R+;♂R¥i

Po raz kolejny słabą umiejętnością przetwarzania strun jest kryptonit. Jest nadal krótszy niż Java, więc mam to dla siebie, co jest miłe.

Wypróbuj online!

Wyjaśnienie:

Kod można podzielić na 3 odrębne części: kod tłumaczenia, kod przetwarzania i kod dublowania. Dla czytelności wyjaśnię każdą sekcję osobno.

Kod tłumaczenia (zaczyna się od ciągu wejściowego s, na stosie):

;l╗;∙`♂O♂ii-s3@%" |-"E`M
;l╗                       push len(s) to reg0 (needed for processing step; we'll call this n)
   ;∙                     cartesian product of s with itself
     `♂O♂ii-s3@%" |-"E`M  map:
      ♂O♂ii                 get a pair of ordinals for the characters
           -s               subtract, signum
             3@%            mod by 3 because element access with negative indices isn't working
                " |-"E      get corresponding string

Przetwarzanie kodu (zaczyna się od listy n**2znaków odpowiadających prawym dolnym rogu):

W╜`d@`nkd@Σ'.o@WX
W╜`d@`nkd@Σ'.o@W   while loop (while top of stack is truthy):
 ╜`d@`n              remove n characters from the list
       kd@Σ'.o       concatenate those n characters, and append a period
                X  discard the empty list

Kod lustrzany (zaczyna się od n**2+nłańcucha -length, z kropkami działającymi jako znaki nowej linii)

'.@s;R+;♂R¥i
'.@s          split on periods
    ;R+       add the reverse list (vertical mirror)
       ;♂R    make a copy of the list with each string reversed (horizontal mirror)
          ¥   concatenate each pair of strings in the two lists (zip-concat)
           i  flatten list
              (implicitly print each stack item, separated by newlines)

3

> <> , 109 bajtów

i:0(?\:}
,[r]l\~l2,[r]rl2
1-:?!\$:}l1-[}
~]\  \
&r\l:?!;1-
?!\$:@@:@$:@@:@)}(}"- |"{?$@{?$o~~$}&1-:&
4.>~ao]2

Wejście odbywa się przez STDIN. Wypróbuj online!

Wyjaśnienie:

Dane wejściowe odczytano i dublowano w pierwszym wierszu. W przypadku danych wejściowych abcdpozostawia to dcbaabcdna stosie. Każda połowa jest następnie dublowana, aby dać abcddcba(linia 2). Następnie każdy element jest duplikowany i pozostawiany po kolei na swoim stosie (linie 3 i 4). Po tym procesie stosy wyglądają trochę tak:

aabcddcba  <-- top of the stack of stacks
b
c
d
d
c
b
a          <-- bottom of the stack of stacks

Z kolei dla każdego stosu wartość rzędu (spód stosu) jest porównywana z wartością kolumny (szczyt stosu). Odpowiedni znak jest wybierany - |i zapisywany w STDOUT. Wartości kolumn są następnie obracane, tak aby następna kolumna znajdowała się na górze stosu (linia 6).

Po rozważeniu wszystkich kolumn wartość wiersza jest odrzucana, drukowana jest nowa linia, a wartości kolumn są umieszczane na poprzednim stosie (wiersz 7), aby proces wyjściowy zaczął się od nowa.

]Polecenia, oprócz popping ze stosu stosów, opróżnia aktualny stos, jeśli jest to tylko jeden. Warunkiem końcowym programu jest sytuacja, gdy stos jest pusty, ponieważ wszystkie wiersze zostały przetworzone (wiersz 5).


3

C #, 169 150 bajtów

dzięki FryAmTheEggman

void f(string s){s+=new string(s.Reverse().ToArray());foreach(char c in s){var t="";foreach(char k in s)t+=c==k?" ":c>k?"|":"-";Console.WriteLine(t);}

bez golfa:

    public static void f(string s)
    {
        s += new string(s.Reverse().ToArray());
        foreach (char c in s)
        {
            var t="";
            foreach (char k in s)
            t+=c==k?" ":c>k?"|":"-";

            Console.WriteLine(t);
        }

    }

doceniono więcej porad golfowych


t+=c==k?" ":c>k?"|":"-";powinno działać. Nie grałem dużo w C #, ale jest całkiem możliwe, że regularne forpętle będą krótsze.
FryAmTheEggman

Ta odpowiedź ma ten sam problem, co moja pierwotna odpowiedź w języku C # Reverse() iToArray() są częścią System.Linqwymaganego tak użyciu instrukcji.
Phaeze

3

C # 166 143 bajty,

using System.Linq;s=>string.Join("\n",(s+=string.Concat(s.Reverse())).Select(x=>s.Aggregate("",(c, y)=>c+"- |"[Math.Sign(x.CompareTo(y))+1])));

Wyjaśnienie:

using System.Linq;

s=>                                     // Expression bodied member allows for implicit return
  string.Join("\n",                     // Join the generate lines into the final output
    (s+=string.Concat(s.Reverse()))     // Combine s and its reverse inline so aggregate has the whole line
        .Select(x=>                     // For each character in the line run the aggregate to generate its row
            s.Aggregate("",             // Empty string is required to cooerce the output type from char
                (c, y)=>                // c is the generated string so far, y is the next character
                        c+
                                        // Compare the two letters here (row to column)
                                        // Then take the sign of the result to collapse to -1, 0, or 1
                                        // Finally add 1 to line it up with the indexes of the constant string;                                             
                        "- |"[Math.Sign(x.CompareTo(y))+1]
)));

Test:

Wordenticons

 |||||||||||||||||||||| 
- -|||-|| |--| ||-|||- -
-| |||-||||--||||-||| |-
--- ----|------|---- ---
---| ---|------|--- |---
---|| -||- -- -||- ||---
-||||| |||||||||| |||||-
---||-- |------| --||---
-------- ------ --------
- -|||-|| |--| ||-|||- -
---|| -||- -- -||- ||---
-|||||-||||  ||||-|||||-
-|||||-||||  ||||-|||||-
---|| -||- -- -||- ||---
- -|||-|| |--| ||-|||- -
-------- ------ --------
---||-- |------| --||---
-||||| |||||||||| |||||-
---|| -||- -- -||- ||---
---| ---|------|--- |---
--- ----|------|---- ---
-| |||-||||--||||-||| |-
- -|||-|| |--| ||-|||- -
 |||||||||||||||||||||| 

Nie byłem pewien, czy metoda jest do zaakceptowania, jeśli nie, daj mi znać, a ja odpowiednio dostosuję swoją odpowiedź
Phaeze

@Downgoat dzięki za edycję, nie byłem pewien właściwej metody na ucieczkę #.
Phaeze

Który najwyraźniej pomylił się w podglądzie, dobrze wiedzieć
Phaeze

ponieważ ciąg znaków implementuje IEnumerable<char>, możesz zaoszczędzić niektóre bajty, używając .Reverse()bezpośrednio na łańcuchu pomijając.ToCharArray()
grabthefish

możesz również zmienić var a = new[] { '-', ' ', '|' };na, var a = "- |"; ponieważ możesz używać indeksowania ciągów
grabthefish

2

CJam, 20 bajtów

l_W%+_ff{-g" |―"=}N*

Sprawdź to tutaj.

Wykorzystuje oczywiste podejście do obliczania produktu zewnętrznego i używania różnic i sgn do obliczenia znaku w każdej komórce.


2

Clojure, 171 bajtów

(fn[w](let[f concat r reverse p(map #(f %(r %))(partition(count w)(for[x w y w :let[c(compare x y)]](if(neg? c)\-(if(pos? c)\|\ )))))](run! #(apply println %)(f p(r p)))))

bez golfa:

(fn [w]
  (let [n (count w)
        a (for [x w y w
                :let [c (compare x y)]]
            (if (neg? c)
              \-
              (if (pos? c)
                \|
                \ )))
        p (map #(concat % (reverse %))(partition n a))
        p (concat p (reverse p))]
    (run! #(apply println %) p))))

2

J, 75 70 bajtów

5 bajtów zaoszczędzonych dzięki Dennisowi.

3 :'(],.|:@|.@|:)(],|.)''- |''{~]([:-.@*(,~@#$])-(,~@#$(##])@]))3 u:y'

Popracuję później nad przekształceniem go w milczący czasownik.


2

Oktawa, 39 bajtów

@(x)'| -'(sign([x,y=flip(x)]-[x y]')+2)

Tworzy anonimową funkcję, którą można uruchomić za pomocą ans('string').

Próbny

Wyjaśnienie

To rozwiązanie łączy łańcuch wejściowy ( x) i odwrotną ( flip(x)) za pomocą [x, flip(x)]. Odwrotność jest przypisany do yskrócenia odpowiedź [x, y = flip(x)]. Następnie tworzymy wektor kolumny samo przez łączenie xi ybiorąc transpozycję: [x,y]'. Następnie bierzemy różnicę, która zostanie automatycznie nadana, aby utworzyć tablicę 2D różnic między dowolnymi reprezentacjami liter ASCII w łańcuchach. Używamy signdo nich albo -1, 0lub 1, a następnie dodać 2, aby uzyskać prawidłowe wartości indeksu 1 opartych. Następnie używamy ich do indeksowania do początkowego ciągu '| -'.


2

Julia, 70 bajtów

To moja pierwsza próba gry w golfa kodowego i wcześniej nie korzystałem z Julii, więc powiedz mi, co myślisz:

f(s)=join([join([r>c?'|':r<c?'―':' 'for c=s])for r=s*=reverse(s)],"
")

Wypróbuj online!

Nie golfowany:

function wordenticon(word::AbstractString)
    word*=reverse(word)
    join([
        join([
            if r>c
                '|'
            elseif r<c
                '―'
            else
                ' '
            end
            for c in word
        ])
        for r in word]
        ,"\n"
    )
end

Myślę, że prawdopodobnie można go skrócić. Ten kod przechowuje znaki słowa w macierzy:

f(s)=[r>c?'|':r<c?'―':' 'for r=s*=reverse(s),c=s]

Niestety nie udało mi się uzyskać pożądanego wyniku przy użyciu matrycy.


Witaj i witaj w PPCG! Dziękujemy za dołączenie do nas!
NoOneIsHere

1

Jolf, 42 bajty

Trudno grać w golfa. Prawdopodobnie zapominam o wbudowanej macierzy Jolfa.

ΆΖR~mGiEd+γR~mGiEΨ."| -"hmA-~@ά~@HE_γSSZiζ

Wypróbuj tutaj! Ten kod używa funkcji strzałki ( Ψ) dla mapy macierzy.


1

JavaScript, 303 bajtów

function w(o){function r(o){var r=Array.prototype.slice.call(o).reverse();console.log(o.join("")+r.join(""))}var e,n,c,h=[],s=o.length;for(e=0;s>e;e++){for(h.push([]),n=0;s>n;n++)c=o.charCodeAt(n)-o.charCodeAt(e),0===c?h[e].push(" "):0>c?h[e].push("|"):h[e].push("-");r(h[e])}for(e=s-1;e>=0;e--)r(h[e])}

Nie golfił

function w(s) {
    var arr = [],
        l = s.length, r, c, x;
    for (r = 0; r < l; r++) {
        arr.push([]);
        for (c = 0; c < l; c++) {
            x = s.charCodeAt(c) - s.charCodeAt(r);
            if (0 === x) {
                arr[r].push(' ');
            } else if (x<0) {
                arr[r].push('|');
            } else {
                arr[r].push('-');
            }
        }
        out(arr[r]);
    }
    for (r = l - 1; r>=0; r--) {
        out(arr[r]);
    }
    function out(r){
        var rev = Array.prototype.slice.call(r).reverse();
        console.log(r.join('') + rev.join(''));
    }
}

Brak fanaberii ecma 2015 tutaj


Możesz sprawdzić, czy litera pojawia się wcześniej w alfabecie, po prostu wykonując „a” <”b”
Bálint

Nie musisz się tym przejmować var x = 1, po prostu zrób to x = 1. W golfowym kodzie nikt nie dba o przestrzeganie najlepszych praktyk. :)
gcampbell

1

Python 2, 126 bajtów

def f(s):x=[''.join(" -|"[cmp(ord(a),ord(b))]for a in s)for b in s];y=[a+b[::-1]for a,b in zip(x,x)];print'\n'.join(y+y[::-1])

Jest to w zasadzie port mojego rozwiązania .

Wypróbuj online

Wyjaśnienie:

x=[''.join(" -|"[cmp(ord(a),ord(b))]for a in s)for b in s] # get the correct character for each pair of characters in the Cartesian product of s with itself, and concatenate the characters in each line
y=[a+b[::-1]for a,b in zip(x,x)] # mirror each line horizontally
print'\n'.join(y+y[::-1]) # mirror vertically and print

1

Python 3.5, 250 223 175 bajtów:

def H(o):O=ord;G=len(o);p=[[' ―'[O(i)<O(g)],'|'][O(i)>O(g)]for i in o for g in o];u='\n'.join([''.join(p[i:G+i]+p[i:G+i][::-1])for i in range(0,len(p),G)]);print(u+'\n'+u[::-1])

Wypróbuj online! (Ideone) (Dwa ostatnie przypadki testowe nie pojawią się w danych wyjściowych, ponieważ są to tylko puste wiersze. Mój program je jednak przetwarza, co potwierdza fakt, że jest 10 danych wejściowych, ale pojawia się tylko 8 wyników).

Ungolfed, po którym następuje wyjaśnienie:

def H(o):
    O=ord
    G=len(o)
    p=[[' ―'[O(i)<O(g)],'|'][O(i)>O(g)]for i in o for g in o]
    u='\n'.join([''.join(p[i:G+i]+p[i:G+i][::-1])for i in range(0,len(p),G)])
    print(u+'\n'+u[::-1])
  1. p=[[' ―'[O(i)<O(g)],'|'][O(i)>O(g)]for i in o for g in o]

    Utwórz listę, do pktórej |dodaje się a, jeśli wartość punktu Unicode litery kolumny jest mniejsza niż wartość litery wiersza, a dodaje się, jeśli wartość punktu Unicode litery kolumny jest większa niż wartość litery wiersza, lub jeśli oba wartości są równe.

  2. u='\n'.join([''.join(p[i:G+i]+p[i:G+i][::-1])for i in range(0,len(p),G)])

    Utwórz połączony ciąg nowego wiersza uz listy p, dzieląc go na połączone ciągi znaków, z których każdy składa się z wejściowej długości liczby znaków zarówno do przodu, jak i do tyłu, dzięki czemu każdy z nich ma długość 2 razy większą niż liczba znaków na wejściu. To jest górna połowa twojego wordenticonu. Tak więc, w przypadku twojego wkładu food, to zwróci:

     ――||―― 
    |  ||  |
    |  ||  |
    ―――  ―――
    
  3. print(u+'\n'+u[::-1])

    Wreszcie wyjście, upo którym następuje nowa linia, a następnie uodwrócone, aby odzwierciedlić w pionie pierwszą połowę dla drugiej połowy. To jest Twój ukończony wordenticon, który w przypadku testowym foodbędzie w końcu:

     ――||―― 
    |  ||  |
    |  ||  |
    ―――  ―――
    ―――  ―――
    |  ||  |
    |  ||  |
     ――||―― 
    

0

R , 101 bajtów

101 bajtów, ponieważ używam (co moim zdaniem wygląda lepiej niż -).

function(s)write(c("|"," ","―")[sign(outer(g<-c(r<-utf8ToInt(s),rev(r)),g,"-"))+2],"",2*nchar(s),,"")

Wypróbuj online!

Byłem zaskoczony, że wcześniej nie było odpowiedzi R, ponieważ możemy wykorzystać symetrię i macierze R, aby uzyskać dość konkurencyjną odpowiedź, mimo że jest to stringproblem.

Niegolfowane Objaśnienie:

function(s){
 r <- utf8ToInt(s)               # turn to vector of ints (charcodes)
 g <- c(r, rev(r))               # concatenate r and its reverse
 idx <- sign(outer(g,g,"-")) + 2 # compute all differences and their signs.
                                 # -1=>less than, 0=>equal, +1=>greater than
                                 # add 2 to make them 1-based indices into the vector
 write(c("|"," ","―")[idx],"",2*nchar(s),,"")
     # write the vector of characters to stdout "" with line width 2*nchar(s)
     # and no separator
}

0

C (gcc) , 202 bajty

f(c,i,j,s,t,a,v)char*c,*v;{v=malloc((a=strlen(c)*2)*a);for(j=0;t=c[j];j++)for(i=0;s=c[i];i++)v[j*a+i]=v[j*a+a+~i]=v[a*(a+~j)+i]=v[a*(a+~j)+a+~i]="- |"[(s<t)-(s>t)+1];for(;*v;v+=a)write(1,v,a),puts("");}

Wypróbuj online!

Działa poprzez zapętlanie każdego znaku, a następnie aktualizowanie wynikowego znaku (i jego odbić).


0

05AB1E (starsza wersja) , 20 22 21 bajtów

Ǹ˜ãε… |-s`.Sè}sgôJ∞∊

+2 bajty jako poprawka błędów dla danych wejściowych jednoznakowych ..
-1 bajt przy użyciu zwykłych myślników -zamiast , ponieważ możemy wtedy użyć … |-zamiast "… |―"(ponieważ … |―działałby niepoprawnie jako ciąg słownika)

Używa starszej wersji 05AB1E, ponieważ domyślnie łączy się z nowymi liniami podczas tworzenia kopii lustrzanej, co wymaga dodatkowego jawnego »w nowej wersji.

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

Ç             # Push the unicode values of the characters of the (implicit) input-string
 ¸˜           # Wrap this into a list and flatten (workaround for single-char inputs,
              #  since `Ç` will then result in a single value instead of a list of values..)
   ã          # Create each possible pair
ε             # Map each pair to:
  |-         #  Push string " |-" (note: `… |―` cannot be used here, since it will
              #   incorrectly act as a dictionary string)
 s            #  Swap to take the current map-pair
  `           #  Push both values seperated to the stack
   .S         #  Compare them with each other (-1 if a<b; 0 if a==b; 1 if a>b)
 è            #  Use it to index into the string " |―" (-1 will wraparound to the tail)
      }s      # After the map: swap to get the (implicit) input-string again
        gô    # Get its length, and split the mapped list into parts of that size
          J   # Join each character in the inner lists together to a string
           ∞∊ # Mirror both horizontally and vertically (which implicitly joins by newlines
              #  in the legacy version of 05AB1E)
              # (and output the result implicitly)
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.