मैंने किया था एक अंतरिक्ष यान बनाया!

Question

परिचय:

से प्रेरित होकर की इस टिप्पणी @MagicOctopusUrn पर @Emigna के 05AB1E जवाब मेरे लिए " यह सिर्फ एक बग था चुनौती" :

8F9ÝÀNð×ý}».∊मैंने किया था एक अंतरिक्ष यान बनाया! और मैं 12-बाइट संपादित करने का सुझाव देने के बारे में उत्साहित था। - मैजिक ऑक्टोपस Urn Jul 17 '17 20:10 पर

यह एक 05AB1E (विरासत) कार्यक्रम है जिसके परिणामस्वरूप:

1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890

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

चुनौती:

इनपुट: एक गैर-रिक्त स्ट्रिंग

आउटपुट: बाहर की ओर जाने से, प्रत्येक वर्ण के बीच एक और स्थान हर पंक्ति में जोड़ते हैं, जैसा कि ऊपर दिए गए आउटपुट में किया जाता है, के बराबर length - 1। इसलिए इनपुट के 1234567890लिए आउटपुट वास्तव में इसके बजाय होगा:

1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1        2        3        4        5        6        7        8        9        0
1         2         3         4         5         6         7         8         9         0
1        2        3        4        5        6        7        8        9        0 
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890

क्यूं कर? की लंबाई 1234567890है 10। तो हम 10 लाइनों के आउटपुट से शुरू करते हैं: रिक्त स्थान के बिना पहली पंक्ति; एक अंतरिक्ष सीमांकक के साथ दूसरा; तीसरे के साथ दो; आदि और फिर ( length - 1रिक्त स्थान के साथ मध्य रेखा डुप्लिकेट के बिना ), हम नीचे जाते समय प्रारंभिक इनपुट पर वापस जाते हैं।

चुनौती नियम:

• इनपुट गैर-रिक्त (एक लंबाई >= 1) होने की गारंटी है । (सिंगल चार इनपुट के लिए हम बस उस चरित्र का उत्पादन करते हैं।)
• अनुगामी / अग्रणी स्थानों / नईलाइन्स की किसी भी राशि की अनुमति दी जाती है, जब तक कि आउटपुट स्वयं (स्क्रीन पर जहां भी हो) सही हो। (आउटपुट लाइनों के बीच में खाली लाइन) की भी अनुमति नहीं है।)
• इनपुट में केवल व्हाट्सएप को छोड़कर प्रिंट करने योग्य ASCII अक्षर होंगे (कोड-पॉइंट रेंज [33, 126])
• I / O लचीला है। इनपुट को STDIN, तर्क या फ़ंक्शन पैरामीटर के रूप में लिया जा सकता है। स्ट्रिंग के बजाय वर्णों की एक सूची / सरणी / स्ट्रीम हो सकती है। आउटपुट स्ट्रिंग्स के बजाय वर्णों की एक सूची / सरणी / स्ट्रीम भी हो सकता है; STDOUT पर मुद्रित किया जा सकता है; न्यूलाइन-सीमांकित स्ट्रिंग के रूप में लौटा; आदि।

सामान्य नियम:

• यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
  कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव कम उत्तर के साथ आने की कोशिश करें।
• आपके उत्तर के लिए मानक नियम लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-प्रकार, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा कॉल।
• डिफ़ॉल्ट लूपोल्स निषिद्ध हैं।
• यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
• साथ ही, आपके उत्तर के लिए स्पष्टीकरण जोड़ने की अत्यधिक अनुशंसा की जाती है।

परीक्षण के मामलों:

Input: @
Output:
@

Input: test
Output:
test
t e s t
t  e  s  t
t   e   s   t
t  e  s  t
t e s t
test

Input: ?!
Output:
?!
? !
?!

Input: Spaceship
Output:
Spaceship
S p a c e s h i p
S  p  a  c  e  s  h  i  p
S   p   a   c   e   s   h   i   p
S    p    a    c    e    s    h    i    p
S     p     a     c     e     s     h     i     p
S      p      a      c      e      s      h      i      p
S       p       a       c       e       s       h       i       p
S        p        a        c        e        s        h        i        p
S       p       a       c       e       s       h       i       p
S      p      a      c      e      s      h      i      p
S     p     a     c     e     s     h     i     p
S    p    a    c    e    s    h    i    p
S   p   a   c   e   s   h   i   p
S  p  a  c  e  s  h  i  p
S p a c e s h i p
Spaceship

Input: 05AB1E
Output:
05AB1E
0 5 A B 1 E
0  5  A  B  1  E
0   5   A   B   1   E
0    5    A    B    1    E
0     5     A     B     1     E
0    5    A    B    1    E
0   5   A   B   1   E
0  5  A  B  1  E
0 5 A B 1 E
05AB1E

Input: )}/\
Output:
)}/\
) } / \
)  }  /  \
)   }   /   \
)  }  /  \
) } / \
)}/\

Comments

हो जाता है सब बस चिड़चिड़ा !!!

— 22

मुझे पता था कि मैंने उस आउटपुट को पहचान लिया है। मुझे प्यार है कि यह विचार अभी भी चल रहा है।

— कारपेटिनेट

TFW आप अस्पष्ट रूप से एक प्रश्न में एक पैटर्न को पहचानते हैं, ಠ_ಠतो इसे महसूस करें क्योंकि आपने गलती से इसे एक साल पहले बनाया था ಠ⌣ಠ।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn प्रेरणा के लिए धन्यवाद। ; डी

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

@KevinCruijssen नासमझ बोली लगा के रखने के लिए धन्यवाद!

— मैजिक ऑक्टोपस Urn

Answer 1

जाप , 8 6 बाइट्स

वर्णों के एक सरणी के रूप में इनपुट लेता है, तार की एक सरणी आउटपुट करता है।

£qYçÃê

कोशिश करो

---

व्याख्या

