Generar Wordenticons


54

Los identicones son representaciones visuales de valores hash, a menudo hechos de arreglos simétricos de formas geométricas. Tu avatar predeterminado de Stack Exchange es un identicon. Este desafío se trata de crear "wordenticons" , versiones simples basadas en texto de identicons que se aplican a cadenas de letras minúsculas, es decir, palabras.

Desafío

Escriba un programa o función que tome una cadena S y genere su icono de wordent. Se garantiza que S no está vacío y solo contiene letras minúsculas en inglés az. Opcionalmente, puede suponer que S tiene una nueva línea final.

El icono de wordent de S será una cuadrícula de texto cuadrada con longitudes laterales 2*length(S)compuestas de espacios ( ), barras verticales, ( |) y barras horizontales ( ).

Para generar el icono de wordent de S, forme una cuadrícula cuadrada donde cada columna corresponda a una letra de S (en el orden normal de lectura de izquierda a derecha) y cada fila corresponda a una letra de S (en el orden normal de lectura de arriba a abajo )

Por ejemplo, si S es foodnuestra cuadrícula inicial se ve así

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

donde .es solo un marcador de posición.

Para cada punto vacío (cada .) en la cuadrícula:

  1. Si la letra de la columna viene antes de la letra de la fila alfabéticamente, reemplace la .con |.
  2. Si la letra de la columna viene después de la letra de la fila alfabéticamente, reemplace la .con .
  3. Si las letras de columna y fila son iguales, reemplace .con (espacio).

Aquí está el foodejemplo después de cada uno de estos pasos:

  1. Agregando |:

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

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

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

Para completar el icono de wordenticon, elimine la fila y columna superfluas que contienen las palabras

 ――|
|  |
|  |
――― 

luego refleja todo en horizontal

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

y finalmente reflejarlo nuevamente verticalmente

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

dando como resultado la 2*length(S)cuadrícula de texto de longitud lateral que es el icono de wordent final.

Ejemplos

Aquí hay algunos ejemplos adicionales de wordenticon. Tenga en cuenta que diferentes palabras pueden tener wordenticons idénticos y algunos wordenticons pueden estar completamente hechos de espacios (desafortunadamente, la rebaja no quiere representarlos).

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

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

Puntuación

Este es el , gana el código más corto en bytes. Tiebreaker va a la respuesta anterior.

Notas

  • Cualquier instancia de barra horizontal ( ) en su código puede contarse como 1 byte en lugar de los 3 bytes UTF-8 que realmente ocupa. (Hasta diez instancias).
  • Si lo desea, puede usar guiones regulares ( -) en lugar de barras horizontales ( ).
  • No está permitido eliminar o agregar espacios finales en las líneas de un icono de gusano (incluso si la forma permanece sin cambios). Debe ser un 2*length(S)cuadrado de texto de longitud lateral exacta .
  • El icono de salida de salida puede tener opcionalmente una nueva línea final.

¿Podemos tomar la entrada como una matriz de caracteres?
Downgoat

@Downgoat No, debería ser una cadena normal a menos que no haya absolutamente ninguna otra forma para su idioma.
Hobbies de Calvin

2
Tienes ejemplos para programming, andy codegolfaunque se le olvidó puzzles...
Neil

¿Podría agregar una tabla de clasificación?
Leaky Nun

Así que eventualmente descubrimos por qué preguntaban sobre portmanteaus en el chat :)
gcampbell

Respuestas:


21

MATL, 20 15 bytes

'-| 'jtPht!-ZS)

Pruébalo en MATL Online

Explicación

'-| '       % 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

99
: ¡Oh, superaste a Dennis!
Downgoat

@Downgoat ¡Esta es una de esas raras ocasiones en que MATL es más corto que Jelly!
Suever

¡Buena idea usar la función de signo!
Luis Mendo

18

Java, 329 305 264 259 192 bytes

Gracias a:

  • @ Bálint por sugerir utilizar operadores ternarios.
  • @ user902383 por sugerir invertir la cadena yo mismo
  • @Frozn y @ user902383 por sugerir reemplazar StringBuildercon String.

Golfizado:

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

Sin golf:

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

Definitivamente uno divertido. El primer intento fue una función que fue O(n)reemplazada por esta forma más simple después de que me frustré demasiado.

Y, para probar:

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

2
¡Bienvenido a Programming Puzzles & Code Golf! Esta es una muy buena primera respuesta. :)
Alex A.

1
Tenga en cuenta que no tiene que usar \u2015. Usar barra horizontal (o simplemente guión) en el código sin procesar está bien.
Aficiones de Calvin

Estoy bastante seguro de que si Stringusaras StringBuilderla respuesta normal en lugar de la respuesta podría ser mucho más corta ... (a pesar de que puede requerir mucha más memoria)
Leaky Nun

