परिचय

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

यह संभवतः सबसे बुरी पहेली है, जो मैंने लिखी है, लेकिन आपको यह विचार मिलता है।

आवश्यकताएँ

शून्य या अधिक सकारात्मक पूर्णांकों की सूची को देखते हुए, पहले से लेकर अंतिम तक प्रत्येक संख्या पर निम्नलिखित नियम लागू करें:

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

समाधान के लिए:

समाधान एक कार्यक्रम या एक समारोह हो सकता है।
इनपुट एक स्ट्रिंग, एक सरणी, तर्क या कीबोर्ड इनपुट के रूप में पारित हो सकता है।
आउटपुट एक स्ट्रिंग, एक सरणी, या स्क्रीन पर मुद्रित हो सकता है।
आउटपुट सूची के सभी नंबर अलग हैं।

मान्यताओं

इनपुट सूची साफ है। इसमें केवल धनात्मक पूर्णांक होते हैं।
एक सकारात्मक पूर्णांक में 1 से 2 ³¹ -1 तक की सीमा होती है ।
आपके प्रोग्राम के चरों के लिए 256 एमबी से कम मेमोरी उपलब्ध है। (मूल रूप से, 2,147,483,648-तत्व सरणियों की अनुमति नहीं है।)

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

Input:  empty
Output: empty

Input:  5
Output: 5

Input:  1, 4, 2, 5, 3, 6
Output: 1, 4, 2, 5, 3, 6

Input:  3, 3, 3, 3, 3, 3
Output: 3, 1, 2, 4, 5, 6

Input:  6, 6, 4, 4, 2, 2
Output: 6, 1, 4, 3, 2, 5

Input:  2147483647, 2, 2147483647, 2
Output: 2147483647, 2, 1, 3

स्कोरिंग

बस एक साधारण कोड गोल्फ है। अगले सप्ताह इस समय तक सबसे कम बाइट की गिनती जीतती है।

code-golf set-theory

— हाथ-ए-खाना
स्रोत

4

टेस्ट केस जोड़ें: 6, 6, 1, 2, 3, 4, 5→6, 7, 1, 2, 3, 4, 5

— एडम

2

@ Adám नहीं 6, 6, ...देना चाहिए 6, 1, ...?

— xnor

5

@ मुझे लगता है कि आप इसके बारे में सही हैं, लेकिन शब्दांकन स्पष्ट हो सकता है, क्या "सेट" उन तत्वों का संदर्भ देता है, जो इनपुट सूची के सभी तत्वों, या सूची के तत्वों के रूप में यह अब खड़ा है?

— xnor

3

@xnor 6, 6, 4, 4, 2, 2परीक्षण का मामला Adám की व्याख्या की पुष्टि करता है: अपेक्षित आउटपुट है 6, 1, 4, 3, 2, 5, और नहीं 6, 1, 4, 2, 3, 5।

— घातक

2

क्या इस चुनौती के लिए 0 एक सकारात्मक पूर्णांक के रूप में गिना जाता है?

— ल्यूक

11

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

{|∧ℕ₁}ᵐ≠

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

व्याख्या

{    }ᵐ     Map on the Input:
              Input = Output…
 |            …or…
  ∧ℕ₁         …Output is in [1,+inf)
       ≠    All elements of the output must be different
            (Implicit labeling)

— Fatalize
स्रोत

8

जावा 8, 158 144 बाइट्स

a->{int m=0;String r="",c=",",b=r;for(int x:a)b+=x+c;for(int x:a)if(r.contains(x+c)){for(;(r+b).contains(++m+c););r+=m+c;}else r+=x+c;return r;}

.contains(m+c);m++)करने के लिए .contains(++m+c);)1 बाइट को बचाने के लिए, और एक साथ 13 से अधिक बाइट को बचाने के लिए जावा 8 करने के लिए परिवर्तित।

स्पष्टीकरण:

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

a->{                      // Method with integer-array parameter and String return-type
  int m=0;                //  Lowest integer
  String r="",            //  Result-String
         c=",",           //  Comma delimiter for result String
         b=r;for(int x:a)b+=x+c;
                          //  Input array as String
  for(int x:a)            //  Loop (2) over the integers in the array
    if(r.contains(x+c)){  //   If the result already contains this integer
      for(;(r+b).contains(++m+c););
                          //    Inner (3) as long as either the result-String or array-String contains the lowest integer
                          //     and raise the lowest integer before every iteration by 1
      r+=m+c;             //    Append the result with this lowest not-present integer
    }else                 //   Else:
      r+=x+c;             //    Append the result-String with the current integer
                          //  End of loop (2) (implicit / single-line body)
  return r;               //  Return the result-String
}                         // End of method

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