£          :Map each element at (0-based) index Y
 q         :  Join input with
  Yç       :   Space repeated Y times
    Ã      :End Map
     ê     :Palindromise

---

मूल, 8 बाइट्स

I / O एक स्ट्रिंग है। -Rझंडे का उपयोग करता है । प्रत्येक पंक्ति पर अनुगामी रिक्त स्थान शामिल हैं।

¬£múYÄÃê

कोशिश करो

व्याख्या

             :Implicit input of string U
¬            :Split
 £           :Map each character at 0-based index Y
  m          :  Map original U
   ú         :    Right pad with spaces to length ...
    YÄ       :     Y+1
      Ã      :End map
       ê     :Palindromise
             :Implicitly join with newlines

Comments

S.ç()FTW एक बार फिर :-)

— ETHproductions

गंभीर सवाल: क्या इस तरह से एक पहेली के लिए सभी 1 से 6 बाइट्स लंबे समाधानों के माध्यम से पुनरावृत्त रूप से खोज करना संभव होगा?

— फिलिप

@ फीलिप नं: 256 से अधिक ** 6 = 281474976710656 (कम से कम भोले) संयोजन हैं। यह एक पासवर्ड का अनुमान लगाने जैसा है।

— किरिल ब्यूलगिन

@KirillBulygin, Japt में उपलब्ध वर्णों के संयोजन के संभावित तरीके 37 से अधिक ट्रिलियन (37,764,717,485,592) हैं, जो 1 & 6 वर्णों के बीच एक स्ट्रिंग में उपलब्ध हैं। यदि आप अन्य सभी 1 बाइट वर्णों को शामिल करते हैं जो कि स्ट्रिंग शाब्दिक या संपीड़ित तारों में उपयोग किए जा सकते हैं, तो यह संख्या 276 ट्रिलियन (276,024,445,697,280) से अधिक हो जाती है। तो, नहीं, उन सभी को उत्पन्न करने के लिए एक बॉट लिखना, फिर वैध जाप कार्यक्रमों को फ़िल्टर करें फिर एक को खोजें (यदि कोई मौजूद है) जो हाथ में चुनौती के लिए काम करता है तो संभवत: संभव नहीं होगा। इसके अलावा एक बॉट देने में मज़ा आप के लिए अपने गोल्फ क्या है ?!

— झबरा

@ शैगी: "जहां बॉट देने में मज़ा आपके लिए आपकी गोल्फिंग है ?!" क्या होगा अगर आपने बॉट को वास्तव में, वास्तव में छोटा बना दिया है?

— विषम

Answer 2

आर , 105 99 85 85 84 79 बाइट्स

-6 धन्यवाद @ केविन क्रूज़ेन और @ गिउसेपे

-14 को रेगेक्स आधारित विधि में बदलने से

-1 शुक्रिया @Giuseppe के लिए

-5 @ @igigmml को धन्यवाद

function(w,n=nchar(w)-1)write(trimws(Map(gsub,"",strrep(" ",n-abs(n:-n)),w)),1)

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

Comments

आप स्थान को हटाकर 1 बाइट गोल्फ कर सकते हैं in(r<-।

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

और आप केवल sएक बार उपयोग करते हैं ताकि आप इसे writeसीधे तर्क के रूप में उपयोग कर सकें; आपको 99 बाइट्स

— Giuseppe

एक के 1बजाय होना चाहिए कि एक ""में write? मैं आपके उपयोग की खुदाई कर रहा हूँ Map!

— ग्यूसेप

बहुत बढ़िया ! गणित का उपयोग करते हुए 79 बाइट्स :)

— digEmAll

मुझे यकीन था कि मैं इसे collapseतर्क से हरा सकता हूं, pasteलेकिन ऐसा नहीं हो रहा है ...

— JDL

Answer 3

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

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

f=(s,p=i='',o=s.join(p)+`
`)=>s[++i]?o+f(s,p+' ')+o:o

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

Comments

रेक्सएक्स के जवाब से एक स्ट्रिंग के साथ इसे आज़माया गया, एक्सएचटीएमएल स्व-निहित टैग को छोड़कर खुले टैग से मेल खाता है और आउटपुट दिलचस्प दिखता है

— टॉम एम

Answer 4

चारकोल , 10 बाइट्स

Ｅθ⪫θ× κ‖Ｏ↓

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｅθ          Map over characters of input string
  ⪫θ        Join characters of input string using
    ×       a literal space repeated 
      κ     current index number of times
            Implicitly print each result on its own line
       ‖Ｏ↓  Reflect vertically with overlap

Comments

चारकोल जैसी चीजों को प्रतिबिंबित नहीं करता [है ]- या यह एक और अलग कमांड है?

— मैजिक ऑक्टोपस उर्फ़

@MagicOctopusUrn यदि आप प्रतिबिंब को बदलना चाहते हैं तो अलग-अलग कमांड हैं। उदाहरण के लिए codegolf.stackexchange.com/a/127164 देखें ।

— नील

मैंने सोचा था कि मैंने इसे पहले भी दिखाया था, लेकिन यह निश्चित नहीं था। साफ!

— मैजिक ऑक्टोपस उर्फ़

Answer 5

कैनवस , 8 बाइट्स

┐² ×＊］──

यहाँ कोशिश करो!

7 बाइट संस्करण इस चुनौती के लिए बहुत अच्छा था ..

Comments

मुझे आपका 7 बाइट संस्करण पसंद है। क्या आप यह समझाने के लिए तैयार हैं कि यह कैसे काम करता है? किस ऑपरेटर ने दोनों /को एक में ओवरलैप किया X?

— काया

@ काया का यह अंतिम चरित्र है - ─- लंबवत तालमेल । कैनवस का तालमेल शांत चीजें करता है । अतिव्यापी भाग का अपना चरित्र भी होता है।

— दिज़िमा

Answer 6

पायथन 2 , 72 70 68 66 65 बाइट्स

