वर्णमाला के एक स्निपेट को स्ट्रिंग कम करें

25

एक गैर-रिक्त स्ट्रिंग को देखते हुए केवल निचले और ऊपरी मामले के वर्णमाला वर्ण और रिक्त स्थान होते हैं ( [a-zA-Z ]), इसे वर्णमाला के एक स्निपेट में घटाएं, जो पहले चरित्र से शुरू होता है।

एक स्ट्रिंग को कम करने के लिए, पहले वर्णमाला वर्ण से शुरू करें, फिर प्रत्येक वर्ण को उसके बाद हटा दें जो वर्णमाला का अगला अक्षर नहीं है। जब तक आप स्ट्रिंग के अंत तक नहीं पहुंचते तब तक ऐसा करना जारी रखें।

उदाहरण के लिए codegolf:

इसके साथ शुरू करें c, हटाएं oक्योंकि यह वर्णमाला का अगला अक्षर नहीं है।
रखें dके रूप में यह है वर्णमाला के अगले पत्र, और रखने eके रूप में यह अगले पत्र भी है।
निकालें g, oऔर l, और रखें f।

आपका अंतिम स्निपेट तब होगा cdef

नियम

  • पूंजीकरण बनाए रखा जाना चाहिए, इसलिए इसमें CodEgolFपरिणाम होगाCdEF
  • अंतरिक्ष वर्णमाला का एक अक्षर नहीं है, और इस तरह इसे हमेशा हटा दिया जाना चाहिए, भले ही यह स्ट्रिंग की शुरुआत हो
  • कमी की प्रकृति के कारण, इनपुट का पहला वर्णमाला वर्ण हमेशा आउटपुट का पहला चरित्र होगा ।
  • zZवर्णमाला का अंतिम अक्षर है। इसके बाद कोई अक्षर नहीं हैं, वर्णमाला पाश नहीं है।

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

codegolf -> cdef
CodEgolf -> CdEf
 codeolfg -> cdefg
ProgrammingPuzzles -> P
Stack Exchange -> St
The quick red fox jumped over the lazy brown dog -> Tuvw
Zebra -> Z
Abcdegfhijkl -> Abcdef

स्कोरिंग

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

code-golf  string  alphabet 
— Skidsdev
स्रोत
दूसरे अंतिम परीक्षण मामले से, मैं देख रहा हूं कि अगर हम पहुंचते हैं तो zहम बस रुक जाते हैं, है ना?
— श्री एक्सकोडर
@ Mr.Xcoder सही, "नियम" के तहत अंतिम बिंदु देखें
— स्काइड्सडेव
2
कृपया शुरुआत में एक स्थान के साथ एक परीक्षण मामला जोड़ें। जैसे:<space>codegolf
— मिस्टर एक्सकोडर
क्या मैं आउटपुट अक्षरों की एक सरणी वापस कर सकता हूं?
— TheLethalCoder
1
@ Mr.Xcoder हाँ आप कर सकते हैं
— स्काइड्सडेव

जवाबों:

12

जावास्क्रिप्ट (ईएस 6), 66 79 68 67 बाइट्स

f=([c,...s],p)=>c?(p?~parseInt(c+p,36)%37:c<'!')?f(s,p):c+f(s,c):''

कैसे?

लगातार पत्रों का परीक्षण

क्योंकि दो वर्णों को उनके ASCII कोडों में परिवर्तित करना JS में एक लंबा ऑपरेशन होगा, हम इसके बजाय निम्न सूत्र का उपयोग करते हैं:

~parseInt(b + a, 36) % 37

बशर्ते कि ए और बी दोनों हैं [a-zA-Z ], उपरोक्त अभिव्यक्ति बराबर होती है 0अगर और केवल अगर ए और बी लगातार पत्र हैं (यानी बेस 36 में लगातार अंक), कोई फर्क नहीं पड़ता कि पात्रों का मामला।

उदाहरण के लिए:

~parseInt("Y" + "x", 36) = ~(36 * parseInt("Y", 36) + parseInt("x", 36))
                         = ~(36 * 34 + 33)
                         = -(36 * 34 + 33 + 1)
                         = -(37 * 34)

प्रारूपित और टिप्पणी की गई

