Gerar Wordenticons


54

Identicons são representações visuais de valores de hash, geralmente feitos de arranjos simétricos de formas geométricas. Seu avatar padrão do Stack Exchange é um identicon. Esse desafio é sobre a criação de "wordenticons" , versões simples de identicons baseadas em texto que se aplicam a cadeias de letras minúsculas, ou seja, palavras.

Desafio

Escreva um programa ou função que use uma string S e produza seu wordenticon. É garantido que S não é vazio e contém apenas caracteres em minúsculas da letra em inglês az. Opcionalmente, você pode assumir que S tem uma nova linha à direita.

O wordenticon de S será uma grade quadrada de texto com comprimentos laterais 2*length(S)compostos por espaços ( ), barras verticais, ( |) e barras horizontais ( ―).

Para gerar o wordenticon de S, forme uma grade quadrada em que cada coluna corresponda a uma letra de S (na ordem normal de leitura da esquerda para a direita) e cada linha corresponda a uma letra de S (na ordem de leitura normal de cima para baixo) )

Por exemplo, se S é foodnossa grade inicial, parece

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

onde .é apenas um espaço reservado.

Para cada ponto vazio (todos .) na grade:

  1. Se a letra da coluna vier antes da letra da linha em ordem alfabética, substitua .por |.
  2. Se a letra da coluna vier após a letra da linha em ordem alfabética, substitua .por ―.
  3. Se as letras da coluna e da linha forem iguais, substitua .por (espaço).

Aqui está o foodexemplo após cada uma dessas etapas:

  1. Adicionando |:

     food
    f...|
    o|..|
    o|..|
    d....
    
  2. Adicionando ―:

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

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

Para concluir o wordenticon, remova a linha e a coluna supérfluas que contêm as palavras

 ――|
|  |
|  |
――― 

espelhar a coisa toda horizontalmente

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

e finalmente espelhe-o novamente na vertical

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

resultando na 2*length(S)grade de texto de comprimento lateral que é o wordenticon final.

Exemplos

Aqui estão alguns exemplos adicionais do wordenticon. Observe que palavras diferentes podem ter wordenticons idênticos e alguns wordenticons podem ser completamente compostos por espaços (infelizmente a marcação não quer renderizá-los).

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

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

Pontuação

Isso é , o código mais curto em bytes vence. O desempatador vai para a resposta anterior.

Notas

  • Qualquer instância de barra horizontal ( ―) no seu código pode ser contada como 1 byte, em vez dos 3 bytes UTF-8 que ele realmente ocupa. (Até dez instâncias.)
  • Se desejar, você pode usar traços regulares ( -) no lugar de barras horizontais ( ―).
  • Não é permitido remover ou adicionar espaços à direita nas linhas de um wordenticon (mesmo que a forma permaneça inalterada). Deve ser um 2*length(S)quadrado de texto com o comprimento exato do lado.
  • O wordenticon de saída pode, opcionalmente, ter uma única nova linha à direita.

Podemos considerar a entrada como uma matriz de caracteres?
— Downgoat

@Downgoat Não, deve ser uma sequência normal, a menos que não exista outra maneira para o seu idioma.
— Calvin Hobbies

2
Você tem exemplos para programming, ande codegolfmas você esqueceu puzzles...
— Neil

Você poderia adicionar uma tabela de classificação?
— Leaky Nun

Assim fez finalmente descobrir por que você estava perguntando sobre portmanteaus no chat :)
— gcampbell

Respostas:


21

MATL, 20 15 bytes

'-| 'jtPht!-ZS)

Experimente no MATL Online

Explicação

'-| '       % 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
: Oh, você derrotou Dennis!
— Downgoat 26/05

@Downgoat Esta é uma daquelas raras ocasiões em que o MATL é mais curto que o Jelly!
— Suever 26/05

Boa ideia usar a função de sinal!
— Luis Mendo

18

Java, 329 305 264 259 192 bytes

Graças a:

  • @ Bálint por sugerir o uso de operadores ternários.
  • @ user902383 por sugerir reverter a string pessoalmente
  • @Frozn e @ user902383 por sugerir a substituição StringBuilderpor String.

Golfe:

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

Definitivamente divertido. A primeira tentativa foi uma função que O(n)acabou sendo substituída por essa forma mais simples depois que fiquei muito frustrado.

E, para testar:

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

2
Bem-vindo à programação de quebra-cabeças e código de golfe! Esta é uma primeira resposta muito boa. :)
— Alex A.

11
Observe que você não precisa usar \u2015. Usar barra horizontal (ou simplesmente traço) no código bruto é bom.
— Hobbies de Calvin

Tenho certeza que se você usou normal, Stringem vez StringBuilderda resposta poderia ser muito mais curto ... (embora possa ocupar muito mais memória)
— Leaky Nun

