इसे बनाने में मुझे बहुत समय लगा, pls जैसे। (YouTube टिप्पणियाँ # 1)

84

पकड़ो ..... यह ट्रोलिंग नहीं है।

पृष्ठभूमि

YouTube पर इन दिनों, टिप्पणी अनुभाग ऐसे पैटर्न से अटे पड़े हैं:

S
St
Str
Stri
Strin
String
Strin
Stri
Str
St
S

जहां Stringएक मात्र प्लेसहोल्डर है और पात्रों के किसी भी संयोजन को संदर्भित करता है। ये पैटर्न आमतौर पर एक It took me a lot of time to make this, pls likeया कुछ के साथ होते हैं , और अक्सर ओपी कई पसंदों को प्राप्त करने में सफल होता है।

काम

यद्यपि आपको अपने आकर्षक गोल्फ कौशल के साथ PPCG पर अपवित्र संचय करने की एक महान प्रतिभा मिली है, आप निश्चित रूप से YouTube टिप्पणी अनुभागों में मजाकिया टिप्पणी या संदर्भ मेम बनाने के लिए शीर्ष विकल्प नहीं हैं। इस प्रकार, जानबूझकर की गई आपकी रचनात्मक टिप्पणियां YouTube पर कुछ 'पसंद नहीं' करने वाली हैं। आप यह बदलना चाहते हैं। तो, आप अपनी अंतिम महत्वाकांक्षा को प्राप्त करने के लिए उपर्युक्त क्लिच पैटर्न बनाने का सहारा लेते हैं, लेकिन किसी भी समय को बर्बाद किए बिना उन्हें मैन्युअल रूप से लिखने की कोशिश कर रहे हैं।

सीधे शब्दों में कहें, तो आपका काम एक स्ट्रिंग लेना, कहना s, और आउटपुट 2*s.length - 1सबस्ट्रिंग का sन्यूलाइन द्वारा सीमांकित करना है, ताकि निम्नलिखित पैटर्न का पालन किया जा सके:

( s= "हैलो" के लिए)

H
He
Hel
Hell
Hello
Hell
Hel
He
H

इनपुट

एक ही तार s। समुदाय के इनपुट डिफॉल्ट लागू होते हैं। आप मान सकते हैं कि इनपुट स्ट्रिंग में केवल मुद्रण योग्य ASCII वर्ण होंगे।

उत्पादन

ऊपर बताए अनुसार एक उपयुक्त पैटर्न बनाते हुए, एक नई रेखा द्वारा अलग की गई कई लाइनें। समुदाय के आउटपुट डिफॉल्ट्स लागू होते हैं। रिक्त और अनुगामी (जिसमें कोई वर्ण या वर्ण नहीं देखा जा सकता, जिसमें स्थान की तरह) आउटपुट में लाइनें अनुमत हैं।

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

एक बहु-शब्द परीक्षण मामला:

Input => "Oh yeah yeah"

Output =>

O
Oh
Oh 
Oh y
Oh ye
Oh yea
Oh yeah
Oh yeah 
Oh yeah y
Oh yeah ye
Oh yeah yea
Oh yeah yeah
Oh yeah yea
Oh yeah ye
Oh yeah y
Oh yeah 
Oh yeah
Oh yea
Oh ye
Oh y
Oh 
Oh
O

ध्यान दें कि उपरोक्त परीक्षण मामले के आउटपुट के आकार में स्पष्ट विकृतियाँ हैं (उदाहरण के लिए, लाइन दो और आउटपुट के लाइन तीन समान दिखाई देते हैं)। वे इसलिए हैं क्योंकि हम अनुगामी व्हाट्सएप नहीं देख सकते हैं। आपके कार्यक्रम को इन विकृतियों को ठीक करने की कोशिश करने की आवश्यकता नहीं है।

जीत का मानदंड

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में बाइट्स में सबसे छोटा कोड जीत जाता है!

code-golf  string  ascii-art 
— अर्जुन
स्रोत
19
मैं भविष्य में कुछ और YouTube टिप्पणियों से संबंधित चुनौतियाँ बनाने की योजना बना रहा हूँ; इसलिए YouTube Comments #1शीर्षक में।
— अर्जुन
1
लाइनों की एक सरणी लौटने की अनुमति है?
— कोई
2
क्या हम वर्णों के एक सरणी के रूप में इनपुट ले सकते हैं और वर्णों के सारणियों की एक सरणी लौटा सकते हैं?
— झबरा
3
— Giuseppe
3
क्या इनपुट हो सकता है ""? एक एकल चरित्र के बारे में क्या "H"? यदि हां, तो उन दोनों मामलों के लिए आउटपुट क्या होना चाहिए?
— AdmBorkBork

जवाबों:

103

ब्रेनफक , 32 बाइट्स

,[[<]>[.>]++++++++++.,[>>]<[-]<]

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

पैटर्न के दोनों हिस्सों के लिए एक ही लूप का उपयोग किया जाता है।

स्पष्टीकरण:

,             Take first input character as initial line
[             Until line to output is empty:
  [<]>        Move to beginning of line
  [.>]        Output all characters in line
  ++++++++++. Output newline
  ,           Input next character
  [>>]        Move two cells right if input character nonzero
  <[-]        Otherwise remove last character in line
  <           Move to new last character in line
]
— Nitrodon
स्रोत
2
यह सिर्फ सादा भयानक है। मैं दिमाग में कुछ करने की कोशिश कर रहा था, लेकिन यह इस लंबे समय के बारे में 10 गुना निकला और अभी भी ठीक से काम नहीं किया।
— एलपीड्रो
34
कभी नहीं सोचा था कि मैं एक चुनौती देखूँगा जहाँ दिमाग़ का जवाब वास्तव में प्रतिस्पर्धात्मक रूप से, भयानक काम कर रहा था!
— प्रश्न अंक
54

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

f=([c,...r],s=`
`)=>c?s+f(r,s+c)+s:s

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

टिप्पणी की गई

f = (             // f is a recursive function taking:
                  //   the input string split into:
  [c,             //     c   = next character (may be undefined if we've reached the end)
      ...r],      //     r[] = array of remaining characters
  s = `\n`        //   the output string s, initialized to a linefeed
) =>              // 
  c ?             // if c is defined:
    s +           //   append s (top of the ASCII art)
    f(r, s + c) + //   append the result of a recursive call to f, using r[] and s + c
    s             //   append s again (bottom of the ASCII art)
  :               // else:
    s             //   append s just once (this is the final middle row) and stop recursion
— Arnauld
स्रोत
3
बहुत अच्छा जवाब: D
— lois6b
10
@MartinBarker विंडोज पर, मैं डिफ़ॉल्ट लाइन एंडिंग के साथ नोटपैड ++ का उपयोग कर रहा हूं Unix (LF)। एक बार और सभी के लिए समस्या हल हो गई। :)
— अरनौल
3
बहुत बढ़िया! क्या आप इसके लिए एक स्पष्टीकरण लिख सकते हैं जो JS के लिए पूरी तरह से newbies हैं?
— अखोय
3
@Akhoy मैंने एक टिप्पणी संस्करण जोड़ा है।
— Arnauld
3
धन्यवाद। अब बहुत साफ है।
— अखोय
47

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

