पहचानकर्ता हैश मूल्यों के दृश्य चित्रण हैं, जो अक्सर ज्यामितीय आकृतियों के सममित व्यवस्था से बनाए जाते हैं। आपका डिफ़ॉल्ट स्टैक एक्सचेंज अवतार एक पहचान है। यह चुनौती "वर्डेंटिकॉन्स" बनाने के बारे में है , पहचानकर्ताओं के सरल पाठ-आधारित संस्करण जो लोअरकेस अक्षरों के स्ट्रिंग पर लागू होते हैं, अर्थात शब्द।

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें जो एक स्ट्रिंग एस में लेता है और इसके वर्डेंटिकॉन को आउटपुट करता है। एस को गैर-रिक्त होने की गारंटी दी गई है और इसमें केवल अंग्रेजी अक्षर अक्षर az शामिल हैं। आप वैकल्पिक रूप से मान सकते हैं कि S के पास अनुगामी न्यूलाइन है।

S का शब्दकूट पाठ का एक वर्ग ग्रिड होगा 2*length(S)जिसमें रिक्त स्थान ( ), लंबवत पट्टियाँ, ( |), और क्षैतिज पट्टियाँ ( ―) से बना होता है।

S के वर्डेंटिकॉन को जेनरेट करने के लिए, एक वर्गाकार ग्रिड बनाएँ जहाँ हर कॉलम S के अक्षर से मेल खाता हो (सामान्य बाएँ-से-दाएँ पढ़ने के क्रम में) और हर पंक्ति S के अक्षर से मेल खाती है (सामान्य टॉप-टू-बॉटम रीडिंग ऑर्डर में) )।

उदाहरण के लिए, यदि S foodहमारी प्रारंभिक ग्रिड की तरह दिखता है

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

जहां .सिर्फ एक प्लेसहोल्डर है।

.ग्रिड में प्रत्येक खाली बिंदु (हर ) के लिए:

यदि स्तंभ पत्र पंक्ति वर्ण से पहले आता है वर्णानुक्रम में, के .साथ बदलें |।
यदि स्तंभ पत्र पंक्ति वर्ण के बाद वर्णानुक्रम में आता है, तो .साथ बदलें ―।
यदि स्तंभ और पंक्ति अक्षर समान हैं, तो (स्थान) के .साथ बदलें ।

यहाँ foodइन चरणों में से प्रत्येक के बाद उदाहरण दिया गया है:

जोड़ना |:
```
 food
f...|
o|..|
o|..|
d....
```

जोड़ना ―:

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

जोड़ना :

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

वर्डेंटिकॉन को पूरा करने के लिए, शब्दों से युक्त अति सुंदर पंक्ति और कॉलम को हटा दें

 ――|
|  |
|  |
―――

फिर पूरी चीज़ को क्षैतिज रूप से दर्पण करें

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

और अंत में इसे फिर से लंबवत दर्पण करें

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

2*length(S)साइड लंबाई पाठ ग्रिड के परिणामस्वरूप जो अंतिम वर्डेंटिकॉन है।

उदाहरण

यहाँ कुछ अतिरिक्त शब्दार्थिक उदाहरण दिए गए हैं। ध्यान दें कि विभिन्न शब्दों में समान शब्दार्थक हो सकते हैं और कुछ शब्दार्थक पूरी तरह से रिक्त स्थान से बने हो सकते हैं (दुर्भाग्यवश मार्कडाउन उन लोगों को प्रस्तुत करना नहीं चाहता है)।

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

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

स्कोरिंग

यह कोड-गोल्फ है , बाइट्स जीत में सबसे छोटा कोड। टाईब्रेकर पहले वाले उत्तर पर जाता है।

आपके कोड में क्षैतिज बार ( ―) के किसी भी उदाहरण को 3 UTF-8 बाइट्स के बजाय 1 बाइट के रूप में गिना जा सकता है। (दस उदाहरण तक)
यदि वांछित है तो आप -क्षैतिज सलाखों ( ―) के स्थान पर नियमित डैश ( ) का उपयोग कर सकते हैं ।
एक शब्दार्थक की पंक्तियों में अनुगामी रिक्त स्थान को हटाने या जोड़ने की अनुमति नहीं है (भले ही आकार अपरिवर्तित रहे)। यह एक सटीक 2*length(S)साइड लेंथ टेक्स्ट स्क्वायर होना चाहिए ।
आउटपुट वर्डेंटिकॉन में वैकल्पिक रूप से एक एकल अनुगामी न्यूलाइन हो सकती है।

