Đây là câu hỏi đầu tiên của tôi, vì vậy tôi hy vọng nó diễn ra tốt đẹp.

Lý lịch:

Đó không phải là những dòng sông mà bạn có thể nghĩ đến. Câu hỏi xoay quanh khái niệm sông kỹ thuật số. Một dòng sông kỹ thuật số là một chuỗi các số mà số sau đây nlà ncộng tổng các chữ số của nó.

Giải trình:

12345 được theo sau bởi 12360 kể từ 1 + 2 + 3 + 4 + 5 = 15 và do đó 12345 + 15 cho 12360. tương tự 145 được theo sau bởi 155. Nếu số đầu tiên của một dòng sông kỹ thuật số, Mchúng ta sẽ gọi nó là sông M.

Ví dụ: Sông 480 là dãy bắt đầu {480,492,506,519 ....} và sông 483 là dãy bắt đầu {483,498,519, ....}. Các dòng sông và sông thông thường có thể gặp nhau, và điều tương tự cũng đúng với các dòng sông kỹ thuật số. Điều này xảy ra khi hai con sông kỹ thuật số chia sẻ một số giá trị giống nhau.

Thí dụ:

Sông 480 gặp sông 483 ở 519. Sông 480 gặp sông 507 ở 507 và không bao giờ gặp sông 480. Mỗi dòng sông kỹ thuật số cuối cùng sẽ gặp sông 1, sông 3 hoặc sông 9.

Viết chương trình có thể xác định cho một số nguyên cho trước ngiá trị nơi sông nlần đầu tiên gặp một trong ba con sông này.

Đầu vào

Đầu vào có thể chứa nhiều trường hợp thử nghiệm. Mỗi trường hợp thử nghiệm chiếm một dòng riêng và chứa một số nguyên n( 1 <= n <= 16384). Một trường hợp thử nghiệm có giá trị 0cho nchấm dứt đầu vào và kiểm tra trường hợp này phải không được xử lý.

Đầu ra

Đối với mỗi trường hợp thử nghiệm trong đầu ra đầu tiên, số trường hợp thử nghiệm (bắt đầu từ 1) như được hiển thị trong đầu ra mẫu. Sau đó, trên một dòng đầu ra riêng biệt, dòng "đầu tiên gặp sông x tại y". Ở đây y là giá trị thấp nhất trong đó sông nlần đầu tiên gặp sông x(x = 1 hoặc 3 hoặc 9). Nếu sông ngặp sông xở ynhiều hơn một giá trị x, xuất giá trị thấp nhất. In một dòng trống giữa hai trường hợp thử nghiệm liên tiếp.

Trường hợp thử nghiệm

Đầu vào:

86
12345
0

Đầu ra:

Case #1

first meets river 1 at 101

Case #2

first meets river 3 at 12423

Ghi điểm:

Thuật toán nhanh nhất chiến thắng. Trong trường hợp cà vạt. Người nào có mã ngắn hơn sẽ thắng.

Cảm ơn mbomb007 đã chỉ ra lỗi của tôi.

ps: Tôi muốn có giải pháp nhanh nhất chứ không phải giải pháp nhỏ nhất. Tôi cũng có một giải pháp của tôi là chậm. Đối với cái nhìn ở đây .

Ghi chú:

Tôi sẽ sử dụng điều này để kiểm tra mã. Và kiểm tra hiệu suất.

C, 320 294 byte

Biên dịch với -std = c99

#include<stdio.h>
int s(int i){for(int j=i;j;j/=10)i+=j%10;return i;}int main(){int c=0,i;while(scanf("%d",&i)){c++;if(!i)continue;int j,o[]={1,3,9},p[]={1,3,9};Q:for(j=0;j<3;j++){if(o[j]==i)goto D;else if(o[j]<i){o[j]=s(o[j]);goto Q;}}i=s(i);goto Q;D:printf("Case #%d\n\nfirst meets river %d at %d\n\n",c,p[j],o[j]);}}

Ung dung:

#include <stdio.h>

int s(int i)
{
    for(int j = i; j; j /= 10)
        i += j % 10;
    return i;
}

