Kısa bir süre önce PPCG'de 10.000 soru eşiğine ulaştık. Yaşasın! Bunu basit bir meydan okuma ile kutlayalım.

Giriş

[ 1..9999 ] ' daki iki $A$ ve $B$tamsayısı , A + B < 10000 olacak şekildedir .$[1..9999]$$A+B<10000$

Görev

Görevin, bu tamsayılardan birine bir rakam veya ikisine de $A+B=10000$ şekilde bir rakam eklemektir . Hem bir haneyi ekleyerek Eğer $A$ ve $B$ , mutlaka aynı haneli olması gerekmez.

Yeni rakam başlangıçta, sonunda veya orijinal tamsayının ortasında herhangi bir yere eklenebilir. Ancak, baştaki sıfır ekleyemezsiniz.

Örnek:

For $A=923$ , aşağıdaki dönüşümler geçerlidir:

Ancak bunlar geçersiz :

$A=923$ ve $B=72$ verildiğinde , iki olası çözüm vardır:

Çıktı

Tüm olası çözümlerin bir listesini yazdırmanız veya yazdırmanız gerekir.

Yukarıdaki örnek için beklenen çıktı olacaktır [[9238,762],[9273,727]].

kurallar

• G / Ç, makul ve açık herhangi bir biçimde işlenebilir. Tamsayılar yerine dizeleri, basamak listelerini vb. Kullanabilirsiniz.
• Girişin en az bir çözüme sahip olması garanti edilir.
• Çıktıyı tekilleştirmemeye izin verilir. Bununla birlikte, test kodunun, örneğin TIO’nun alt bölümünde , bazı işlem sonrası işlemlerle veri tekilleştirilmesi durumunda, takdir edilecektir .
• Bu bir kod golf mücadelesi.

Test durumları

Input    --> Output

934, 654 --> [[9346,654]]

737, 628 --> [[7372,2628]]

9122, 88 --> [[9122,878]]

923, 72  --> [[9238,762],[9273,727]]

998, 3   --> [[9968,32],[9987,13]]

900, 10  --> [[9900,100],[9090,910]]    NB: solutions such as [9000,1000] are NOT valid
                                            (more than one digit added to 10)

363, 632 --> [[3673,6327],[3638,6362]]

288, 711 --> [[2881,7119],[2882,7118],[2883,7117],[2884,7116],[2885,7115],[2886,7114],
              [2887,7113],[2888,7112],[2889,7111]]

365, 635 --> [[365,9635],[1365,8635],[2365,7635],[3365,6635],[4365,5635],[5365,4635],
              [6365,3635],[7365,2635],[8365,1635],[9365,635],[3065,6935],[3165,6835],
              [3265,6735],[3465,6535],[3565,6435],[3665,6335],[3765,6235],[3865,6135],
              [3965,6035],[3605,6395],[3615,6385],[3625,6375],[3635,6365],[3645,6355],
              [3655,6345],[3675,6325],[3685,6315],[3695,6305],[3650,6350]]

Haskell , 99 97 82 81 bayt

^{-Delfad0r sayesinde -16 bayt (girişleri bir liste olarak almak, kötüye kullanmak gerekmeksizin kullanma -> n her zaman [0,4] olabilir ve akıllı bir girdi formatı kombinasyonu kullanarak ap) ve !}

filter((==1e4).sum).mapM([read.(take n<>(c:).drop n)|c<-['0'..'9'],n<-[0..4]]<*>)

Çevrimiçi deneyin!

R , 96 bayt

function(a,b)(w<-grep(gsub("",".?",a?b),1:1e4?9999:0)?r<-1e4-w)[w+a<2&r+b<2]
"?"=paste
"+"=adist

Çevrimiçi deneyin!

Açıklama (ungolfed)