code-golf string ascii-art

— केल्विन के शौक
स्रोत

क्या हम इनपुट को वर्णों के एक सरणी के रूप में ले सकते हैं?

— डाउनगेट

@Downgoat नहीं, यह एक सामान्य स्ट्रिंग होना चाहिए जब तक कि आपकी भाषा के लिए कोई अन्य तरीका न हो।

— केल्विन के शौक

2

आपके पास उदाहरण हैं programming, andऔर codegolfआप भूल गए puzzles...

— नील

क्या आप एक लीडरबोर्ड जोड़ सकते हैं?

— लीक नून

इसलिए हमने आखिरकार पता लगाया कि आप चैट में

— पोर्टमिंटस के

21

MATL, 20 15 बाइट्स

'-| 'jtPht!-ZS)

इसे MATL ऑनलाइन पर आज़माएं

व्याख्या

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

— Suever
स्रोत

9

: ओ तुम डेनिस outgolfed!

— डाउनगेट

@Downgoat यह उन दुर्लभ अवसरों में से एक है जो MATL जेली से कम है!

— स्वेवर

साइन फ़ंक्शन का उपयोग करने के लिए अच्छा विचार है!

— लुइस मेंडो

18

जावा, 329 305 264 259 192 बाइट्स

करने के लिए धन्यवाद:

@ टर्नरी ऑपरेटरों का उपयोग करने के सुझाव के लिए बैलिंट।
@ user902383 स्वयं स्ट्रिंग को उलटने का सुझाव देने के लिए
StringBuilderसाथ में बदलने के सुझाव के लिए @Frozn और @ user902383 String।

golfed:

String g(String w){char[]a=w.toCharArray();String s="";for(int i=a.length-1;i>=0;s=s+a[i--]);w+=s;a=w.toCharArray();s="";for(char x:a){for(char y:a)s+=(x>y?'|':x<y?'-':' ');s+='\n';}return s;}

Ungolfed:

String g(String w) {
    char[] a = w.toCharArray();
    String s = "";
    for (int i = a.length - 1; i >= 0; s = s + a[i--]);
    w += s;
    a = w.toCharArray();
    s = "";// To keep the output pure (ie. without the input string as well)
    for (char x : a) {
        for (char y : a)
            s += (x > y ? '|' : x < y ? '-' : ' ');
        s += '\n';
    }
    return s;
}

निश्चित रूप से एक मजेदार। पहला प्रयास एक ऐसा कार्य था जिसे O(n)समाप्त करने के बाद मैं इस सरल रूप में बदल गया।

और, परीक्षण करने के लिए:

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

— Zymus
स्रोत

2

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! यह एक बहुत अच्छा पहला जवाब है। :)

— एलेक्स ए

1

ध्यान दें कि आपको उपयोग नहीं करना है \u2015। कच्चे कोड में क्षैतिज पट्टी (या बस डैश) का उपयोग करना ठीक है।

— केल्विन के शौक

मुझे पूरा यकीन है कि अगर आप उत्तर के Stringबजाय सामान्य इस्तेमाल करते हैं तो StringBuilderबहुत कम हो सकता है ... (भले ही इसमें बहुत अधिक मेमोरी लग सकती है)

— लीकी नून

