Générer des Wordenticons


54

Les identicons sont des représentations visuelles de valeurs de hachage, souvent réalisées à partir d'arrangements symétriques de formes géométriques. Votre avatar Stack Exchange par défaut est un identicon. Ce défi consiste à créer des "wordenticons" , de simples versions d'identicons textuelles qui s'appliquent aux chaînes de lettres minuscules, c'est-à-dire des mots.

Défi

Ecrivez un programme ou une fonction qui prend une chaîne S et affiche son wordenticon. Il est garanti que S ne contient pas de vide et ne contient que des lettres minuscules en anglais, az. Vous pouvez éventuellement supposer que S a une nouvelle ligne.

Le wordenticon de S sera une grille carrée de texte avec des côtés 2*length(S)composés d'espaces ( ), de barres verticales ( |) et de barres horizontales ( ).

Pour générer le mot-symbole de S, formez une grille carrée où chaque colonne correspond à une lettre de S (ordre de lecture normal de gauche à droite) et chaque ligne correspond à une lettre de S (ordre de lecture normal de haut en bas). )

Par exemple, si S est foodnotre grille initiale ressemble à

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

.est juste un espace réservé.

Pour chaque point vide (chaque .) de la grille:

  1. Si la lettre de la colonne vient avant la lettre de la ligne par ordre alphabétique, remplacez-la .par |.
  2. Si la lettre de la colonne vient après la lettre de la ligne par ordre alphabétique, remplacez-la .par .
  3. Si les lettres des colonnes et des lignes sont identiques, remplacez-les .par (espace).

Voici l' foodexemple après chacune de ces étapes:

  1. Ajout |de:

     food
    f...|
    o|..|
    o|..|
    d....
    
  2. Ajout de:

     food
    f.――|
    o|..|
    o|..|
    d―――.
    
  3. Ajout de:

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

Pour compléter le wordenticon, supprimez la ligne et la colonne superflues contenant les mots

 ――|
|  |
|  |
――― 

puis refléter la chose entière horizontalement

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

et enfin le refléter verticalement

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

résultant en la 2*length(S)grille de texte de longueur de côté qui est le wordenticon final.

Exemples

Voici quelques exemples de wordenticon supplémentaires. Notez que des mots différents peuvent avoir des libellés identiques et que certains peuvent être entièrement constitués d'espaces (malheureusement, Markdown ne veut pas rendre ceux-ci).

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

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

Notation

C'est , le code le plus court en octets gagne. Tiebreaker va à la réponse précédente.

Remarques

  • Toute instance de barre horizontale ( ) dans votre code peut être comptée pour 1 octet au lieu des 3 octets UTF-8 qu’elle occupe réellement. (Jusqu'à dix instances.)
  • Si vous le souhaitez, vous pouvez utiliser des tirets ordinaires ( -) à la place des barres horizontales ( ).
  • La suppression ou l'ajout d'espaces de fin dans les lignes d'un wordenticon n'est pas autorisée (même si la forme reste inchangée). Il devrait s'agir d'un 2*length(S)carré de texte de longueur de côté exacte .
  • Le wordenticon en sortie peut éventuellement avoir une seule nouvelle ligne.

Pouvons-nous prendre l’entrée comme un tableau de caractères?
Downgoat

@Downgoat Non, ce devrait être une chaîne normale à moins qu'il n'y ait absolument aucun autre moyen pour votre langue.
Hobbies de Calvin

2
Vous avez des exemples pour programming, andet codegolfmais vous avez oublié puzzles...
Neil

Pourriez-vous ajouter un classement?
Leaky Nun

Nous avons donc avons fini par savoir pourquoi vous posiez au sujet portemanteau dans le chat :)
gcampbell

Réponses:


21

MATL, 20 15 octets

'-| 'jtPht!-ZS)

Essayez-le sur MATL Online

Explication

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

9
: O tu as golfé Dennis!
Downgoat

@Downgoat C'est l'une des rares occasions où MATL est plus court que Jelly!
Suever