int main()
{
    int c = 0, i;
    while(scanf("%d", &i))
    {
        c++;
        if(!i)
            continue;
        int j,o[]={1,3,9},p[]={1,3,9};
        Q: for(j = 0; j < 3; j++)
        {
            if(o[j] == i)
                goto D;
            else if(o[j] < i)
            {
                o[j] = s(o[j]);
                goto Q;
            }
        }
        i = s(i);
        goto Q;
        D: printf("Case #%d\n\nfirst meets river %d at %d\n\n", c, p[j], o[j]);
    }
}

Hãy thử nó!

Về cơ bản, các dòng sông "mục tiêu" được tăng lên cho đến khi chúng lớn hơn dòng sông mà chúng tôi đang thử nghiệm và sau đó, dòng sông thử nghiệm được tăng lên. Điều này được lặp lại cho đến khi dòng sông thử nghiệm bằng với một số dòng sông khác.

Tôi không đọc các tham số từ dòng lệnh trong chương trình này và tôi không chắc liệu bạn có phải không. Bây giờ bạn có thể truyền tham số cho STDIN. Bạn có thể chấm dứt bằng cách chuyển một đầu vào không phải là số.

_{Cũng chết tiệt, bị đánh bởi nửa giờ.}

JavaScript (ES6)

Đây là một câu trả lời khá nhanh bằng cách sử dụng một ngôn ngữ khá chậm. Thực sự, thời gian thực hiện không phải là vấn đề khi sử dụng bất kỳ ngôn ngữ nào với bảng băm. Tất cả các bài kiểm tra của tôi dưới 100 ms.

Phương thức ẩn danh với danh sách trường hợp thử nghiệm làm tham số đầu vào.

F=cases=>{
  var t0 = +new Date
  var result = 0
  var spots = []
  var top=[,1,3,,9]
  var rivers=[,1,3,1,9,1,3,1]
  cases.forEach((n,i)=>{
    var found = result = spots[n]
    for (;!found;)
    {
      found = top.some((v,i)=>{
        for(;spots[v] |= i, v<n; top[i] = v)
          [...v+''].forEach(d=>v-=-d)
        return result = v-n ? 0 : i;
      }) || (
        [...n+''].forEach(d=>n-=-d),
        result = spots[n]
      )
    }  
    console.log(`Case #${i+1}\nfirst meets river ${rivers[result]} at ${n}`)
  })  
  return 'Time (ms) ' + (new Date-t0)
}  

console.log(F([86, 12345, 123, 456, 789, 16384]))

Java 7, 519 505 byte

import java.util.*;String c(int i){if(i<=0)return"";ArrayList<Long>r=f(1),s=f(3),t=f(9),x=f(i);String z="first meets river ";for(int j=0;j<r.size();j++){long u=r.get(j),v=s.get(j),w=t.get(j);if(x.contains(u))return z+1+" at "+u;if(x.contains(v))return z+3+" at "+v;if(x.contains(w))return z+9+" at "+w;}return"";}ArrayList f(long i){ArrayList<Long>l=new ArrayList();l.add(i);for(long j=0,x;j<9e4;j++){x=l.get(l.size()-1);for(char c:(x+"").toCharArray())x+=new Long(c+"");l.add(x);if(x>16383)return l;}return l;}

Vâng, nó dài, xấu và không nghi ngờ gì có thể được thay đổi hoàn toàn thành môn đánh gôn nhiều hơn .. Tôi vừa mất tập trung vừa mệt mỏi, vì vậy có lẽ tôi nên xóa nó một lần nữa ..
Thành thật là một thử thách khá khó khăn. . Nhưng ít nhất bạn có câu trả lời đầu tiên của mình ..;) (Điều này thậm chí có thể dài hơn chương trình C ++ không được ban đầu của bạn .. xD)

Các trường hợp bất khả kháng & thử nghiệm:

Hãy thử nó ở đây.

import java.util.*;
class M{
  static String c(int i){
    if(i <= 0){
      return "";
    }
    ArrayList<Long> r = f(1),
                    s = f(3),
                    t = f(9),
                    x = f(i);
    String z = "first meets river ",
           y = " at ";
    for(int j = 0; j < r.size(); j++){
      long u = r.get(j),
           v = s.get(j),
           w = t.get(j);
      if(x.contains(u)){
        return z+1+y+u;
      }
      if(x.contains(v)){
        return z+3+y+v;
      }
      if(x.contains(w)){
        return z+9+y+w;
      }
    }
    return "";
  }