आप intएक ही लाइन पर सभी एस की घोषणा करके कुछ बाइट्स जीत सकते हैं :int i,j,l=m.length();for(i=0;i<l;i++){...

— आरोन

मुझे लगता है कि यदि आप प्रत्येक छोरों के लिए छोरों को बदलते हैं तो आप बहुत बचत कर सकते हैं। आपको चार्ट प्राप्त करने के अलावा किसी और चीज के लिए सूचकांकों की आवश्यकता नहीं है।

— फ्रोज़न

11

हास्केल, 93 बाइट्स

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

उपयोग उदाहरण:

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

यह कैसे काम करता है (नोट: (f <*> g) xइस रूप में परिभाषित किया गया है 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

वैकल्पिक संस्करण: "प्रतिस्थापन खोजें" फ़ंक्शन को उसी बाइट काउंट के लिए ((("- |"!!).fromEnum).).compareभी लिखा a#b|a<b='-'|a>b='|'|1<2=' 'और कहा जा सकता है (#)।

— nimi
स्रोत

8

जेली , 16 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

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

जावास्क्रिप्ट (ईएस 6), 94 बाइट्स

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

एक डैश का उपयोग करते हुए क्योंकि मैं आमतौर पर विंडोज पर स्पाइडरमोंक जेएस शेल चलाता हूं और यदि मैं ऐसा करता हूं तो यूनिकोड काम नहीं करता है।

— नील
स्रोत

[...s,s].reverse()+1 के साथ शानदार विचार

— डाउनगैट

5

Pyth, 31 30

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

परीक्षण सूट

अफसोस की बात है Qक्योंकि कई bifurcates की वजह से एस को नहीं छोड़ा जा सकता है । अब तक की सुंदर बुनियादी एल्गोरिथ्म, गिनती क्षैतिज पट्टी को 1 बाइट मानती है।

— FryAmTheEggman
स्रोत

इससे पहले कि मैं अपना 31 चार समाधान पोस्ट करूं, 2 सेकंड पहले; इसे

— माल्टीसेन

1

@ मैलेटेन मैं FGITWed होने के कारण थक गया;) वैसे भी मुझे यकीन है कि यह छोटा हो सकता है ...

— FryAmTheEggman

5

हास्केल, 66 बाइट्स

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

— लिन
स्रोत

4

जावास्क्रिप्ट ईएस 6, 138 126 123 बाइट्स

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

अधिकांश कोड रिफ्लेक्टिंग / फ़्लिपिंग है

— Downgoat
स्रोत

4

जे, 26 20 बाइट्स

6 बाइट्स @Zbb को धन्यवाद ।

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

पिछला 26-बाइट उत्तर

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

डेनिस के उत्तर के समान एल्गोरिथ्म का उपयोग करता है।

उपयोग:

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

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

( >>अर्थ इनपुट (STDIN), <<अर्थ आउटपुट (STDOUT))

— लीक नन
स्रोत

1

कुछ पुनर्गठन के साथ, आप 20 बाइट्स प्राप्त कर सकते हैं:' |-'{~3*@-/~@u:[,|.

— जर्गब

यह कांटे का एक अच्छा उपयोग है ...

— लीक नून

3

गणितज्ञ, 124 110 104 102 बाइट्स

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

अनाम फ़ंक्शन। यूनिकोड वर्ण U + F3C7 है \[Transpose]।

— LegionMammal978
स्रोत

3

जावास्क्रिप्ट 146 142 132 130 124 बाइट्स

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

परीक्षण सूट:

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

स्निपेट का विस्तार करें

@HelkaHomba के लिए धन्यवाद, कम से कम 50 बाइट्स निकालने में मदद करने के लिए, और 3 बाइट्स के लिए @Downgoat!

— Bálint
स्रोत

1

आप आमतौर पर => {...} को => (...) से बदल सकते हैं और सभी अर्धविरामों को उस समय के अल्पविराम से बदल सकते हैं

— डाउगोएट

यह उत्तर डाउनगोट के लगभग समान है, मैं कसम खाता हूं, मैंने उसकी तरफ नहीं देखा।

— बैलिंट

3

दरअसल, 53 बाइट्स

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

एक बार फिर, वास्तव में खराब स्ट्रिंग-प्रोसेसिंग क्षमताएं इसकी क्रिप्टोनाइट हैं। यह अभी भी जावा से छोटा है, इसलिए मेरे पास मेरे लिए जा रहा है, जो अच्छा है।

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

कोड को 3 अलग-अलग भागों में विभाजित किया जा सकता है: अनुवाद कोड, प्रोसेसिंग कोड और मिररिंग कोड। पठनीयता के लिए, मैं प्रत्येक अनुभाग को अलग से समझाने जा रहा हूँ।

अनुवाद कोड (इनपुट स्ट्रिंग के साथ शुरू होता है, sस्टैक पर):

;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

प्रोसेसिंग कोड ( n**2नीचे-दाएं कोने के अनुरूप वर्णों की सूची से शुरू होता है ):

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

मिररिंग कोड (शुरुआत-एक n**2+nस्ट्रिंग के साथ, नई अवधि के रूप में अभिनय करने वाली अवधि के साथ)

'.@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 बाइट्स

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

इनपुट STDIN के माध्यम से है। इसे ऑनलाइन आज़माएं!

explaination:

पहली पंक्ति में इसे पढ़ा और मिरर किया गया इनपुट। इनपुट के लिए abcd, यह dcbaabcdस्टैक पर निकलता है । प्रत्येक आधे को फिर देने के लिए प्रतिबिंबित किया जाता हैabcddcba (रेखा 2) । फिर, प्रत्येक तत्व को डुप्लिकेट किया जाता है और बदले में अपने स्वयं के स्टैक पर छोड़ दिया जाता है (लाइनें 3 और 4)। इस प्रक्रिया के बाद, ढेर का ढेर कुछ इस तरह दिखता है:

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

बदले में प्रत्येक स्टैक के लिए, स्तंभ मान (स्टैक के निचले भाग) की तुलना स्तंभ मान (स्टैक के शीर्ष) से की जाती है। उपयुक्त चरित्र से चुना गया है - |और STDOUT को लिखा गया है। स्तंभ मान तब घुमाए जाते हैं ताकि अगला स्तंभ स्टैक (पंक्ति 6) के शीर्ष पर हो।

एक बार सभी कॉलमों पर विचार करने के बाद, आउटपुट मान फिर से शुरू करने के लिए, पंक्ति मूल्य को खारिज कर दिया जाता है, एक नई लाइन प्रिंट की जाती है, और कॉलम मान पिछले स्टैक (लाइन 7) पर डाल दिया जाता है।

]आदेश, ढेर के ढेर से पॉपिंग के अलावा, वर्तमान ढेर खाली अगर यह केवल एक ही छोड़ दिया है। कार्यक्रम की अंतिम स्थिति है यदि स्टैक खाली है, क्योंकि सभी पंक्तियों को संसाधित किया गया है (पंक्ति 5)।

— सोक
स्रोत

3

सी #, 169 150 बाइट्स

धन्यवाद 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);
        }

    }

