इस स्ट्रिंग को चित्रित करें!

Question

इस चुनौती के अनुसार उत्पन्न एक पैलिंड्रोम को देखते हुए , इसे चित्रित किया गया।

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

abcdedcba -> abcde
johncenanecnhoj -> johncena
ppapapp -> ppap
codegolflogedoc -> codegolf

जैसा कि यह depalindromizing के बारे में है, आपका कोड एक palindrome नहीं हो सकता है ।

याद रखें, यह कोड-गोल्फ है , इसलिए सबसे कम बाइट्स वाला कोड जीत जाता है।

Comments

-1 अपने कोड पर व्यर्थ प्रतिबंध के लिए एक palindrome नहीं है। यह IMO को चुनौती देने के लिए कुछ नहीं जोड़ता है, बहुत कम भाषाओं में यह मायने रखता है।

— 23

प्रतिबंध के लिए +1। यह तो paliondrome चुनौती को प्रतिबिंबित कर रहा है ... और यह esolangs को चुनौती जोड़ रहा है। मुझें यह पसंद है। क्या मैं इस धारणा में सही हूं कि इनपुट में हमेशा एक असमान लंबाई होगी?

— टाइटस

गैर-तालबद्ध प्रतिबंध संभवतः पिछली चुनौती पर आधारित एक मजाक है। क्या किसी ने वास्तव में उस पर आधारित था?

— लुइस मेंडू

यह एकल-बाइट समाधानों को रोकता है। अनावश्यक के लिए @diynevala +1।

— Adám

क्या होगा अगर स्ट्रिंग के साथ शुरू करने के लिए एक पैलिंड्रोम नहीं है?

— Xavon_Wrentaile

Answer 1

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

x->x[1:end/2+1]

इसे ऑनलाइन आज़माएं! (अतिरिक्त कोड मुद्रण उत्पादन के लिए है)

Comments

end/2शांत सुविधा है

— डाउगोएट

@Downgoat हाँ, डेनिस ने मुझे यह दिखाया।

— R

Answer 2

05AB1E , 3 बाइट्स

2ä¬

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

Answer 3

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

मैं अपने फोन पर परीक्षण करने में सक्षम नहीं हूं, लेकिन यह काम करना चाहिए:

lambda s:s[:-~len(s)/2]

Comments

यदि आप Android पर चल रहे हैं, तो आप Google Play स्टोर से QPython का उपयोग कर सकते हैं। यह सबसे अच्छा मैंने पाया है :)

— Yytsi

termux apt-get install python2

— मैट

@ मट वह ओवरकिल है यदि आप चाहते हैं कि सभी पायथन है।

— mbomb007

@ माट और साथ ही अगर आप apt-getअपने फोन पर पा सकते हैं , तो यह शायद एक सामान्य फोन नहीं है।

— कानूनन आलसी

@MathManiac termux Google Play से किसी भी गैर निहित एंड्रॉइड फोन पर स्थापित किया गया है। उस से अधिक सामान्य नहीं मिल सकता।

— मैट

Answer 4

फजी ऑक्टो गुआकामोल, 4 बाइट्स

2.^/

मैंने एक भाषा की खोज में कुछ समय बिताया जिसमें यह चुनौती कम है, और मुझे एहसास हुआ कि मैं गूंगा था और मेरी अपनी भाषा ने ऐसा किया।

Answer 5

05AB1E, 5 बाइट्स

Dg;î£

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

स्पष्टीकरण:

D      Duplicate
 g;î   Divide length by two and round up
    £  First b letters of a

Answer 6

चेडर, 22 18 बाइट्स

@.head($0.len/2+1)

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

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

Answer 7

पायथ - 4 बाइट्स

hc2Q

टेस्ट सूट ।

Answer 8

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

1 बाइट ने नील को धन्यवाद दिया:

s=>s.slice(0,-s.length/2)

f=
  s=>s.slice(0,-s.length/2)
;
console.log(f('abcdedcba'))
console.log(f('johncenanecnhoj'))
console.log(f('ppapapp'))
console.log(f('codegolflogedoc'))

---

पिछले समाधान
26 बाइट्स डाउनगेट के लिए धन्यवाद:

s=>s.slice(0,s.length/2+1)

32 बाइट्स:

s=>s.slice(0,(l=s.length/2)+l%2)

Comments

आप बस s=>s.slice(0,s.length/2+1)तब से छोटा कर सकते हैं जब लंबाई हमेशा विषम होगी

— डाउनगैट 22

@Downgoat आपको धन्यवाद कि मैंने पाया कि एक और बाइट के s=>s.slice(0,s.length/2+.5)लिए लंबाई भी काम करेगी।