बाहर पार &nbsp;4&nbsp;अब 4 नहीं है :)

η.∊

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

स्पष्टीकरण:

η     # Get the prefixes of the (implicit) input-string
 .∊   # Vertically mirror everything with the last line overlapping
      # (which implicitly joins by newlines in the legacy version of 05AB1E)
      # (and output the result implicitly)

05AB1E के नए संस्करण में, और स्पष्ट के »बाद की आवश्यकता है η, यही कारण है कि मैं एक बाइट को बचाने के लिए यहां 05AB1E के विरासत संस्करण का उपयोग करता हूं।

— केविन क्रूज़सेन
स्रोत
7
हम्म, यह UTF8 में 6 बाइट्स लगता है:\xce\xb7\x2e\xe2\x88\x8a
— rubenvb
10
@rubenvb UTF-8 में यह वास्तव में अधिक है। 05AB1E का उपयोग करता है, ठीक उसी तरह, जैसे कुछ प्रोग्रामिंग लैंग्वेज का उपयोग अन्य उत्तरों में किया जाता है (जैसे कि जेली; जप; चारकोल) यह स्वयं का सोर्स कोड है (जो कि 05AB1E के मामले में CP-1252 है), जहाँ प्रत्येक 256x इसे जानता है सिंगल बाइट।
— केविन क्रूज़सेन
बिलकुल ठीक, काफी गोरा :)।
— rubenvb
@KevinCruijssen PHP को लगता है कि ये वर्ण CP-1252 के लिए अमान्य हैं, लेकिन बस PHP बग हो सकता है: 3v4l.org/UC1QE
— hanshenrik
7
@hanshenrik अच्छा सवाल। यह वास्तव में CP-1252 नहीं है, लेकिन वास्तव में 05AB1E एन्कोडिंग , जो कस्टम एन्कोडिंग है, जो इसका उपयोग करती है। हेक्स में इस कोड के बाइट्स हैं 08 2e 17, जिन्हें आप चला सकते हैं और --osabieझंडे के साथ सत्यापित कर सकते हैं : tio.run/…
— अदनान
21