Podrías ganar algunos bytes declarando todos los ints en la misma línea:int i,j,l=m.length();for(i=0;i<l;i++){...
Aaron

Creo que podría ahorrar mucho si cambia los bucles for por cada bucles. No necesita los índices para otra cosa que no sea obtener el carbón.
Frozn

11

Haskell, 93 bytes

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

Ejemplo de uso:

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

Cómo funciona (nota: (f <*> g) xse define como 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

Versión alternativa: la función "buscar reemplazo" ((("- |"!!).fromEnum).).comparetambién se puede escribir a#b|a<b='-'|a>b='|'|1<2=' 'y llamar a través (#)del mismo número de bytes.


8

Jalea , 16 bytes

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

Pruébalo en línea!

Cómo funciona

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 bytes

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

Uso un guión porque generalmente ejecuto el shell SpiderMonkey JS en Windows y Unicode no funciona si lo hago.


Idea brillante con el [...s,s].reverse()+1
Downgoat

5

Pyth 31 30

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

Banco de pruebas

Lamentablemente, no puedo soltar el Qs debido a los varios bifurcados. Algoritmo bastante básico hasta ahora, cuenta trata la barra horizontal como 1 byte.


maldita sea, 2 segundos antes de publicar mi solución de 31 caracteres; P
Maltysen

1
@Maltysen Me cansé de estar fuera FGITWed;) De todos modos, estoy seguro de que puede ser más corto ...
FryAmTheEggman

5

Haskell, 66 bytes

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

4

JavaScript ES6, 138 126 123 bytes

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

la mayor parte del código es el reflejo / volteo


4

J 26 20 bytes

6 bytes gracias a @Zgarb .

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

Respuesta anterior de 26 bytes

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

Utiliza el mismo algoritmo que la respuesta de Dennis.

Uso:

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

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

( >>entrada de significado (STDIN), <<salida de significado (STDOUT))


1
Con un poco de reestructuración, puede llegar a 20 bytes:' |-'{~3*@-/~@u:[,|.
Zgarb

Es un buen uso de tenedores ...
Leaky Nun

3

Mathematica, 124 110 104 102 bytes

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

Función anónima. El carácter Unicode es U + F3C7 para \[Transpose].


3

Javascript 146 142 132 130 124 bytes

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

Banco de pruebas:

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

¡Gracias por @HelkaHomba, por ayudar a eliminar al menos 50 bytes, y por @Downgoat por 3 bytes!


1
generalmente puede reemplazar => {...} con => (...) y reemplazar todos los puntos y comas dentro de ese tiempo comas
Downgoat

Esta respuesta es casi idéntica a la de Downgoat, lo juro, no miré la suya.
Bálint

3

En realidad, 53 bytes

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

Una vez más, las pobres habilidades de procesamiento de cuerdas de Actually son su criptonita. Todavía es más corto que Java, así que tengo eso para mí, lo cual es bueno.

Pruébalo en línea!

Explicación:

El código se puede separar en 3 partes distintas: el código de traducción, el código de procesamiento y el código reflejado. Para facilitar la lectura, voy a explicar cada sección por separado.

Código de traducción (comienza con la cadena de entrada,, sen la pila):

;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

Código de procesamiento (comienza con una lista de n**2caracteres, correspondiente a la esquina inferior derecha):

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

Código reflejado (comienza con una n**2+ncadena de longitud, con puntos que actúan como líneas nuevas)

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

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

La entrada es a través de STDIN. Pruébalo en línea!

Explicación:

La entrada leyó y se reflejó en la primera línea. Para la entrada abcd, esto deja dcbaabcden la pila. Cada mitad se refleja para dar abcddcba(línea 2). Luego, cada elemento se duplica y se deja en su propia pila (líneas 3 y 4). Después de este proceso, la pila de pilas se parece un poco a esto:

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

Para cada pila, el valor de la fila (la parte inferior de la pila) se compara con el valor de la columna (la parte superior de la pila). El carácter apropiado se selecciona - |y se escribe en STDOUT. Los valores de la columna se rotan para que la siguiente columna esté en la parte superior de la pila (línea 6).

Una vez que se han considerado todas las columnas, se descarta el valor de la fila, se imprime una nueva línea y los valores de la columna se colocan en la pila anterior (línea 7), para que el proceso de salida comience nuevamente.

El ]comando, además de aparecer en la pila de pilas, vacía la pila actual si es la única que queda. La condición final del programa es si la pila está vacía, ya que se han procesado todas las filas (línea 5).


3

C #, 169 150 bytes

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

sin golf:

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

    }

más consejos de golf apreciados


t+=c==k?" ":c>k?"|":"-";Deberia trabajar. No he jugado mucho al C #, pero es muy posible que el uso de forbucles regulares sea ​​más corto.
FryAmTheEggman

Esta respuesta tiene el mismo problema que mi respuesta original de C # en que ambos Reverse()y ToArray()son parte de System.Linqlo que se requiere una declaración de uso.
Phaeze

3

C # 166 143 bytes,

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

Explicación:

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

Prueba:

Wordenticons

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

No estaba seguro de si el método solo era aceptable, si no, hágamelo saber y ajustaré mi respuesta en consecuencia
Phaeze

@Downgoat gracias por la edición, no estaba seguro del método adecuado para escapar del #.
Phaeze

Lo que aparentemente solo se equivocó en la vista previa, es bueno saberlo
Phaeze

dado que la cadena se implementa IEnumerable<char>, puede guardar algunos bytes al usar .Reverse()directamente en la cadena omitiendo el.ToCharArray()
grabthefish

también podría cambiar var a = new[] { '-', ' ', '|' };a var a = "- |"; porque puede usar la indexación en cadenas
grabthefish

2

CJam, 20 bytes

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

Pruébalo aquí.

Utiliza el enfoque obvio de calcular un producto externo y usar la diferencia y sgn para calcular el carácter en cada celda.


2

Clojure, 171 bytes

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

sin golf:

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

5 bytes guardados gracias a Dennis.

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

Trabajaré para convertirlo en un verbo tácito más tarde.


2

Octava, 39 bytes

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

Crea una función anónima que se puede ejecutar usando ans('string') .

Manifestación

Explicación

Esta solución combina la cadena de entrada ( x) y es inversa ( flip(x)) usando [x, flip(x)]. La inversa es asignado a yacortar la respuesta, [x, y = flip(x)]. Entonces se crea un vector columna de lo mismo mediante la combinación de xy yy tomando la transpuesta: [x,y]'. Luego tomamos la diferencia que se transmitirá automáticamente para crear una matriz 2D de diferencias entre cualquier representación ASCII de letras en las cadenas. Utilizamos signpara hacer estos tampoco -1, 0o 1y luego añadir 2para obtener los valores de índice basado en 1 válido. Luego los usamos para indexar en la cadena inicial '| -'.


2

Julia, 70 bytes

Este es mi primer intento de golf de código y no he usado a Julia antes, así que dime qué piensas:

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

Pruébalo en línea!

Sin golf:

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

Creo que probablemente podría hacerse más corto. Este código almacena los caracteres del wordicon en una matriz:

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

Desafortunadamente, no pude producir la salida deseada usando la matriz.


Hola y bienvenidos a PPCG! ¡Gracias por unirte a nosotros!
NoOneIsHere

1

Jolf, 42 bytes

Apenas golfizado. Probablemente me estoy olvidando de una matriz incorporada que tiene Jolf.

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

Pruébalo aquí! Este código utiliza una función de flecha ( Ψ) para el mapa matricial.


1

Javascript, 303 bytes

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

Sin golf

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

No hay fantasía de ecma 2015 aquí


Puede verificar, si una letra aparece antes en alphahet, simplemente haciendo "a" <"b"
Bálint

No necesitas molestarte var x = 1, solo hazlo x = 1. En el código de golf, a nadie le importa adherirse a las mejores prácticas. :)
gcampbell

