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.