आईबीएम पीसी डॉस, 8088 विधानसभा,  44  43

d1ee ad8b d6b4 0948 8af8 8ac8 d0e1 49b3 243a cf7d 024e
4e46 861c cd21 861c 52ba 2901 cd21 5ae2 eac3 0d0a 24

unassembled:

    SHR  SI, 1              ; point SI to DOS PSP at 80H (SI intialized at 100H)
    LODSW                   ; load arg length into AL, advance SI to 82H
    MOV  DX, SI             ; save start of string pointer
    MOV  AH, 9              ; DOS API display string function
    DEC  AX                 ; remove leading space from string length
    MOV  BH, AL             ; save string len in BH (AL gets mangled by INT 21H,9)
    MOV  CL, AL             ; set up loop counter in CL
    SHL  CL, 1              ; number of lines = 2 * string length - 1
    DEC  CX
    MOV  BL, '$'            ; end of string marker
LINE_LOOP:
    CMP  CL, BH             ; if CL >= string length, ascend
    JGE  ASCEND
    DEC  SI                 ; descend by backing up two places (always increments)
    DEC  SI                 ; (this is fewer bytes than 'SUB SI, 2' or two branches)
ASCEND:
    INC  SI                 ; increment current string position
    XCHG BL, [SI]           ; swap current string byte with end of string delimiter
    INT  21H                ; write substring to console
    XCHG BL, [SI]           ; restore string byte
    PUSH DX                 ; save output string pointer
    MOV  DX, OFFSET CRLF    ; load CRLF string
    INT  21H                ; write to console
    POP  DX                 ; restore output string pointer
    LOOP LINE_LOOP          ; move to next line
    RET
CRLF DB 0DH,0AH,'$'

व्याख्या

2 * input length - 1प्रत्येक पंक्ति के लिए लूप । डॉस एपीआई का स्ट्रिंग डिस्प्ले फंक्शन ( INT 21H,9) $स्क्रीन पर एक -स्ट्रिंग लिखा जाता है , इसलिए लूप के माध्यम से हर बार अंतिम प्रदर्शित होने के बाद कैरेक्टर को एंड-ऑफ-स्ट्रिंग टर्मिनेटर के साथ स्वैप किया जाता है।

लूप काउंटर की तुलना स्ट्रिंग की लंबाई के साथ की जाती है, और यदि यह अधिक होता है (मतलब आउटपुट का आरोही भाग) स्ट्रिंग / स्वैप स्थिति में वृद्धि होती है, अन्यथा इसे घटाया जाता है (वास्तव में यह -1-1+1एक if / अन्यथा शाखाओं की संरचना की तुलना में कम बाइट्स है)।

स्टैंडअलोन निष्पादन योग्य प्रोग्राम, कमांड लाइन से इनपुट स्ट्रिंग लेता है।

उत्पादन

यहाँ छवि विवरण दर्ज करें

YT2.COM डाउनलोड करें (43 बाइट्स)

— 640KB
स्रोत
1
COM फ़ाइल लोड करने पर अधिकांश DOS फ्लेवर्स में SI = 100 h होता है। यह आपको पहले निर्देश की जगह एक बाइट बचा सकता है SHR SI, 1।
— गैस्ट्रोपनर
@ बहुत बड़ा चतुर! मूल डीओएस 1.0 पर वैसे भी नहीं चलेगा क्योंकि यह सीएच 0 पर गिना जाता है (आरंभ करने के लिए +2 बाइट का खर्च आएगा, जो कि केवल डॉस 1 के लिए इसके लायक नहीं है)। नए संस्करण के साथ अपडेट किया गया!
— 640KB
क्या आपको टर्मिनल खोलने के लिए हर बार तारीख दर्ज करनी होगी?
— user14492
1
@ user14492 हा, नहीं! मैं बस DOS स्क्रीनशॉट से उस हिस्से को काट देना भूल गया!
— 640KB
19

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

f=lambda s,n=1:s[n:]and[s[:n]]+f(s,n+1)+[s[:n]]or[s]

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

पायथन 3.8 (प्री-रिलीज़) , 50 बाइट्स

f=lambda s,n=1:s>(x:=s[:n])and[x,*f(s,n+1),x]or[s]

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