Você pode ganhar alguns bytes declarando todos os ints na mesma linha:int i,j,l=m.length();for(i=0;i<l;i++){...
— Aaron

Eu acho que você poderia economizar muito se alterar os loops for para cada loops. Você não precisa dos índices para nada além de obter o caractere.
— Frozn 28/05

11

Haskell, 93 bytes

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

Exemplo de uso:

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

Como funciona (nota: (f <*> g) xé definida 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

Versão alternativa: a função "encontrar substituição" ((("- |"!!).fromEnum).).comparetambém pode ser escrita a#b|a<b='-'|a>b='|'|1<2=' 'e chamada via (#)para a mesma contagem de bytes.


8

Gelatina , 16 bytes

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

Experimente online!

Como 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?`-`:` `)+`
`)

Usando um traço, porque geralmente executo o shell SpiderMonkey JS no Windows e o Unicode não funciona se eu fizer isso.


Idéia brilhante com o [...s,s].reverse()+1
— Downgoat

5

Pyth, 31 30

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

Suíte de teste

Infelizmente, não consigo largar os Qs por causa dos vários bifurcados. Até agora, um algoritmo bastante básico, count trata a barra horizontal como 1 byte.


caramba, 2 segundos antes de eu postar minha solução de 31 caracteres; P
— Maltysen

11
@Maltysen eu cansei de estar fora FGITWed;) De qualquer forma eu tenho certeza que ele pode ser mais curto ...
— 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`
`

a maior parte do código é a reflexão / inversão


4

J, 26 20 bytes

6 bytes graças a @Zgarb .

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

Resposta anterior de 26 bytes

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

Usa o mesmo algoritmo da resposta de Dennis.

Uso:

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

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

( >>significando entrada (STDIN), <<significando saída (STDOUT))


11
Com algumas reestruturações, você pode obter 20 bytes:' |-'{~3*@-/~@u:[,|.
— Zgarb

Isso é um uso agradável de garfos ...
— Leaky Nun

3

Mathematica, 124 110 104 102 bytes

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

Função anônima. O caractere Unicode é U + F3C7 para \[Transpose].


3

Javascript 146 142 132 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`
`

Suíte de teste:

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

Obrigado por @HelkaHomba, por ajudar a remover pelo menos 50 bytes, e por @Downgoat por 3 bytes!


11
geralmente você pode substituir => {...} com => (...) e substituir todos os pontos e vírgulas dentro desse vírgulas tempo
— Downgoat

Essa resposta é quase idêntica à de Downgoat, eu juro, não olhei para a dele.
— Bálint 26/05

3

Na verdade, 53 bytes

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

Mais uma vez, as más habilidades de processamento de cordas da Actually são sua criptonita. Ainda é mais curto que o Java, então tenho isso para mim, o que é legal.

Experimente online!

Explicação:

O código pode ser separado em três partes distintas: o código de conversão, o código de processamento e o código de espelhamento. Para facilitar a leitura, vou explicar cada seção separadamente.

Código de conversão (começa com a sequência de entrada,, sna pilha):

;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 processamento (começa com uma lista de n**2caracteres, correspondente ao canto inferior direito):

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 de espelhamento (começa com uma n**2+ncadeia de comprimento, com períodos atuando como novas linhas)

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

A entrada é via STDIN. Experimente online!

Explicação:

A entrada lida e espelhada na primeira linha. Para entrada abcd, isso deixa dcbaabcdna pilha. Cada metade é então espelhada para dar abcddcba(linha 2). Em seguida, cada elemento é duplicado e deixado em sua própria pilha por vez (linhas 3 e 4). Após esse processo, a pilha de pilhas fica mais ou menos assim:

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

Para cada pilha por vez, o valor da linha (a parte inferior da pilha) é comparado ao valor da coluna (a parte superior da pilha). O caractere apropriado é selecionado - |e gravado em STDOUT. Os valores da coluna são rotacionados para que a próxima coluna esteja no topo da pilha (linha 6).

Depois que todas as colunas forem consideradas, o valor da linha é descartado, uma nova linha impressa e os valores da coluna colocados na pilha anterior (linha 7), para que o processo de saída seja iniciado novamente.

O ]comando, além de saltar da pilha de pilhas, esvazia a pilha atual, se esta for a única. A condição final do programa é se a pilha estiver vazia, pois todas as linhas foram processadas (linha 5).


3

C #, 169 150 bytes

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

    }

mais conselhos sobre golfe apreciados


t+=c==k?" ":c>k?"|":"-";Deveria trabalhar. Eu não joguei muito c #, mas é bem possível que o uso de forloops regulares seja mais curto.
— FryAmTheEggman

Esta resposta tem o mesmo problema minha resposta inicial C # fez em que tanto Reverse()e ToArray()fazem parte do System.Linqmodo é necessária uma declaração usando.
— 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])));

Explicação:

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

Teste:

Wordenticons

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

Eu não tinha certeza se método só era aceitável, se não me avise e eu vou ajustar a minha resposta em conformidade
— Phaeze

