Genera wordenticon


54

Gli identiconi sono rappresentazioni visive di valori di hash, spesso realizzati da disposizioni simmetriche di forme geometriche. L'avatar di Stack Exchange predefinito è identicon. Questa sfida riguarda la creazione di "wordenticon" , semplici versioni testuali di identicon che si applicano a stringhe di lettere minuscole, cioè parole.

Sfida

Scrivi un programma o una funzione che accetta una stringa S e genera il suo wordenticon. S è garantito come non vuoto e contiene solo caratteri alfabetici minuscoli az. Puoi facoltativamente supporre che S abbia una nuova riga finale.

Il wordenticon di S sarà una griglia quadrata di testo con lunghezze laterali 2*length(S)composta da spazi ( ), barre verticali, ( |) e barre orizzontali ( ).

Per generare il wordenticon di S, forma una griglia quadrata in cui ogni colonna corrisponde a una lettera di S (nel normale ordine di lettura da sinistra a destra) e ogni riga corrisponde a una lettera di S (nel normale ordine di lettura dall'alto verso il basso ).

Ad esempio, se S è la foodnostra griglia iniziale assomiglia

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

dove .è solo un segnaposto.

Per ogni punto vuoto (ogni .) nella griglia:

  1. Se la lettera della colonna precede alfabeticamente la lettera della riga, sostituire .con |.
  2. Se la lettera della colonna segue la lettera in ordine alfabetico, sostituire .con .
  3. Se le lettere di colonna e riga sono uguali, sostituire .con (spazio).

Ecco l' foodesempio dopo ciascuno di questi passaggi:

  1. Aggiunta |di:

     food
    f...|
    o|..|
    o|..|
    d....
    
  2. Aggiunta di:

     food
    f.――|
    o|..|
    o|..|
    d―――.
    
  3. Aggiunta di:

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

Per completare il wordenticon, rimuovere la riga e la colonna superflue contenenti le parole

 ――|
|  |
|  |
――― 

quindi rispecchia l'intera cosa in orizzontale

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

e infine rispecchiarlo di nuovo in verticale

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

risultante nella 2*length(S)griglia di testo della lunghezza laterale che è il wordenticon finale.

Esempi

Ecco alcuni esempi di wordenticon aggiuntivi. Nota che parole diverse possono avere wordenticon identici e alcuni wordenticon possono essere completamente fatti di spazi (sfortunatamente il markdown non vuole renderli).

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

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

punteggio

Questo è , vince il codice più breve in byte. Tiebreaker va alla risposta precedente.

Appunti

  • Qualsiasi istanza di barra orizzontale ( ) nel codice può essere conteggiata come 1 byte anziché 3 byte UTF-8 che occupa effettivamente. (Fino a dieci istanze.)
  • Se lo si desidera, è possibile utilizzare trattini regolari ( -) al posto delle barre orizzontali ( ).
  • La rimozione o l'aggiunta di spazi finali nelle righe di un wordenticon non è consentita (anche se la forma rimane invariata). Dovrebbe essere un 2*length(S)quadrato di testo di lunghezza laterale esatta .
  • Il wordenticon di output può facoltativamente avere una nuova riga finale.

Possiamo prendere l'input come una matrice di caratteri?
Downgoat,

@Downgoat No, dovrebbe essere una stringa normale a meno che non ci sia assolutamente nessun altro modo per la tua lingua.
Calvin's Hobbies,

2
Hai esempi per programming, ande codegolfma si è dimenticato puzzles...
Neil

Potresti aggiungere una classifica?
Leaky Nun,

Quindi alla fine abbiamo scoperto perché stavi chiedendo dei portmanteaus in chat :)
gcampbell,

Risposte:


21

MATL, 20 15 byte

'-| 'jtPht!-ZS)

Provalo su MATL Online

Spiegazione

'-| '       % 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 hai superato Dennis!
Downgoat,

@Downgoat Questa è una di quelle rare occasioni in cui MATL è più corto di Jelly!
Suever,