— TFeld
स्रोत
2
क्या यह 3.8 की आगामी विशेषता पर निर्भर करता है? कौन सी सुविधा?
— एलेक्सिस
7
@alexis यह एक उपयोग कर रहा है काम अभिव्यक्ति : x:=s[:n]।
— अरनौल
1
आह, मैं इसे अब देख रहा हूँ :-) मैंने पहले इस फीचर के बारे में पढ़ा है, इसके लिए आगे देख रहा हूँ। फिर भी यह मेरे सी दिनों से याद आती है ...
— एलेक्सिस
1
हालांकि ये आउटपुट प्रिंट नहीं करते हैं। वे सिर्फ सरणी बनाते हैं, है ना?
— जेडन ट्रावनिक
@JadenTravnik पायथन स्वचालित रूप से अंतिम अभिव्यक्ति परिणाम को डुबो देता है यदि कंसोल के माध्यम से अंतःक्रियात्मक रूप से चल रहा है
— Xeverous
18

MATL , 8 बाइट्स

nZv"G@:)

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

कृपया इस पोस्ट को स्माइली :)कोड के लिए पसंद करें, इसे बनाने में मुझे बहुत समय लगा।

n  % Length of the input string
Zv % Symmetric range ([1 2 ... n ... 1])
"  % For each k in above range
G  % Push input
@: % Push [1 2 ... k]
)  % Index
— Sanchises
स्रोत
17

जे , 11 बाइट्स

बेनामी tacit उपसर्ग समारोह। एक अंतरिक्ष-पेड चरित्र मैट्रिक्स लौटाता है।

[:(}:,|.)]\

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

]\ उपसर्गों की सूची

[:(… ) उस सूची में निम्नलिखित फ़ंक्शन लागू करें

 |. रिवर्स सूची

 , के साथ शुरू हुआ

 }: curtailed (अंतिम आइटम के बिना) सूची

— एडम
स्रोत
18
[:(और }:,|बहुत उदास लग रहे हो ...
— एडम
लेकिन यह (}: जो एक फैंसी मूंछ के साथ एक खुशहाल व्यक्ति है
— डॉनफुसिली
13

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

{[\~](@_)[0...@_-1...0]}o*.comb

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

अनाम कोड ब्लॉक जो एक स्ट्रिंग लेता है और लाइनों की एक सूची देता है।

स्पष्टीकरण:

{                      }o*.comb   # Pass the list of characters into the codeblock
 [\~](@_)                 # Triangular reduce by concatenation
                          # e.g. The list [1,2,3,4] turns into [1,12,123,1234]
         [0...@_-1        # Return the elements from 0 to length of string minus 1
                  ...0]   # And back down to 0
— मजाक कर रहा है
स्रोत
5
यह अजीब बात है कि इन दिनों यहां तक ​​कि गिरे हुए पर्ल सबसे पठनीय प्रतियोगियों में से हैं।
— को बंद करना
7
@ceasedtoturncounterclockwis खैर, यह पर्ल 6 है। पर्ल 5 का जवाब अभी भी अपठनीय है
— जो किंग
12

जाप -आर , 4 बाइट्स

å+ ê

एक स्ट्रिंग पर संचयी कमी।

-1 बाइट @ शुगी को धन्यवाद

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

— Quintec
स्रोत
"-R" के बारे में संदेह जिसे स्ट्रिंग में शामिल किया जाना है (इसके बिना आउटपुट काम नहीं करता है)
— फ्लाइंग थंडर
3
@FlyingThunder कोई संदेह नहीं है :) यहाँ देखें
— क्विंटेक
@ क्विंट, मैंने अपने समाधान हेडर में झंडे को उस मेटा पोस्ट से लिंक करने का प्रयास किया है ताकि इस प्रकार की टिप्पणियों को हटाने की कोशिश की जा सके।
— झबरा
1
बहुत यकीन है कि सम्मेलन <भाषा> + -flagया <भाषा> है -flag। इसके अलावा: | मैं संचयी कम भूल गया था एक बात है, मैं कसम खाता हूँ मैं हर बार जब मैं इसे देखा पर छोड़ दिया
— ASCII- केवल
@ ASCII- केवल समान, मैंने केवल इसे याद किया क्योंकि मैं सोच रहा था कि मैं एपीएल में इसे कैसे हल करूंगा और कहा "मुझे आश्चर्य है कि अगर जाप में यह बिल्डिन है"। इसके अलावा, क्या मैंने <भाषा> का उपयोग नहीं किया -flag?
— Quintec
11

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

-2 बाइट्स शैगी को धन्यवाद

Êõ@¯XÃê

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

— ASCII-केवल
स्रोत
— झबरा
1
@ शगुन ओह रुको ... Ãएक बात है
— केवल
एक और 300 रिपीट अपने रास्ते पर जैसे ही यह प्रश्न एक इनाम के लिए पात्र है।
— झबरा
1
— क्विंटेक
1
@ क्विंट, कमिंग स्ट्रिंग्स पर भी काम कम करता है, इसलिए आपको शुरुआत में विभाजित होने की आवश्यकता नहीं है। मैं यह भी कहूंगा कि यह अपने आप को पोस्ट करने के लिए अलग वारंट है।
— शैगी
10