Bonne idée d'utiliser la fonction de signalisation!
Luis Mendo

18

Java, 329 305 264 259 192 octets

Grâce à:

  • @ Bálint pour avoir suggéré d'utiliser des opérateurs ternaires.
  • @ user902383 pour avoir suggéré d'inverser moi-même la chaîne
  • @Frozn et @ user902383 pour suggérer de remplacer StringBuilderpar String.

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

Certainement amusant. La première tentative a été une fonction qui a été O(n)remplacée par une forme plus simple après une frustration excessive.

Et pour tester:

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

2
Bienvenue dans Programming Puzzles & Code Golf! C'est une très bonne première réponse. :)
Alex A.

1
Notez que vous ne devez pas utiliser \u2015. L'utilisation de la barre horizontale (ou simplement d'un tiret) dans le code brut convient.
Les passe-temps de Calvin

Je suis à peu près sûr que si vous utilisiez normal Stringau lieu de StringBuilderla réponse, la réponse pourrait être beaucoup plus courte ... (même si cela peut prendre beaucoup plus de mémoire)
Leaky Nun

Vous pourriez gagner quelques octets en déclarant tous les ints sur la même ligne:int i,j,l=m.length();for(i=0;i<l;i++){...
Aaron

Je pense que vous pourriez économiser beaucoup si vous modifiez les boucles for pour chaque boucle. Vous n'avez pas besoin des indices pour obtenir autre chose que le caractère.
Frozn

11

Haskell, 93 octets

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

Exemple d'utilisation:

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

Comment ça marche (note: (f <*> g) xest défini comme 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

Version alternative: la fonction "trouver un remplacement" ((("- |"!!).fromEnum).).comparepeut également être écrite a#b|a<b='-'|a>b='|'|1<2=' 'et appelée via (#)pour le même nombre d'octets.


8

Gelée , 16 octets

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

Essayez-le en ligne!

Comment ça fonctionne

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 octets

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

L'utilisation d'un tiret, car j'exécute généralement le shell SpiderMonkey JS sous Windows et Unicode ne fonctionne pas si je le fais.


Excellente idée avec le [...s,s].reverse()+1
Downgoat

5

Pyth, 31 30

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

Suite de tests

Malheureusement, je ne peux pas laisser tomber le Qs à cause de plusieurs bifurcates. Joli algorithme de base jusqu'à présent, compte traite la barre horizontale comme 1 octet.


sacrément, 2 secondes avant que je publie ma solution de 31 caractères; P
Maltysen

1
@Maltysen J'en ai marre d'être sorti de FGITWed;) En tout cas je suis sûr que ça peut être plus court ...
FryAmTheEggman

5

Haskell, 66 octets

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

4

JavaScript ES6, 138 126 123 octets

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

la majeure partie du code est le reflet / retournement


4

J, 26 20 octets

6 octets grâce à @Zgarb .

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

Réponse précédente de 26 octets

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

Utilise le même algorithme que la réponse de Dennis.

Usage:

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

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

( >>signifiant entrée (STDIN), <<signifiant sortie (STDOUT))


1
Avec une restructuration, vous pouvez obtenir jusqu'à 20 octets:' |-'{~3*@-/~@u:[,|.
Zgarb

C'est une bonne utilisation de fourches ...
Leaky Nun

3

Mathematica, 124 110 104 102 octets

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

Fonction anonyme. Le caractère Unicode est U + F3C7 pour \[Transpose].


3

Javascript 146 142 132 130 124 octets

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

Suite de tests:

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

Merci pour @HelkaHomba, pour avoir aidé à supprimer au moins 50 octets, et à @Downgoat pour 3 octets!


1
vous pouvez généralement remplacer => {...} par => (...) et remplacer tous les points-virgules de ce délai. virgules
Date

Cette réponse est presque identique à celle de Downgoat, je jure que je n’ai pas regardé la sienne.
Bálint

3

En fait, 53 octets

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

Encore une fois, les faibles capacités de traitement des cordes d’Actually sont sa kryptonite. Il est toujours plus court que Java, alors ça me convient, ce qui est bien.

Essayez-le en ligne!

Explication:

Le code peut être séparé en 3 parties distinctes: le code de traduction, le code de traitement et le code en miroir. Par souci de lisibilité, je vais expliquer chaque section séparément.

Code de traduction (commence par la chaîne d'entrée s, sur la pile):

;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

Code de traitement (commence par une liste de n**2caractères, correspondant au coin inférieur droit):

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

Code en miroir (commence par une n**2+nchaîne de longueur, avec des périodes agissant comme des lignes nouvelles)

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

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

L'entrée se fait via STDIN. Essayez-le en ligne!

Explication:

L'entrée a été lue et mise en miroir sur la première ligne. Pour les entrées abcd, cela laisse dcbaabcdsur la pile. Chaque moitié est ensuite reflétée pour donner abcddcba(ligne 2). Ensuite, chaque élément est dupliqué et laissé tour à tour sur sa propre pile (lignes 3 et 4). Après ce processus, la pile de piles ressemble un peu à ceci:

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

Pour chaque pile, tour à tour, la valeur de la ligne (le bas de la pile) est comparée à la valeur de la colonne (le haut de la pile). Le caractère approprié est sélectionné - |et écrit dans STDOUT. Les valeurs de colonne sont ensuite pivotées afin que la colonne suivante se trouve en haut de la pile (ligne 6).

Une fois que toutes les colonnes ont été considérées, la valeur de la ligne est supprimée, une nouvelle ligne est imprimée et les valeurs des colonnes sont placées dans la pile précédente (ligne 7) pour que le processus de sortie puisse redémarrer.

La ]commande, en plus de sortir de la pile de piles, vide la pile actuelle si c'est la seule qui reste. La condition de fin du programme est si la pile est vide, toutes les lignes ayant été traitées (ligne 5).


3

C #, 169 150 octets

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

    }