function(a,b){
    # Regex inserting ".*": (998,3) => ".?9.?9.?8.? .?3.?"
  regex <- gsub("",".?",paste(a,b)) 
    # Positions matching in the whole vector of strings that add to 10K ("1 9999", "2 9998", "3 9997", "4 9996", ...)
  w <- grep(regex,paste(1:1e4,9999:0)) 
    # 10K minus these matching positions
  r <- 1e4-w 
    # Form position-string vector of ('pos1 10K-pos1', 'pos2 10K-pos2', ...)
  paste(w,r)[
  # Filter only those positions where the edit distance between the matched numbers and the originals are less than 2
    adist(w,a)<2 & adist(r,b)<2 
  ]
}

Biz atamak ?için paste. Bu bize bir şey serin yapalım: a<-b?c<-dsatır içi atamaları yapar pastebiz daha başka operatörle yapamadı çağrı, ?o sahip olduğundan, düşük önceliğe göre <-.

Şimdi @JoKing'in dikkat çektiği gibi 900 10, iki yerleştirmenin olduğu gibi durumlar olabilir 9100 8100. Böylece, her iki sayıdaki karakter sayısının 1'den fazla arttığı eşleşmeleri filtreliyoruz. Bunu yapmanın hızlı yolu, bağladığımız Levenshtein düzenleme mesafesiyle .adist+

Pyth, 28 27 25 24 22 20 bayt

fq^;4sT*FmvsmXLkdThl

Online Deneyin burada veya tüm test durumları doğrulamak burada - test paketi bir prepending tarafından sonucunu tekilleştirir {.

Giriş, dizelerin bir listesi gibidir.

fq^;4sT*FmvsmXLkdThldQ   Implicit: Q=eval(input()), T=10
                         Trailing d, Q inferred
         m           Q   Map each input string, as d, using:
                   ld      Take the length of d
            m     h        Map 0 to the above (inclusive), as k, using:
             X  d            Insert into d...
               k             ... at position k...
              L  T           ... each number [0-9]
           s               Flatten the result
          v                Convert each back to an integer
       *F                Take the cartesian product of the result
                         (this generates all possible pairs of mutated numbers)
f                        Keep the pairs, as T, where...
     sT                  ... the sum of the pair...
 q                       ... is equal to...
  ^;4                    ... 10,000 (; == 10 here, so this is 10^4)

Düzenleme 4: - Kayıtlı başka 2 byte, Bay Xcoder sayesinde vvarsayılan olarak vectorises ve Lkullanımları myapma aralığında haritalama ima böylece altına, Uçok gereksiz

Düzenleme 3: ;FryAmTheEggman ve issacg sayesinde, 2 bayttan tasarruf etmek için 10'a erişebilmek için operatörün global kullanımına tanıtıldı:

fq^T4sT*FmvMsmXLkdUThl

Düzenleme 2: Toplam operatörün var olduğunu unuttum, nasıl utanç verici ...

Düzenleme 1: Önceki sürüm, 27 bayt için el ile dize dönüşümleri gerçekleştirerek bir tam sayı listesini girdi olarak kabul etti:

fq10000+FT*FmvMsmXLk`dUThl`

Perl 6 , 64 bayt

->\a{grep {all (a Z~$_)X~~/^(.*)(.*)$0.?$1$/},(^1e4 Z(1e4...1))}

Çevrimiçi deneyin!

Bu, numaraların geçerli olup olmadığını kontrol etmek için bir regex kullanarak GB'nin cevap limanıdır . Taşıdığı için nwellnhof'a teşekkürler .

Eski cevap, 127 110 , 88 bayt

Nwellnhof sayesinde -22 bayt!

->\a{grep {all ~<<a Z∈.map:{.comb.combinations(.comb-1..*)>>.join}},(^1e4 Z(1e4...1))}

Çevrimiçi deneyin!

İki numara listesini alan ve bir çift sayı listesini döndüren adsız kod bloğu.

Rakamların girilmesiyle çalışmak yerine, bu çözüm 10000'e karşılık gelen her sayı kombinasyonunu kontrol eder ve verilen sayıların çiftin bir parçası olduğunu filtreler.

Açıklama:

->\a{  # Anonymous code block that takes an argument a
     grep ... ,(^1e4 Z(1e4...1))    # Filter from all pairs that add to 10000
         {      ~<<a     # Stringify the contents of a
                     .map:{      # Map the pair to
                           .comb  # The digits of the number
                           .combinations(.comb-1..*)  # The combinations of the digits
                           >>.join  # Each combination joined
                           # Note that combinations preserve order
                           # "123" -> (12,13,123)
                          }
          all       Z∈   # Zip that each element of a is an element of the combination
         }
}

R , 179 161 150 144 bayt

function(a,b,w=g(a),r=rep(g(b),e=1e4))paste(w,r)[w+r==1e4]
g=function(x,n=sum(x|1)){for(i in 0:n)for(j in 0:9)F=c(F,append(x,j,i)%*%10^(n:0));F}

Çevrimiçi deneyin!

@JayCe ve @Giuseppe tarafından kaydedilen 35 bayt.

açıklama

Yardımcı fonksiyon g tüm olası yerleştirmeleri alır.

g <- function(x,            # Input vector of digits
              n=sum(x|1)    # Length of x
              ) {
  for(i in 0:n)             # i is the insertion point
    for(j in 0:9)           # j is a digit from 0 to 9
      # Dot product of vector of digits with insert and 10^(n:0) performs the
      # conversion to integer (and gets rid of the leading 0s)
      F=c(F,append(x,j,i)%*%10^(n:0))  # F is a non-reserved built-in alias to FALSE (numerically 0)
  F
}

Ana işlev.

f <- 
function(a,                 # Input vectors of digits
         b,
         w=g(a),            # Get all possible insertions for a
         r=rep(g(b),e=1e4)  # Insertions for b replicated 1e4 times each
         )
  paste(w,r)[w+r==1e4]      # paste and w+r recycle w to match length of r
                            # Lots of duplication!

Bunun aslında Pyth cevabıyla aynı mantık olduğuna dikkat ettim .

Ruby , 93 91 bayt

->a,b{(1..r=10000).map{|x|/^(.*)(.*:)\1.?\2(.*)(.*):\3.?\4$/=~[a,x,b,y=r-x]*?:&&[x,y]}-[p]}

Çevrimiçi deneyin!

Her bir numarayı 10000’e kadar deneyin ve sayıların uyuşup uyuşmadığını kontrol etmek için regex kullanın.

Jöle , 30 bayt

DµJṬ€k€jþ9Ż¤;9R¤;€$ḌF)ŒpS=ȷ4ƊƇ