अधिक गोल्फ सलाह की सराहना की

— downrep_nation
स्रोत

t+=c==k?" ":c>k?"|":"-";कार्य करना चाहिए। मैंने C # को अधिक नहीं बढ़ाया है, लेकिन यह संभव है कि नियमित रूप से उपयोग किया जाएfor छोरों कम होगा।

— FryAmTheEggman

इस उत्तर एक ही समस्या मेरे मूल सी # जवाब में किया था कि दोनों है Reverse()और ToArray()का हिस्सा हैं System.Linqतो एक कथन का उपयोग आवश्यक है।

— फेजे

3

सी # 166 143 बाइट्स,

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

स्पष्टीकरण:

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

परीक्षा:

Wordenticons

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

— Phaeze
स्रोत

मुझे यकीन नहीं था कि अगर विधि केवल स्वीकार्य थी, अगर मुझे पता नहीं है और मैं तदनुसार अपना जवाब समायोजित करूंगा

— फेज २

@Downgoat संपादन के लिए धन्यवाद, मुझे यकीन है कि # बचने के लिए उचित तरीका नहीं था।

— फेज २ P

जाहिरा तौर पर केवल पूर्वावलोकन में गड़बड़ की गई, यह जानना अच्छा है

— फेज़

जब से स्ट्रिंग लागू होता है IEnumerable<char>आप कुछ बाइट्स को .Reverse()सीधे तार पर लंघन करके बचा सकते हैं.ToCharArray()

— Grabthefish

आप भी बदल सकता है var a = new[] { '-', ' ', '|' };करने के लिए var a = "- |"; है क्योंकि आप तारों पर अनुक्रमण का उपयोग कर सकते

— grabthefish

2

CJam, 20 बाइट्स

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

इसका परीक्षण यहां करें।

बाहरी उत्पाद की गणना के स्पष्ट दृष्टिकोण का उपयोग करता है और प्रत्येक सेल में चरित्र की गणना करने के लिए अंतर और sgn का उपयोग करता है।

— मार्टिन एंडर
स्रोत

2

क्लोजर, 171 बाइट्स