Buona idea usare la funzione segno!
Luis Mendo,

18

Java, 329 305 264 259 192 byte

Grazie a:

  • @ Bálint per aver suggerito di usare operatori ternari.
  • @ user902383 per aver suggerito di invertire la stringa da solo
  • @Frozn e @ user902383 per aver suggerito di sostituire StringBuildercon String.

golfed:

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

Ungolfed:

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

Sicuramente divertente. Il primo tentativo fu una funzioneO(n) sostituita da questa forma più semplice dopo che sono diventato troppo frustrato.

E, per testare:

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

2
Benvenuto in Programmazione di puzzle e codice golf! Questa è un'ottima prima risposta. :)
Alex A.

1
Nota che non devi usare \u2015. L'uso della barra orizzontale (o semplicemente del trattino) nel codice non elaborato va bene.
Calvin's Hobbies,

Sono abbastanza sicuro che se avessi usato normale Stringinvece che StringBuilderla risposta potrebbe essere molto più breve ... (anche se potrebbe richiedere molta più memoria)
Leaky Nun,

Potresti vincere dei byte dichiarando tutti inti messaggi sulla stessa linea:int i,j,l=m.length();for(i=0;i<l;i++){...
Aaron,

Penso che potresti risparmiare molto se cambi i for per in per ogni loop. Non hai bisogno degli indici per nient'altro che ottenere il carattere.
Frozn,

11

Haskell, 93 byte

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

Esempio di utilizzo:

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

Come funziona (nota: (f <*> g) xè definito come 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

Versione alternativa: la funzione "trova sostituzione" ((("- |"!!).fromEnum).).comparepuò anche essere scritta come a#b|a<b='-'|a>b='|'|1<2=' 'e chiamata tramite (#)per lo stesso conteggio byte.


8

Gelatina , 16 byte

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

Provalo online!

Come funziona

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 byte

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

Usando un trattino perché di solito eseguo la shell SpiderMonkey JS su Windows e Unicode non funziona se lo faccio.


Idea [...s,s].reverse()
geniale

5

Pyth, 31 30

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

Test Suite

Purtroppo non è possibile eliminare la Qs a causa dei numerosi biforcati. Algoritmo abbastanza semplice finora, il conteggio considera la barra orizzontale come 1 byte.


dannazione, 2 secondi prima di pubblicare la mia soluzione di 31 caratteri; P
Maltysen,

1
@Maltysen Mi sono stancato di essere fuori FGITWed;) Comunque sono sicuro che può essere più breve ...
FryAmTheEggman

5

Haskell, 66 byte

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

4

JavaScript ES6, 138 126 123 byte

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

la maggior parte del codice è il reflecting / flipping


4

J, 26 20 byte

6 byte grazie a @Zgarb .

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

Risposta precedente a 26 byte

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

Utilizza lo stesso algoritmo della risposta di Dennis.

Uso:

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

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

( >>significato input (STDIN), <<significato output (STDOUT))


1
Con qualche ristrutturazione, puoi arrivare a 20 byte:' |-'{~3*@-/~@u:[,|.
Zgarb,

È un bell'uso delle forcelle ...
Leaky Nun,

3

Mathematica, 124 110 104 102 byte

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

Funzione anonima. Il carattere Unicode è U + F3C7 per \[Transpose].


3

Javascript 146 142 132 130 124 byte

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

Suite di test:

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

Grazie per @HelkaHomba, per l'aiuto nella rimozione di almeno 50 byte, e per @Downgoat per 3 byte!


1
di solito puoi sostituire => {...} con => (...) e sostituire tutti i punti e virgola entro quelle virgole
Downgoat,

Questa risposta è quasi identica a quella di Downgoat, lo giuro, non ho guardato la sua.
Bálint,

3

In realtà, 53 byte

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

Ancora una volta, le scarse capacità di elaborazione delle stringhe in realtà sono la sua criptonite. È ancora più corto di Java, quindi ho quello che fa per me, il che è bello.

Provalo online!

Spiegazione:

Il codice può essere separato in 3 parti distinte: il codice di traduzione, il codice di elaborazione e il codice di mirroring. Per leggibilità, spiegherò ciascuna sezione separatamente.

Codice di traduzione (inizia con la stringa di input,, snello stack):

;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

Codice di elaborazione (inizia con un elenco di n**2caratteri, corrispondente all'angolo in basso a destra):

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

Codice di mirroring (inizia con una n**2+nstringa di lunghezza, con punti che agiscono come nuove righe)

'.@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 byte

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

L'ingresso è tramite STDIN. Provalo online!

spiegazione:

L'input che ha letto e rispecchiato sulla prima riga. Per input abcd, questo lascia dcbaabcdin pila. Ogni metà viene quindi specchiata per dare abcddcba(linea 2). Quindi, ogni elemento viene duplicato e lasciato a sua volta sul proprio stack (righe 3 e 4). Dopo questo processo, la pila di pile appare un po 'così:

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

Per ogni pila a sua volta, il valore della riga (la parte inferiore della pila) viene confrontato con il valore della colonna (la parte superiore della pila). Il carattere appropriato viene selezionato - |e scritto in STDOUT. I valori della colonna vengono quindi ruotati in modo che la colonna successiva sia nella parte superiore dello stack (riga 6).

Una volta considerate tutte le colonne, il valore della riga viene scartato, viene stampata una nuova riga e i valori della colonna vengono inseriti nello stack precedente (riga 7), per far ripartire il processo di output.

Il ] comando, oltre a spuntare dalla pila di pile, svuota la pila corrente se è l'unica rimasta. La condizione finale del programma è se lo stack è vuoto, poiché tutte le righe sono state elaborate (riga 5).


3

C #, 169 150 byte

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

ungolfed:

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

    }

più consigli sul golf apprezzati


t+=c==k?" ":c>k?"|":"-";dovrebbe funzionare. Non ho giocato a golf C # molto, ma è abbastanza possibile che l'uso di foranelli regolari sarà più breve.
FryAmTheEggman,

Questa risposta ha lo stesso problema che la mia risposta C # originale ha fatto in entrambi Reverse()e ne ToArray()fanno parte, System.Linqpertanto è richiesta un'istruzione using.
Phaeze,

3

C # 166 143 byte,

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

Spiegazione:

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

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

Non ero sicuro che solo il metodo fosse accettabile, in caso contrario fammelo sapere e
modificherò di

@Downgoat grazie per la modifica, non ero sicuro del metodo corretto per sfuggire al #.
Phaeze,

Che apparentemente si è solo incasinato nell'anteprima, buono a sapersi
Phaeze

poiché la stringa implementa IEnumerable<char>puoi salvare alcuni byte usando .Reverse()direttamente la stringa saltando il.ToCharArray()
grabthefish

potresti anche passare var a = new[] { '-', ' ', '|' };a var a = "- |"; perché puoi usare l'indicizzazione sulle stringhe
prendi

2

CJam, 20 byte

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

Provalo qui.

Utilizza l'approccio ovvio di calcolare un prodotto esterno e usare la differenza e sgn per calcolare il carattere in ogni cella.


2

Clojure, 171 byte

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

ungolfed:

(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 byte

5 byte salvati grazie a Dennis.

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

Lavorerò per convertirlo in un verbo tacito più tardi.


2

Ottava, 39 byte

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

Crea una funzione anonima che può essere eseguita utilizzando ans('string').

dimostrazione

Spiegazione

Questa soluzione combina la stringa di input ( x) e il suo inverse ( flip(x)) utilizzando [x, flip(x)]. L'inverso viene assegnato yper accorciare la risposta, [x, y = flip(x)]. Abbiamo quindi creare un vettore colonna della stessa cosa, combinando xed ye prendendo la trasposta: [x,y]'. Quindi prendiamo la differenza che verrà automaticamente trasmessa per creare una matrice 2D di differenze tra qualsiasi rappresentazione ASCII di lettere nelle stringhe. Usiamo signquesti o -1, 0oppure, 1quindi aggiungiamo 2per ottenere valori di indice basati su 1 validi. Quindi li usiamo per indicizzarli nella stringa iniziale '| -'.


2

Julia, 70 byte

Questo è il mio primo tentativo di code golf e non ho mai usato Julia prima, quindi dimmi cosa ne pensi:

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

Provalo online!

Ungolfed:

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

Penso che probabilmente potrebbe essere ridotto. Questo codice memorizza i caratteri del wordicon in una matrice:

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

Sfortunatamente, non sono riuscito a produrre l'output desiderato usando la matrice.


Ciao e benvenuto in PPCG! Grazie per esserti unito a noi!
NoOneIsHere

1

Jolf, 42 byte

Difficilmente giocato a golf. Probabilmente mi sto dimenticando di una matrice costruita da Jolf.

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

Provalo qui! Questo codice utilizza una funzione freccia ( Ψ) per la mappa matrice.


1

Javascript, 303 byte

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

Ungolfed

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(''));
    }
}

