Monotonik olarak artan (veya azaltmayan) bir sayı listesine , her bir eleman ondan önceki öğeye eşit veya ondan büyüktür.

Örneğin 1, 1, 2, 4, 5, 5, 5, 8, 10, 11, 14, 14, monoton olarak artmaktadır.

Monoton olarak artan pozitif tamsayıların listesi verilen, rasgele sayıda boş noktaya sahip pozitif tamsayıların listesi göz önüne alındığında ?, boş noktaları, mümkün olduğunca çok sayıda benzersiz tamsayılar mevcut olacak şekilde, pozitif tamsayılarla doldurun;

Bunu başarmanın birçok yolu olabilir. Herhangi biri geçerlidir.

Sonuç listesini çıkar.

Örneğin , giriş

?, 1, ?, 1, 2, ?, 4, 5, 5, 5, ?, ?, ?, ?, 8, 10, 11, ?, 14, 14, ?, ?

Boş noktalar olmadan listenin monoton bir şekilde artacağı garanti edilir

1, 1, 2, 4, 5, 5, 5, 8, 10, 11, 14, 14

ve göreviniz, ?listedeki farklı tam sayıların sayısını en aza indirmeye devam ettirmek için her birine pozitif tamsayılar atamaktır .

Olduğu bir atama geçerli değil ise

1, 1, 1, 1, 2, 3, 4, 5, 5, 5, 5, 5, 5, 5, 8, 10, 11, 14, 14, 14, 14, 14

Çünkü, değer düşüklüğü yaparken, girdiden yalnızca bir tek tam sayı daha var 3.

Bu örnekte altı benzersiz pozitif tamsayı eklemek ve listeyi düşük tutmak mümkündür.
Birkaç olası yol vardır:

1, 1, 1, 1, 2, 3, 4, 5, 5, 5, 6, 7, 8, 8, 8, 10, 11, 12, 14, 14, 15, 16

1, 1, 1, 1, 2, 3, 4, 5, 5, 5, 5, 6, 6, 7, 8, 10, 11, 13, 14, 14, 20, 200

Bunlardan herhangi biri (ve diğerleri) geçerli çıktı olacaktır.

Tüm boş noktalar doldurulmalı.

Eklenebilecek tamsayılar için üst sınır yoktur. Bilimsel gösterimde çok büyük tamsayılar yazdırıldığında sorun yok.

Sıfır, pozitif bir tamsayı değildir ve asla yerleştirilmemelidir.

Yerine ?pozitif bir tamsayı olmayan herhangi istikrarlı bir değer gibi kullanabilir size 0, -1, null, False, veya "".

Bayt cinsinden en kısa kod kazanır.

Daha fazla örnek

[input]
[one possible output] (a "*" means it is the only possible output)

2, 4, 10
2, 4, 10 *

1, ?, 3
1, 2, 3 *

1, ?, 4
1, 2, 4

{empty list}
{empty list} *

8
8 *

?
42

?, ?, ?
271, 828, 1729

?, 1
1, 1 *

?, 2
1, 2 *

?, 3
1, 3

45, ?
45, 314159265359

1, ?, ?, ?, 1
1, 1, 1, 1, 1 *

3, ?, ?, ?, ?, 30
3, 7, 10, 23, 29, 30 

1, ?, 2, ?, 3, ?, 4
1, 1, 2, 3, 3, 3, 4

1, ?, 3, ?, 5, ?, 7
1, 2, 3, 4, 5, 6, 7 *

1, ?, 3, ?, 5, ?, ?, 7
1, 2, 3, 4, 5, 6, 7, 7

1, ?, ?, ?, ?, 2, ?, ?, ?, ?, 4, ?, 4, ?, ?, 6
1, 1, 1, 1, 1, 2, 3, 4, 4, 4, 4, 4, 4, 5, 6, 6

98, ?, ?, ?, 102, ?, 104
98, 99, 100, 101, 102, 103, 104 *

Haskell , 41 bayt

fbir liste alır ve 0'ı ?s ile temsil eden bir liste döndürür .