हास्केल, 52 50 44 बाइट्स

f x=unlines$init<>reverse$scanr(\_->init)x x

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

— जोसेफ सेबल
स्रोत
साइट पर आपका स्वागत है। initsएक आयात की आवश्यकता है ताकि आप को जोड़ने import Data.Listया कुछ इसी तरह की आवश्यकता के लिए जा रहे हैं ।
— श्रीओटीचिलिज्म ओ'जैसिक
@ SriotchilismO'Zaic यह निश्चित नहीं था कि गिनती करना आवश्यक है या नहीं। जोड़ा, धन्यवाद!
— जोसेफ सेबल
4
मुझे यह भी उल्लेख करना चाहिए कि हमारे पास हास्केल गोल्फिंग के लिए एक चैट रूम है । यदि आपके पास कोई विचार या प्रश्न है जो एक शानदार जगह है।
— श्रीओटीचिलिज्म ओ'जैसिक
1
मुझे विश्वास नहीं हो रहा है कि आप वास्तव में मैं क्या पोस्ट करने जा रहा था:import Data.List putStr.unlines.((++)<*>reverse.init).tail.inits
— Axman6
9

आर , 79 65 62 58 बाइट्स

write(substring(s<-scan(,""),1,c(1:(r=nchar(s)),r-1:r)),1)

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

-14 Giuseppe के बेहतर फ़ंक्शन ज्ञान द्वारा

-3 क्लीनर अनुक्रमण के साथ

करने के लिए निक कैनेडी और ग्यूसेप के कदम के -4 धन्यवाद scanऔरwrite

छोरों (और substr) से बचना अच्छा है।

— CriminallyVulgar
स्रोत
2
लूप पूरी तरह से अनावश्यक हैं, जैसा कि है sapply- substringवही करेंगे जो आप चाहते हैं (एक अतिरिक्त अनुगामी खाली लाइन के साथ), और 65 बाइट्स के लिए ! मैं निश्चित रूप से नहीं सोचा होता कि substringअगर मैंने आपका अच्छा उपयोग substrयहाँ नहीं देखा होता ।
— ग्यूसेप
1
हाहा, अच्छी पकड़! मुझे लगता है कि मैंने इस बिंदु पर कहीं और से आपके संपादन से समान कार्य के लिए वैकल्पिक कार्यों के बारे में अधिक सीखा है।
— आपराधिक रूप से
2
हाहा, आर में सूक्ष्म अंतर के साथ समानार्थी शब्द की एक मूर्खता है। हर बार जब मुझे लगता है कि मैं नौकरी के लिए सबसे अच्छा उपकरण जानता हूं, मुझे कुछ और मिल गया है जो एक अजीब धार के मामले में थोड़ा बेहतर है ...
— Giuseppe
3
कैसे के बारे में यह ऑनलाइन कोशिश करो! का उपयोग कर scanऔर write? केवल 59 बाइट्स!
— निक कैनेडी
1
@NickKennedy 58 बाइट्स यदि आप के ""साथ प्रतिस्थापित करते हैं 1।
— ग्यूसेप
7

जेली , 5 4 बाइट्स

-1 बाइट @JonathanAllan को धन्यवाद !

¹ƤŒḄ

इसे ऑनलाइन आज़माएं! मुझे लगता है कि यह मेरा दूसरा जेली जवाब है? मुझे नहीं पता कि क्या यह इष्टतम है। मैं इसके इष्टतम होने के बारे में अधिक आश्वस्त हूं। लाइनों की एक सरणी देता है।

व्याख्या

¹ƤŒḄ     input: "Hi!"
¹Ƥ       prefixes of the input: [["H"], ["H", "i"], ["H", "i", "!"]]
  ŒḄ     bounce, using each array: [["H"], ["H", "i"], ["H", "i", "!"], ["H", "i"], ["H"]]

@JonathanAllan द्वारा प्रस्तावित एक और दृष्टिकोण है ;\ŒḄ, जो कि संचयी रूप से कम ( \) संघनन ( ;) है, जो उपसर्गों को उत्पन्न करने का एक और तरीका है।

