Thử thách

Mark là một sinh viên nhận được Nđiểm của mình theo cách nối liền trong một dòng duy nhất.

Thách thức là để tách các nhãn hiệu của mình, biết rằng mỗi dấu chỉ có thể là 0hay 1hay 2hay 3hay 4hay 5hay6 hay 7hay 8hay 9hay 10.

Đầu vào

N số tự nhiên và một dòng.

Đầu ra

Một tập hợp các số tự nhiên.

Thí dụ

N, One line------------------> Set of marks
3, '843'---------------------> [8, 4, 3]
1, '0'-----------------------> [0]
2, '1010'--------------------> [10,10]
3, '1010'--------------------> [1,0,10] or [10,1,0] 
4, '1010'--------------------> [1,0,1,0]
9, '23104441070'-------------> [2, 3, 10, 4, 4, 4, 10, 7, 0]
12,'499102102121103'---------> [4, 9, 9, 10, 2, 10, 2, 1, 2, 1, 10, 3]
5, '71061'-------------------> [7, 1, 0, 6, 1]
11,'476565010684'------------> [4, 7, 6, 5, 6, 5, 0, 10, 6, 8, 4]
4, '1306'--------------------> [1, 3, 0, 6]
9, '51026221084'-------------> [5, 10, 2, 6, 2, 2, 10, 8, 4]
14,'851089085685524'---------> [8, 5, 10, 8, 9, 0, 8, 5, 6, 8, 5, 5, 2, 4]
11,'110840867780'------------> [1, 10, 8, 4, 0, 8, 6, 7, 7, 8, 0]
9, '4359893510'--------------> [4, 3, 5, 9, 8, 9, 3, 5, 10]
7, '99153710'----------------> [9, 9, 1, 5, 3, 7, 10]
14,'886171092313495'---------> [8, 8, 6, 1, 7, 10, 9, 2, 3, 1, 3, 4, 9, 5]
2, '44'----------------------> [4, 4]
4, '9386'--------------------> [9, 3, 8, 6]

Quy tắc

• Khi một số đầu ra có thể chỉ cung cấp một đầu ra.
• Chỉ đánh dấu giá trị 10 là trên hai số thập phân, số khác là trên một số thập phân.
• Đầu vào và đầu ra có thể được cung cấp ở bất kỳ định dạng thuận tiện
• Không cần xử lý đầu vào không hợp lệ
• Một chương trình đầy đủ hoặc một chức năng được chấp nhận. Nếu một chức năng, bạn có thể trả lại đầu ra thay vì in nó.
• Nếu có thể, vui lòng bao gồm một liên kết đến một môi trường thử nghiệm trực tuyến để người khác có thể thử mã của bạn!
• Sơ hở tiêu chuẩn bị cấm.
• Đây là môn đánh gôn để áp dụng tất cả các quy tắc chơi golf thông thường và mã ngắn nhất (tính bằng byte) sẽ thắng.

Brachylog , 23 21 byte

-2 byte nhờ Fatalize

h~c.{ịℕ≤10&ịṫ?∧}ᵛ&t~l

Hãy thử trực tuyến!

Đầu vào là một cặp [Line, N] .

Đây là chương trình Brachylog đầu tiên của tôi, vì vậy có lẽ có rất nhiều chỗ để cải thiện.

Nó rất chậm khi độ dài của dòng> 7.

Giải trình:

h~c.{ịℕ≤10&ịṫ?∧}ᵛ&t~l
h                         The first element in the input
 ~c                       is formed by concatenating
   .                      the elements in the output array
   .{         ∧}ᵛ     AND For every element in the output array holds that
     ị                      The element converted to an integer
      ℕ                       is a natural number
       ≤10                    and less than or equal to 10
          &ịṫ?              and it has no leading zeroes (*)
                 &t   AND The second element of the input
                   ~l     is the length of the output 

(*) ịṫ?kiểm tra rằng không có số 0 đứng đầu. Nó chuyển đổi chuỗi thành số nguyên và sau đó trở lại chuỗi và so sánh với chuỗi ban đầu.

Perl 6 , 25 byte

->\a,\b{b~~/(10|.)**{a}/}

Hãy thử trực tuyến!

Khối mã ẩn danh lấy một số và một chuỗi và trả về làm đối tượng Khớp.