f = ([c,                              // c = current character
         ...s],                       // s = array of remaining characters
                p) =>                 // p = previous matching letter
  c ? (                               // if there's still at least 1 character to process:
      p ?                             //   if p was already defined:
        ~parseInt(c + p, 36) % 37     //     test if p and c are NON-consecutive letters
      :                               //   else:
        c < '!'                       //     test if c is a space character
    ) ?                               //   if the above test passes:
      f(s, p)                         //     ignore c and keep the current value of p
    :                                 //   else:
      c + f(s, c)                     //     append c to the final result and update p to c
  :                                   // else:
    ''                                //   stop recursion

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

कोड स्निपेट दिखाएं

— Arnauld
स्रोत
7

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

lambda s:reduce(lambda x,y:x+y*((ord(y)-ord(x[~0]))%32==1),s.strip())

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

स्ट्रिंग की एक सरल कमी। हम अगले चरित्र को केवल और केवल अगर सम्‍मिलित करते हैं (ord(y)-ord(x[~0]))%32==1। बहुत बदसूरत जाँच - मुझे यकीन है कि इसमें सुधार किया जा सकता है, लेकिन मुझे यकीन नहीं है कि कैसे!

— Sisyphus
स्रोत
चतुर समाधान! बहुत बुरा यह अजगर 2-ही है: पी
— श्री Xcoder
आप इसे पायथन 3 के साथ संगत बना सकते हैं from functools import*।
— 12 अक्टूबर को पूरी तरह से अमानवीय
1
@ThomasWard पूरी तरह से अमानवीय सिर्फ दूसरों को बता रहा था कि इसे पायथन 3 को कैसे संगत बनाया जाए। Btw, import functools as fऔर यकीन है कि एक बार भी इस्तेमाल किया, की f.तुलना में बहुत लंबा है from functools import*। देखें इस सूत्र में अधिक जानकारी के लिए।
— श्री Xcoder
7

पायथन 3 , 75 85 84 91 81 77 75 बाइट्स

मुझे लगता है कि यह पायथन 3 में मिल सकता है । इसे पाइथन 2 में कुछ बाइट्स द्वारा छोटा किया जा सकता है, जैसा कि सेज़ीफ़स के सबमिशन में दिखाया गया है ।

  • संपादित करें: बग को ठीक करने के लिए +10
  • EDIT: -1 दूसरे बग को ठीक करके
  • EDIT: +7 दूसरे बग को ठीक करने के लिए
  • EDIT: -10 बाइट @Ruud की मदद से
  • EDIT: -4 बाइट्स के बाद से ओपी ने हमें एक नई लाइन द्वारा अलग किए गए पत्रों को आउटपुट करने की अनुमति दी
  • संपादित करें: -2 बाइट्स @Ruud , मूल बाइट काउंट पर वापस धन्यवाद !
s=input().strip();k=0
for i in s:
 if(ord(i)-ord(s[0]))%32==k:k+=1;print(i)

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

— श्री Xcoder
स्रोत
मेरे पास सुधार के लिए विचार हैं, जल्द ही मोबाइल पर गोल्फ करना होगा।
— मिस्टर एक्सकोडर
2
81 बाइट्स । अपरकेस और लोअरकेस अक्षर आसानी से मेल खाते हैं जब 32 से
— संशोधित होता है
@Rudud वे ही चीजें हैं जो मैं अपनी टिप्पणी, संपादन के बारे में बात कर रहा था।
— मिस्टर एक्सकोडर १17 ’१49
— आरफी
8
मैं उनके कारणों की व्याख्या करने के लिए downvoter की प्रतीक्षा कर रहा हूं।
— श्री Xcoder
4

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

;ṢxS⊇.ḷ~sẠ∧Sh~h

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

यह 10 बाइट्स होगा: ⊇.ḷ~sẠ&h~hयदि यह काफी निर्बाध नहीं थे "स्ट्रिंग्स रिक्त स्थान" बाधा के साथ शुरू हो सकते हैं।

व्याख्या

;ṢxS               S is the Input with all spaces removed
   S⊇.             The Output is an ordered subset of the Input
     .ḷ            The Output lowercased…
        ~sẠ          …is a substring of "abcdefghijklmnopqrstuvwxyz"
           ∧
            Sh     The first char of S…
              ~h   …is the first char of the Output

चूंकि यह काफी घोषणात्मक है, इसलिए यह वास्तव में धीमा है।

