पूर्णांक की सूची को देखते हुए, बूलियन मास्क बनाएं, ताकि सूची से अलग-अलग मूल्यों को फ़िल्टर करने के लिए सच्चे सूचक का उपयोग किया जा सके। कौन सा इंडेक्स सही के रूप में चुना जाता है, इससे कोई फर्क नहीं पड़ता, जब तक कि उनमें से केवल एक को समान मूल्यों के अनुरूप सूचकांकों के प्रत्येक सेट के लिए चुना गया हो।

इनपुट आपकी भाषा के लिए उपयुक्त प्रारूप में गैर-नकारात्मक पूर्णांकों की गैर-रिक्त सूची होगी और आउटपुट ऊपर विनिर्देशन के बाद बूलियन मानों की एक सूची होगी। आपको आउटपुट सूची में सत्य और मिथ्या मूल्यों की अपनी परिभाषाओं का उपयोग करने की अनुमति है।

नीचे दिए गए मेरे उदाहरणों में, मैं 1सत्य होने और मिथ्या होने के लिए परिभाषित करता हूं 0।

[5, 4, 7, 1]  Input
[1, 1, 1, 1]  Output
              Select only the values with with true indicies in the sieve
[5  4  7  1]  Contains zero duplicate values

[5, 9, 7, 5, 6, 0, 5]
[0, 1, 1, 1, 1, 1, 0]
[   9, 7, 5, 6, 0   ]

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

जब एक होता है or, तो इसका मतलब है कि कई वैध आउटपुट हैं। अगर वहाँ के ...बाद एक अनुगामी दीर्घवृत्त है or, तो इसका मतलब है कि सभी संभावित आउटपुट सूचीबद्ध नहीं थे।

[0] = [1]

[55] = [1]

[32, 44] = [1, 1]

[0, 0] = [1, 0] or [0, 1]

[9001, 9001, 9001] = [1, 0 , 0] or [0, 1, 0] or [0, 0, 1]

[5, 4, 7, 1] = [1, 1, 1, 1]

[1, 2, 3, 4, 3, 5] = [1, 1, 1, 1, 0, 1] or
                     [1, 1, 0, 1, 1, 1]

[5, 9, 7, 5, 6, 0, 5] = [1, 1, 1, 0, 1, 1, 0] or
                        [0, 1, 1, 1, 1, 1, 0] or
                        [0, 1, 1, 0, 1, 1, 1]

[0, 8, 6, 6, 3, 8, 7, 2] = [1, 1, 1, 0, 1, 0, 1, 1] or
                           [1, 0, 0, 1, 1, 1, 1, 1] or
                           [1, 0, 1, 0, 1, 1, 1, 1] or
                           [1, 1, 0, 1, 1, 0, 1, 1]

[45, 47, 47, 45, 24, 24, 24, 8, 47, 41, 47, 88]
= [1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1] or ...

[154, 993, 420, 154, 154, 689, 172, 417, 790, 175, 790, 790, 154, 172, 175, 175, 420, 417, 154, 175, 172, 175, 172, 993, 689, 993, 993, 790]
= [1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] or ...

नियम

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

code-golf array-manipulation

— मील की दूरी पर
स्रोत

2

के लिए [0, 8, 6, 6, 3, 8, 7, 2], [1, 0, 0, 1, 1, 1, 1, 1]वैध आउटपुट की सूची में जोड़ा जाना चाहिए?

— एटलसोलॉजिस्ट

क्या सत्य और मिथ्या मूल्यों की आपकी अपनी परिभाषाएँ भाषा को संदर्भित करती हैं या हम स्वतंत्र रूप से चुन सकते हैं? क्या उन्हें लगातार रहना होगा?

— डेनिस

@atlasologist टाइपो को पकड़ने के लिए धन्यवाद

— मील

@ डेनिस आप अपने स्वयं के बूलियन मूल्यों को परिभाषित करने के लिए स्वतंत्र हैं, उन्हें आपके द्वारा चुनी गई भाषा के समान नहीं होना चाहिए, लेकिन आपको अपनी स्वयं की परिभाषाओं के अनुरूप होना होगा। मेरे उदाहरणों में सच्चे और झूठे के लिए 1 और 0 के बजाय, मैं नकारात्मक मूल्यों को गलत और गैर-नकारात्मक (शून्य या सकारात्मक) मूल्यों के रूप में सच कर सकता था।