Giải trình:

->\a,\b{                }  # Anonymous code block taking params a and b
        b~~/           /   # Match using b
            (10|.)           # 10 or a single digit
                  **{a}      # Exactly a times, being greedy

Python 3 , 47 byte

lambda s,n:[*s.replace(b'\1\0',b'\n',len(s)-n)]

Hãy thử trực tuyến!

Lấy "một dòng" làm dấu phụ với các byte thô \x00 - \x09. Nếu nó không được chấp nhận:

Python 3 , 56 byte

lambda s,n:[x-48for x in s.replace(b'10',b':',len(s)-n)]

Hãy thử trực tuyến!

Mất "một dòng" là tạm biệt.

V , 17 , 12 byte

\ÓòÀGjí1“î…0

Hãy thử trực tuyến!

Tôi hài lòng với 17 byte, nhưng hơn 05AB1E đi kèm với 13 byte và tôi không thể để một thách thức không được trả lời. : D

\Ó                      " Put each character on it's own line
  ò                     " Recursively (repeat until an error happens)...
   ÀG                   "   Go to the "n"th line
     j                  "   Move down a line (this will error if there are exactly "n" lines)
      í                 "   Remove...
       1                "     a '1'
        <0x93>          "     START THE MATCH HERE
              î         "     a newline
               <0x85>   "     END THE MATCH HERE
                   0    "     a '0'

Hexdump:

00000000: 5cd3 f2c0 476a ed31 93ee 8530            \...Gj.1...0

Giải pháp thay thế:

\ÓòÀGjç1î0/J

Thật không may, điều này thay thế 10bằng1 0

Ruby , 57 byte

->n,m{m.sub!"10",?A while m[n];m.chars.map{|c|c.to_i 16}}

Hãy thử trực tuyến!

Đây có thể không phải là cách tiếp cận golf nhất, nhưng có vẻ như đó là một ý tưởng thú vị để tạm thời thay thế 10cho một hình lục giác A, điều này cũng là một điểm cao (nếu chúng tôi xem xét hệ thống phân loại AF :))

Haskell , 68 byte

n!('1':'0':x)|n-2<length x=10:(n-1)!x
n!(s:x)=read[s]:(n-1)!x
n!_=[]

Hãy thử trực tuyến!

Tham lam mất 10 giây miễn là có nhiều chữ số hơn các dấu còn lại.

JavaScript, 57 52 byte

n=>g=s=>s[n]?g(s.replace(x=10,`x`)):[...s].map(eval)

Dùng thử trực tuyến

Trăn 3 , 71 68 59 byte

giảm thêm 9 byte nhờ vào ovs.

lambda n,s:[int(c,11)for c in s.replace('10','a',len(s)-n)]

Hãy thử trực tuyến!

Tôi đã cố gắng sử dụng str.partition()đệ quy một cách vô thức, nhưng sử dụng replacetôi đã đánh vào mặt tôi không lâu sau đó. Bất cứ ai có thể cải thiện về điều này?

Ngoài ra, đây là một liên kết TIO mà tôi đã sử dụng để biến các trường hợp thử nghiệm thành một bản sao / dán nhiều hơn

Haskell , 98 byte

n!x=[y|y<-s x,y==take n y]!!0
s('1':'0':x)=do y<-s x;[1:0:y,10:y]
s(x:y)=(read[x]:)<$>s y
s _=[[]]

Hãy thử trực tuyến hoặc kiểm tra tất cả!

Giải trình

Hàm sthực hiện tất cả các phân tách có thể, ví dụ: "1010"trở thành [[1,0,1,0],[10,1,0],[1,0,10],[10,10]], lưu ý cách phân chia dài nhất kết thúc ở đầu (vì 1:0:yđến trước10:y ).

Với ý nghĩ đó, chúng ta có thể lấy tất cả các giá trị này và lọc yra những nơi y == take n ygiữ các phần tách ngắn hơn yêu cầu. Ví dụ với4 chúng tôi để lại danh sách giống nhau[[1,0,1,0],[10,1,0],[1,0,10],[10,10]] .