— Fatalize
स्रोत
खैर, कम से कम यह जेली को हरा देता है! और, प्लस साइड पर, मुझे नहीं लगता कि आप वास्तव में इसको पछाड़ सकते हैं ...
— एरिक आउट द ऑलफॉल्गर
3

MATL , 18 16 15 बाइट्स

गलती को इंगित करने के लिए Mr.Xcoder का धन्यवाद , अब सही किया गया

Xz1&)"t@hkd1=?@

आउटपुट में अक्षरों को नई सूचियों से अलग किया जाता है।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें (पाद लेख कोड स्पष्टता के लिए एक ही लाइन पर सभी आउटपुट पत्र प्रदर्शित करता है)।

व्याख्या

Xz       % Implicitly input a string. Remove spaces
1&)      % Push first character and then the remaining substring
"        % For each
  t      %   Duplicate previous character
  @      %   Push current character
  h      %   Concatenate both characters
  k      %   Convert to lowercase
  d      %   Consecutive difference. Gives a number
  1=     %   Is it 1?
  ?      %   If so
    @    %     Push current char
         %   End (implicit)
         % End (implicit)
         % Display stack (implicit)
— लुइस मेंडो
स्रोत
जब आप स्ट्रिंग की शुरुआत में होते हैं, तो आप रिक्त स्थान हटाना भूल गए: अंतरिक्ष वर्णमाला का एक अक्षर नहीं है, और इस तरह इसे हमेशा हटाया जाना चाहिए, भले ही यह स्ट्रिंग की शुरुआत हो ।
— मिस्टर एक्सकोडर
@ Mr.Xcoder धन्यवाद! सही किया
— लुइस मेंडो
3

जावा (ओपनजेडके 8) , 102 101 74 बाइट्स

s->{char c=0;for(char x:s)if(c<1&x>32|~-x%32==c%32)System.out.print(c=x);}

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

-27 बाइट्स थैंक्स टू @Olivier Grégoire

— Nevay
स्रोत
1
75 बाइट्स: s->{char c=0;for(char x:s)if(c<33&x>33|~-x%32==c%32)System.out.print(c=x);}( char[]इनपुट के रूप में)।
— ओलिवियर ग्रेगोइरे
2

सी # (मोनो) , 129 107 93 91 87 बाइट्स

s=>{var r=s.Trim()[0]+"";foreach(var c in s)if(r[r.Length-1]%32==~-c%32)r+=c;return r;}

@Mr की बदौलत 2 बाइट्स बचाए। Xcoder।
4 बाइट्स @jkelm की बदौलत सहेजे गए।

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

— TheLethalCoder
स्रोत
अग्रणी स्थानों पर विफल रहता है
— स्काइडदेव
@Mayube Woops ने तय नहीं किया।
— TheLethalCoder
2
91 बाइट्स । में सी जैसी भाषाओं और अजगर, (c-1)%32है~-c%32
— श्री Xcoder
1
87 बाइट्स आपको लूप के चेक के कारण छंटनी किए गए स्ट्रिंग को फिर से असाइन करने की आवश्यकता नहीं है
— jkelm
2

PHP, 64 + 1 बाइट्स

while($c=$argn[$i++])$c<A||$n&&($c&_)!=$n||(print$c)&$n=++$c&__;

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

इसके अलावा सामान्य चाल से: जब $cपहुँच Z, ++$cमें परिणाम AA,
और &__कि लंबाई अछूता रहता है; तो $nआगे कोई मेल नहीं होगा $c।

— टाइटस
स्रोत
2

हास्केल, 106 105 97 बाइट्स

import Data.Char
import Data.List
z=ord.toUpper
a%b|z a+1==z b=b|0<3=a
nub.scanl1(%).filter(>' ')

मैंने fromEnumआयात करने के बजाय + char अंकगणित का उपयोग करने की कोशिश की Data.Char, लेकिन यह लंबे समय तक समाप्त हो रहा है ...

H.PWiz के लिए धन्यवाद 8 बाइट्स सहेजे गए!

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

— क्रिस्टियन लुपस्कू
स्रोत
102 बाइट्स के साथfilter
— H.PWiz
या 100 बाइट्स के साथData.List
— H.PWiz
@ H.PWiz बढ़िया! धन्यवाद!
— क्रिश्चियन लुपस्क्यू
2

पायथ, 21 20 18 बाइट्स