— हेदी

-s.length/2विषम और लंबाई दोनों के लिए काम करता है।

— नील

Answer 9

WinDbg, 87 71 बाइट्स

db$t0 L1;.for(r$t1=@$t0;@$p;r$t1=@$t1+1){db$t1 L1};da$t0 L(@$t1-@$t0)/2

लंबाई डालने के बजाय, NULL न डालकर -16 बाइट्स da

इनपुट को psuedo-register में एक पते के माध्यम से पारित किया गया है $t0। उदाहरण के लिए:

eza 2000000 "abcdedcba"       * Write string "abcdedcba" into memory at 0x02000000
r $t0 = 33554432              * Set $t0 = 0x02000000
* Edit: Something got messed up in my WinDB session, of course r $t0 = 2000000 should work
* not that crazy 33554432.

यह मध्य चार (या दाएं-मध्य यदि स्ट्रिंग की लंबाई भी है) के स्थान को एक नल के साथ बदलकर काम करता है और फिर स्ट्रिंग को मूल शुरुआती मेमोरी पते से प्रिंट करता है।

db $t0 L1;                                   * Set $p = memory-at($t0)
.for (r $t1 = @$t0; @$p; r $t1 = @$t1 + 1)   * Set $t1 = $t0 and increment until $p == 0
{
    db $t1 L1                                * Set $p = memory-at($t1)
};
da $t0 L(@$t1-@$t0)/2                        * Print half the string

आउटपुट:

0:000> eza 2000000 "abcdeedcba"
0:000> r $t0 = 33554432
0:000> db$t0 L1;.for(r$t1=@$t0;@$p;r$t1=@$t1+1){db$t1 L1};da$t0 L(@$t1-@$t0)/2
02000000  61                                               a
02000000  61                                               a
02000001  62                                               b
02000002  63                                               c
02000003  64                                               d
02000004  65                                               e
02000005  65                                               e
02000006  64                                               d
02000007  63                                               c
02000008  62                                               b
02000009  61                                               a
0200000a  00                                               .
02000000  "abcde"

Answer 10

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

take=<<succ.(`div`2).length

का पॉइंटफ्री संस्करण

\x->take(div(length x)2+1)x

जो कि 27 बाइट्स भी है।

Answer 11

MATL , 7 6 बाइट्स

9LQ2/)

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

व्याख्या

9L       % Push array [1, 1j]
  Q      % Add 1: transforms into [2, 1+1j]
   2/    % Divide by 2: transforms into [1, 0.5+0.5j]
     )   % Apply as index into implicit input. The array [1, 0.5+0.5j] used as an index
         % is interpreted as [1:0.5+end*0.5]

Comments

वाह, कि

— मील

@ मीलों धन्यवाद! हाँ, यह आसान है। काल्पनिक इकाई के रूप में काम करता है end, और सरणी तत्वों के बीच

— कॉलोन

Answer 12

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

œs2Ḣ

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

व्याख्या

œs2      Split input into 2 chunks of similar lengths. For odd-length input,
         the first chunk is the longest
   Ḣ     Keep the first chunk

Answer 13

वी , 12 बाइट्स

दो पूरी तरह से अलग समाधान, दोनों 12 बाइट्स।

ò"Bx$xh|ò"bP

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

Ó./&ò
MjdGÍî

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

Answer 14

ब्रेकीलॉग , 4 बाइट्स

@2tr

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

व्याख्या

@2        Split in half
  t       Take the second half
   r      Reverse it

यदि इनपुट में विषम लंबाई है, तो दूसरी छमाही उत्पन्न होती @2है जो सबसे लंबी है, वह वह है जिसे हमें वापस करना चाहिए (इसे उलटने के बाद)।

Answer 15

दिल्लोग एपीएल , 9 बाइट्स

⊢↑⍨2÷⍨1+≢

⊢ बहस

↑⍨ पर काट दिया गया

2÷⍨ का आधा

1+ एक प्लस

≢ लम्बाई

TryAPL ऑनलाइन!

Answer 16

पर्ल, 15 बाइट्स

के लिए +2 शामिल है -lp

STDIN पर इनपुट स्ट्रिंग दें:

depal.pl <<< "HelleH"

depal.pl:

#!/usr/bin/perl -lp
s/../chop/reg

-lवास्तव में जरूरत नहीं है अगर आप इनपुट अंतिम न्यू लाइन के बिना विलोमपद, लेकिन मैं शामिल यह अन्य पर्ल समाधान है कि इसका इस्तेमाल करने के निष्पक्ष होने के लिए।