7

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

a=>a.map(g=(e,i)=>a.indexOf(e)-i?g(++n,-1):e,n=0)

— नील
स्रोत

7

रूबी , 63 बाइट्स

->a{r=*0..a.size;r.map{|i|[a[i]]-a[0,i]==[]?a[i]=(r-a)[1]:0};a}

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

व्याख्या

->a{                                    # Anonymous function with one argument
    r=*0..a.size;                       # Numbers from 0 to array size
    r.map{|i|                           # For all numbers in range:
        [a[i]]                          #  Get array with just a[i]
              -a[0,i]                   #  Remove elements from array that are
                                        #    also in a[0..i-1]
                    ==[]?               #  Check if result is an empty array
                        a[i]=           #  If true, set a[i] to:
                             (r-a)      #   Remove elements from number range
                                        #     that are also in input array
                                  [1]   #   Get second element (first non-zero)
                        :0};            #  If false, no-op
                            a}          # Return modified array

— मूल्य स्याही
स्रोत

6

05AB1E , 17 16 18 बाइट्स

vy¯yåi¹gL¯K¹K¬}ˆ}¯

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

व्याख्या

v                    # for each y in input
 y                   # push y
  ¯yåi               # if y exist in global list
      ¹gL            # push [1 ... len(input)]
         ¯K          # remove any number that is already in global list
           ¹K        # remove any number that is in the input
             ¬       # get the first (smallest)
              }      # end if
               ˆ     # add to global list
                }¯   # end loop, push and output global list

— Emigna
स्रोत

मुझे संभवतः नक्शे के बजाय कम का उपयोग करना चाहिए ... मुझे देखने दें कि क्या मदद करता है

— लीक नून

@ लीकेन: कम या नक्शा अक्सर जाने का तरीका है :)

— एमिग्ना

1

पर गलत परिणाम देता है 6, 6, 1, 2, 3, 4, 5।

— एडम

3

देता है [6, '1', '2', '3', '4', '5', '7']। देना चाहिए [6, '7', '1', '2', '3', '4', '5']।

— एडम

1

@ Adám: पकड़ने के लिए धन्यवाद! अब नियत :)

— Emigna

6

PHP, 121 बाइट्स

<?$n=array_diff(range(0,count($g=$_GET)),$g);sort($n);$r=[];foreach($g as$v)$r[]=in_array($v,$r)?$n[++$i]:$v;print_r($r);

ऑनलाइन संस्करण

विस्तारित

$n=array_diff(range(0,count($g=$_GET)),$g); # create array of ascending values which are not in input array plus zero
sort($n); # minimize keys
$r=[];  # empty result array
foreach($g as$v) # loop input array
  $r[]=in_array($v,$r)?$n[++$i]:$v; # if value is not in result array add value else take new unique value skip zero through ++$i
print_r($r); # output result array

— जार्ग हुल्सरमन
स्रोत

5

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

a=input();u=[];j=1
for x in a:
 u+=[[x,j][x in u]]
 while j in u+a:j+=1
print u

कीबोर्ड इनपुट लेता है, जैसे [3, 3, 3, 3, 3, 3] ।

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

संपादित: एक गलती के इनपुट से निपटने ठीक करने के लिए [6, 6, 4, 4, 2, 2]। गलती ठीक करने के साथ ही ठीक करने के लिए @Rod को धन्यवाद। गलती यह थी कि, एक डुप्लिकेट प्रविष्टि की स्थिति में, यह सूची में उस बिंदु पर अप्रयुक्त सबसे छोटी संख्या को आउटपुट करेगा, भले ही वह आउटपुट बाद में इनपुट में दिखाई दे। (यह गलत था, जैसा कि पोस्ट और टिप्पणियों में स्पष्ट किया गया है, लेकिन मैंने अभी भी इसे किसी तरह गड़बड़ कर दिया है।) वैसे भी, बस इनपुट सूची को जोड़ने के लिए फिक्स था।a उन मूल्यों के सेट तक जो उस मामले में आउटपुट नहीं हो सकते थे।

— mathmandan
स्रोत