plus de conseils de golf appréciés


t+=c==k?" ":c>k?"|":"-";devrait marcher. Je n'ai pas beaucoup joué au C #, mais il est tout à fait possible que l'utilisation de forboucles régulières soit plus courte.
FryAmTheEggman

Cette réponse a le même problème que ma réponse originale en C # en ce sens que les deux Reverse()et ToArray()font partie de System.Linqsorte qu'une instruction using est requise.
JustinM - Réintégrer Monica

3

C # 166 143 octets,

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

Explication:

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

Tester:

Wordenticons

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

Je ne savais pas si seule la méthode était acceptable, sinon laissez-moi savoir et je modifierai ma réponse en conséquence
JustinM - Réintégrer Monica

@Downgoat merci pour l'édition, je n'étais pas sûr de la bonne méthode pour échapper à #.
JustinM - Réintégrer Monica


depuis que la chaîne est implémentée, IEnumerable<char>vous pouvez économiser des octets en utilisant .Reverse()directement la chaîne en sautant.ToCharArray()
grabthehefish

vous pouvez aussi changer var a = new[] { '-', ' ', '|' };à var a = "- |"; parce que vous pouvez utiliser l' indexation sur les chaînes
grabthefish

2

CJam, 20 octets

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

Testez-le ici.

Utilise l'approche évidente consistant à calculer un produit externe et à utiliser différence et sgn pour calculer le caractère dans chaque cellule.


2

Clojure, 171 octets

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

5 octets sauvés grâce à Dennis.

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

Je vais travailler à le convertir en un verbe tacite plus tard.


2

Octave, 39 octets

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

Crée une fonction anonyme pouvant être exécutée avec ans('string').

Démo

Explication

Cette solution combine la chaîne d'entrée ( x) et l'inverse ( flip(x)) à l'aide de [x, flip(x)]. L'inverse est affecté à yraccourcir la réponse, [x, y = flip(x)]. Nous créons alors un vecteur de colonne de la même chose en combinant xet yet en prenant la transposition: [x,y]'. Ensuite, nous prenons la différence qui sera automatiquement diffusée pour créer un tableau 2D de différences entre les représentations ASCII des lettres dans les chaînes. Nous les utilisons signpour -1, soit , 0ou 1puis 2pour ajouter des valeurs valides d'index basées sur 1. Nous les utilisons ensuite pour indexer dans la chaîne initiale '| -'.