Çevrimiçi deneyin!

Biraz sakar, çünkü Jelly'in takması yok.

açıklama

                                   Given [a, b].
Dµ                   )             Get [digits(a), digits(b)] then map:
  JṬ€k€jþ9Ż¤;9R¤;€$ḌF                Generate all the insertions.
                      Œp           Cartesian product: get all pairs.
                        S=ȷ4ƊƇ     Filter for: sum equal to ȷ4 (10000).

                       Given e.g. [6,3,5]:
J                      Get [1,2,3].
 Ṭ€                    Get [[1], [0,1], [0,0,1]].
   k€                  Split input with these: gets us
                         [[6],[3,5]] , [[6,3],[5]] , [[6,3,5],[]]
     jþ9Ż¤             Join table-wise with [0..9]
                         → [[[6,0,3,5], [6,3,0,5], [6,3,5,0]],
                            [[6,1,3,5], [6,3,1,6], [6,3,5,1]], …]
          ;9R¤;€$      Append the prefixings of the input by [1..9].
                           [[1,6,3,5], [2,6,3,5], [3,6,3,5]]…
                 ḌF    Undigits all, and flatten.

PHP, 162 159 bayt

jeneratör işlevi için güzel bir örnek!

function f($n){for($n+=.1;$n>=1;$n/=10)for($d=-1;$d++<9;)yield strtr($n,".",$d)/10|0;}foreach(f($argv[1])as$x)foreach(f($argv[2])as$y)$x+$y-1e4||print"$x+$y\n";