(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

जे, 75 70 बाइट्स

5 बाइट्स ने डेनिस को धन्यवाद दिया।

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

मैं इसे बाद में एक मौन क्रिया में बदलने पर काम करूँगा।

— कोनोर ओ ब्रायन
स्रोत

2

ऑक्टेव, 39 बाइट्स

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

एक अनाम फ़ंक्शन बनाता है जिसका उपयोग करके चलाया जा सकता है ans('string')।

डेमो

व्याख्या

यह समाधान इनपुट स्ट्रिंग ( x) को जोड़ती है और इसका flip(x)उपयोग करके उलटा ( ) है [x, flip(x)]। उलटा को सौंपा गया है y, इस सवाल का जवाब छोटा करने के लिए [x, y = flip(x)]। हम फिर एक ही चीज़ का कॉलम वेक्टर बनाते हैं xऔर संयोजन yलेते हैं और [x,y]':। फिर हम उस अंतर को लेते हैं जो स्ट्रिंग्स में अक्षरों के किसी भी ASCII प्रतिनिधित्व के बीच अंतर का 2 डी सरणी बनाने के लिए स्वचालित रूप से प्रसारित करेगा। हम signइनका उपयोग या तो करने के लिए करते हैं -1, 0या 1फिर 2मान्य 1-आधारित सूचकांक मान प्राप्त करने के लिए जोड़ते हैं। हम फिर प्रारंभिक स्ट्रिंग में अनुक्रमित करने के लिए इनका उपयोग करते हैं '| -'।

— Suever
स्रोत

2

जूलिया, 70 बाइट्स

कोड गोल्फ में यह मेरा पहला प्रयास है और मैंने पहले जूलिया का उपयोग नहीं किया है, इसलिए मुझे बताएं कि आप क्या सोचते हैं:

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

इसे ऑनलाइन आज़माएं!

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

मुझे लगता है कि यह शायद कम किया जा सकता है। यह कोड मैट्रिक्स में वर्डकॉन के वर्णों को संग्रहीत करता है:

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

दुर्भाग्य से, मैं मैट्रिक्स का उपयोग करके वांछित उत्पादन का प्रबंधन नहीं कर सका।

— टिम बी।
स्रोत

नमस्कार, और PPCG में आपका स्वागत है! हमसे जुड़ने के लिए धन्यवाद!

— NoOneIsHere

1

जोल्फ, 42 बाइट्स

मुश्किल से गोल्फ। मैं शायद एक मैट्रिक्स बिल्टिन के बारे में भूल रहा हूं जो जोल्फ के पास है।

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

यहाँ कोशिश करो! यह कोड Ψमैट्रिक्स मैप के लिए एरो फंक्शन ( ) का उपयोग करता है ।

— कोनोर ओ ब्रायन
स्रोत

1

जावास्क्रिप्ट, 303 बाइट्स

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

कोई एक्जाम 2015 की धूम नहीं

— क्रिस ओ'केली
स्रोत

आप चेक कर सकते हैं, यदि कोई पत्र अल्फ़ाज़ में पहले आता है, तो बस "" <"b" करके

— Bálint

आप के साथ परेशान करने की जरूरत नहीं है var x = 1, बस करो x = 1। कोड गोल्फ में कोई भी सर्वोत्तम प्रथाओं का पालन करने की परवाह नहीं करता है। :)

— gcampbell

1

पायथन 2, 126 बाइट्स

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

यह अनिवार्य रूप से मेरे वास्तव में समाधान का एक बंदरगाह है ।

इसे ऑनलाइन आज़माएं

स्पष्टीकरण:

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

पायथन 3.5, 250 223 175 बाइट्स:

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

यह ऑनलाइन की कोशिश करो! (Ideone) (पिछले दो परीक्षण मामले आउटपुट में दिखाई नहीं देंगे क्योंकि वे सिर्फ खाली लाइनें हैं। मेरा कार्यक्रम उन्हें हालांकि संसाधित कर रहा है, जो इस तथ्य की पुष्टि करता है कि 10 मामले इनपुट हैं, लेकिन केवल 8 आउटपुट दिखाई देते हैं।)

अनजाने में एक स्पष्टीकरण के बाद:

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

p=[[' ―'[O(i)<O(g)],'|'][O(i)>O(g)]for i in o for g in o]

एक सूची बनाएं p, जहां एक |जोड़ा जाता है यदि स्तंभ पत्र का यूनिकोड बिंदु मान पंक्ति पत्र के मूल्य से कम है, तो एक –जोड़ दिया जाता है यदि स्तंभ पत्र का यूनिकोड बिंदु मान पंक्ति पत्र के मूल्य से अधिक है, या यदि दोनों मान बराबर हैं।
u='\n'.join([''.join(p[i:G+i]+p[i:G+i][::-1])for i in range(0,len(p),G)])