f=scanr1 min.tail.scanl(#)0
m#0=m+1
_#n=n

Temel olarak, ilk tarama listesi soldan, 0'ları önceki öğeden bir veya daha fazla (veya başlangıçta 0) ile değiştirin; sonra sağdan aşağı doğru çok büyük elemanları sağ tarafındakiyle eşitlemek için tarayın.

Çevrimiçi deneyin! ( ?s dönüştürmek için sarıcı ile .)

Mathematica, 84 bayt

Rest[{0,##}&@@#//.{a___,b_,,c___}:>{a,b,b+1,c}//.{a___,b_,c_,d___}/;b>c:>{a,c,c,d}]&

Boş noktaların Null(içinde olduğu gibi {1, Null, Null, 2, Null}) belirtildiği veya tamamen silindiği (içinde olduğu gibi ) olduğu bir argüman olarak listeye giren saf işlev {1, , , 2, }ve (bu durumda, {1, 2, 2, 2, 3}) uygun bir listenin döndürülmesi .

Ørjan Johansen'in Haskell'in cevabında olduğu gibi aynı algoritmayı kullanıyorum : önce Nullsoldaki numaradan bir taneden daha fazlasını //.{a___,b_,,c___}:>{a,b,b+1,c}değiştirin ( ), ardından sağdaki numaradan ( //.{a___,b_,c_,d___}/;b>c:>{a,c,c,d}) çok büyük herhangi bir sayıyı değiştirin . NullListenin başındaki olası s'lerle başa çıkmak için, bir 0( {0,##}&@@#) hazırlayarak , algoritmayı yaparak, sonra baştaki 0( Rest) 'i silerek başlıyoruz .

Evet, tam anlamıyla bir baytı kodda (aksi halde virgül arasında olacaktı) kaydetmek için Nullonun yerine Xya da onun gibi bir şey seçtim b_,,c___.

C 160

Bu asla kazanamayacak ama:

#define p(x)printf("%d ",x);
i=1,l=0,m=0,n;main(c,v)char**v;{for(;i<c;i++)if(*v[i]==63)m++;else{for(n=atoi(v[i]);m>0;m--)p(l<n?++l:n)p(l=n)}for(;m>0;m--)p(++l)}

Listeyi komut satırı argümanlarından alır.

05AB1E , 31 23 13 bayt

Grimy sayesinde 10 bayt kaydedildi

ε®X:D>U].sR€ß

Çevrimiçi deneyin!

açıklama

ε      ]       # apply to each number in input
 ®X:           # replace -1 with X (initially 1)
    D>U        # store current_number+1 in X
        .s     # get a list of suffixes
          R    # reverse
           ۧ  # take the minimum of each

Pip , 25 23 21 bayt

Y{Y+a|y+1}MgW PMNyPOy

Girdiyi birden çok boşlukla ayrılmış komut satırı argümanları olarak alır. Sonuç listesini satır başına bir sayı olarak verir. Çevrimiçi deneyin! (Çoklu komut satırı argümanlarını karıştırdım, çünkü TIO'ya 25 argüman eklemek acı vericiydi ama reklamı da yapıldı.

açıklama

İki seferde ilerliyoruz. Öncelikle, ?girişteki her s sırasını listedeki önceki sayıdan başlayarak bir sıra ile değiştiririz :

? 1 ? 1 2 ? 4 5 5 5 ? ? ? ? 8 10 11 ?  14 14 ?  ?
1 1 2 1 2 3 4 5 5 5 6 7 8 9 8 10 11 12 14 14 15 16

Sonra tekrar döngüden geçiyoruz; Her numara için, minimumunu ve sağındaki tüm numaraları yazdırırız. Bu monotonluğu korumak için çok yüksek sayıları aşağıya çekiyor.

                      y is initially "", which is 0 in numeric contexts
                      Stage 1:
 {       }Mg           Map this function to list of cmdline args g:
   +a                  Convert item to number: 0 (falsey) if ?, else nonzero (truthy)
     |                 Logical OR
      y+1              Previous number +1
  Y                    Yank that value into y (it is also returned for the map operation)
Y                      After the map operation, yank the whole result list into y
                      Stage 2:
            W          While loop, with the condition:
               MNy      min(y)
              P         printed (when y is empty, MN returns nil, which produces no output)
                  POy  Inside the loop, pop the leftmost item from y

NumPy ile Python 2, 163 bayt

@Wythagoras sayesinde 8 bayt kaydedildi

Boş noktaları işaretlemek için kullanılan sıfırlar

import numpy
l=[1]+input()
z=numpy.nonzero(l)[0]
def f(a,b):
 while b-a-1:a+=1;l[a]=l[a-1]+1;l[a]=min(l[a],l[b])
i=1
while len(z)-i:f(z[i-1],z[i]);i+=1
print l[1:]

Yorumlarla daha okunaklı:

import numpy
l=[1]+input()           # add 1 to the begining of list to handle leading zeros
z=numpy.nonzero(l)[0]   # get indices of all non-zero values
def f(a,b):             # function to fill gap, between indices a and b
    while b-a-1:
        a+=1
        l[a]=l[a-1]+1   # set each element value 1 larger than previous element
        l[a]=min(l[a],l[b])   # caps it by value at index b
i=1
while len(z)-i:       
    f(z[i-1],z[i])      # call function for every gap
    i+=1
print l[1:]             # print result, excluding first element, added at the begining

PHP, 95 77 71 69 68 bayt

for($p=1;$n=$argv[++$i];)echo$p=$n>0?$n:++$p-in_array($p,$argv)," ";

komut satırı argümanlarından girdi alır, boşlukla ayrılmış listeyi yazdırır. İle koş -nr.

Yıkmak

for($p=1;$n=$argv[++$i];)   # loop through arguments
    echo$p=                     # print and copy to $p:
    $n>0                            # if positive number
        ?$n                             # then argument
        :++$p                           # else $p+1 ...
            -in_array($p,$argv)         # ... -1 if $p+1 is in input values
    ," ";                       # print space

$nBoş dize ancak herhangi bir dize için truthy ve "0".
$n>0Olumlu sayılar için truthy - ve onları içeren dizeleri.

Perl 6 , 97 bayt

{my $p;~S:g/(\d+' ')?<(('?')+%%' ')>(\d*)/{flat(+($0||$p)^..(+$2||*),(+$2 xx*,($p=$2)))[^+@1]} /}

Giriş, bir değerler listesi veya boşluklarla ayrılmış bir dizedir; burada ?, değiştirilecek değerlerin durması için kullanılır.

Çıktı, sonunda boşluk olan boşlukla ayrılmış bir dizedir.

Dene

Expanded:

{                       # bare block lambda with implicit parameter ｢$_｣

    my $p;              # holds the previous value of ｢$2｣ in cases where
                        # a number is sandwiched between two replacements

    ~                   # stringify (may not be necessary)
    S                   # replace
    :global
    /
        ( \d+ ' ' )?    # a number followed by a space optionally ($0)

        <(              # start of replacement

          ( '?' )+      # a list of question marks
          %%            # separated by (with optional trailing)
          ' '           # a space

        )>              # end of replacement

        (\d*)           # an optional number ($2)

    /{                  # replace with the result of:

        flat(

          +( $0 || $p ) # previous value or 0
          ^..           # a range that excludes the first value
          ( +$2 || * ), # the next value, or a Whatever star

          (
            +$2 xx *,   # the next value repeated endlessly

            ( $p = $2 ) # store the next value in ｢$p｣
          )

        )[ ^ +@1 ]      # get as many values as there are replacement chars
    } /                 # add a space afterwards
}

JavaScript (ES6), 65 bayt

a=>a.map(e=>a=e||-~a).reduceRight((r,l)=>[r[0]<l?r[0]:l,...r],[])

Çünkü kullanmak istedim reduceRight. Açıklama: mapHer falsy değerini önceki değerden bir taneyle değiştirir, ardından reduceRighthiçbir değerin aşağıdaki değeri geçmemesini sağlayarak en baştan çalışır.

Q, 63 bayt

{1_(|){if[y>min x;y-:1];x,y}/[(|){if[y=0;y:1+-1#x];x,y}/[0,x]]}

Esasen Ørjan Johansen'in Haskell'in cevabıyla aynı algoritma .

• Varsayım mı? = 0.
• Durumda dizinin başına 0 ekler? başlangıçta.
• 0 yerine 1 + önceki öğeyi içeren diziyi tarar.
• Diziyi ters çevirir ve tekrar tarar, önceki öğeden daha büyük olan öğeleri önceki öğeyle değiştirir.
• İlk elemanı ters çevirir ve keser (baştan 0 eklenir).

En son vs vs son kullanımı bir bayt kurtarmak için kullanılmıştır, çünkü son elemanın dizinin azalan türüne göre verilen min elemanı olacağını varsayabiliriz.

TI-Basic (TI-84 Plus CE), 81 bayt

not(L1(1))+L1(1→L1(1
For(X,2,dim(L1
If not(L1(X
1+L1(X-1→L1(X
End
For(X,dim(L1)-1,1,-1
If L1(X)>L1(X+1
L1(X+1→L1(X
End
L1

Ørjan Johansen'in Haskell'in basit bir limanı TI-Basic'e cevap veriyor. 0 değerini boş değer olarak kullanır. L _1'den girdi alır .

Açıklama:

not(L1(1))+L1(1→L1(1 # if it starts with 0, change it to a 1
For(X,2,dim(L1     # starting at element 2:
If not(L1(X              # if the element is zero
1+L1(X-1→L1(X            # change the element to one plus the previous element
End
For(X,dim(L1)-1,1,-1 # starting at the second-last element and working backwards
If L1(X)>L1(X+1           # if the element is greater than the next
L1(X+1→L1(X               # set it equal to the next
End
L1                   # implicitly return

Java 8, 199 164 bayt

a->{for(int l=a.length,n,j,x,i=0;i<l;)if(a[i++]<1){for(n=j=i;j<l;j++)if(a[j]>0){n=j;j=l;}for(j=i-3;++j<n-1;)if(j<l)a[j+1]=j<0?1:a[j]+(l==n||a[n]>a[j]|a[n]<1?1:0);}}

Girdileri kaydetmek için yenisini döndürmek yerine girdi dizisini değiştirir.
Kullanımları 0yerine ?.

Çevrimiçi deneyin.

Açıklama:

a->{                      // Method with integer-array parameter and no return-type
  for(int l=a.length,     //  Length of the input-array
      n,j,x,              //  Temp integers
      i=0;i<l;)           //  Loop `i` over the input-array, in the range [0, length):
    if(a[i++]<1){         //   If the `i`'th number of the array is 0:
                          //   (And increase `i` to the next cell with `i++`)
      for(n=j=i;          //    Set both `n` and `j` to (the new) `i`
          j<l;j++)        //    Loop `j` in the range [`i`, length):
        if(a[j]>0){       //     If the `j`'th number of the array is not 0:
          n=j;            //      Set `n` to `j`
          j=l;}           //      And set `j` to the length to stop the loop
                          //    (`n` is now set to the index of the first non-0 number 
                          //     after the `i-1`'th number 0)
      for(j=i-3;++j<n-1;) //    Loop `j` in the range (`i`-3, `n-1`):
        if(j<l)           //     If `j` is still within bounds (smaller than the length)
          a[j+1]=         //      Set the `j+1`'th position to:
            j<0?          //       If `j` is a 'position' before the first number
             1            //        Set the first cell of the array to 1
            :             //       Else:
             a[j]+        //        Set it to the `j`'th number, plus:
              (l==n       //        If `n` is out of bounds bounds (length or larger)
               ||a[n]>a[j]//        Or the `n`'th number is larger than the `j`'th number
               |a[n]<1?   //        Or the `n`'th number is a 0
                1         //         Add 1
               :          //        Else:
                0);}}     //         Leave it unchanged by adding 0

Python 2 , 144 124 119 bayt

l=input()
for n in range(len(l)):a=max(l[:n]+[0]);b=filter(abs,l[n:]);b=len(b)and b[0]or-~a;l[n]=l[n]or a+(b>a)
print l

Çevrimiçi deneyin!

Kullanımları 0yerine?

JavaScript (ES6), 59

Tamsayı dizisi giriş olarak kullanılan bir işlev. Boş noktalar0

a=>a.map((v,i)=>v?w=v:(a.slice(i).find(x=>x)<=w?w:++w),w=0)

Ölçek

var F=
a=>a.map((v,i)=>v?w=v:(a.slice(i).find(x=>x)<=w?w:++w),w=0)

;[[2, 4, 10]
,[1, 0, 3]
,[1, 0, 4]
,[]
,[8]
,[0]
,[0, 0, 0]
,[0, 1]
,[0, 2]
,[0, 3]
,[45, 0]
,[1, 0, 0, 0, 1]
,[3, 0, 0, 0, 0, 30]
,[1, 0, 2, 0, 3, 0, 4]
,[1, 0, 3, 0, 5, 0, 7]
,[1, 0, 3, 0, 5, 0, 0, 7]
,[1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 4, 0, 4, 0, 0, 6]
,[98, 0, 0, 0, 102, 0, 104]]
.forEach(a=>{
  console.log(a+'\n'+F(a))
})

C # (.NET Core) , 182 bayt

Ørjan Johansen ile aynı stratejiyi kullanmak.

Bilinmeyen var işaretlemek için giriş listesinde 0 kullanır.

l=>{if(l[0]<1)l[0]=1;int j;for(j=0;j<l.Length;j++)l[j]=l[j]==0?l[j-1]+1:l[j];for(j=l.Length-2;j>=0;j--)l[j]=l[j]>l[j+1]?l[j+1]:l[j];foreach(var m in l) System.Console.Write(m+" ");};

Çevrimiçi deneyin!

Perl 5 -p , 99 bayt

s,(\d+ )?\K((\? )+)(?=(\d+)),$d=$1;$l=$4;$2=~s/\?/$d<$l?++$d:$l/rge,ge;($d)=/.*( \d+)/;s/\?/++$d/ge

Çevrimiçi deneyin!