komut satırı argümanlarından girdi alır; kopyaları yazdırır. Çevrimiçi olarak çalıştırın -nr '<code>veya deneyin .

Pyth, 18 bayt

fqsT^;4*FsMvXLRRTT

Gösteri , test paketi (test paketi öncülükle tekilleştirilir {).

Giriş, iki karakter dizisi şeklindedir.

XLRRTT: L ve R iç içe geçmiş haritalar yapar. Bunlardan 3 tane olduğundan, üçlü iç içe geçmiş bir Xişlev göstereceğiz . Bu durumda, Xişlev bir dizgeye belirtilen pozisyonda bir karakter ekleyecektir.

Dize, örtük olan ve ilk yerleştirilen girdidir R. Karakter değişiyor 0 ... 9, bu yüzden mümkün olan tüm rakamları ekliyoruz ve L. Aralık, Törtük olarak ayarlanmış ve 10örtük olarak muamele edilmiş olarak verilir [0 ... 9]. Konum 0 ... 9, yeterlidir, çünkü 10. pozisyondan sonra bir sayı girmek asla kullanışlı olmayacaktır. Yinelenen sonuçlar iyi. Aralık, ikinci tarafından yerleştirilir ve ikinci Rtarafından verilir T.

v: İç içe geçmiş dizeler, inç olarak.

sM: Girişlerin her biri için, rakam girme işleminden sonra olası tüm sayıları içeren bir liste bırakarak, ikinci liste düzeyini düzleştirin.

*F: İki olası sayılar listesinin Kartezyen ürününü alın.

fqsT^;4: Ürünü olan çiftlere filtre uygulayın 10000. ;değerini alır 10olarak, burada Tfiltre değişken olarak kullanımda olan ve ;kullanımda olan değişkenin değeri her zaman olduğu gibi.

Japt , 30 29 25 23 bayt

Bir dizge dizisi olarak girdi alır, dizge dizileri dizisi çıkarır.

£L²ôs f_à øX
rï k@L²aXx

Dene

açıklama

£L²ôs f_à øX
£                :Map each X
 L               :  100
  ²              :  Squared
   ô             :  Range [0,L²]
    s            :  Convert each to a string
      f_         :  Remove elements that return false
        à        :    All combinations of current element
          øX     :    Contains X?
rï k@L²aXx
r                :Reduce by
 ï               : Cartesian product
   k@            :Remove each X that returns true (not 0)
     L²          :  100 squared
      a          :  Absolute difference with
        Xx       :   X reduced by addition

Javascript (Düğüm) - 183 136 123 Bayt

Shaggy sayesinde 123 Bayt

a=>b=>(o={},g=(s,h)=>[...s+0].map((y,x)=>{for(y=10;y--;)h(s.slice(0,x)+y+s.slice(x))}))(a,x=>g(b,y=>1e4-x-y?0:o[+x]=+y))&&o

Arnauld sayesinde 136 Bayt

e=(h,c,i=h.length+1,j)=>{for(;i--;)for(j=10;j--;)c(h.slice(0,i)+j+h.slice(i))}
f=(a,b,c=[])=>e(a,n=>e(b,m=>1E4-n-m||c.push([+n,+m])))||c

Eski Kod

Bununla gurur duymuyorum ama yine de göndereceğimi düşündüm. Baytın büyük bir bölümünü alan haritaya benzer bir dize prototip işlevi oluşturur. Fonksiyon sadece her iki permütasyonda tekrar eder ve 1000-ab olduğunda 0 bulur. Girdiyi dizge olarak alır.

String.prototype.e=function(c){let h=this,L=h.length,i,j;for(i=0;i<=L;i++)for(j=0;j<=9;j++)c(h.slice(0,i)+j+h.slice(i,L));}
f=(a,b,c=[])=>a.e(n=>b.e(m=>1E4-n-m?c:c.push([+n,+m])))?c:c

Çevrimiçi deneyin!

Ungolfed

String.prototype.e=function(c) {
  let h=this,L=h.length,i,j;
  for(i=0;i<=L;i++)
    for(j=0;j<=9;j++)
      c(h.slice(0,i)+j+h.slice(i,L));
}
f=(a, b, c=[]) =>
  a.e(n =>
    b.e(m =>
      1E4-n-m ? c : c.push([+n,+m])
    )
  ) ? c : c

Jöle , 23 bayt

œcL’$$€ċ"⁹o⁼"Ạ
ȷ4ḶṚĖDçƇ

Basamak listelerin bir listesini kabul bir monadik bağlantı
(girişi 923 ve 72, örneğin, örneğin [[9,2,3],[7,2]])

Çevrimiçi deneyin! (altbilgi bunu yapar, böylece G / Ç, iki tamsayı çiftidir ve [biçimlendirilmiş] tamsayı çiftleri listesidir.

Veya test odasına bakın .

Nasıl?

Geçerlilik için toplam 10000 olan toplam "sayı" çiftlerini (sayı listeleri) kontrol eder; ve geçerli olanları saklar (geçerlilik aynı zamanda test edilen "sayı" nın orijinal "sayıya eşit olmasını sağlar").

œcL’$$€ċ"⁹o⁼"Ạ - Link 1, is piar valid?: pairToCheck, originalInputPair
      €        - for each list of digits in pairToCheck: e.g. [9,2,3]
     $         -   last two links as a monad:
    $          -     last two links as a monad:
  L            -       length                                 3
   ’           -       decremented                            2
œc             -     choices of that many items               [[9,2],[9,3],[2,3]]
         ⁹     - chain's right argument (originalInputPair)
        "      - zip with: (i.e. apply the following f(x,y) *respectively* across the results above and the originalInputPair)
       ċ       -   count occurrences
            "  - zip with (this time with an implicit right argument of originalInputPair)
           ⁼   -   equal (non-vectorising version)
          o    - locgical OR (vectorising version) i.e. we now have: [OR(isOneDigitLonger(item1),isEqual(item1)), OR(isOneDigitLonger(item2),isEqual(item2))]
             Ạ - all?

ȷ4ḶṚĖDçƇ - Main Link: list (pair) of lists of digits
ȷ4       - literal 10^4 -> 10000
  Ḷ      - lowered range -> [0,1,2,...,9998,9999]
   Ṛ     - reversed -> [9999,9998,...,2,1,0]
    Ė    - enumerate -> [[1,9999],[2,9998],...,[9998,2],[9999,1],[10000,0]] (N.B. last is redundant, but this does not matter)
     D   - to decimals -> [[[1],[9,9,9,9]],[[2],[9,9,9,8]],...,[[9,9,9,8],[2]],[[9,9,9,9],[1]],[[1,0,0,0,0],[0]]]
       Ƈ - filter keep those for which this is truthy:
      ç  -   call last link as a dyad (with a right argument of the pair of lists of digits)

Stax , 24 bayt

⌐çΘ♠╖øû°-h∟ñµ%üw▲∞Ç╫[½π=

Koş ve hata ayıkla

Bu program iki girişini bir dizi dizge gibi alır, bunun gibi.

["934", "654"]

Kömür , 33 bayt

ΦＥ×χφＩ⟦ι⁻×χφι⟧⌊Ｅι№Ｅ⊕ＬλΦλ⁻ξρ§⟦θη⟧μ

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

   χ                                10
    φ                               1000
  ×                                 Multiply
 Ｅ                                  Map over implicit range
       ι    ι                       Current value
        ⁻×χφ                        Subtract from 10000
      ⟦      ⟧                      Pair of values
     Ｉ                              Cast to string
Φ                                   Filter
                ι                   Current pair
               Ｅ                    Map
                     λ              Current value
                    Ｌ               Length
                   ⊕                Increment
                  Ｅ                 Map over implicit range
                       λ            Current value
                      Φ             Filter over characters
                         ξ          Range value
                          ρ         Character index
                        ⁻           Subtract
                            ⟦θη⟧    Original inputs as a list
                                μ   Index of current value
                           §        Get input at that index
                 №                  Count matching values
              ⌊                     Minimum
                                    Implicitly print each pair double-spaced

Bunu anlamadıysanız, 10000'e (dizge olarak) eklenen tüm değer çiftleri boyunca ilerler, ardından her girişin ilgili değerden 1 karakter silmenin sonucuna karşı kaç kez eşleştiğini sayar. Minimum sayım sıfır değilse, her iki giriş de aynı olur ve bu olası bir çözümdür.

Python 3, 165 160 153 125 117 bayt

• setÇıktı kopyaları içerebileceği için, geri dönüş değerinden kaldırılması için @ JackBrounstein önerisi sayesinde 5 bayt kaydedildi .
• Değiştirerek 7 Kaydedilen range(len(s))ile range(5).
• @Eric Duminil'in itertoolsiç içe geçmiş liste kavramaları (ve bir boşluğu kaldırma) ile değiştirilmesi önerisi sayesinde 23 bayt kurtarıldı .
• @Jo King'in iç içe geçmiş liste kavrayışını tek bir döngü ve modül operatörüyle değiştirmek yerine önerisi sayesinde 8 adet tasarruf sağladı.

Kullanımı itertoolsve basit bir yardımcı fonksiyon. Dizeleri girdi olarak kabul eder, çıktı olarak bir dizi diziyi döndürür.

c=lambda s:[int(s[:i%5]+str(i//5)+s[i%5:])for i in range(50)]
lambda a,b:{(i,j)for i in c(a)for j in c(b)if i+j==1e4}

Ruby , 110 bayt

Dizeleri giriş olarak kabul eder, bir tamsayı dizisi döndürür.

Dayanarak piton sürümü. Belirli bir tam sayı için, Cbir rakam ekleyerek oluşturulabilecek bir sayı dizisi oluşturur.

Lambda, her olası çift üzerinde yinelenir ve toplamı 10000 olan birini seçer.

C=->n{(0..49).map{|i|([n[0...i%5],i/5,n[i%5..-1]]*'').to_i}}
->(a,b){C[a].product(C[b]).select{|i,j|i+j==1e4}}

Çevrimiçi deneyin!

05AB1E (eski) , 36 bayt

0ìε.œʒg3‹}εU9ÝεXDgiìësý}}}˜}`âʒOT4mQ

Hiç şüphesiz büyük ölçüde golf oynanır.

Çevrimiçi deneyin ya da tüm test durumlarını doğrulayın ( êaltbilgide Uniquify & Sort (Sırala).

Açıklama:

0ì                            # Prepend a 0 before each of the input numbers
  ε                        }  # Map each to:
   .œ                         #  Take all possible partitions
     ʒg3‹}                    #  Only keep those of length 1 or 2
          ε              }    #  Map each partition to:
           U                  #   Pop and store the partition in variable `X`
            9Ý                #   List in the range [0, 9]
              ε         }     #   Map each of those digits to:
               X              #    Get the variable `X`
                Dgi           #    If it's a single number (length == 1):
                   ì          #     Prepend `X` before this digit
                  ë           #    Else (length == 2):
                   sý         #     Join both numbers in `X` with the current digit
                  }           #    Close the if-else
                          ˜   #   Flatten the list of lists
`                             # Now push both lists to the stack
 â                            # Create all possible pairs (cartesian product)
  ʒ                           # Filter this list of pairs by:
   O                          #  Take the sum of the two numbers
    T4m                       #  Push 10000 (10^4)
       Q                      #  And check if they are equal

Jöle , 25 bayt

LŻœṖ€z⁶ZjþØDVẎṢḊ)p/S⁼ȷ4ƊƇ

Çevrimiçi deneyin!

Buradaki en kısa Jelly çözümü değil, belki birileri bunu golf edebilir mi? Ben güdük