Нещодавно ми досягли межі 10000 питань щодо PPCG. Ура! Відзначимо це простим викликом.

Вхідні дані

Два цілих числа $A$ і $B$ , обидва в $[1..9999]$ , такі, що $A+B<10000$ .

Завдання

Ваше завдання - додати одну однозначну цифру до одного з цих цілих чисел або одну одну цифру до обох таких, щоб $A+B=10000$ . Якщо додати цифру як до $A$ і до $B$ , вона не обов'язково повинна бути однаковою.

Нова цифра може бути додана на початку, наприкінці або в будь-якому середині початкового цілого числа. Однак ви не можете додати початковий нуль.

Приклад:

Для $A=923$ справедливі наступні перетворення:

Але ці недійсні :

Враховуючи $A=923$ і $B=72$ , можливі два варіанти:

Вихідні дані

Ви повинні надрукувати або вивести список усіх можливих рішень.

У наведеному вище прикладі очікуваний результат буде [[9238,762],[9273,727]].

Правила

• Введення / виведення можна обробити в будь-якому розумному, однозначному форматі. Замість цілих чисел можна використовувати рядки, списки цифр тощо.
• Гарантія матиме хоча б одне рішення.
• Вам дозволяється не дублювати результат. Однак було б вдячно, якщо тестовий код дедубліфікує його з деякою післяобробкою, наприклад, у розділі колонтитулу TIO.
• Це проблема з кодовим гольфом .

Тестові справи

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 байт

^{-16 байт завдяки Delfad0r (беручи дані як список, використовуючи зловживання, які нам не потрібно дедублювати -> n завжди може бути в [0,4] і використовуючи хитру комбінацію формату введення та ap)!}

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

Спробуйте в Інтернеті!

R , 96 байт

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

Спробуйте в Інтернеті!

Пояснення (невольф)

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 
  ]
}

Задамо ?в paste. Це дозволяє нам робити щось круте: a<-b?c<-dвиконує вбудовані завдання в межах pasteвиклику, які ми не могли зробити з будь-яким іншим оператором, окрім цього ?, оскільки він має нижчий пріоритет ніж <-.

Тепер, як люб'язно зазначав @JoKing, можуть бути випадки, як, наприклад, 900 10два вставки, такі як 9100 8100. Таким чином ми фільтруємо відповідність, коли кількість символів у будь-якій кількості збільшилася більш ніж на 1. Швидкий спосіб зробити це - відстань редагування Левенштейна, adist яку ми пов'язуємо +.

Pyth, 28 27 25 24 22 20 байт

fq^;4sT*FmvsmXLkdThl

Спробуйте в Інтернеті тут або перевірте всі тестові випадки тут - тестовий набір дедублює результат, попередньо натискаючи кнопку a {.

Введення - це список рядків.

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)

Редагувати 4: Збережено ще 2 байти, завдяки містеру Xcoder - vза замовчуванням векторизується, і Lвикористовується mпід ним, тому мається на увазі відображення діапазону, що робить і Uнепотрібним

Edit 3: Представлено глобальним використанням ;оператора для збереження доступу до 10 для збереження 2 байтів, завдяки FryAmTheEggman та issacg:

fq^T4sT*FmvMsmXLkdUThl

Редагувати 2: Я забув, що існує оператор суми, як неприємно ...

Редагувати 1: Попередня версія прийняла список цілих чисел як вхід, виконуючи перетворення рядків вручну, на 27 байт:

fq10000+FT*FmvMsmXLk`dUThl`

Perl 6 , 64 байти

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

Спробуйте в Інтернеті!

Це порт відповіді GB, використовуючи регулярний вираз, щоб перевірити, чи дійсні числа. Завдяки nwellnhof за перенесення його.

Стара відповідь, 127 110 , 88 байт

-22 байти завдяки nwellnhof!

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

Спробуйте в Інтернеті!

Блок анонімного коду, який бере список двох чисел і повертає список пар чисел.

Замість того, щоб міркувати із вставкою цифр, це рішення перевіряє кожну комбінацію чисел, що дорівнюють 10000, і фільтрує, що дані числа є частиною пари.

Пояснення:

->\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 байт

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}

Спробуйте в Інтернеті!

35 байтів, збережених @JayCe та @Giuseppe.

Пояснення

Допоміжна функція g отримує всі можливі вставки.

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
}

Основна функція.

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!

Я помітив після факту, що це по суті та сама логіка, що і відповідь Піта .

Рубі , 93 91 байт

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

Спробуйте в Інтернеті!

Спробуйте кожне число до 10000 і скористайтеся регулярним виразом, щоб перевірити, чи збігаються цифри.

Желе , 30 байт

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

Спробуйте в Інтернеті!

Вид незграбний, тому що желе не має вставки.

Пояснення

                                   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 байт

прекрасний приклад для функції генератора!

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";