— कोनोर ओ ब्रायन
स्रोत
हम लाइनों की एक सरणी उपज के लिए अनुमति दी जाती है, तो आप कर सकते हैं टक्कर Yकोड से बाहर (मैं पाद लेख या तो बनाना चाहते हैं ÇYया ÇŒṘएक पूर्ण कार्यक्रम का अंतर्निहित स्मैश प्रिंट से बचने के लिए)। एक साइड-नोट पर यह ;\ŒḄसमान बाइट-काउंट के लिए भी समान रूप से लागू किया गया है (आप इस तर्क को भी पारित कर सकते हैं "blah"क्योंकि जेली इसे पात्रों की सूची के रूप में व्याख्या करता है - आपका वास्तव में पात्रों की सूची की सूची है, जैसा कि आप देखेंगे। अगर आप पाद बनाते हैं ÇŒṘ)
— जोनाथन एलन
@JonathanAllan धन्यवाद! बहुत दिलचस्प :)
— कॉनर ओ'ब्रायन
7

पायथन 3.8 (पूर्व-रिलीज़) , 48 बाइट्स

lambda s,r='':(l:=[r:=r+c for c in s])+l[-2::-1]

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

उपसर्गों की एक सूची को जमा करने और फिर परिणाम को बचाने के लिए इसके रिवर्स (पहले चार के बिना) के साथ असाइनमेंट अभिव्यक्तियों का उपयोग करता है ।:=

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

f=lambda s,l=[]:s and f(s[:-1],[s]+l)or l+l[-2::-1]

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

हमारे पास लगभग अच्छा 45-बाइट समाधान है, लेकिन इसमें दो बार मूल स्ट्रिंग है और मुझे इसे ठीक करने का एक छोटा तरीका नहीं है।

f=lambda s,l=[]:s and f(s[:-1],[s]+l+[s])or l

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