^{-2 बाइट्स धन्यवाद केविन क्रूज़सेन
-3 बाइट्स ओव्स को धन्यवाद}

w=input();c=s=-1
while c:print(' '*~c).join(w);s*=w[:c]>'';c+=s|1

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

Comments

c==len(w)-11 बाइट के साथ गोल्फ हो सकता है c+2>len(w)। EDIT: आपके नए 70-बाइट संस्करण में, 0<cहो सकता है c।

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

Answer 7

05AB1E , 10 9 बाइट्स

अदनान की बदौलत बचा 1 बाइट्स

εINð×ý}û»

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

व्याख्या

ε            # apply to each in input
 I           # push the input
  Nð×        # push <index> spaces
     ý       # merge the input on the spaces
      }      # end loop
       û     # palendromize
        »    # join on newlines

Comments

तुम गिरा सकते हो S। इनपुट लचीला है, इसलिए सूची के रूप में इनपुट करने की अनुमति है।

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

@ केविनक्रूजसेन: आपका पहला संस्करण विरासत में 9 बाइट्स है, हालांकि »छोड़ा जा सकता है।

— एमिग्ना

तुम्हारा वास्तव में 9 बाइट्स में विरासत में काम करता है और साथ ही यदि आप »लूप vको हटाते हैं और नक्शे में बदलते हैं ε।

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

जवाब पोस्ट किया । और वर्तमान में Japt हमें 6 बाइट्स के साथ मार रहा है मुझे डर है। या आपका मतलब 05AB1E (अमृत पुनर्लेखन) और 05AB1E (पायथन विरासत) में सबसे छोटा था? :)

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

करता εINð×ý}û»भी काम करते हैं?

— अदनान

Answer 8

रूबी , 54 49 बाइट्स

->a{(-(z=a.size-1)..z).map{|i|a*(?\s*(z-i.abs))}}

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

वर्णों के एक सरणी के रूप में इनपुट लेता है, स्ट्रिंग के सरणी को आउटपुट करता है।

Answer 9

जाप , ९ by बाइट्स

-1 बग्गी से @ बाइट

ÊƬqXîÃê

---

ÊƬqXîÃê        Full program, implicity input U
ÊÆ              Rage from 0 to U length and map
  ¬             split U at ""
   qXîà     join U using " " times range current value
        ê       horizontal mirror

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

Comments

डैंग; ऐसा लगता है जैसे आपने मुझे फिर से निंजा बना दिया! Lemme पता है कि क्या आप मुझे मेरा हटाना चाहते हैं।

— झबरा

@ नहीं, अपना जवाब रखें, आप इनपुट के रूप में सरणी का उपयोग कर रहे हैं, जबकि मैं एक स्ट्रिंग का उपयोग करता हूं ताकि वे अलग तरह के xD हों

— लुइस फेलिप डी जीसस मुनोज़

SpX-> Xî1 बाइट की बचत के लिए।

— झबरा

Answer 10

पॉवरशेल , 66 54 बाइट्स

-12 बाइट्स mazzy के लिए धन्यवाद

0..($x=($a=$args).count-1)+$x..0|gu|%{$a-join(' '*$_)}

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

स्प्लिटिंग के माध्यम से इनपुट लेता है, जो TIO पर प्रत्येक वर्ण के लिए अलग कमांड-लाइन तर्क के रूप में प्रकट होता है।

हम पहले $a=$argsइनपुट तर्क के रूप में सेट करते हैं। फिर हम उस सरणी के $xबराबर सेट करते हैं । हमें तब स्पेसशिप के निर्माण के लिए अक्षरों के माध्यम से लूप करना पड़ता है। यह एक सीमा का निर्माण करके किया जाता है , फिर वापस नीचे की ओर , फिर उचित सीमा को खींचने के लिए उपयोग किया जाता है।.count-10$x$x0Get-Unique

प्रत्येक पुनरावृत्ति, हम अपने इनपुट तर्कों और -joinउन्हें एक साथ रिक्त स्थान की संख्या के साथ लेते हैं। उन तारों में से प्रत्येक को पाइप लाइन पर छोड़ दिया गया है, और एक निहित Write-Outputकार्यक्रम के पूरा होने पर हमें मुफ्त में नए समाचार देता है।

Comments

इसे 0..($x=($a=$args).count-1)+$x..0|gu|%{$a-join(' '*$_)}

— आजमाइए

@ mazzy क्या ... कैसे Get-Uniqueसीमा पर उस तरह काम करता है ? वह पागल है! धन्यवाद!

— AdmBorkBork

Answer 11

05AB1E (विरासत) , 9 बाइट्स

εINúíJ}û»

पात्रों की सूची के रूप में इनपुट।

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

स्पष्टीकरण:

ε     }    # Map each character in the input to:
 I         #  Take the input
  Nú       #  Prepend each with the 0-indexed amount of spaces
           #   i.e. ["t","e","s","t"] & 3 → ["   t","   e","   s","   t"]
    í      #  Reverse each item
           #   i.e. ["   t","   e","   s","   t"] → ["t   ","e   ","s   ","t   "]
     J     #  Join them together to a single string
           #   i.e. ["t   ","e   ","s   ","t   "] → "t   e   s   t   "
       û»  # Palindromize the list, and join by newlines
           #  i.e. ["test","t e s t ","t  e  s  t  ","t   e   s   t   "]
           #   → "test\nt e s t \nt  e  s  t  \nt   e   s   t   \nt  e  s  t  \nt e s t \ntest"

Comments

Oooooo, यह भी मान्य नहीं है क्योंकि दर्पण दर्पण के / / to के अभिविन्यास को बदल देता है, जब उसी के साथ [, ]और (, और )। चारकोल को पकड़ने के लिए उन मामलों को भी जोड़ना चाहते हैं। (अन्य टिप्पणियों को एमिग्ना के उत्तर में ले जाया गया, क्योंकि वह उत्तर था जो मैंने मूल रूप से टिप्पणी की थी)