Bây giờ chúng ta chỉ có thể lấy phần tử đầu tiên trong danh sách đó vì các đầu vào sẽ luôn hợp lệ (ví dụ: 5!"1010"cũng sẽ cung cấp [1,0,1,0], nhưng chúng ta không cần phải xử lý nó).

Lưu ý: Tôi bằng cách nào đó đã nhầm lẫn .. y==take n ycó cùng độ dài với length y==n: S

Perl 5 -plF , 39 byte

$a=<>;$_="@F";s/1 0/10/ while$a-1<y/ //

Hãy thử trực tuyến!

Sạch , 128 byte

import StdEnv
@[]=[[]]
@['10':t]=[u++v\\u<-[[10],[1,0]],v<- @t];@[h:t]=[[digitToInt h:v]\\v<- @t]
?n l=hd[e\\e<- @l|length e==n]

Hãy thử trực tuyến!

05AB1E , 13 byte

.œsù.ΔïTÝÃJ¹Q

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

Giải trình

.œ              # partitions of the first input
  sù            # of a length equal to the second input
    .Δ          # find the first partition that returns true when:
      ï         # each element is converted to integer
       TÝÃ      # and only numbers in [0 ... 10] are kept
          J     # then join it together
           ¹Q   # and compare it to the first input for equality

JavaScript (Nút Babel) ,  70 69  59 byte

Đưa đầu vào là (n)(line).

n=>s=>(a=s.match(/10|./g)).flatMap(x=>x>9&&!a[--n]?[1,0]:x)

Hãy thử trực tuyến!

Đã bình luận

n => s =>                       // given n and s
  (a = s.match(/10|./g))        // split s into marks; a '1' followed by a '0' is always
                                // interpreted as '10'
  .flatMap(x =>                 // for each mark x:
    x > 9 &&                    //   if x = '10',
    !a[--n] ?                   //   then decrement n; if a[n] is undefined:
      [1, 0]                    //     yield [1, 0]
    :                           //   else:
      x                         //     yield the mark unchanged
  )                             // end of flatMap()

JavaScript (ES6),  64  59 byte

Đã lưu 5 byte nhờ @ guest271314

Đưa đầu vào là (n)(line).

n=>g=([...s])=>1/s[n]?g(eval(`[${s}]`.replace('1,0',10))):s

Hãy thử trực tuyến!

Đã bình luận

n =>                            // main function, taking n
  g = ([...s]) =>               // g = recursive function, taking s
                                //     (which is either a string or an array)
    1 / s[n] ?                  // if s[n] is defined (i.e. we have too many marks):
      g(                        //   do a recursive call to g:
        eval(                   //     build a new array by evaluating ...
          `[${s}]`              //       ... the string representation of s[] where the
          .replace('1,0', 10)   //       first occurrence of '1,0' is replaced with '10'
        )                       //     end of eval()
      )                         //   end of recursive call
    :                           // else:
      s                         //   return s

Java (OpenJDK 8) , 78 byte

Một lớp lót đẹp bằng cách sử dụng API stream.

(n,l)->l.join(":",l.split("10",l.length()-n+1)).chars().map(i->i-48).toArray()

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

(n,l)->                     // Lambda function taking int and string
  l.join(":",               // Join the following array with colons
    l.split("10",           // Split the original string on "10"...
      l.length()-n+1))      // But limit the parts to the difference between the length
                            // and expected length, to only remove  required number of 10s              
  .chars()                  // Convert to an intstream of codepoints
  .map(i->i-48)             // Remove 48 to get the numeric value of each codepoint
  .toArray()                // Return an int array

R , 63 byte

Mặc dù độ dài của chuỗi lớn hơn n, thay thế 10 tiếp theo bạn đạt được ":"(ký tự ASCII sau 9). Sau đó chia thành các số bằng cách lấy giá trị ASCII của mỗi char trong chuỗi.

function(n,x){while(nchar(x)>n)x=sub(10,":",x);utf8ToInt(x)-48}

Hãy thử trực tuyến!

Màu đỏ , 91 byte

func[n s][while[n < length? s][replace s"10""a"]foreach c s[prin[either c =#"a"[10][c]""]]]

Hãy thử trực tuyến!

Thạch , 18 byte

Ḍ⁵⁻ƊƝr1ŒpS‘⁼ɗƇḢk⁸Ḍ

Hãy thử trực tuyến!