  static ArrayList f(long i){
    ArrayList<Long> l = new ArrayList();
    l.add(i);
    for(long j = 0, x; j < 9e4; j++){
      x = l.get(l.size() - 1);
      for(char c : (x + "").toCharArray()){
        x += new Long(c+"");
      }
      l.add(x);
      if(x > 16383){
        return l;
      }
    }
    return l;
  }

  public static void main(String[] a){
    System.out.println(c(86));
    System.out.println(c(12345));
    System.out.println(c(0));
  }
}

Đầu ra:

first meets river 1 at 101
first meets river 3 at 12423
(empty output)

Scala, 774 byte

Fiddle: http://scalafiddle.net/console/4ec96ef90786e0f2d9f7b61b5ab0209b

Tôi không cảm thấy thích chơi gôn. Nó tìm ra giải pháp cho vấn đề đặt ra trong vòng 50ms

Cách sử dụng có thể không chính xác như bạn muốn:

scala river.scala

Bây giờ bạn có thể liên tục nhập số theo sau là một nhập. Và kết thúc chương trình với 0. Kết quả sẽ được in ngay khi bạn nhấn enter.

io.Source.stdin.getLines.map(_.toInt)
  .takeWhile(_ != 0)
  .map(stream(_).takeWhile(_ < 16383))
  .zipWithIndex
  .map { cur =>
    Seq(1, 3, 9).map { i =>
      val s = stream(i).takeWhile(_ < 16383)
      (cur._2+1, i, s.intersect(cur._1).headOption)
    }
  }.foreach { opts =>
    val options = opts.filterNot(_._3.isEmpty)

    if(options.isEmpty) {
      println("No result")
    } else {
      val opt = options(0)
      println(s"Case #${opt._1}\n\nfirst meets ${opt._2} at ${opt._3.get}\n\n")
    }
  }

def stream(i:Int): Stream[Int] = {
  def sub: Int => Stream[Int] = {
    i => i #:: sub(a(i))
  }
  sub(i)
}

def a(i:Int): Int = i + i.toString.map{_.asDigit}.sum

C, 228 283 300 byte

Đây là một bản sửa đổi mã của Yakov để tận dụng các mẫu sông. Điều này làm cho nó nhanh hơn gấp 3 lần. Ngoài ra, các số nguyên không dấu tránh cltodhình phạt trên các máy 64 bit, do đó, nó dài hơn một vài byte nhưng nhanh hơn một chút.

#define sum(z) for(y=z;y;y/=10)z+=y%10;
n,x;main(){unsigned i,j,y;while(scanf("%d",&i)){if(i){j=x=1+!(i%3)*2+!(i%9)*6;do{while(j<i)sum(j)}while(j^i&&({sum(i)i;}));printf("Case #%u\n\nfirst meets river %u at %u\n\n",++n,x,i);}}}

Ung dung:

#define sum(z) for(y=z;y;y/=10)z+=y%10;
n, x;
main() {
    unsigned i, j, y;
    while(scanf("%d", &i)) {
        if(i){
            j = x = 1 + !(i%3)*2 + !(i%9)*6;
            do{
                while (j < i) sum(j)
            }
            while(j^i&&({sum(i)i;}));
            printf("Case #%u\n\nfirst meets river %u at %u\n\n", ++n, x, i);
        }
    }
}

Giải trình:

j = x = 1 + !(i%3)*2 + !(i%9)*6;

Điều này chọn sông chính xác. Sông 1 gặp mọi con sông khác, vì vậy chúng tôi sử dụng trường hợp này như trường hợp dự phòng. Nếu 3 là ước số chung lớn nhất của sông thử nghiệm, chúng ta chọn sông 3 ( 1 + !(i%3)*2). Nếu 9 là ước số chung lớn nhất của dòng sông thử nghiệm, chúng tôi sẽ ghi đè các giá trị trước đó và chọn sông 9.

Tại sao điều này làm việc? Sông 9 đi 9, 18, 27, 36, v.v ... Đây là bước của bội số 9 mỗi lần, do đó, nó sẽ luôn là con đường ngắn nhất đến sông chị em. Mỗi lần sông 3 sẽ nhân bội số 3: 3, 6, 12, 15, 21, v.v ... Trong khi các sông có bội số 9 cũng là bội số của 3, chúng tôi chọn chúng là sông 9 trước, chỉ để lại sông bội số của 3. Phần còn lại sẽ gặp sông 1 trước: 1, 2, 4, 8, 16, 23, 28, v.v.