Answer 17

जावा 7, 57 बाइट्स

String c(String s){return s.substring(0,s.length()/2+1);}

Comments

आपको एक समापन याद आ रहा है }(इसलिए यह 57 बाइट्स है)।

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

@ केविनक्रूजसेन ने तय किया।

— नंबरनोट

Answer 18

टीआई-बेसिक, 14 बाइट्स

मानक समारोह। इंडेक्स 1 से इंडेक्स (लंबाई / 2 + 1/2) तक स्ट्रिंग लौटाता है।

sub(Ans,1,.5+.5length(Ans

Answer 19

गेममेकर भाषा, 59 बाइट्स

a=argument0 return string_copy(a,1,ceil(string_length(a)/2)

Answer 20

PHP, 40 बाइट्स

<?=substr($a=$argv[1],0,1+strlen($a)/2);

strlen($a)/2इंट को कास्ट किया जाता है, इनपुट में हमेशा विषम लंबाई होती है, +1गोल करने के लिए पर्याप्त होती है।

किसी भी लंबाई के लिए 42 बाइट्स :

<?=substr($a=$argv[1],0,(1+strlen($a))/2);

अज्ञात लंबाई के (1+strlen)/2लिए, अंत तक डाली जाती है, गोलाई में strlen/2।

Comments

चूंकि इनपुट को इस से आने के रूप में परिभाषित किया गया है ( codegolf.stackexchange.com/questions/98325/… ) चुनौती यह है कि लंबाई हमेशा विषम होगी, इसलिए आप बस अपने छोटे के साथ जा सकते हैं।

— user59178

Answer 21

डुबकी, 8 बाइट्स

H{C'0ÏEI

स्पष्टीकरण:

           # Implicit input
 H         # Push length of input
  {        # Add 1
   C       # Divide by 2
    '      # Convert to int
     0Ï    # Get string back
       E   # Push prefixes of string
        I  # Push prefixes[a]
           # Implicit print

इससे शायद बहुत सुधार हो सकता है।

Answer 22

पर्ल, 23 ​​+ 2 ( -plध्वज) = 28 25 बाइट्स

perl -ple '$_=substr$_,0,1+y///c/2'

Ungolfed:

while (<>) {             # -p flag
    chomp($_)            # -l flag
    $_ = substr($_, 0, 1 + length($_) / 2);
    print($_, "\n")      # -pl flag
}

@Xnew को थैंक्स।

Comments

आप की जगह 3 वर्ण बचा सकता है length()के साथy|||c

— ardnew

Answer 23

Befunge , 24 22 बाइट्स

~:0`!#v_\1+
0:-2,\_@#`

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

---

Befunge का कोई string या array टाइप नहीं है इसलिए सब कुछ एक समय में एक ही स्टैक पर किया जाता है। पहला लूप (शीर्ष पंक्ति पर) पढ़ने वाले वर्णों की संख्या को गिनता है (स्टैक में 2 से कम तत्वों के साथ स्वैप करना प्रारंभिक 0 का उत्पादन करता है)। दूसरी (मध्य रेखा पर) तेजी से दो बार गिनती करते हुए वर्णों को प्रिंट करती है। परिणामस्वरूप इनपुट का केवल अंतिम आधा भाग ही मुद्रित होता है, लेकिन LIFO इसलिए यह सही क्रम में है।

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

Comments

आपने मुझे आधे घंटे और 7 बाइट्स से हराया

— ब्रायन

@BrianGradin, अच्छा है। अब मैंने तुम्हें 9 बाइट्स से हराया है;)

— लिनुस

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

— ब्रायन ग्रैडिन

Answer 24

पर्ल, 14 + 3 ( -lFध्वज) = 19 17 बाइट्स

5.20.0+ के लिए:

perl -lF -E 'say@F[0..@F/2]'

5.10.0+ (19 बाइट्स) के लिए:

perl -nlaF -E 'say@F[0..@F/2]'

Ungolfed:

while (<>) {             # -n flag (implicitly sets by -F in 5.20.0+)
    chomp($_)            # -l flag
    @F = split('', $_);  # -aF flag (implicitly sets by -F in 5.20.0+)
    say(@F[0 .. (scalar(@F) / 2)]);
}

थैंक्स टू @ सिंबाबेक।

Comments

आप दो बाइट्स बचा सकते हैं, आपको सेट करने की आवश्यकता नहीं है -nऔर -aक्योंकि -Fऐसा निहित है।

— 12

@ सिंबाके हां। लेकिन केवल 5.20.0+ के लिए।

— डेनिस इबाव

Answer 25

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

,
[
  [>,]
  <[<]
  >.,>[>]
  <<
]

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

यह मुख्य लूप शुरू करने से पहले इनपुट का उपभोग करने के अधिक सरल दृष्टिकोण पर एक बाइट बचाता है:

,[>,]
<
[
  [<]
  >.,>[>]
  <,<
]

Answer 26

पायथ , 8 7 बाइट्स

<zh/lz2

@Steven H के धन्यवाद के साथ 1 सहेजा गया

कम से कम Pyth उत्तर नहीं (आधे से) लेकिन मैं भाषा सीखने का प्रयास कर रहा हूं और यह मेरा पहला पोस्ट है। टिप्पणियों और प्रतिक्रिया के लिए ज्यादा से ज्यादा पोस्ट करें। यह पहला पायथ प्रोग्राम भी है जो मुझे वास्तव में काम करने के लिए मिला है :)

अब मुझे सिर्फ वर्कआउट करने की ज़रूरत है कि @Maltysen से 4 बाइट का उत्तर कैसे काम करता है :-)

Comments

यदि आप अभी भी जानना चाहते हैं कि माल्टेसन का उत्तर कैसे काम करता है, तो यह cइनपुट Qको 2टुकड़ों में बंद कर देता है और पहले टुकड़े का उपयोग करता है h(जो, चॉप के कार्यान्वयन के लिए धन्यवाद, केंद्र पत्र को भी पकड़ लेगा)। अपने कोड के रूप में, आप बदल सकते +1साथ hसंख्या बढ़ाने के लिए, निर्मित।

— स्टीवन एच।

स्पष्टीकरण के लिए धन्यवाद और hसंकेत के लिए @Steven H. बहुत सारे बिल्ट-इन हैं, मुझे लगता है कि यह उन सभी को खोजने में कुछ समय लगता है :)

— ElPedro

कोई दिक्कत नहीं है! यदि आपको कभी किसी सहायता की आवश्यकता हो, तो मुझे उन्नीसवीं बाइट में पिंग करने का प्रयास करें।

— स्टीवन एच।

Answer 27

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

l½KßH

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

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

स्पष्टीकरण:

l½K@H
l½K    ceil(len(input)/2)
   ßH  first (len(input)//2 + 1) characters of input

Comments

6 बाइट्स:: ;l½K@Hडी

— शर्लक

Answer 28

सी, 31 30 बाइट्स

साइओस को धन्यवाद 1 बाइट की बचत।

f(char*c){c[-~strlen(c)/2]=0;}

उपयोग:

main(){
 char a[]="hellolleh";
 f(a);
 printf("%s\n",a);
}

Comments

@ केविनक्रूजसेन ने तय किया

— कार्ल

हाय, क्षमा करें मैंने अपनी टिप्पणी हटा दी। मैं यह कहने में सही था कि यह काम भी नहीं करेगा। लेकिन, चूंकि यह उस दूसरी चुनौती से उलट है, इसलिए किसी भी तरह के परीक्षण के मामले सामने नहीं आएंगे। इसके बारे में क्षमा करें, आप अपने परिवर्तन को पूर्ववत कर सकते हैं। मुझ से +1। :)

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

ठीक है, अब इसकी लंबाई समान है, सम + विषम के लिए काम करता है और गोल्फ दिखता है। मैं इसके साथ ठीक हूं।

— कार्ल नैप

यह यकीनन एक मेमोरी लीक :-)

— श्रीवत्सआर

मुझे लगता है कि आप char* c

— Cyoce

Answer 29

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

lambda x:x[:len(x)/2+1]

Comments

मुझे लगता है कि इसके लिए अजगर 2 की आवश्यकता है; आपको अपने उत्तर में यह संकेत देना चाहिए कि

— लुइस मेंडोज़

@LuisMendo ओह, धन्यवाद!

— R

Answer 30

MATLAB / ऑक्टेव, 20 19 18 16 बाइट्स

1 बाइट बंद से एक विचार उधार पूर्वी Irk के जवाब (जोड़ने 1के बजाय .5)
@StewieGriffin करने के लिए धन्यवाद बंद 2 बाइट्स (अनावश्यक कोष्ठकों)

@(x)x(1:end/2+1)

Ideone में यह कोशिश करो ।

Comments

@StewieGriffin धन्यवाद! मुझे नहीं पता कि मैं क्या सोच रहा था ...

— लुइस मेंडू

न तो मैं: पी यह ऐसा नहीं है कि यह एक "चाल" है, जिसके बारे में आप नहीं जानते ... मैंने उनमें से कुछ भी किया है :)

— स्टीवी ग्रिफिन