— मैजिक ऑक्टोपस उर्फ़

@MagicOctopusUrn मुझे बताने के लिए धन्यवाद। के û»बजाय का उपयोग करके इसे ठीक किया .∊।

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

Answer 12

हास्केल , 60 59 बाइट्स

(init<>reverse).(scanl(?)<*>tail)
a?_=do u<-a;u:[' '|' '<u]

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

व्याख्या

एक स्ट्रिंग (जैसे। "abc") के लिए हम पहले आवेदन करते हैं

scanl (?) <*> tail

जो जैसा है वैसा है

\str -> scanl (?) str (tail str)

यह बार-बार लागू होता है (?)(सीमा में प्रत्येक चरित्र के लिए एक अंतरिक्ष संलग्न कर देता है [33 ..] करने के लिए) strजब तक वहाँ है कि कई तार कर रहे हैं के रूप में strकैरेक्टर हैं:["abc","a b c ", "a b c "]

अब हमें केवल इसके उल्टे काउंटर भाग के साथ परिणाम (अंतिम तत्व घटाकर) प्राप्त करने की आवश्यकता है:

init<>reverse

Answer 13

MATL , 25 22 13 बाइट्स

zZv"Gtz@he!1e

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

एक 5 बाइट गोल्फ का सुझाव देने के लिए लुइस मेंडो के लिए धन्यवाद , जिसने मुझे 4 और बाइट्स से दाढ़ी बनाने के लिए प्रेरित किया!

उदाहरण इनपुट के साथ स्पष्टीकरण 'abc':

         # Implicit input, 'abc'
z        # find number of nonzero elements (length of string)
         # stack: [3]
Zv       # symmetric range
         # stack: [[1 2 3 2 1]]
"        # begin for loop, iterating over [1 2 3 2 1] as the loop indices
G        # push input
         # stack: ['abc']
tz       # dup and push length
         # stack: ['abc', 3]
@        # push loop index, i (for example, 2)
         # stack: ['abc', 3, 2]
h        # horizontally concatenate
         # stack: ['abc', [3, 2]]
e!       # reshape to matrix of 3 rows and i columns, padding with spaces, and transpose
         # stack: [['abc';'   ';'   ']]
1e       # reshape to matrix of 1 row, leaving last value on stack
         # stack: ['a  b  c  ']
         # implicit end of for loop
         # implicit end of program, display stack contents

Answer 14

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

jⱮLḶ⁶ẋƲŒḄ

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

लाइनों की एक सूची देता है; टीआईओ पर उत्पादन पूर्व निर्धारित।

Comments

कुछ अलग 9 ,€⁶$LСŒḄ:। अन्य, अधिक समान, 9: J’⁶ẋŒḄɓjⱮऔर J’⁶ẋŒḄjⱮ@(मैं अभी तक छोटी लेकिन कोई खुशी नहीं तलाश रहा था)

— जोनाथन एलन

@JonathanAllan मुझे पूरा यकीन है कि यह इष्टतम है, मुझे नहीं लगता कि लिखने के लिए कोई छोटा रास्ता है LḶ⁶ẋया ŒḄ। हालाँकि, यदि आप एक बचत खोजने का प्रबंधन करते हैं, तो मुझे पिंग करें। :-)

— आउटगॉल्फ

इसके बारे में सोचना मेरे लिए थोड़ा ,€⁶$LСŒḄवैध नहीं हो सकता क्योंकि इसमें पागल घोंसले के शिकार की आवश्यकता हो सकती है Yऔर एक पूर्ण कार्यक्रम हो सकता है।

— जोनाथन एलन

@JonathanAllan हाँ, निश्चित रूप से यह नहीं है। ['I', 'f', [[' '], 't', 'h', [['i']], 's'], ' ', 'i', ['s', ' '], 'a', [[' ', 's', 't'], 'r', ['i', 'n', 'g'], ' '], 'w', ['e', ' ', 'a', 'r', 'e'], ' ', 'd', 'o', ['o'], 'm', [[[[['e']]]]], [[[['d']]]], '!']कम से कम मैंने 05AB1E को आउटगोल्फ किया है ...

— आउटगॉल्फ

मैंने कहा कि मैं 05AB1E से आगे निकल गया, एह? बाह, अब और नहीं। : /

— आउटगॉल्फ

Answer 15

पायथ , 12 बाइट्स

बस मेरा अनिवार्य Pyth सबमिशन। मुझे इस पर काफी गर्व है इसलिए स्पष्टीकरण जल्द ही आएगा।

+P_=jRQ*L;_U

यहाँ कोशिश करो!

+P_=jRQ_.e*d

यहाँ कोशिश करो!

Answer 16

स्टैक्स , 10 बाइट्स

Ç·9ƒù▌╘Ä┘e

इसे चलाएं और डीबग करें

प्रत्येक लाइन पर व्हॉट्सएप के साथ आउटपुट।

स्पष्टीकरण:

%R|pmx{]n(m Full program, unpacked, implicit input
%           Length of input
 R          1-based range
  |p        Palindromize
    m       Map:
     x{   m   Map over characters of input:
       ]        Character -> string
        n(      Right-pad to length given by outer map value
              Implicit flatten and output

Answer 17

जावा (JDK 10) , 115 बाइट्स

s->{for(int l=s.length(),i=-l;++i<l;)System.out.printf(s.replaceAll(".","%-"+(i<0?l+i:l-i)+"s")+"%n",s.split(""));}

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

• -2 बाइट्स केविन क्रूज़सेन की बदौलत

Comments

l-Math.abs(i)i<0?l+i:l-i-2 बाइट्स के लिए गोल्फ हो सकता है ।

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

@ केविनक्रूजसेन धन्यवाद! :)

— ओलिवियर ग्रेजायर

क्या यह हो सकता है l-i<0?-i:i?

— क्विंट

@ thecoder16 आपको कोष्ठक की आवश्यकता होगी: l-(i<0?-i:i)(12 बाइट्स)।

— जोनाथन फ्रेच

Answer 18

के (ओके) , 25 24 बाइट्स

समाधान:

,/'(1+a,1_|a:!#x)$\:+,x:

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

स्पष्टीकरण:

मेरे K4 समाधान का पोर्ट :

,/'(1+a,1_|a:!#x)$\:+,x: / the solution
                      x: / save input as x
                     ,   / enlist
                    +    / flip
                 $\:     / pad ($) right by each-left (\:)
   (            )        / do this together
              #x         / count length of input,           e.g. 3
             !           / range 0..length,                 e.g. 0 1 2
           a:            / save as a
          |              / reverse it,                      e.g. 2 1 0
        1_               / drop first,                      e.g. 1 0
      a,                 / join to a,                       e.g. 0 1 2 1 0
    1+                   / add 1,                           e.g. 1 2 3 2 1
,/'                      / flatten (,/) each (')

टिप्पणियाँ:

• -1 बाइट धन्यवाद ngn करने के लिए

Comments

,:'-> +,

— ngn

Answer 19

पास्कल (एफपीसी) , 143 135 बाइट्स

var s:string;i,j,l:word;begin read(s);l:=length(s);repeat i:=i+1;for j:=1to l do write(s[j],'':l-abs(l-i)-1);writeln until i=l*2-1 end.

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

मैं शायद केवल पेंग्वेंज के खिलाफ जीत हासिल करूंगा ...

Answer 20

PHP, 88 89 बाइट्स

for(;++$i<2*$e=count($a=str_split($argn));)echo join(str_pad("",~-$e-abs($i-$e)),$a),"\n";

PHP 5 या बाद के लिए की आवश्यकता है str_split। ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

Comments

आपकी कोशिश यह ऑनलाइन लिंक गलत आउटपुट देता है जिससे मुझे डर लगता है। आपके आउटपुट में सभी लाइनों में केवल वर्णों (या वैकल्पिक रूप से अनुगामी) के बजाय प्रमुख स्थान होते हैं। पहला चरित्र सभी आउटपुट में एक ही कॉलम में होना चाहिए।

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

@KevinCruijssen Didnevint पर्याप्त उत्पादन के करीब देखो। फिक्स्ड। (हालांकि मेरी पिछली आउटपुट एक रॉकेट की तरह दिखती थी) ;-)

— टाइटस

यह थोड़े मुझे तीर के सिर की तरह लग रहा था। : D लेकिन +1 अब यह तय हो गया है।

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

यदि आप \ n के बजाय एक वास्तविक न्यूलाइन रखते हैं, तो आप बाइट बचाते हैं :)

— Martijn

@Martijn मैंने वास्तव में इसके लिए केवल एक बाइट की गिनती की थी ... जब मैंने यहां कोड पेस्ट किया था, तो इसे बदलना भूल गया था।

— टाइटस

Answer 21

K4 , 23 बाइट्स

समाधान:

,/'(1+a,1_|a:!#x)$\:$x:

उदाहरण:

q)k),/'(1+a,1_|a:!#x)$\:$x:"Spaceship"
"Spaceship"
"S p a c e s h i p "
"S  p  a  c  e  s  h  i  p  "
"S   p   a   c   e   s   h   i   p   "
"S    p    a    c    e    s    h    i    p    "
"S     p     a     c     e     s     h     i     p     "
"S      p      a      c      e      s      h      i      p      "
"S       p       a       c       e       s       h       i       p       "
"S        p        a        c        e        s        h        i        p        "
"S       p       a       c       e       s       h       i       p       "
"S      p      a      c      e      s      h      i      p      "
"S     p     a     c     e     s     h     i     p     "
"S    p    a    c    e    s    h    i    p    "
"S   p   a   c   e   s   h   i   p   "
"S  p  a  c  e  s  h  i  p  "
"S p a c e s h i p "
"Spaceship"

स्पष्टीकरण:

प्रत्येक लाइन पर व्हॉट्सएप को पीछे छोड़ रहा है।

,/'(1+a,1_|a:!#x)$\:$x: / the solution
                     x: / save input as x,                 e.g. "abc"
                    $   / string,                          e.g. (,"a";,"b";,"c")
                 $\:    / pad ($) right by each-left (\:)
   (            )       / do this together
              #x        / count length of input,           e.g. 3
             !          / range 0..length,                 e.g. 0 1 2
           a:           / save as a
          |             / reverse it,                      e.g. 2 1 0
        1_              / drop first,                      e.g. 1 0
      a,                / join to a,                       e.g. 0 1 2 1 0
    1+                  / add 1,                           e.g. 1 2 3 2 1
,/'                     / flatten each

Answer 22

सी #, 113 105 98 बाइट्स

s=>{for(int l=s.Length,i=-l;++i<l;)WriteLine(Join("",s.Select(c=>$"{c}".PadRight(i<0?l+i:l-i))));}

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

Comments

नमस्ते। वर्तमान में आपका उत्तर किसी फ़ंक्शन या पूर्ण कार्यक्रम के बजाय एक स्निपेट है। यह सस्ते में s=>{पहले और }बाद में इसे लंबो-फ़ंक्शन जोड़कर तय किया जा सकता है । इसके अलावा, गोल्फ के लिए एक चीज फोर-लूप के चारों ओर ब्रैकेट को हटा रही है। इसे ऑनलाइन आज़माएं।

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

@ केविनक्रूजसेन धन्यवाद! पोस्ट करने से पहले ठीक करना भूल गए ...

— RobIII

Answer 23

स्काला , 82 बाइट्स

for(i<-(0 to a.size)union(-a.size to 0))println(a.map(_+" "*Math.abs(i)).mkString)

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