2

Julia, 70 octets

C'est ma première tentative de code golf et je n'ai jamais utilisé Julia auparavant, alors dites-moi ce que vous pensez:

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

Essayez-le en ligne!

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

Je pense que cela pourrait probablement être raccourci. Ce code stocke les caractères du wordicon dans une matrice:

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

Malheureusement, je n'ai pas réussi à produire le résultat souhaité à l'aide de la matrice.


Bonjour et bienvenue chez PPCG! Merci de vous joindre a nous!
NoOneIsHere

1

Jolf, 42 octets

À peine joué au golf. J'oublie probablement une matrice intégrée à celle de Jolf.

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

Essayez-le ici! Ce code utilise une fonction de flèche ( Ψ) pour la carte matricielle.


1

Javascript, 303 octets

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

Pas de fantaisie ecma 2015 ici


Vous pouvez vérifier, si une lettre vient avant dans alphahet, simplement en faisant "a" <"b"
Bálint

Vous n'avez pas besoin de vous embêter var x = 1, faites-le x = 1. En code golf, personne ne se soucie d’adhérer aux meilleures pratiques. :)
Gcampbell

1

Python 2, 126 octets

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

Ceci est essentiellement un port de ma solution actuelle .

Essayez-le en ligne

Explication:

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

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

Essayez-le en ligne! (Idéone) (Les deux derniers cas de test pas dans la sortie car ce ne sont que des lignes vierges. Mon programme les traite cependant, ce qui confirme le fait qu'il y a 10 entrées en entrée, mais que seulement 8 sorties apparaissent.)

Ungolfed suivi d'une explication:

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]

    Créez une liste, poù un |est ajouté si la valeur de point Unicode de la lettre de colonne est inférieure à la valeur de la lettre de ligne, un est ajouté si la valeur de point Unicode de la lettre de colonne est supérieure à la valeur de la lettre de ligne, ou si les deux les valeurs sont égales.

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

    Créez une chaîne jointe newline u, à partir de liste, pen la divisant en segments de chaîne jointe comprenant chacun un nombre de caractères de longueur en entrée, à la fois en avant et en arrière, ce qui donne une longueur de 2 fois le nombre de caractères saisis dans l'entrée. Ceci est la moitié supérieure de votre wordenticon. Ainsi, dans le cas de votre entrée food, ceci renverrait:

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

    Enfin, la sortie est usuivie d’un retour à la ligne, puis uinversée pour refléter verticalement la première moitié de la seconde moitié. Ceci est votre wordenticon complété, qui pour le cas de test foodserait finalement:

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

0

R , 101 octets

101 octets depuis que j'utilise (ce qui, à mon avis, est meilleur que -).

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

Essayez-le en ligne!

J'ai été surpris qu'il n'y ait pas eu de réponse R auparavant, car nous pouvons exploiter la symétrie et les matrices de R pour obtenir une réponse assez compétitive, bien que ce soit un stringproblème.

Explication non golfée:

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 octets

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

Essayez-le en ligne!

Fonctionne en boucle à travers chaque caractère, puis en mettant à jour le caractère résultant (et ses réflexions).


0

05AB1E (ancien) , 20 22 21 octets

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

+2 octets comme correctif pour les entrées à un seul caractère.
-1 octet en utilisant des tirets ordinaires à la -place de , puisque nous pouvons alors utiliser à la … |-place de "… |―"(puisque … |―agirait incorrectement comme une chaîne de dictionnaire)

Utilise la version héritée de 05AB1E, car elle se joint implicitement à de nouvelles lignes lors de la mise en miroir, ce qui nécessite un explicite supplémentaire »dans la nouvelle version.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

Ç             # 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)
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.