— XNOR
स्रोत
क्या आपको वांछित आउटपुट प्राप्त करने के लिए कुछ नईलाइन जोड़ने और प्रिंट करने की आवश्यकता नहीं होगी?
— जेडन ट्रावनिक
कुछ पसंद है print('\n'.join(f(s))) ?
— जेडन ट्रावनिक
@JadenTravnik समुदाय डिफ़ॉल्ट (जो इस चुनौती का अनुसरण करता है) कार्यक्रमों के अलावा कार्यों के लिए अनुमति देता है । और चुनौती लेखक ने टिप्पणियों में कहा कि वे डिफ़ॉल्ट रूप से शामिल होने के भीतर तार की एक सूची के साथ ठीक हैं , हालांकि मैं खुद को डिफ़ॉल्ट के रूप में पसंद नहीं करता हूं और इसे डाउनवोट कर दिया है। अजगर नियम सारांश भी देखें ।
— xnor
हुह। ठीक है, यह इंगित करने के लिए धन्यवाद। Im नया ¯_ (ツ) _ / (। यदि मामला है, यहाँ एक प्रतिस्पर्धा है 45-बाइट समाधान:x=[s[:i+1]for i in range(len(s))];x+x[-2::-1]
— Jaden Travnik
@JadenTravnik कोई समस्या नहीं, नियम दुर्भाग्य से जगह पर बिखरे हुए हैं। आपका उदाहरण हालांकि एक स्निपेट है जिसकी अनुमति नहीं है। इसे इनपुट और आउटपुट की तरह करना होगा s=input();x=[s[:i+1]for i in range(len(s))];print x+x[-2::-1]। यहां शीर्ष पर उदाहरण देखें ।
— xnor
6

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

Ｇ^Ｌθθ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण: Ｇएक भरा हुआ बहुभुज खींचता है, ^निर्दिष्ट करता है कि पक्ष दाईं और नीचे बाईं ओर हैं (बहुभुज तब स्वतः बंद हो जाता है), Ｌθमूल इनपुट की लंबाई के रूप में उन पक्षों की लंबाई θनिर्दिष्ट करता है और अंतिम भरण स्ट्रिंग निर्दिष्ट करता है।

— नील
स्रोत
6

सी # (विज़ुअल सी # इंटरएक्टिव कंपाइलर) , 123 109 94 84 74 बाइट्स

मान लें कि हम एक चार सरणी सरणी वापस कर सकते हैं (मेरा मानना ​​है कि हम कर सकते हैं, एक चार सरणी स्ट्रिंग के लिए एक वैध प्रतिनिधित्व है और एक स्ट्रिंग सरणी कई लाइनों के लिए एक वैध प्रतिनिधित्व है) 

a=>new int[a.Length*2-1].Select((b,i)=>a.SkipLast(Math.Abs(a.Length-i-1)))

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

— कोई व्यक्ति
स्रोत
5

ब्रेकीलॉग (v2), 6 बाइट्स

a₀ᶠ⊆.↔

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

फ़ंक्शन सबमिशन, लाइनों की एक सरणी लौटना। @ घातक परिणाम के उत्तर के आधार पर शिथिल ।

व्याख्या

a₀ᶠ⊆.↔
    .↔  Find a palindrome
   ⊆      that contains, in order,
  ᶠ       all
a₀        prefixes of {the input}

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

— ais523
स्रोत
5

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

-2 बाइट्स @AdmBorkBork के लिए धन्यवाद

param($a)0..($d=$a.Length-1)|%{$b+=,-join$a[0..$_]};$b+$b[--$d..0]

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

यह वास्तव में पहले निर्दिष्ट के रूप में काम नहीं किया, इस बारे में क्षमा करें! मैंने इसे संपादित किया है और कुछ बाइट्स को शेव करने में भी कामयाब रहा।

— गेब्रियल मिल्स
स्रोत
आप अंत में एक जोड़े को बचाने के --$dबजाय कर सकते हैं ($d-1)।
— AdmBorkBork
@AdmBorkBork धन्यवाद।
— गेब्रियल मिल्स
यह दुख की बात है कि एकल चरित्र इनपुट के लिए काम नहीं करता है।
— AdmBorkBork
5

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

($l=$args|% t*y|%{($s+=$_);++$i})+$l[$i..0]|gu

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

PowerShell , 42 बाइट्स (YouTube विशेष, गंदा)

यह ज्ञात है कि यूट्यूब पर एक टिप्पणी की अधिकतम लंबाई 10,000 वर्ण है। ठीक है, ऊपरी सीमा के रूप में इसका उपयोग करें।

($l=$args|% t*y|%{($s+=$_)})+$l[1e4..0]|gu

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

— Mazzy
स्रोत
4

एपीएल (Dyalog यूनिकोड) , 9 बाइट्स SBCS

बेनामी tacit उपसर्ग समारोह। तार की सूची लौटाता है।

(⊢,1↓⌽),\

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

,\ उपसर्गों की सूची (प्रकाशित, संचयी संघटन)

(… ) उस सूची में निम्नलिखित फ़ंक्शन लागू करें:

 ⌽ उलट सूची

 1↓ पहला आइटम गिराओ

 , आगे जोड़ते

 ⊢ अनमोल सूची

— एडम
स्रोत
4

जावास्क्रिप्ट (Node.js) , 90 बाइट्स

यह शायद बहुत अधिक golfed जा सकता है, Arnauld पहले से ही एक तरह से कम से एक है, लेकिन मैं कम से कम मज़ा आया!

s=>{a=[];for(c=s.length-1;c--;)a[c]=s.slice(0,c+1);return[...a,s,...a.reverse()].join`\n`}

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

— टी। डिर्क
स्रोत
4

SNOBOL4 (CSNOBOL4) , 118 बाइट्स

	N =INPUT
	L =1
1	X =LT(X,SIZE(N)) X + 1	:F(D)
O	N ARB . OUTPUT POS(X)	:($L)
D	X =GT(X) X - 1	:F(END)
	L ='D'	:(O)
END

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

SNOBOL के इस कार्यान्वयन में एक बग प्रतीत होता है; लेबल के Dसाथ लेबल को बदलने का प्रयास 2एक त्रुटि का कारण बनता है, हालांकि वेनिला SNOBOL के लिए मैनुअल इंगित करता है कि (जोर जोड़ा)

यदि कोई लेबल मौजूद है, तो उसे पंक्ति के पहले वर्ण से शुरू करना चाहिए। लेबल विवरण के लिए एक नाम प्रदान करते हैं, और किसी भी बयान के GOTO क्षेत्र से नियंत्रण के हस्तांतरण के लिए लक्ष्य के रूप में कार्य करते हैं। लेबल को अक्षर या अंक के साथ शुरू करना चाहिए, वैकल्पिक रूप से वर्णों की एक मनमानी स्ट्रिंग द्वारा।लेबल फ़ील्ड को वर्ण रिक्त, टैब या अर्धविराम द्वारा समाप्त किया जाता है। यदि किसी पंक्ति का पहला वर्ण रिक्त या टैब है, तो लेबल फ़ील्ड अनुपस्थित है।

मेरा तर्क है कि CSNOBOL दुभाषिया केवल एक ही लेबल का समर्थन करता है जो पूर्णांक से शुरू होता है।

— ग्यूसेप
स्रोत
4

एपीएल + विन, 31 बाइट्स

स्ट्रिंग के इनपुट के लिए संकेत:

 ⊃((⍳n),1↓⌽⍳n)↑¨(¯1+2×n←⍴s)⍴⊂s←⎕

स्पष्टीकरण:

(¯1+2×n←⍴s)⍴⊂s create a nested vector of the string of length =1+2x length of string

((⍳n),1↓⌽⍳n)↑¨ progressively select elements from each element of the nested vector 
              following the pattern 1  2 ...to n to n-1 ... 1

⊃ convert nested vector into a 2d array.
— ग्राहम
स्रोत
4

एफ # (.NET कोर) , 67 61 बाइट्स

let l=s.Length
[1..l*2-1]|>Seq.map(fun i->s.[..l-abs(i-l)-1])

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

इनपुट एक है stringऔर आउटपुट एक हैseq<string>

एक और समाधान let f(s:string)=for i=1 to s.Length*2-1 do printfn"%s"s.[..s.Length-abs(i-s.Length)-1]80ish बाइट्स के लिए हो सकता है ... मुझे यकीन नहीं है कि यह देखने लायक है।

— aloisdg
स्रोत
4

sed , 31 35 बाइट्स

:x
h
s/.\n.*\|.$//
/^$/{x;q}
H
G
bx

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

व्याख्या

लूप के प्रत्येक पुनरावृत्ति की शुरुआत में, पैटर्न स्पेस वांछित आउटपुट का कुछ "सेंट्रल चंक" होता है, और प्रत्येक लूप ऊपर और नीचे के लिए एक छोटी प्रतिलिपि जोड़ता है।

:x                 
h                  Copy the current chunk to hold space
s/.\n.*\|.$//      Remove the last letter of the first line, and all other lines (if there are any)
/^$/{x;q}          If pattern space is empty we're done; output hold space
H                  Add the shortened line to the end of hold space
G                  and add the new hold space to pattern space.
bx
— सोफिया लेचनर
स्रोत
1
एक अच्छा है, लेकिन मध्य रेखा (पूर्ण मूल इनपुट) 3 बार आउटपुट लगती है। कम से कम जीएनयू के साथ sed। TIO पर भी। sedआप किस कार्यान्वयन का उपयोग करते हैं और आप इसे इनपुट कैसे पास करते हैं? (BTW, s/.\n.*\|.$//इसे ठीक करने के लिए प्रतिस्थापन बदल रहा है।)
— मैनटवर्क
2
आह, तुम सही हो। यह मेरे sedकार्यान्वयन के साथ कोई समस्या नहीं है (जीएनयू संस्करण 4.2.1 का उपयोग करके), मैंने अभी बग को नोटिस नहीं किया है। मैंने कुछ अन्य सुधारों के साथ खेला है और चार बाइट्स से कम में कुछ भी नहीं मिला है, इसलिए मैं आपके फिक्स को अपना रहा हूं, धन्यवाद।
— सोफिया लेचनर
4

पायथन 2 , 131 100 84 बाइट्स

कोड गोल्फ पर मेरा पहला जवाब!

-47 बाइट्स ओवरऑल थैंक्स टू @ SriotchilismO'Zaic

a,b=[],len(x)
for i in range(2*b-1):
 if i<b:a+=x[i]
 else:a=a[:-1]
 print''.join(a)

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

— Yoni Matz
स्रोत
1
PCG में आपका स्वागत है! दौरे और आचार संहिता को अवश्य पढ़ें । अच्छा समाधान!
— एकोजी
2
अजगर के लिए आप ;खरोज से बचने के लिए newlines के बजाय s का उपयोग कर सकते हैं । इसके अलावा printऔर के बीच रिक्त स्थान की कोई जरूरत नहीं है''
— श्रीओटीचिलिज्म ओ'जाइक
सुझावों के लिए धन्यवाद @ SriotchilismO'Zaic, वास्तव में मेरी बाइट की संख्या को कम करने में मदद की!
— योनी माटज़
2
और एक आखिरी बात, यदि आप aएक सूची के बजाय एक स्ट्रिंग बनाते हैं, तो आपको अब joinबिल्कुल भी ज़रूरत नहीं है और आप बस कर सकते हैं print a।
— श्रीओटीचिलिज्म ओ’जैविक
4
अमान्य, इसके लिए एक पूर्ण प्रोग्राम या फ़ंक्शन होना चाहिए, जबकि आप मानते हैं कि इनपुट में है x।
— केवल
4

जे , 12 बाइट्स

]\,[:}.@|.]\

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

अभी भी Adám की तुलना में 1 बाइट लंबी है

के (ओके) , 12 11 बाइट्स

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

{x,1_|x}@,\

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

— गैलेन इवानोव
स्रोत
2
मैं था outgolf master‽
— एडम
@ Adám मैं J मास्टर होने से बहुत दूर हूँ :) यहाँ कई J कोडर्स हैं जो मैं बेहतर हूँ।
— गैलेन इवानोव
1
-1 बाइट {x,1_|x}@,\
— ओके के
@ng धन्यवाद!
— गैलन इवानोव
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.