स्काला में बहुत सारे शॉर्टकट हैं जो यहाँ मेरी मदद कर रहे हैं और यह काफी पठनीय है! Scala की कोशिश करो

Comments

नमस्ते वहाँ, PPCG में आपका स्वागत है! हालांकि यह एक अच्छा जवाब है, मुझे डर है कि दो चीजें थोड़ी गलत हैं। सबसे अधिक रिक्त स्थान वाली लाइन केवल दो बार के बजाय मध्य में एक बार आउटपुट होनी चाहिए। और वर्तमान में आप प्रिंट 0करने के लिए lengthरिक्त स्थान की मात्रा के बजाय 0करने के लिए length-1रिक्त स्थान की राशि। मैं स्काला को बहुत अच्छी तरह से नहीं जानता, लेकिन ऐसा लगता है कि आप दोनों मुद्दों को +4 बाइट्स (कुल 86 बाइट्स) के साथ ठीक कर सकते हैं: for(i<-(0 to a.size-1)union(-a.size+2 to 0))println(a.map(_+" "*Math.abs(i)).mkString)फिर से स्वागत है, और अपने प्रवास का आनंद लें! :)

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

Answer 24

Oracle SQL, 115 बाइट्स

गोल्फ की भाषा नहीं बल्कि ...

SELECT TRIM(REGEXP_REPLACE(v,'(.)',LPAD('\1',1+LENGTH(v)-ABS(LEVEL-LENGTH(v)))))FROM t CONNECT BY LEVEL<2*LENGTH(v)

मान लें कि मान vतालिका के स्तंभ में है t:

एसक्यूएल फिडल

Oracle 11g R2 स्कीमा सेटअप :

CREATE TABLE t ( v ) AS
  SELECT 'test' FROM DUAL;

क्वेरी 1 :

SELECT TRIM(REGEXP_REPLACE(v,'(.)',LPAD('\1',1+LENGTH(v)-ABS(LEVEL-LENGTH(v)))))
FROM   t
CONNECT BY LEVEL<2*LENGTH(v)

परिणाम :

(SQLField किसी कारण से कॉलम में दाएं-संरेखित मान प्रिंट करता है ... प्रमुख स्थान नहीं हैं)

| TRIM(REGEXP_REPLACE(V,'(.)',LPAD('\1',1+LENGTH(V)-ABS(LEVEL-LENGTH(V))))) |
|---------------------------------------------------------------------------|
|                                                                      test |
|                                                                   t e s t |
|                                                                t  e  s  t |
|                                                             t   e   s   t |
|                                                                t  e  s  t |
|                                                                   t e s t |
|                                                                      test |

Comments

आपका SQL फिडेल परिणाम केवल वर्णों के बीच एकल रिक्त स्थान है? इस स्क्रीनशॉट को देखें । मुझे लगता है कि यह SQL फिडेल के कारण है और यह स्थानीय स्तर पर काम करता है? Btw, यकीन नहीं है कि अगर SQL मानक regex नियमों का उपयोग करता है, लेकिन उदाहरण के लिए जावा में आप के बजाय का उपयोग करके (.)गोल्फ हो सकता है? संपादित करें: कोई बात नहीं, वह है , नहीं .. ( जावा उदाहरण मेरा मतलब है )। .\0\1$0\0

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

@KevinCruijssen "रन एसक्यूएल" बटन के बगल में नीचे तीर पर क्लिक करें और आउटपुट को "प्लेनटेक्स्ट आउटपुट" या "मार्कडाउन आउटपुट" में बदल दें और आप रिक्त स्थान देखेंगे।

— MT0

धन्यवाद। यह वास्तव में उस मामले में अच्छा लग रहा है!

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

Answer 25

8086 मशीन कोड, 56 53 बाइट्स

00000000  bf 35 01 57 ba 01 00 52  be 82 00 b3 ff ac 59 51  |.5.W...R......YQ|
00000010  aa 3c 0d 74 07 b0 20 e2  f7 43 eb f1 b0 0a aa 59  |.<.t.. ..C.....Y|
00000020  00 d1 e3 08 38 cb d6 08  c2 51 eb dc c6 05 24 5a  |....8....Q....$Z|
00000030  b4 09 cd 21 c3                                    |...!.|
00000035

से लिया गया:

org 0x100
use16
        mov di, buffer
        push di
        mov dx, 1
        push dx
nextl:  mov si, 0x82
        mov bl, -1
nextc:  lodsb
        pop cx
        push cx
stor:   stosb
        cmp al, 0x0d
        je cr
        mov al, ' '
        loop stor
        inc bx
        jmp nextc
cr:     mov al, 0x0a
        stosb
        pop cx
        add cl, dl
        jcxz done
        cmp bl, cl
        salc
        or dl, al
        push cx
        jmp nextl
done:   mov [di], byte '$'
        pop dx
        mov ah, 0x09
        int 0x21
        ret
buffer:

परीक्षण का मामला:

Comments

नमस्ते। मुझे लगता है कि 8086 मशीन कोड के लिए कोई ऑनलाइन संकलित नहीं किया गया है, लेकिन क्या आप शायद परीक्षण मामलों में से एक के लिए आउटपुट का स्क्रीनशॉट जोड़ सकते हैं? तब मैं जांच कर सकता हूं कि क्या सब कुछ सही है। :)

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

किया हुआ। इसके अलावा एक और बाइट का

— मुंडन