приймає дані з аргументів командного рядка; друкує дублікати. Запустіть -nr '<code>або спробуйте в Інтернеті .

Піт, 18 байт

fqsT^;4*FsMvXLRRTT

Демонстрація , тестовий набір (тестовий набір дедублюється із ведучим {).

Вхід у вигляді списку з двох рядків.

XLRRTT: L і R виконують вкладені карти. Оскільки їх є 3, ми виконаємо потрійно вкладену карту Xфункції. У цьому випадку Xфункція вставить символ у визначене положення у рядок.

Рядок - це вхід, який неявний і розміщений першим R. Символ 0 ... 9розміщується в діапазоні , тому у нас є всі можливі вставлені цифри і розміщується символом L. Діапазон задається тим T, що імпліцитно задано 10, який неявно трактується як [0 ... 9]. Позиція знаходиться в діапазоні 0 ... 9, що достатньо, тому що вставлення цифри після 10-ї позиції ніколи не буде корисним. Дублікати результатів чудово. Діапазон розміщується другим R, а задається другим T.

v: Вкладені рядки відливання до ints.

sM: Вирівняйте списки другого рівня, залишивши нам список усіх можливих чисел після вставки цифр для кожного з вхідних чисел.

*F: Візьміть декартовий добуток із двох списків можливих чисел.

fqsT^;4: Фільтр по парам, продукт яких є 10000. ;приймає значення 10тут, Tяке використовується як змінну фільтра, і ;завжди як значення змінної, яка використовується.

Japt , 30 29 25 23 байт

Приймає вхід як масив рядків, виводить масив масивів рядків.

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

Спробуй це

Пояснення

£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 (вузол) - 183 136 123 байт

123 байт завдяки Шаггі

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

136 байт завдяки Арнольду

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

Старий кодекс

Не пишаюся цим, але подумав, що все-таки підкажу. Створює функцію прототипу рядка, схожу на карту, яка займає основну частину байтів. Функція просто повторюється через обидві перестановки і знаходить, коли 1000-ab дорівнює 0. Бере введення в якості рядків.

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

Спробуйте в Інтернеті!

Безумовно

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

Желе , 23 байти

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

Монадійне посилання, що приймає список списків цифр
(наприклад, для прикладу 923 та 72 введення [[9,2,3],[7,2]])

Спробуйте в Інтернеті! (колонтитул робить його таким, що введення / виведення - це пара з двох цілих чисел і [відформатований] список пар цілих чисел)

Або дивіться тестовий набір .

Як?

Перевіряє всі пари "чисел" (списків цифр), які нараховують дійсність до 10000, формуючи всі способи вибору цифр n-1 з цих "чисел", підтримуючи порядок; і зберігає ті, які є дійсними (якщо дійсність також дозволяє тестуваному "числу" бути рівним початковому "число").

œ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)

Стакс , 24 байти

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

Запустіть і налагоджуйте його

Ця програма приймає два входи як масив рядків, як цей.

["934", "654"]

Вугілля деревне , 33 байти

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

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Пояснення:

   χ                                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

Якщо ви цього не зрозуміли, він проходить через усі пари значень, що додають до 10000 (як рядки), а потім підраховує, скільки разів кожен вхід відповідає результату видалення до 1 символу з відповідного значення. Якщо мінімальна кількість не дорівнює нулю, то обидва входи збігаються, і це можливе рішення.

Python 3, 165 160 153 125 117 байт

• Збережено 5 байт завдяки пропозиції @JackBrounstein видалити setіз поверненого значення, оскільки вихід може містити дублікати.
• Збережено 7, замінивши range(len(s))на range(5).
• Збережено 23 байти завдяки пропозиції @Eric Duminil замінити itertoolsвкладені списки (і видалити пробіл).
• Збережено 8 завдяки пропозиції @Jo King замінити розуміння вкладеного списку одним оператором циклу та модуля.

Використання itertoolsі проста функція помічника. Приймає рядки як вхідні дані, повертає набір ints як вихід.

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}

Рубін , 110 байт

Приймає рядки як вхідні дані, повертає масив масиву цілих чисел.

На основі версії python . Для заданого цілого числа Cстворює масив чисел, який можна створити додаванням цифри.

Лямбда повторює кожну можливу пару і вибирає ту, сума якої 10000.

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}}

Спробуйте в Інтернеті!

05AB1E (спадщина) , 36 байт

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

Без сумніву, можна значно пограти в гольф. Особливо вставляючи цифри, включаючи провідні / кінцеві.

Спробуйте в Інтернеті або перевірте всі тестові випадки ( êу нижньому колонтитулі - Уніфікація та сортування).

Пояснення:

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

Желе , 25 байт

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

Спробуйте в Інтернеті!

Тут не найкоротше рішення Jelly, але, можливо, хтось може це пограти в гольф? Я спотикався