— मील

ठीक है, स्पष्ट करने के लिए धन्यवाद। सुसंगत द्वारा, मेरा मतलब था कि अगर एक एकल सत्य मूल्य होना चाहिए या यदि कई हो सकते हैं।

— डेनिस

11

MATL, 7 6 4 बाइट्स

1 बाइट ने @Luis को धन्यवाद दिया
2 बाइट ने @ डेनिस को धन्यवाद दिया

&=Rs

हम 1सत्य और अन्य सभी मूल्यों को गलत बताते हैं

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

सभी परीक्षण मामले

व्याख्या

    % Implicitly grab input array
&=  % 2D array of equality comparisons
R   % Get the upper triangular portion
s   % Sum down the columns
    % Implicitly display the result

— Suever
स्रोत

1 बाइट कम:&=Rs1=

— लुइस मेंडो

@LuisMendo हा मैं सचमुच उस दृष्टिकोण के साथ खेल रहा था!

— स्वेवर

2

ओपी ने स्पष्ट किया है कि इस चुनौती में सच्चाई और झूठा क्या है। यदि आप 1 को सत्य और बाकी सब को मिथ्या के रूप में परिभाषित करते हैं , तो आप इसे छोड़ सकते हैं l=।

— डेनिस

महान उपयोग। इरादा एक फ़िल्टरिंग कदम जोड़ने से बचने का था और अब आप डेनिस के जेली समाधान से मेल खाते हैं।

— मील

9

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

ĠṪ€Ṭ

अंतिम घटनाओं के पक्षधर हैं। इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

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

ĠṪ€Ṭ  Main link. Argument: A (array)

Ġ     Group; paritition the indices of A according to their corresponding values.
 Ṫ€   Tail each; select the last index of each group.
   Ṭ  Untruth; generate a Boolean array with 1's at the specified indices.

— डेनिस
स्रोत

यह अंत में शून्य से काट नहीं होगा?

— लीक नन

2

अंत में एक शून्य नहीं हो सकता है, क्योंकि हम प्रत्येक अद्वितीय पूर्णांक की अंतिम घटना का चयन करते हैं ।

— डेनिस

यह चालाकी है ।

— लीक नन

8

पायथन 3, 47 35 39 36 बाइट्स

lambda n:[n.pop(0)in n for x in n*1]

सूची से पहला आइटम पॉप करता है, यह जाँचता है कि क्या यह सूची में कहीं और मौजूद है, और आवेषण True या Falseएक नई सूची में।

इस फ़ंक्शन के लिए, Falseएक अलग मूल्य इंगित करता है, और Trueअन्यथा (True=0 और False=1) है

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

मूल, 47 बाइट्स:

lambda n:[(1,0)[n.pop()in n]for x in[1]*len(n)]

कोशिश करो

— atlasologist
स्रोत

lambda n:[1-(n.pop()in n)for x in n*1]कुछ बाइट्स बचाता है।

— डेनिस

3

ओपी ने स्पष्ट किया है कि सत्य मूल्य वास्तव में सत्य नहीं है, इसलिए भी lambda n:[n.pop()in n for x in n*1]काम करता है।

— डेनिस

नए संस्करण ने मुझे तब तक खो दिया था जब तक मुझे एहसास नहीं हुआ कि यह सत्य और मिथ्या के लिए xnor जैसे नकारात्मक मूल्यों का उपयोग करता है।

— मील

आपको करने की आवश्यकता है .pop(0)या मुखौटा उलट आता है।

— xnor

यही नहीं xnor का मतलब था। अंतिम तत्व को पहले .pop()संसाधित करता है , इसलिए उलटे क्रम में होते हैं।

— डेनिस

7

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

.eqxQb

बूल ( Trueऔर False) की एक सूची आउटपुट करता है । इनपुट में प्रत्येक तत्व की जांच करता है, यदि इसका सूचकांक मूल्य की पहली घटना के सूचकांक के बराबर है। दूसरे शब्दों में, यह जाँच रहा है कि क्या प्रत्येक तत्व पहली घटना है।

पायथोनिक स्यूडोकोड में:

.e      enumerated_map(lambda b,k:    # maps with b as value and k as index
  q       equal(
   xQb      Q.index(b),
            k),                       # implicit lambda variable
          Q)                          # implicit argument to map

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

— busukxuan
स्रोत

6

जे , 2 बाइट्स

~:

यहीं से इस चुनौती का विचार उत्पन्न हुआ। बिल्टिन ~:को Nub-Sieveजे में बुलाया जाता है और एक बूलियन सूची बनाता है जो चुनौती में वर्णित ऑपरेशन करता है। यहाँ, 1प्रतिनिधित्व trueऔर 0प्रतिनिधित्व करता है false।

— मील की दूरी पर
स्रोत

6

05AB1E , 8 बाइट्स

कोड:

v¹ykN>Qˆ

स्पष्टीकरण:

y         # For each in the array
 ¹yk      # Get the index of that element in the array
    N>Q   # And see if it's equal to the index
       ˆ  # Add to the global array and implicitly output

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

— अदनान
स्रोत

4

एपीएल, 6 बाइट्स

⍳∘⍴∊⍳⍨

कोशिश करो

स्पष्टीकरण:

   ⍳⍨  For each character in the string, get the index of its first occurrence
⍳∘⍴     Make a list 1 .. length of input
  ∊    Check if each index is present

— Woofmao
स्रोत

4

सी #, 63 बाइट्स

int[]l(List<int> i)=>i.Select((m,n)=>i.IndexOf(m)-n).ToArray();

मैं इसे 1 या 0 लौटा भी सकता हूं और इसके लिए पैरामीटर बना सकता हूं और उसी प्रकार का एक रिटर्न भी लिख सकता हूं, जिससे मुझे यह एक लंबोदर अभिव्यक्ति मिल सके?

कुछ मार्गदर्शन की सराहना की जाएगी

एक ही प्रकार का कोड

    public static List<int>l(List<int>i){
        return i.Select((m,n)=>i.IndexOf(m)==n?1:0).ToList();
    }

— downrep_nation
स्रोत

यदि आप 0 को

— सत्य मानते हैं

एक महान विचार है

— डाउन

भी अभिव्यक्ति शारीरिक समारोह का उपयोग करें int [] l (सूची <int> i) => i.Select ((m, n) => i.IndexOf (m) -n) .ToArray ();

— रागी

हे भगवान, अब से मेरे जवाब में इतने सारे बाइट्स सहेजने वाला है। बहुत बहुत धन्यवाद

— downrep_nation

क्या आप .NetFiddle पर एक उदाहरण प्रदान कर सकते हैं?

— aloisdg

3

पायथन, 35 बाइट्स

f=lambda l:l and[l.pop(0)in l]+f(l)

Trueमिथ्या मूल्य के रूप में और सत्य मूल्य के Falseलिए उपयोग करता है । प्रत्येक तत्व के अंतिम रूप को चिह्नित करता है।

पहले तत्व का चयन करता है केवल अगर यह शेष तत्वों के बीच प्रकट नहीं होता है, तो शेष सूची में तब तक पुनरावृत्ति करता है जब तक कि यह गैर-खाली न हो। l.pop(0)पहला तत्व निकालता करते हुए भी इसे हटाने।

— XNOR
स्रोत

3

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

(\d+)((?!.* \1\b))?
$#2

इनपुट एक अंतरिक्ष-पृथक सूची है। (वास्तव में, अन्य प्रारूप [1, 2, 3]भी तब तक काम करेंगे जब तक कि पहले को छोड़कर प्रत्येक संख्या के सामने एक स्थान हो।)

इसे ऑनलाइन आज़माएं! (एक बार में कई लाइनफ़ीड-अलग-अलग परीक्षण मामलों पर काम करता है।)

हम बस प्रत्येक तत्व को चालू करते हैं 0यदि इनपुट में और बाद में इसकी एक और प्रतिलिपि होती है 1।

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

2

PowerShell v2 +, 40 बाइट्स

$a=@();$args[0]|%{(1,0)[$_-in$a];$a+=$_}