1

Python 2, 126 bytes

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

Esto es esencialmente un puerto de mi solución de hecho .

Pruébalo en línea

Explicación:

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

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

¡Pruébelo en línea! (Ideone) (Los dos últimos casos de prueba no aparecerán en la salida ya que son solo líneas en blanco. Sin embargo, mi programa los está procesando, lo que confirma el hecho de que hay 10 casos de entrada, pero solo aparecen 8 salidas).

Ungolfed seguido de una Explicación:

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]

    Cree una lista, pdonde a |se agrega si el valor de punto Unicode de la letra de la columna es menor que el valor de la letra de la fila, se agrega a si el valor de punto Unicode de la letra de la columna es mayor que el valor de la letra de la fila, o a si ambos Los valores son iguales.

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

    Cree una cadena unida de nueva línea u, a partir de la lista, pdividiéndola en segmentos de cadena unidos, cada uno de los cuales consta de un número de caracteres de longitud de entrada tanto hacia adelante como hacia atrás, lo que hace que cada uno tenga la longitud de 2 veces la cantidad de caracteres que hay en la entrada. Esta es la mitad superior de su icono de wordent. Entonces, en el caso de que su entrada sea food, esto devolvería:

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

    Finalmente, salida useguida de una nueva línea y luego uinvertida para reflejar verticalmente la primera mitad para la segunda mitad. Este es su icono de wordent completo, que para el caso de prueba foodfinalmente sería:

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

0

R , 101 bytes

101 bytes ya que estoy usando (que creo que se ve mejor que -).

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

Pruébalo en línea!

Me sorprendió que no hubiera una respuesta R antes, ya que podemos explotar la simetría y las matrices de R para obtener una respuesta bastante competitiva, a pesar de ser string problema.

Explicación no golfista:

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 bytes

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

Pruébalo en línea!

Funciona recorriendo cada carácter y luego actualizando el carácter resultante (y sus reflexiones).


0

05AB1E (heredado) , 20 22 21 bytes

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

+2 bytes como corrección de errores para entradas de un solo carácter.
-1 byte usando guiones regulares en -lugar de , ya que podemos usar en … |-lugar de"… |―" (ya que… |― que actuaría incorrectamente como una cadena de diccionario)

Utiliza la versión heredada de 05AB1E, ya que se une implícitamente a las nuevas líneas cuando se refleja, lo que requiere un explícito adicional » en la nueva versión.

Pruébalo en línea o verifique todos los casos de prueba .

Explicación:

Ç             # 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)
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.