स्क्रीनशॉट के लिए धन्यवाद! दुर्भाग्य से आउटपुट में एक छोटी सी गलती है। मध्य रेखा में अब lengthरिक्त स्थान है और कुल 9 रेखाएँ हैं, लेकिन मध्य रेखा length-1में रिक्त स्थान की मात्रा होनी चाहिए और इसके स्थान पर कुल 7 रेखाएँ होनी चाहिए (4-अक्षर शब्द 'test'` के लिए): (मुझे आशा है कि इसे ठीक करने के लिए बाइट्स के मामले में महंगा नहीं है?

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

ओह अछा। यह अब तय हो गया है, मैंने इसे एक और बाइट से घटा दिया है।

— user5434231

Answer 26

हास्केल, 64 60 59 बाइट्स

(""#)
a#s|l<-(:a)=<<s,w<-' ':a=l:[x|w<(' '<$s),x<-w#s++[l]]

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

a#s                         -- take a string of spaces 'a' and the input string 's'
 |l<-(:a)=<<s               -- let 'l' be the current line, i.e. the spaces in 'a'
                            -- appended to each char in 's'
  w<-' ':a                  -- let 'w' be 'a' with an additional space   
 =l                         -- return that 'l'
   :[   |w<(' '<$s)   ]     -- and, if 'w' is shorter than 's',
     x  ,x<-w#s++[l]        -- followed by a recursive call with 'w' 
                            -- and by another copy of 'l'

(""#)                       -- start with an empty 'a'

Answer 27

बैश , 115 , 109 , 105 , 100 , 97 , 96 , 92 , 91 , 90 बाइट्स

-5 और -3 केविन क्रूसेन को धन्यवाद

read s;for((c=f=1;f;c-=2*(f>=${#s}),f+=c))
{ printf '%-'${f}'.c' `grep -o .<<<"$s"`
echo
}

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

---

ध्यान दें कि चूंकि \शेल एस्केप चार है, इसलिए परीक्षण मामले )}/\को \इस तरह से एक अतिरिक्त के साथ दर्ज किया जाना चाहिए )}/\\:।

Comments

नमस्ते। क्या परीक्षण मामले के साथ TIO- लिंक जोड़ना संभव है ? इसके अलावा, मैं बैश को बहुत अच्छी तरह से नहीं जानता, लेकिन क्या पायथन के बाद inऔर printfजैसी जगहों को हटाना संभव है ?

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

@ केविनक्रूजसेन, धन्यवाद, संशोधित उत्तर देखें। मैं TIO- लिंक के लिए नया हूँ , और मुझे यकीन नहीं है कि कई परीक्षण मामलों का उपयोग कैसे किया जाए, क्योंकि यह bashकोड केवल एक स्ट्रिंग इनपुट करता है, ( यानी सिर्फ एक लाइन)। परीक्षण के मामले सभी काम करते हैं, हालांकि )}/\ इस तरह एकल उद्धरण होना चाहिए <<< ')}/\' read s; ...etc. । रिक्त स्थान के बाद inऔर printfजरूरत है।

— एजीसी

धन्यवाद। और टीआईओ के लिए एक एकल परीक्षण मामला ठीक है। यह मुख्य रूप से सत्यापित करने के लिए है कि क्या सब कुछ उम्मीद के मुताबिक काम कर रहा है, जो वास्तव में मामला लगता है। मुझ से +1। :)

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

अपने नए संस्करण में आप इस तरह से 5 और बाइट्स गोल्फ कर सकते हैं । के बाद रिक्त स्थान forऔर doहटाया जा सकता है। f=1को बदला जा सकता है c=f=1। और f=f+cहो सकता है f+=c।

— केविन क्रूजेसेन

ओह, गोल्फ के लिए एक और छोटी सी बात। नहीं था यकीन है कि अगर यह बैश में संभव है, लेकिन जाहिरा तौर पर यह (एक और कारण है कि एक TIO-लिंक से उपयोगी है;) है), बदलकर है f!=0करने के लिए fके लिए लूप में। जैसे जावास्क्रिप्ट और पायथन में, 0फाल्सी है और बाश में हर दूसरे सकारात्मक / नकारात्मक पूर्णांक स्पष्ट रूप से सत्य है।

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

Answer 28

पर्ल 6 , 43 बाइट्स

{(0....comb-1...0)>>.&{join ' 'x$^a,.comb}}

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

लाइनों की एक सूची देता है।

स्पष्टीकरण:

 {                                         }  # Anonymous code block
  (0....comb-1...0) # A list from
   0                  # 0
    ...               # to
       .comb-1        # the length of the input string -1
              ...     # back to
                 0    # 0
                   >>.&{                  }  # Map each number to
                        join        ,.comb   # Join the list of characters
                             ' 'x$^a         # With the number of spaces

Answer 29

सी (जीसीसी) , 131 129 111 बाइट्स

i;x;f(k,j)char*k,*j;{x=strlen(k)-1;for(i=0;i<x-~x;i+=puts(""))for(j=k;*j;)printf("%c%*s",*j++,i<x?i:2*x-i,"");}

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

-20 के लिए धन्यवाद बाइट्स ceilingcat !

#import<string.h>
i;x;f(k,j)char*k,*j;{x=strlen(k)-1;for(i=0;i<x-~x;i+=puts(""))for(j=k;*j;)printf("%c%*s",*j++,i<x?i:2*x-i,"");}

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

या, अगर लंबाई को एक पैरामीटर के रूप में स्वीकार किया जा सकता है:

सी (जीसीसी), 105 102 बाइट्स

-1 बाइट सीक्रेट के लिए धन्यवाद!

i;x;f(k,x,j)char*k,*j;{for(i=!x--;i<x-~x;i+=puts(""))for(j=k;*j;)printf("%c%*s",*j++,i<x?i:2*x-i,"");}

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

Comments

@ceilingcat हुह!

— कॉनर ओ'ब्रायन

आपके 102 बाइट्स के लंबे गोल्फ में, मुझे लगता है कि वैश्विक xछाया हुआ है और इस तरह इसे बेमानी घोषित किया गया है।

— जोनाथन फ्रेच

Answer 30

PHP, 148 146 143 141 बाइट्स

function s($s){for(;$i<strlen($s);++$i)f($i,$s);for(--$i;--$i>=0;)f($i,$s);}function f($i,$s){echo chunk_split($s,1,str_repeat(' ',$i))."
";}

आप इसे इस तरह से परख सकते हैं:

<?php
error_reporting(0);

$s = 1234567890;
function s($s){for(;$i<strlen($s);++$i)f($i,$s);for(--$i;--$i>=0;)f($i,$s);}function f($i,$s){echo chunk_split($s,1,str_repeat(' ',$i))."
";}

उत्पादन

1234567890
1 2 3 4 5 6 7 8 9 0 
1  2  3  4  5  6  7  8  9  0  
1   2   3   4   5   6   7   8   9   0   
1    2    3    4    5    6    7    8    9    0    
1     2     3     4     5     6     7     8     9     0     
1      2      3      4      5      6      7      8      9      0      
1       2       3       4       5       6       7       8       9       0       
1        2        3        4        5        6        7        8        9        0        
1         2         3         4         5         6         7         8         9         0         
1        2        3        4        5        6        7        8        9        0        
1       2       3       4       5       6       7       8       9       0       
1      2      3      4      5      6      7      8      9      0      
1     2     3     4     5     6     7     8     9     0     
1    2    3    4    5    6    7    8    9    0    
1   2   3   4   5   6   7   8   9   0   
1  2  3  4  5  6  7  8  9  0  
1 2 3 4 5 6 7 8 9 0 
1234567890

सैंडबॉक्स

विस्तारित संस्करण

 function s($s){
    //loop upwards 0-10
    for(;$i<strlen($s);++$i) f($i,$s);
     //decrement so it's odd, from 9 loop downwards to 0
    for(--$i;--$i>=0;)f($i,$s);
 }
 //2nd function to save space
 function f($i,$s){
     //chunk it, split 1 char, insert $i number of spaces
     echo chunk_split($s,1,str_repeat(' ',$i))."
";}

प्रयास 2, 92 बाइट्स

@ जवाब देखने के बाद मैंने इसे कम कर दिया:

for(;++$i<2*$e=strlen($s=$argn);)echo chunk_split($s,1,str_repeat(' ',~-$e-abs($i-$e)))."
";

मैं 2 के बजाय 1 लूप का उपयोग करने का एक तरीका सोचने की कोशिश कर रहा था ... मानो या न मानो, मैं for"वास्तविक" कोड में लूप का उपयोग कभी नहीं करता । यह ~बिटवाइज़ नहीं था, कि मैं गायब था ...

यह एक छोटे से लंबे समय तक है 92 इसलिए मुझे इतना बुरा नहीं लगता है। लेकिन मैं इसे एक दूसरे प्रयास के रूप में वैसे भी डालूंगा।

$argn कमांड लाइन से इनपुट है

-NR के साथ पाइप के रूप में चलाएं या इसे ऑनलाइन आज़माएं।

सैंडबॉक्स

Comments

यह मुझे लगता है कि यदि आपका fअनाम संस्करण असाइन करने के बजाय एक नामित फ़ंक्शन का उपयोग करता है तो आपका पहला संस्करण 4 बाइट्स छोटा होगा $f- function f(2 बाइट्स बचाता है $f=function(, और आप हर बार जब आप कॉल f(...)करते हैं, तो एक बाइट बचाते हैं $f(...)। वैकल्पिक रूप से, आप $s2 बाइट्स सहेजते हुए कैप्चर कर सकते हैं - ($i)use($s)4 बाइट्स से अधिक लंबा है ($i,$s), लेकिन आप $f($i)इसके बजाय प्रत्येक कॉल के लिए 3 बाइट्स बचाते हैं $f($s,$i); जेएस की तरह स्वचालित कैप्चर वाली भाषाओं में, यह अक्सर एक व्यवहार्य बचत है, क्योंकि आप useबयान के दंड का भुगतान नहीं करते हैं ।

— IMSoP

मैं मदद की सराहना करता हूं, मैं गोल्फ को कोड करने के लिए बहुत नया हूं और वास्तव में ऐसा नहीं करता हूं, हालांकि नियमित एसओ पेजों पर ऊब जाता है, हालांकि। मैंने उपयोग करने के बारे में सोचा था useलेकिन यह लंबे समय तक महसूस करता है, यह करने के लिए कि $iयह गतिशील है, इसे संदर्भ से पारित करना होगा। इसलिए इसे होना चाहिए use(&$i)और $iइसे संदर्भ से गुजरने से पहले परिभाषित करना होगा $f। जिसका अर्थ है इसे मूल कार्य में, या किसी अन्य से पहले सेट करना। फ़ंक्शन के लिए यह हो सकता है function s($s,$i)और बस पता है कि इसके साथ कॉल किया जाना है, s($s,0) लेकिन यह बदसूरत लगता है, और यह चारों ओर है11 bytes, use(&$i),$i

— ArtisticPhoenix

हम $sहालांकि उपयोग कर सकते हैं और \nवास्तविक लाइन रिटर्न में बदल सकते हैं। वह इसे 143 समाप्त होने वाली पंक्ति से 2 और उपयोग से 1

— ArtisticPhoenix

हां, मैंने $ i को उपयोग में लाने पर भी विचार नहीं किया था, क्योंकि $ s ने "प्राकृतिक" कब्जा महसूस किया था, लेकिन यह हमेशा शुद्ध बचत की गणना के लायक है। हालांकि, अगर आप अभी भी सिर्फ एक नामित समारोह की घोषणा के द्वारा 2 बाइट्स बचा सकता है fको बंद करने के बजाय: function s($s){for(;$i<strlen($s);++$i)f($i,$s);for(--$i;--$i>=0;)f($i,$s);}function f($i,$s){echo chunk_split($s,1,str_repeat(' ',$i))." ";}इस तरह अतिरिक्त कार्यों इस मेटा पोस्ट के अनुसार अनुमति दी जाती है: codegolf.meta.stackexchange.com/questions/7614/...

— IMSoP

अद्यतित, एक जोड़े को बचाया

— ArtisticPhoenix