एक खाली सरणी बनाता है $a। फिर हम इनपुट सूची के माध्यम से $args[0]और पाइप को एक लूप में ले जाते हैं |%{...}। प्रत्येक पुनरावृत्ति हम 1या तो 0एक छद्म-त्रिगुट से चयन करते हैं कि वर्तमान तत्व अंदर है $aया नहीं। उन चयनों को पाइपलाइन पर छोड़ दिया जाता है। हम फिर सरणी में वर्तमान तत्व जोड़ते हैं $a। पाइपलाइन तत्वों को इकट्ठा किया जाता है, और एक सरणी के रूप में आउटपुट निहित है।

उदाहरण:

(एक न्यूलाइन सेपरेटर के साथ यहां आउटपुट, क्योंकि यह .ToString()एरे के लिए डिफ़ॉल्ट है )

PS C:\Tools\Scripts\golfing> .\distinct-sieves.ps1 1,2,3,4,1,3,5,7
1
1
1
1
0
0
1
1

— AdmBorkBork
स्रोत

1

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

f=a=>a.map((e,i)=>i-a.indexOf(e))

शून्य सत्य है और अन्य संख्याएं मिथ्या हैं।

— नील
स्रोत

1

गणितज्ञ, ५३ ३१ बाइट्स

मीलों तक मुझे एक विचार देने के लिए धन्यवाद जिसने 22 बाइट्स बचाए।

s[[;;x++]]~FreeQ~#&/@(x=0;s=#)&

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