uसूची pमें शामिल होने से स्ट्रिंग में एक नई पंक्ति बनाएं, इसे स्ट्रिंग सेगमेंट में विभाजित करके प्रत्येक में आगे और पीछे दोनों वर्णों की इनपुट लंबाई की संख्या होती है, जिसके परिणामस्वरूप प्रत्येक की लंबाई 2 गुना होती है कि इनपुट में कितने वर्ण हैं। यह आपके वर्डेंटिकॉन का शीर्ष आधा हिस्सा है। तो, आपके इनपुट के मामले में food, यह वापस आ जाएगा:
```
 ――||―― 
|  ||  |
|  ||  |
―――  ―――
```
print(u+'\n'+u[::-1])

अंत में, आउटपुट uएक न्यूलाइन द्वारा पीछा किया और फिर uदूसरी छमाही के लिए पहली छमाही को लंबवत रूप से दर्पण में उलट दिया। यह आपका पूरा शब्द है, जो परीक्षण के मामले में foodअंत में होगा:
```
 ――||―― 
|  ||  |
|  ||  |
―――  ―――
―――  ―――
|  ||  |
|  ||  |
 ――||―― 
```

— आर। कप
स्रोत

0

आर , 101 बाइट्स

101 बाइट्स जब से मैं उपयोग कर रहा हूं ―(जो मुझे लगता है कि इससे बेहतर है -)।

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

इसे ऑनलाइन आज़माएं!

मुझे आश्चर्य था कि पहले कोई R उत्तर नहीं था क्योंकि हम समरूपता और R के मैट्रिसेस का फायदा उठा सकते हैं, एक बहुत ही प्रतिस्पर्धी उत्तर पाने के बावजूद, यह एक होने के बावजूद string समस्यात्मक समस्या ।

असंगठित व्याख्या:

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

सी (जीसीसी) , 202 बाइट्स

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

इसे ऑनलाइन आज़माएं!

प्रत्येक चरित्र के माध्यम से लूप करके काम करता है, फिर परिणामी चरित्र (और उसके प्रतिबिंब) को अपडेट करता है।

— कोनोर ओ ब्रायन
स्रोत

0

05AB1E (विरासत) , 20 22 21 बाइट्स

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

+2 बाइट्स सिंगल-चार इनपुट के लिए बग-फिक्स के रूप में ..
-1 बाइट के -बजाय नियमित डैश का उपयोग करके ―, क्योंकि हम … |-इसके बजाय उपयोग कर सकते हैं "… |―"(क्योंकि … |―गलत तरीके से एक शब्दकोश स्ट्रिंग के रूप में कार्य करेगा)

05AB1E की विरासत संस्करण का उपयोग करता है, क्योंकि यह स्पष्ट रूप से मिररिंग करते समय नईलाइन्स से जुड़ता है, जिसके »लिए नए संस्करण में एक अतिरिक्त स्पष्ट की आवश्यकता होती है ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

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

— केविन क्रूज़सेन
स्रोत

Wordenticons उत्पन्न करें

चुनौती

उदाहरण

स्कोरिंग

टिप्पणियाँ

MATL, 20 15 बाइट्स

जावा, 329 305 264 259 192 बाइट्स

हास्केल, 93 बाइट्स

जेली , 16 बाइट्स

यह काम किस प्रकार करता है

जावास्क्रिप्ट (ईएस 6), 94 बाइट्स

Pyth, 31 30

हास्केल, 66 बाइट्स

जावास्क्रिप्ट ईएस 6, 138 126 123 बाइट्स

जे, 26 20 बाइट्स

पिछला 26-बाइट उत्तर

गणितज्ञ, 124 110 104 102 बाइट्स

जावास्क्रिप्ट 146 142 132 130 124 बाइट्स

दरअसल, 53 बाइट्स

> <> , 109 बाइट्स

सी #, 169 150 बाइट्स

सी # 166 143 बाइट्स,

स्पष्टीकरण:

CJam, 20 बाइट्स

क्लोजर, 171 बाइट्स

जे, 75 70 बाइट्स

ऑक्टेव, 39 बाइट्स

जूलिया, 70 बाइट्स

जोल्फ, 42 बाइट्स

पायथन 2, 126 बाइट्स

पायथन 3.5, 250 223 175 बाइट्स:

अनजाने में एक स्पष्टीकरण के बाद:

आर , 101 बाइट्स

असंगठित व्याख्या:

सी (जीसीसी) , 202 बाइट्स

05AB1E (विरासत) , 20 22 21 बाइट्स