नहीं करने के लिए काम करता है [6,6,4,4,2,2], तो आप कर सकते हैं (शायद) में जोड़कर तय +aकरने के लिए while j in u:->while j in u+a:

— रॉड

@ रोड यू आर राइट, माय मिस्टेक। (किसी तरह मैंने इस बारे में टिप्पणियों के बावजूद इसे गड़बड़ कर दिया - इसे मेरे ध्यान में लाने के लिए धन्यवाद - और मैंने परीक्षण मामलों के खिलाफ अपने समाधान को अच्छी तरह से परीक्षण नहीं किया। शर्मनाक।) ठीक है, मैंने आपका बहुत अच्छा समावेश किया है। इसे ठीक करें, और इसे परीक्षण मामलों के विरुद्ध सत्यापित करें। धन्यवाद!

— मैथमैडैन

5

हास्केल , 79 76 बाइट्स

संपादित करें:

-3 बाइट्स: @nimi ने देखा कि head एक पैटर्न मैच द्वारा प्रतिस्थापित किया जा सकता है।

([]#)एक सूची लेने और वापस करने का एक अनाम कार्य है। का उपयोग करें ([]#)[2147483647, 2, 2147483647, 2]।

(?)=notElem
s#(x:y)|z:_<-[x|x?s]++filter(?(s++y))[1..]=z:(z:s)#y
_#n=n
([]#)

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

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

? यह जाँचने के लिए एक संक्षिप्त ऑपरेटर है कि क्या कोई तत्व किसी सूची से अनुपस्थित है।
s#lपहले से ही उपयोग किए lगए पूर्णांकों की सूची को देखते हुए, पूर्णांकों की सूची को संभालता है s।
- xअगले पूर्णांक को देखना है, yशेष हैं।
- zअगले स्थान के लिए पूर्णांक चुना गया है। यह xअगर xका एक तत्व नहीं है s, और सकारात्मक पूर्णांक पहले न में sहै और न ही में yअन्यथा।
- (z:s)#yफिर zउपयोग किए गए पूर्णांक सूची में जोड़ा जाता है।
- n एक खाली सूची है, क्योंकि गैर-रिक्त सूची को पिछली पंक्ति में संभाला गया है।
मुख्य फ़ंक्शन ([]#)एक सूची लेता है, और #इसे दूसरे तर्क के रूप में कहता है, और पहले तर्क के लिए एक खाली सूची।

— अर्जन जोहान्सन
स्रोत

|z:_<-[x|...]...

— nimi

4

एपीएल (डायलॉग 16.0), 34 बाइट्स

(s↑v~⍨⍳⌈/v+s←+/b←(⍳≢v)≠⍳⍨v)@{b}v←⎕

— एडम
स्रोत

2

इसके लिए अवश्य ही एक बेहतर तरीका होना चाहिए। '

— एडम

3

अजगर , २१ 20 बाइट्स

.b?} NPY@-UhlQQ=hZNQ._
m?}edPd@-SlQQ~hZed._

परीक्षण सूट

जब मेरे पास समय होगा तो मैं एक स्पष्टीकरण जोड़ूंगा।

— लीक नन
स्रोत

3

सी # , 135 बाइट्स

golfed

(int[] i)=>{for(int x=1,v,m=0,l=i.Length,y;x<l;x++){v=i[x];for(y=0;y<l&&v==i[x]?y<x:y<l;y++)if(i[y]==v){v=++m;y=-1;}i[x]=v;}return i;};

Ungolfed

( int[] i ) => {
   for( int x = 1, v, m = 0, l = i.Length, y; x < l; x++ ) {
      v = i[ x ];

      for( y = 0; y < l && v == i[ x ] ? y < x : y < l ; y++ )
         if( i[ y ] == v ) {
            v = ++m;
            y = -1;
         }

      i[ x ] = v;
   }

   return i;
};

अनपढ़ पठनीय

// Takes an array of Int32 objects ( 32-byte signed integers )
( int[] i ) => {

   // Cycles through each element on the array
   //   x: Scan position, starts at the 2nd element
   //   v: Value being processed
   //   m: The next minimum value to replace
   //   l: Size of the array, to save some byte count
   for( int x = 1, v, m = 0, l = i.Length, y; x < l; x++ ) {

      // Hold the value
      v = i[ x ];

      // Re-scan the array for a duplicate value up the the current position ( 'x' ) IF
      //   ... the currently hold value hasn't been modified
      //   ... otherwise, re-scans the entire array to find a suitable value to replace
      for( y = 0; y < l && v == i[ x ] ? y < x : y < l ; y++ )

         // Check if 'v' shares the same value with other element
         if( i[ y ] == v ) {

            // Set 'v' to the minimum value possible
            v = ++m;

            // Reset the scan position to validate the new value
            y = -1;
         }

      // Set the 'v' to the array
      i[ x ] = v;
   }

   // Return the array
   return i;
};

पूर्ण कोड

using System;
using System.Collections.Generic;

namespace Namespace {
   class Program {
      static void Main( String[] args ) {
         Func<Int32[], Int32[]> f = ( int[] i ) => {
            for( int x = 1, v, m = 0, l = i.Length, y; x < l; x++ ) {
               v = i[ x ];

               for( y = 0; y < l && v == i[ x ] ? y < x : y < l ; y++ )
                  if( i[ y ] == v ) {
                     v = ++m;
                     y = -1;
                  }

               i[ x ] = v;
            }

            return i;
         };

         List<Int32[]>
            testCases = new List<Int32[]>() {
               new Int32[] { },
               new Int32[] { 5 },
               new Int32[] { 1, 4, 2, 5, 3, 6 },
               new Int32[] { 3, 3, 3, 3, 3, 3 },
               new Int32[] { 6, 6, 4, 4, 2, 2 },
               new Int32[] { 2147483647, 2, 2147483647, 2 },
            };

         foreach( Int32[] testCase in testCases ) {
            Console.WriteLine( $" Input: {String.Join( ",", testCase )}\nOutput: {string.Join( ",", f( testCase ) )}\n" );
         }

         Console.ReadLine();
      }
   }
}

विज्ञप्ति

v1.0 - 135 bytes- प्रारंभिक समाधान।

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

x=input()
for i,n in enumerate(x):x[i]=[n,list(set(range(1,len(x)+9))-set(x))[0]][n in x[:i]]
print x

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

— छड़ी
स्रोत

3

आर , 39 46 बाइट्स

इनपुट से एक वेक्टर बनाता है, फिर 1 से लाख तक की सीमा वाले डुप्लिकेट मानों को बदलता है जिसमें इनपुट मान हटा दिए जाते हैं। एक संख्यात्मक वेक्टर लौटाता है। कोई भी इनपुट खाली वेक्टर अंक (0) को वापस नहीं करेगा।

i[duplicated(i)]=(1:1e6)[-(i=scan())];i

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

यह प्रतिस्थापन वेक्टर की लंबाई के बारे में एक चेतावनी फेंक देगा

                           i=scan()     # set i as input
                 (1:1e6)                # 1 to a million (could go higher)
                 (1:1e6)[-(i=scan())]   # without input values
  duplicated(i)                         # duplicate values in i
i[duplicated(i)]=(1:1e6)[-(i=scan())]   # set duplicate i values to reduced range vector
                                     ;i # return result

— MickyT
स्रोत

3

सी, 169 बाइट्स 133 बाइट्स

इनपुट = सरणी ए, आउटपुट = संशोधित सरणी ए

i=1,j,k,l;void f(int*a,int n){for(;i<n;i++)for(j=i-1;j>=0;j--)if(a[i]==a[j]){l=1;for(k=0;k<n;)if(l==a[k])k=l++?0:0;else k++;a[i]=l;}}

स्वरूपित

int i, j, k, l;
void f(int* a, int n)
{
    for (i = 1; i<n; i++)
        for (j = i - 1; j >= 0; j--)
            if (a[i] == a[j])
            {
                l = 1;
                for (k = 0; k<n;)
                    if (l == a[k])
                        k = l++ ? 0 : 0;
                    else
                        k++;
                a[i] = l;
            }
}

इन लूप के लिए बहुत सारे बाइट बर्बाद हो गए। क्या कोई नया एल्गोरिथ्म (जो कम लूप का उपयोग करता है) का आविष्कार करके कोड को छोटा करने के बारे में सोचता है? मैं सोच रहा था लेकिन havent एक मिल गया।

— hucancode
स्रोत

2

सी # 7, 116 बाइट्स

int[]f(int[]c){int j=0;int h()=>c.Contains(++j)?h():j;return c.Select((e,i)=>Array.IndexOf(c,e)<i?h():e).ToArray();}

दांतेदार बना हुआ

int[] f(int[] c)
{
    int j = 0;
    int h() => c.Contains(++j) ? h() : j;
    return c
        .Select((e, i) => Array.IndexOf(c, e) < i ? h() : e)
        .ToArray();
}

व्याख्या की

किसी संख्या की पहली घटना को हमेशा की तरह छोड़ दिया जाता है
किसी संख्या की निरंतर घटनाओं [1, 2, 3, ...]को इनपुट में मौजूद मानों को छोड़ दिया जाता है।

ऑनलाइन संस्करण

— user1655772
स्रोत

2

क्लोजर, 72 बाइट्स

#(reduce(fn[r i](conj r(if((set r)i)(nth(remove(set r)(range))1)i)))[]%)

एक बुनियादी कमी। यदि iअब तक आउटपुट सूची में समाहित है, तो हम पूर्णांकों की अनंत सूची से दूसरा तत्व (1-जब 0-अनुक्रमित) लेंगे (range)जिसमें से हमने उन संख्याओं को हटा दिया है जो पहले से ही उपयोग की जा चुकी हैं। रेंज शून्य से शुरू होती है इसलिए हम पहला तत्व नहीं ले सकते हैं लेकिन दूसरा।

— NikoNyrh
स्रोत

1

आर, 74 बाइट्स

स्टड से सूची पढ़ता है; खाली इनपुट के लिए NULL लौटाता है।

o=c();for(i in n<-scan())o=c(o,`if`(i%in%o,setdiff(1:length(n),o)[1],i));o

स्पष्टीकरण:

o=c()                                #initialize empty list of outputs
for(i in n<-scan())                  # loop through the list after reading it from stdin
    o=c(o,                           # set the output to be the concatenation of o and
      `if`(i%in%o,                   # if we've seen the element before
           setdiff(1:length(n),o)[1] # the first element not in 1,2,...
           ,i))                      # otherwise the element
o                                    # print the output

1:length(n) इसका उपयोग तब किया जा सकता है जब हमें उस सीमा के बाहर से प्रतिस्थापन की आवश्यकता न हो।

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

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

0

एक्सोम, 169 बाइट्स

f a==(r:List INT:=[];for i in 1..#a repeat(~member?(a.i,r)=>(r:=concat(r,a.i));for j in 1..repeat if~member?(j,r)and(~member?(j,a)or j=a.i)then(r:=concat(r,j);break));r)

ungolf और परिणाम

ff(a)==
  r:List INT:=[]
  for i in 1..#a repeat
      ~member?(a.i,r)=>(r:=concat(r,a.i))
      for j in 1.. repeat
            if~member?(j,r)and(~member?(j,a) or j=a.i)then(r:=concat(r,j);break)
  r

(3) -> f([])
   (3)  []
                                                       Type: List Integer
(4) -> f([5])
   (4)  [5]
                                                       Type: List Integer
(5) -> f([1,4,2,5,3,6])
   (5)  [1,4,2,5,3,6]
                                                       Type: List Integer
(6) -> f([3,3,3,3,3,3])
   (6)  [3,1,2,4,5,6]
                                                       Type: List Integer
(7) -> f([6, 6, 4, 4, 2, 2])
   (7)  [6,1,4,3,2,5]
                                                       Type: List Integer
(8) -> f([2147483647, 2, 2147483647, 2])
   (8)  [2147483647,2,1,3]
                                                       Type: List Integer

— RosLuP
स्रोत

पहचानकर्ताओं को पहचानें

परिचय

आवश्यकताएँ

मान्यताओं

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

स्कोरिंग

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

व्याख्या

जावा 8, 158 144 बाइट्स

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

रूबी , 63 बाइट्स

05AB1E , 17 16 18 बाइट्स

PHP, 121 बाइट्स

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

हास्केल , 79 76 बाइट्स

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

एपीएल (डायलॉग 16.0), 34 बाइट्स

अजगर , २१ 20 बाइट्स

सी # , 135 बाइट्स

golfed

Ungolfed

अनपढ़ पठनीय

पूर्ण कोड

विज्ञप्ति

टिप्पणियाँ

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

आर , 39 46 बाइट्स

सी, 169 बाइट्स 133 बाइट्स

सी # 7, 116 बाइट्स

क्लोजर, 72 बाइट्स

आर, 74 बाइट्स

एक्सोम, 169 बाइट्स