MapIndexedपिछले उपनलरों का उपयोग कैसे करें ? MapIndexed[s[[;;#-1&@@#2]]~FreeQ~#&,s=#]&41 बाइट्स लेता है।

— मील

@ मीलों ओह, यह बहुत बेहतर है (और मैंने इसे थोड़ा और बेहतर बनाया है;))

— मार्टिन

MapIndexedइस मामले के लिए छोटा करने का एक अच्छा तरीका है ऊ और आपको इंडेक्स निकालने की जरूरत नहीं है और न ही घटाएँ

— मील की दूरी पर

1

पर्ल ५

push@o,map{$b=pop@a;(grep{/^$b$/}@a)?1:0}(1..~~@a);

— Kaundur
स्रोत

1. ..अदिश संदर्भ प्रदान करता है, इसलिए आपको इसकी आवश्यकता नहीं होनी चाहिए ~~। 2. grepसत्य / झूठ को लौटाता है, इसलिए आपको इसकी आवश्यकता नहीं है ?1:0। 3. grep/.../,@aसे छोटा है grep{/.../}@a। 4. आपको फाइनल की जरूरत नहीं होनी चाहिए ;। 5. आपको चारों ओर कोष्ठकों की आवश्यकता नहीं होनी चाहिए 1..@a। 6. आप यह नहीं दिखाते कि इनपुट कहाँ से आ रहा है या आउटपुट आने वाला है: देखिए meta.codegolf.stackexchange.com/q/2447

— msh210

1

जावा, 96 बाइट्स

void s(int[]a){for(int i=0,j,n=a.length,b=1;i<n;a[i++]=b,b=1)for(j=i+1;j<n;)b=a[i]==a[j++]?0:b;}

सरणी में जगह को संशोधित करता है। अंतिम घटना के पक्षधर हैं।

1सत्य मूल्य है , जबकि झूठी मूल्य है 0।

सभी टेस्टकेस को सत्यापित करें ।

Ungolfed:

void sieve(int[]a){
    int n = a.length;
    for(int i=0;i<n;i++){
        int b = 1;
        for(int j=i+1;j<n;j++){
            if(a[i] == a[j]){
                b = 0;
            }
        }
        a[i] = b;
    }
}

— लीक नन
स्रोत

1

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

;╗ñ`i@╜í=`M

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

स्पष्टीकरण:

;╗ñ`i@╜í=`M
;╗           save a copy of input in reg0
  ñ          enumerate
   `i@╜í=`M  for each (index, value) pair:
    i@         flatten, swap
      ╜í       first index in input of value
        =      compare equality

— मै जाऊं
स्रोत

1

Pyke, 4 बाइट्स

F@oq

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

     - o = 0 #(Implicit)
F    - for i in input:
 @   -   input.index(i)
   q -  ^==V
  o  -   o+=1

— नीला
स्रोत

1

सी ++, 242 बाइट्स

कुल मिलाकर एक ओवरकिल समाधान, क्योंकि यह किसी भी प्रकार के किसी भी मानक कंटेनर पर काम करता है :

#include<algorithm>
#include<list>
#include<set>
template<class T>auto f(T a){using V=typename T::value_type;std::set<V>s;std::list<bool>r;std::transform(a.begin(),a.end(),std::back_inserter(r),[&](V m){return s.insert(m).second;});return r;}

Ungolfed:

(और आगे सामान्यीकृत)

template<class T>
auto f(T a)
{
    using std::begin;
    using std::end;
    using V=typename T::value_type;
    std::set<V>s;
    std::list<bool>r;
    std::transform(begin(a),end(a),std::back_inserter(r),[&](V m){return s.insert(m).second;});
    return r;
}

परीक्षण सूट:

int test(const std::list<bool>& expected, const auto& x) { return f(x) != expected; }
#include<array>
#include<chrono>
#include<forward_list>
#include<initializer_list>
#include<string>
#include<vector>
using namespace std::literals::chrono_literals;
int main()
{
    return 0
        + test({},            std::vector<short>{})
        + test({1},           std::array<int,1>{})
        + test({1},           std::vector<char>{55})
        + test({true,true},   std::vector<unsigned>{32,44})
        + test({1,0},         std::list<std::string>{"zero", "zero"})
        + test({1,0,0},       std::vector<long>{9001,9001,9001})
        + test({1,1,1,1},     std::array<char,4>{5,4,7,1})
        + test({1,1,1,1,0,1}, std::initializer_list<std::string>{"one","two","three","four","three","five"})
        + test({1,0,1,0,0},   std::forward_list<std::chrono::seconds>{60s, 1min, 3600s, 60min, 1h});
}

— टोबी स्पाईट
स्रोत

1

TSQL 52 बाइट्स

DECLARE @ TABLE(i int identity, v int)
INSERT @ values(1),(2),(3),(4),(3),(5)

SELECT i/max(i)over(partition by v)FROM @ ORDER BY i

बेला

— t-clausen.dk
स्रोत

1

PHP, 66 62 39 बाइट्स

सभी परमाणु मूल्यों (बूलियन, पूर्णांक, फ्लोट, स्ट्रिंग) को स्वीकार करता है
झूठे (झूठे, 0, "") और संख्यात्मक तार ("1" के बराबर 1) का मूल्यांकन करने वाले मूल्यों को छोड़कर को
झंडे पहले घटना

नया संस्करण (प्रोग्राम, 37 + 2 बाइट्स)
^{जावा को हरा देता है और (अब फिर से) सी #। यहां तक कि अब लगभग पाइथन को पीट रहा है। खुश।}

<?foreach($a as$v)$u[$v]=print$u[$v]|0;

PHP के लिए +6> = 5.4, + 16-3 एक फ़ंक्शन के लिए
0(सच) और 1(झूठा)
डालने के !बाद सूची को हटा दिया गयाprint की विपरीत करने के लिए
उपयोग: सेट register_globals=On, short_open_tags=Onऔर error_reporting=0में php.iniके लिए php-cgi
तो कॉलphp-cgi -f <filename> a[]=<value1> a[]=<value2> ...;echo"" ;
PHP के लिए = = 5.4: (+6), सेट और के $aसाथ बदलें$_GET[a]short_open_tags=Onerror_reporting=0
(+19) के $aसाथ बदलें array_slice($argv,1), <?(-2) निकालें
और कॉल करेंphp -d error_reporting=0 -r '<code>' <value1> <value2> ...;echo""

पुराना संस्करण (फ़ंक्शन, 62 बाइट्स)

function f($a){foreach($a as$v)$u[$v]=1|$m[]=$u[$v];return$m;}

falseसत्य के लिए और trueअसत्य के लिए सरणी देता है ; (खाली स्ट्रिंग के रूप में या 1) के बाद
सम्मिलित करें!$m[]= की विपरीत करने के लिए
55 बाइट्स के साथ एक योग्य फ़ंक्शन के लिए एक और तरीका भी है।

परीक्षण (पुराने संस्करण पर)

function out($a){if(!is_array($a))return$a;$r=[];foreach($a as$v)$r[]=out($v);return'['.join(',',$r).']';}
function test($x,$e,$y){static $h='<table border=1><tr><th>input</th><th>output</th><th>expected</th><th>ok?</th></tr>';echo"$h<tr><td>",out($x),'</td><td>',out($y),'</td><td>',out($e),'</td><td>',(strcmp(out($y),out($e))?'N':'Y'),"</td></tr>";$h='';}
$samples=[
    [0],[1],    [55],[1],    [32,44],[1,1],    [9001,9001,9001],[1,false,false],
    [5,4,7,1],[1,1,1,1],    [1,2,3,4,3,5],[1,1,1,1,false,1],
    [5,9,7,5,6,0,5],[1,1,1,false,1,1,false],    [0,8,6,6,3,8,7,2],[1,1,1,false,1,false,1,1],
    [45,47,47,45,24,24,24,8,47,41,47,88],[1,1,'','',1,'','',1,'',1,'',1],
    [154,993,420,154,154,689,172,417,790,175,790,790,154,172,175,
        175,420,417,154,175,172,175,172,993,689, 993,993,790],
        array_merge([1,1,1,false,false,1,1,1,1,1],array_fill(0,18,false))
];
for($i=count($samples);$i--;--$i)for($j=count($samples[$i]);$j--;)$samples[$i][$j]=!$samples[$i][$j];
while($samples)
{
    $a=array_shift($samples);
    $em=array_shift($samples);
    test($a,$em,$ym=s($a));
    $eu=[];foreach($em as$i=>$f)if($f)$eu[]=$a[$i];
    $yu=[];foreach($ym as$i=>$f)if($f)$yu[]=$a[$i];
#   sort($eu); sort($yu);
    test('unique values',$eu,$yu);
}
echo '</table>';

— टाइटस
स्रोत

1

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

f a=[elem x t|x:t<-tails a]

Falseसत्य के रूप में, Trueझूठे मूल्य के रूप में उपयोग करता है :

λ> let f a=[elem x t|x:t<-tails a] in f [5, 9, 7, 5, 6, 0, 5]
[True,False,False,True,False,False,False]

आपको import Data.Listउपयोग करना पड़ सकता है tailsलेकिन, tryhaskell.org कोड को वैसे ही चलाता है।

— विल नेस
स्रोत

बाहरी कोष्ठक की कोई आवश्यकता नहीं है। \a->[...]एक उचित कार्य है। संदेह में हैं, तो यह एक नाम देना: f a=[...]।

— nimi

@nimi इसे कोष्ठकों के बिना नहीं कह सकते। लेकिन यह नाम काम दे रहा है, बहुत बहुत धन्यवाद।

— विल नेस

मुझे यह छोड़ने का औचित्य पसंद नहीं import Data.Listहै। ए।एक बहुत ही फिसलन ढलान है क्योंकि आप अपने GHCi कॉन्फ़िगरेशन में किसी भी तरह के आयात (या यहां तक कि परिभाषाएँ!) डाल सकते हैं। ख। Haskell भाषा के आधिकारिक कार्यान्वयन के रूप में tryhaskell.org व्यवहार करता है, लेकिन यह वास्तव में एक नहीं है। (फिर, क्या होगा अगर मैं अपनी खुद की कोशिश-हास्केल-ऑनलाइन वातावरण बनाता हूं जो सभी आयात और परिभाषाओं के साथ आता है जो गोल्फ कभी भी चाह सकता है? क्या अभी भी वास्तव में "हास्केल" है?)

— लिन

मुझे एक बार यहां बताया गया था कि यदि कोई भी प्लेटफ़ॉर्म है जो कोड को चलाता है, तो वह कोड स्वीकार्य है। मुझे नहीं पता कि सटीक नियम क्या हैं, मैं जो कुछ भी बताता हूं, उसके अनुसार जाता हूं। मुझे लगता है कि हाँ, यदि आपकी साइट 24/7 उपलब्ध है, और मानक हास्केल चलाता है, तो क्यों नहीं। लेकिन आप पहले वाले के बारे में सही हैं, मैंने इसे हटा दिया। धन्यवाद।

— नेस

1

पर्ल 5 + पर्लिगटा , 343 बाइट्स

315 बाइट्स, प्लस 28 के लिए -MLingua::Romana::Perligata

के रूप में उपयोग करें perl -MLingua::Romana::Perligata foo.pl; इनपुट (स्टडिन से) और आउटपुट (स्टडआउट से) दशमलव पूर्णांक के अंडरस्कोर-अलग किए गए तार हैं। स्ट्राबेरी 5.20.2 पर पर्लिगाटा के संस्करण 0.6 के साथ परीक्षण किया गया; मुझे नहीं पता कि यह पर्लिगाटा संस्करण 0.50 के साथ काम करता है या नहीं।

huic vestibulo perlegementum da.qis _ scindementa da.dum qis fac sic
ao qis decumulamentum da.ao aum tum nullum addementum da.meo io.meo ro.per ium in qis fac sic
si ium tum aum aequalitas fac sic ro I da cis cis
ro nullum tum non rum addementum da.capita bis rum cis
per in bis fac sic hoc tum _ egresso scribe cis

स्पष्ट रूप से यह एक घंटी के रूप में स्पष्ट है। यदि ऐसा नहीं है, तो -MLingua::Romana::Perligata=converteइसके बजाय इसे चलाएं -MLingua::Romana::Perligata, औरperl इच्छा के अनुसार, स्क्रिप्ट चलाने के बजाय, नियमित पर्ल में अनुवाद का उत्पादन करें:

 $_ = Lingua::Romana::Perligata::getline (*STDIN );
 @q = split ( '_');
while (@q) { $a = pop (@q );
 $a =  ($a + 0);
my $i ;
my $r ;
for $i (@q) {if ( ($i eq $a)) { $r = 1}
}
;
 $r =  (0 +  ! ($r));
unshift (@b, $r)}
;
for $_ (@b) {print (STDOUT $_, '_')}

एक टोकन-टू-टोकन विश्लेषण के लिए, का उपयोग करें -MLingua::Romana::Perligata=discribe ।

गोल्फ नोट्स:

अनजाने में (लेकिन अस्वाभाविक), आपको एक स्थान की आवश्यकता नहीं है . ।
(और भी चौंकाने वाली) scinde एक दूसरे तर्क की जरूरत नहीं है, और उपयोग करता है hoc।
मुझे इस्तेमाल करना था ao aum tum nullum addementum damorde काम नहीं कारण मुझे ।
इसी तरह, मैंने इस्तेमाल किया per ium in qis... ro I da क्योंकि मुझे vanneकाम नहीं मिल रहा था ।
के बजाय huic vestibulo perlegementum da , मैंने कोशिश की -pMLingua::Romana::Perligata, लेकिन इसे काम करने के लिए नहीं मिला।

सिर्फ किक्स के लिए (हालाँकि यह पूरा जवाब सिर्फ किक के लिए था):

इसे साफ करने के बाद Huic vestibulo perlegementum da. Qis lacunam scindementa da. Dum qis fac sic ao qis decumulamentum da. Ao aum tum nullum addementum da. Meo io. Meo ro. Per ium in qis fac sic si ium tum aum aequalitas fac sic ro I da cis cis. Ro nullum tum non rum addementum da. Capita bis rum cis. Per in bis fac sic hoc tum lacunam egresso scribe cis., Google अनुवाद देता है This court perlegementum grant. QIS gap scindementa grant. While QIS QIS decumulamentum do so ao da. Ao sum and no addementum grant. My io. My ro. Through ium in QIS do so if the sum ium equality do so ro 1 from cis. Ro was not any rum addementum grant. The heads of the bis side. Write, do so as soon as he at that time that in the gap by the Kish was taken.।

— msh210
स्रोत

विचलित कर देने वाली घटनाएँ

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

नियम

MATL, 7 6 4 बाइट्स

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

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

पायथन 3, 47 35 39 36 बाइट्स

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

जे , 2 बाइट्स

05AB1E , 8 बाइट्स

एपीएल, 6 बाइट्स

सी #, 63 बाइट्स

पायथन, 35 बाइट्स

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

PowerShell v2 +, 40 बाइट्स

उदाहरण:

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

गणितज्ञ, ५३ ३१ बाइट्स

पर्ल ५

जावा, 96 बाइट्स

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

Pyke, 4 बाइट्स

सी ++, 242 बाइट्स

Ungolfed:

परीक्षण सूट:

TSQL 52 बाइट्स

PHP, 66 62 39 बाइट्स

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

पर्ल 5 + पर्लिगटा , 343 बाइट्स