ef&qhThQhxGrT0tyr6

इसे यहाँ आज़माएँ।

अधिक कुशल 20-बाइट संस्करण:

.U+b?t-CrZ1Creb1kZr6

इसे यहाँ आज़माएँ।

-1 श्री एक्सकोडर (अप्रत्यक्ष रूप से) को धन्यवाद ।

— आउटगोल्फर को एरिक करें
स्रोत
समतुल्य: .U+b?tlrreb1rZ1kZrz6(मुझे लगता है)। उस चाल ने हालांकि मेरी मदद की।
— मिस्टर एक्सकोडर
@ Mr.Xcoder अगर यह एक बराबर था, तो मैं एक बाइट बचा सकता था , .U+b?tlrreb1rZ1kZr6लेकिन दुर्भाग्य से r <str> 6इसका मतलब है A.strip(), गैर-प्रमुख या अनुगामी व्हाट्सएप को हटाना नहीं।
— एर्गेल आउटफर
अरे हाँ, मैंने नहीं देखा कि आपका समाधान सभी स्थानों पर निर्भर करता है (मेरा नहीं है)
— श्री एक्सकोडर
@ Mr.Xcoder उम्म, आपको सभी रिक्त स्थान को हटा देना चाहिए।
— आउटगॉल्फ
नहीं, मुझे नहीं चाहिए, क्योंकि अंतरिक्ष में ASCII का मूल्य है 32, जबकि सभी पत्रों में है > 64, और इस प्रकार कार्यक्षमता को प्रभावित नहीं करता है। मुझे लगता है कि यह आपके उत्तर पर भी लागू होता है।
— श्री एक्सकोडर
1

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

{S:i:g/\s|(\w){}<([<!before "{chr $0.ord+1}">.]+//}

झसे आज़माओ

विस्तारित:

{  # bare block lambda with implicit parameter $_

  S                          # substitute implicitly on $_, not in-place
  :ignorecase
  :global
  /

    |  \s                    # match any space

    |  (\w)                  # match a word character
       {}                    # make sure $/ is updated (which $0 uses)

       <(                    # ignore everything before this

       [

           <!before "{       # make sure this won't match after this point
             chr $0.ord + 1  # the next ASCII character
           }">

           .                 # any character

       ]+                    # match it at least once

  //                         # remove what matched
}

ध्यान दें कि <!before …>एक शून्य चौड़ाई का दावा है

— ब्रैड गिल्बर्ट b2gills
स्रोत
1

जाप , 18 17 16 बाइट्स

@ बस्ती के लिए 1 बाइट का धन्यवाद सहेजा गया

x
c
Çc %H¥V%H©V°

इसे ऑनलाइन टेस्ट करें!

सोच रहा था कि यह थोड़ा अच्छा होगा, लेकिन ... ऐसा ही जीवन है ...

व्याख्या

x    First line: set U to the result.
x    Trim all spaces off of the input. Only necessary to remove leading spaces.

c    Second line: set V to the result.
c    Take the charcode of the first character in U.

 Ç   c %H¥ V%H© V°
UoZ{Zc %H==V%H&&V++}   Final line: output the result.
UoZ{               }   Filter to only the chars in Z where
    Zc                   the charcode of Z
       %H                mod 32
         ==V%H           equals V mod 32.
              &&V++      If true, increment V for the next letter.
— ETHproductions
स्रोत
कम से कम मेरी 28 बाइट ट्रैस्टी से कम! : D ऐसा लगता है कि आप के rSसाथ बदल सकते हैं x।
— झबरा
1

सी # (.NET कोर) , 70 60 + 18 बाइट्स

-10 बाइट्स थैंथाल्कर के लिए धन्यवाद

a=>{var c=a.Trim()[0];return a.Where(x=>x%32==c%32&&++c>0);}

बाइट काउंट में ये भी शामिल हैं: 

using System.Linq;

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

1 बाइट अधिक समय तक (वर्तमान में) (अब और नहीं) की तुलना में TheLethalCoder की मस्ती के लिए पोस्टिंग है। LINQ के साथ अलग दृष्टिकोण।

यह सी # में दो सी-लाइक सुविधाओं का लाभ उठाता है - एक वर्ण charचर का एक पूर्णांक के समान व्यवहार होता है int, और बूलियन और ऑपरेटर &&दाएं ऑपरेशन को निष्पादित नहीं करता है यदि बाएं रिटर्न ए false। कोड स्पष्टीकरण:

a =>                                  // Take string as input
{
    var c = a.Trim()[0];              // Delete leading spaces and take first letter
    return a.Where(                   // Filter out characters from the string, leaving those that:
               x => x % 32 == c % 32  // it's the next character in alphabet case-insensitive (thanks to modulo 32 - credits to previous answers)
               && ++c > 0             // If it is, go to the subsequent character in alphabet (and this always has to return true)
           );
}
— ग्रेज़गोरज़ पुलावस्की
स्रोत
बाइट्स को बचाने के लिए .ToArray()रिटर्निंग के रूप में निकालें IEnumerable<char>।
— TheLethalCoder
@ TheLethalCoder सही, मैं सिर्फ चुनौती के तहत टिप्पणी देखा। धन्यवाद!
— ग्रेज़ोगोरज़ पुलावस्की
1

क्यू / केडीबी +, ४ 47 ४५ बाइट्स

समाधान:

{10h$({(x;x,y)1=mod[y-last x;32]}/)7h$trim x}

उदाहरण:

q){"c"$({(x;x,y)1=mod[y-last x;32]}/)7h$trim x}"CodEgolf"
"CdEf"
q){"c"$({(x;x,y)1=mod[y-last x;32]}/)7h$trim x}" codeolfg"
"cdefg"
q){"c"$({(x;x,y)1=mod[y-last x;32]}/)7h$trim x}"ProgrammingPuzzles"
"P"
q){"c"$({(x;x,y)1=mod[y-last x;32]}/)7h$trim x}"The quick red fox jumped over the lazy brown dog"
"Tuvw"