@Downgoat obrigado pela edição, eu não tinha certeza do método adequado para escapar do #.
— Phaeze 27/05

Que, aparentemente, só errei na pré-visualização, é bom saber
— Phaeze

desde implementos cordas IEnumerable<char>você pode economizar alguns bytes usando .Reverse()diretamente na corda pular o.ToCharArray()
— grabthefish

você também pode mudar var a = new[] { '-', ' ', '|' };para var a = "- |"; porque você pode usar a indexação em cordas
— grabthefish

2

CJam, 20 bytes

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

Teste aqui.

Usa a abordagem óbvia de calcular um produto externo e usar diferença e sgn para calcular o caractere em cada célula.


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

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 bytes

5 bytes salvos graças ao Dennis.

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

Vou trabalhar para convertê-lo em um verbo tácito mais tarde.


2

Oitava, 39 bytes

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

Cria uma função anônima que pode ser executada usando ans('string').

Demo

Explicação

Esta solução combina a string de entrada ( x) e é inversa ( flip(x)) usando [x, flip(x)]. O inverso é designado ypara encurtar a resposta [x, y = flip(x)],. Nós, então, criar um vetor da mesma coisa coluna combinando xe ye tendo a transposição: [x,y]'. Então tomamos a diferença que será transmitida automaticamente para criar uma matriz 2D de diferenças entre quaisquer representações ASCII de letras nas strings. Nós usamos signpara fazer estes, quer -1, 0ou 1e, em seguida, adicionar 2para obter valores de índice com base em 1 válido. Nós então os usamos para indexar na string inicial '| -'.


2

Julia, 70 bytes

Esta é a minha primeira tentativa de código de golfe e eu não usei Julia antes, então me diga o que você pensa:

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

Experimente 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

Eu acho que provavelmente poderia ser menor. Este código armazena os caracteres do wordicon em uma matriz:

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

Infelizmente, não consegui produzir a saída desejada usando a matriz.


Olá, e bem-vindo ao PPCG! Obrigado por se juntar a nós!
— NoOneIsHere

1

Jolf, 42 bytes

Dificilmente jogado golfe. Provavelmente estou esquecendo uma matriz incorporada que Jolf possui.

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

Experimente aqui! Este código usa uma função de seta ( Ψ) para o mapa da matriz.


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

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

Aqui não há fantasias de ecma 2015


Você pode verificar, se uma carta vem antes em alphahet, simplesmente fazendo "a" < "b"
— Bálint

Você não precisa se preocupar var x = 1, apenas faça x = 1. No código de golfe, ninguém se importa em aderir às melhores práticas. :)
— gcampbell 27/05

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

Esta é essencialmente uma porta da minha solução Actually .

Experimente online

Explicação:

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

Experimente Online! (Ideona) (Os dois últimos casos de teste não aparecerão na saída, pois são apenas linhas em branco. Meu programa está processando-os, o que confirma o fato de que há 10 casos de entrada, mas apenas 8 saídas aparecem.)

Ungolfed seguido de uma explicação:

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]

    Crie uma lista, ponde a |é adicionada se o Valor do Ponto Unicode da letra da coluna for menor que o valor da letra da linha, a –será adicionado se o Valor do Ponto Unicode da letra da coluna for maior que o valor da letra da linha ou a se ambos valores são iguais.

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

    Crie uma sequência unida de nova linha u, a partir da lista p, dividindo-a em segmentos de sequência unida, cada um consistindo no número de caracteres de comprimento de entrada para frente e para trás, resultando em cada um tendo o comprimento de 2 vezes o número de caracteres existentes na entrada. Esta é a metade superior do seu wordenticon. Portanto, no caso de sua entrada food, isso retornaria:

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

    Finalmente, a saída foi useguida por uma nova linha e, em seguida, urevertida para espelhar verticalmente a primeira metade da segunda metade. Este é o seu wordenticon completo, que para o caso de teste foodseria finalmente:

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

0

R , 101 bytes

101 bytes desde que estou usando ―(o que acho melhor -).

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

Experimente online!

Fiquei surpreso por não haver uma resposta R antes, pois podemos explorar a simetria e as matrizes de R para obter uma resposta bastante competitiva, apesar de ser um stringproblema.

Explicação Ungolfed:

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

Experimente online!

Funciona repetindo cada caractere e atualizando o caractere resultante (e seus reflexos).


0

05AB1E (herdado) , 20 22 21 bytes

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

+2 bytes como correção de bugs para entradas de caractere único ..
-1 byte usando traços regulares em -vez de ―, pois podemos usá- … |-los em vez de "… |―"(já … |―que agiriam incorretamente como uma string de dicionário)

Usa a versão herdada do 05AB1E, uma vez que ela entra implicitamente em novas linhas ao espelhar, o que requer um explícito adicional »na nova versão.

Experimente online ou verifique todos os casos de teste .

Explicação:

Ç             # 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)
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.