Nessuna fantasia ecma 2015 qui


Puoi verificare, se una lettera arriva prima in ordine alfabetico, semplicemente facendo "a" <"b"
Bálint,

Non devi preoccuparti var x = 1, basta x = 1. Nel code golf a nessuno importa aderire alle migliori pratiche. :)
gcampbell,

1

Python 2, 126 byte

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

Questa è essenzialmente una porta della mia soluzione In realtà .

Provalo online

Spiegazione:

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 byte:

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

Provalo online! (Ideone) (Gli ultimi due casi di test non verranno visualizzati nell'output poiché sono solo righe vuote. Il mio programma li sta elaborando, il che è confermato dal fatto che ci sono 10 casi input, ma compaiono solo 8 output.)

Ungolfed seguito da una spiegazione:

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]

    Creare un elenco, in pcui |viene aggiunto a se il valore del punto Unicode della lettera della colonna è inferiore al valore della lettera di riga, viene aggiunto un se il valore del punto Unicode della lettera della colonna è superiore al valore della lettera di riga, oppure se entrambi i valori sono uguali.

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

    Crea una nuova stringa unita,, udalla lista p, suddividendola in segmenti di stringa uniti ciascuno costituito da un numero di caratteri di lunghezza di input sia in avanti che all'indietro, risultando in ognuno con la lunghezza di 2 volte il numero di caratteri presenti nell'input. Questa è la metà superiore del tuo wordenticon. Quindi, nel caso in cui il tuo input sia food, ciò restituirebbe:

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

    Infine, l'output è useguito da una nuova riga e quindi uinvertito per rispecchiare verticalmente la prima metà per la seconda metà. Questo è il tuo wordenticon completo, che per il test case foodsarebbe finalmente:

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

0

R , 101 byte

101 byte da quando sto usando (che penso sia migliore di -).

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

Provalo online!

Sono stato sorpreso che prima non esistesse una risposta R poiché possiamo sfruttare la simmetria e le matrici di R per ottenere una risposta abbastanza competitiva, nonostante questo sia un stringproblema.

Spiegazione non golfata:

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 byte

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

Provalo online!

Funziona ciclicamente attraverso ogni personaggio, quindi aggiornando il carattere risultante (e le sue riflessioni).


0

05AB1E (legacy) , 20 22 21 byte

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

+2 byte come correzione di bug per input a carattere singolo.
-1 byte utilizzando trattini regolari -anziché , poiché potremmo quindi utilizzare … |-invece di "… |―"(poiché … |―fungerebbe erroneamente da stringa del dizionario)

Utilizza la versione legacy di 05AB1E, poiché si unisce implicitamente alle nuove righe durante il mirroring, che richiede un ulteriore esplicito »nella nuova versione.

Provalo online o verifica tutti i casi di test .

Spiegazione:

Ç             # 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)
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.