स्पष्टीकरण:

अभिसरण समारोह mod 32के साथ मौजूदा समाधान से चाल का लाभ । स्ट्रिंग पर ओवररेट करें, यदि परिणाम के अंतिम तत्व के बीच अंतर (उदाहरण के लिए "त्वरित लाल लोमड़ी ..." के साथ शुरू होता है ) और वर्तमान चरित्र 1 है ( 32 के साथ डी होने के बाद ), तो हम इसे जोड़ते हैं परिणाम (इसलिए हम क्यों ले रहे हैं ), फिर सब कुछ एक स्ट्रिंग में वापस डालें।Tmodlast x

{10h$({(x;x,y)1=mod[y-last x;32]}/)7h$trim x} / the solution
{                                           } / lambda function
                                      trim x  / trim whitespace (leading/trailing)
                                   7h$        / cast string to ASCII (a -> 97)
     ({                         }/)           / converge
                    y-last x                  / y is the next item in the list, x contains results so far
              1=mod[        ;32]              / is the result mod 32 equal to 1
       (x;x,y)                                / if false, return x, if true return x concatenated with y
 10h$                                         / cast back to characters
— streetster
स्रोत
0

रेटिना , 76 बाइट्स

 

^.
$&$&$&¶
{T`@@L@l`@l@l@`..¶
T`l`L`.¶
(.)(.)((¶).*?(\1|\2)|¶.*)
$5$5$5$4

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

रिक्त स्थान हटाएं।

^.
$&$&$&¶

पहले चरित्र को तीन गुना करें और एक विभाजक डालें।

{T`@@L@l`@l@l@`..¶
T`l`L`.¶

दूसरे और तीसरे पात्रों को निचले मामले में परिवर्तित करें और उन्हें बढ़ाएँ। ऊपरी मामले में बाद को परिवर्तित करें। ये अब खोज पात्र हैं।

(.)(.)((¶).*?(\1|\2)|¶.*)
$5$5$5$4

या तो खोज वर्णों से मिलान करने का प्रयास करें। यदि पाया जाता है, तो मैच को तीन गुना करें, जो अगली खोज के लिए लूप को पुनरारंभ करता है। अन्यथा, केवल खोज वर्ण और शेष इनपुट हटाएं।

— नील
स्रोत
0

8 वें , 114 बाइट्स

कोड

: z dup n:1+ 32 bor >r "" swap s:+ . ; 
: f s:trim 0 s:@ z ( nip dup 32 bor r@ n:= if rdrop z then ) s:each rdrop ;

व्याख्या

: z             \ n -- (r: x)
                \ print letter and save on r-stack OR-bitwised ASCII code of following letter
  dup           \ duplicate item on TOS
  n:1+          \ get ASCII code of the following letter
  32 bor        \ bitwise OR of ASCII code and 32 
  >r            \ save result on r-stack
  "" swap s:+ . \ print letter
;

: f        \ s -- 
  s:trim   \ remove trailing whitespace
  0 s:@    \ get 1st letter
  z        \ print 1st letter and save on r-stack OR-bitwised ASCII code of following letter
  ( nip    \ get rid of index
    dup    \ duplicate item on TOS
    32 bor \ bitwise OR of current ASCII code and 32 
    r@     \ get value stored on r-stack
    n:=    \ compare values to see if letter is printable or not
    if 
      rdrop \ clean r-stack
      z     \ print letter and save on r-stack OR-bitwised ASCII code of following letter
    then 
  ) 
  s:each    \ handle each character in string
  rdrop     \ clean r-stack
;

उदाहरण

ok> " The quick red fox jumped over the lazy brown dog" f
Tuvw
— अराजकता मनोर
स्रोत
0

अजगर, 15 बाइट्स

eo,}r0NG_xQhNty

परीक्षण सूट

अन्य सभी उत्तरों के विपरीत, यह आउटपुट को एक साथ नहीं रखता है, यह इनपुट के सभी बाद उत्पन्न करता है, और फिर उन्हें वांछित स्ट्रिंग को अंत में रखने का आदेश देता है, और इसे आउटपुट करता है।

— isaacg
स्रोत
मुझे लगता है कि आपको जांचना होगा कि आउटपुट का पहला अक्षर इनपुट का पहला अक्षर भी है या नहीं। और मुझे लगता है कि प्रारंभिक आदेश मायने रखता है।
— एरिक आउटगोल्फर
@EriktheOutgolfer क्षमा करें, क्या आप उत्तर गलत कह रहे हैं? मैं यह सुनिश्चित करता हूं कि अनुक्रम जिसका पहला वर्ण इनपुट में सबसे बाद में है जो वर्णमाला में हैं, वह अंत तक छांटा गया है। अंतरिक्ष से शुरू होने वाले परीक्षण मामले को देखें।
— isaacg
क्या आप कृपया स्पष्टीकरण जोड़ सकते हैं? मुझे गलतफहमी या कुछ और हो सकता है ...
— एरिक आउट द आउटफ्लर
0

जे, आंशिक समाधान

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

पहले एक डायडिक हेल्पर क्रिया जो आपको बताती है कि बाएं और दाएं आर्ग वर्णानुक्रम में आसन्न हैं:

g=.(= <:)&(a.&i.)  NB. could save one char with u:

अगला एक क्रिया जो पहले तत्व को हटाता है जो पहले तत्व से शुरू होने वाले एक अल्फाबेटिक लकीर का हिस्सा नहीं है:

f=.({~<^:3@>:@i.&0@(0,~2&(g/\))) ::]

ध्यान दें हम प्रतिकूल का उपयोग करते हैं :: कि यदि कोई गैर-लकीर तत्व नहीं मिला है (यानी, यदि संपूर्ण तर्क एक मान्य वर्णानुक्रम लकीर है) तो पूरे तर्क को अपरिवर्तित वापस करने के का ।

अंत में, fअभिसरण तक आवेदन करके समाधान दिया जाता है:

f^:_ 'codegolf'  NB. => 'cdef'

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

और यहाँ fआसान पढ़ने के लिए एक पार्स संस्करण है :

           ┌─ ~ ─── {                         
           │                              ┌─ <
           │                       ┌─ ^: ─┴─ 3
           │                 ┌─ @ ─┴─ >:      
       ┌───┤           ┌─ @ ─┴─ i.            
       │   │     ┌─ & ─┴─ 0                   
       │   │     │                            
       │   └─ @ ─┤     ┌─ 0                   
── :: ─┤         │     ├─ ~ ─── ,             
       │         └─────┤                      
       │               │     ┌─ 2             
       │               └─ & ─┴─ \ ─── / ──── g
       └─ ]

साइड सवाल : SO पर प्रदर्शित होने पर बॉक्स वर्ण पूरी तरह से संरेखित क्यों नहीं होते (वे मेरे कंसोल में काम करते हैं):

— जोनाह
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.