Khi chúng tôi đã chọn đúng dòng sông của mình, chúng tôi bước hai con sông cho đến khi chúng gặp nhau.

Python 3, 144 byte

r,a,b,c,i={int(input())},{1},{3},{9},1
while i:
  for x in r,a,b,c:t=max(x);x|={sum(int(c)for c in str(t))+t}
  if r&(a|b|c):i=print(*r&(a|b|c))

C

Rất đơn giản, nó trông có vẻ dài bởi vì tôi đã bỏ cả 3 con sông. Đầu tiên, nó tạo ra 3 con sông lên đến RIVER_LENGTH(mà tôi hy vọng là đủ lớn), và sau đó cho mỗi bước trên Nnó thực hiện tìm kiếm nhị phân trên cả ba luồng để xem nó có nằm trong bất kỳ dòng nào không. Điều này hoạt động vì các luồng đã được sắp xếp, vì vậy chúng tôi có thể thực hiện kiểm tra chứa log(n)thời gian.

#include <stdio.h>

#define RIVER_LENGTH 10000

int main() {
    int num_cases;
    scanf("%d", &num_cases);
    int cases[num_cases];
    int N;
    int s1[RIVER_LENGTH] = {1};
    int s3[RIVER_LENGTH] = {3};
    int s9[RIVER_LENGTH] = {9};
    int i;
    int temp;

    for (i = 1; i < RIVER_LENGTH; i++) {
        s1[i] = temp = s1[i-1];
        while (temp) {
            s1[i] += temp % 10;
            temp /= 10;
        }
    }

    for (i = 1; i < RIVER_LENGTH; i++) {
        s3[i] = temp = s3[i-1];
        while (temp) {
            s3[i] += temp % 10;
            temp /= 10;
        }
    }

    for (i = 1; i < RIVER_LENGTH; i++) {
        s9[i] = temp = s9[i-1];
        while (temp) {
            s9[i] += temp % 10;
            temp /= 10;
        }
    }

    int start;
    int end;
    int pivot;

    for (i=1; i <= num_cases; i++) {
        scanf("%d", &cases[i]);
    }

    for (i=1; i <= num_cases; i++) {
        printf("Case #%d\n\n", i);
        N = cases[i];

        while (1) {

            temp = N;
            while (temp) {
                N += temp % 10;
                temp /= 10;
            }

            start = 0;
            end = RIVER_LENGTH;
            pivot = 1;

            while (end != start && pivot != RIVER_LENGTH - 1) {
                pivot = start + ((end - start) >> 1);
                if (s1[pivot] == N) {
                    printf("first meets river 1 at %d\n\n", N);
                    goto case_done;
                } else if (N < s1[pivot]){
                    end = pivot;
                } else {
                    start = pivot+1;
                }
            }

            start = 0;
            end = RIVER_LENGTH;
            pivot = 1;

            while (end != start && pivot != RIVER_LENGTH - 1) {
                pivot = start + ((end - start) >> 1);
                if (s3[pivot] == N) {
                    printf("first meets river 3 at %d\n\n", N);
                    goto case_done;
                } else if (N < s3[pivot]){
                    end = pivot;
                } else {
                    start = pivot+1;
                }
            }

            start = 0;
            end = RIVER_LENGTH;
            pivot = 1;

            while (end != start && pivot != RIVER_LENGTH - 1) {
                pivot = start + ((end - start) >> 1);
                if (s9[pivot] == N) {
                    printf("first meets river 9 at %d\n\n", N);
                    goto case_done;
                } else if (N < s9[pivot]){
                    end = pivot;
                } else {
                    start = pivot+1;
                }
            }
        }

        case_done:;

    }
}

Trước tiên, phải mất một số cho số trường hợp, thay vì sử dụng 0để phân định phần cuối của đầu vào, bởi vì bạn biết, C. Điều này chỉ để thuận tiện và không thực sự ảnh hưởng đến bất cứ điều gì, vì vậy tôi hy vọng nó ổn.