양의 정수 목록이 제공된 각 프로그램에 가장 작은 양의 정수를 곱하여 엄격하게 증가하는 목록을 작성하는 프로그램 또는 함수를 작성해야합니다.

예를 들어 입력이

5 4 12 1 3

곱셈은

5*1=5 4*2=8 12*1=12 1*13=13 3*5=15

그리고 출력은 증가하는 목록이 될 것입니다

5 8 12 13 15

입력

• 하나 이상의 요소를 포함하는 양의 정수 목록

산출

• 양의 정수 목록

예

9 => 9
1 2 => 1 2
2 1 => 2 3
7 3 => 7 9
1 1 1 1 => 1 2 3 4
5 4 12 1 3 => 5 8 12 13 15
3 3 3 8 16 => 3 6 9 16 32
6 5 4 3 2 1 => 6 10 12 15 16 17
9 4 6 6 5 78 12 88 => 9 12 18 24 25 78 84 88
8 9 41 5 12 3 5 6 => 8 9 41 45 48 51 55 60
15 8 12 47 22 15 4 66 72 15 3 4 => 15 16 24 47 66 75 76 132 144 150 153 156

이것은 코드 골프이므로 가장 짧은 프로그램이나 기능이 승리합니다.

재미있는 사실 : 입력에 대한 출력의 마지막 요소 는 시퀀스 A007952N, N-1, ... ,1 의 (N+1)th요소 인 것 같습니다 . 증명을 찾으면 골프 답변에 포함 시키거나 의견으로 게시 할 수 있습니다.

젤리 , 6 5 바이트

:‘×µ\

@Dennis가 깨어나 기 전에 첫 번째 젤리 답변 . 온라인으로 사용해보십시오!

설명

:          Integer division, m//n
 ‘         Increment, (m//n+1)
  ×        Multiply, (m//n+1)*n
   µ       Turn the previous links into a new monadic chain
    \      Accumulate on the array

-1 바이트의 @Dennis에게 감사드립니다.

자바 스크립트 (ES6), 28

편집 바와 같이 @Patrick 로버츠에 의해 제안, p초기화하고 매개 변수가 될 수 있습니다. 동일한 바이트 수이지만 전역 변수 사용을 피하십시오

(a,p)=>a.map(n=>p=n*-~(p/n))

테스트

f=(a,p)=>a.map(n=>p=n*-~(p/n))

console.log=x=>O.textContent+=x+'\n'

;[
[[9], [ 9]],
[[1, 2], [ 1, 2]],
[[2, 1], [ 2, 3]],
[[7, 3], [ 7, 9]],
[[1, 1, 1, 1], [ 1, 2, 3, 4]],
[[5, 4, 12, 1, 3], [ 5, 8, 12, 13, 15]],
[[3, 3, 3, 8, 16], [ 3, 6, 9, 16, 32]],
[[6, 5, 4, 3, 2, 1], [ 6, 10, 12, 15, 16, 17]],
[[9, 4, 6, 6, 5, 78, 12, 88], [ 9, 12, 18, 24, 25, 78, 84, 88]],
[[8, 9, 41, 5, 12, 3, 5, 6], [ 8, 9, 41, 45, 48, 51, 55, 60]],
[[15, 8, 12, 47, 22, 15, 4, 66, 72, 15, 3, 4], [ 15, 16, 24, 47, 66, 75, 76, 132, 144, 150, 153, 156]]
].forEach(t=>{
  var i=t[0],k=t[1],r=f(i),ok=(k+'')==(r+'')
  console.log(i + ' => ' + r + (ok?' OK':'FAIL expecting '+x))
})

<pre id=O></pre>

파이썬 2, 67 64 바이트

먼저 코드 골프를 시도해 보시면 유용한 정보를 얻을 수 있습니다.

def m(l):
 for x in range(1,len(l)):l[x]*=l[x-1]/l[x]+1
 print l

PHP, 55 46 42 41 바이트

ISO 8859-1 인코딩을 사용합니다.

for(;$a=$argv[++$i];)echo$l+=$a-$l%$a,~ß;

다음과 같이 실행하십시오 ( -d미학에만 추가됨).

php -d error_reporting=30709 -r 'for(;$a=$argv[++$i];)echo$l+=$a-$l%$a,~ß;' 10 10 8

• 1 바이트 thx를 Ismael Miguel에 저장했습니다.
• 플로어 대신 모듈로를 사용하여 8 바이트 절약
• 4 바이트를 Ismael Miguel에 저장함 (foreach 대신)
• ~ß공간을 생성하는 데 사용하여 바이트를 저장했습니다 .

하스켈 (30 28 25 바이트)

scanl1(\x y->y*div x y+y)

확장 버전

f :: Integral n => [n] -> [n]
f xs = scanl1 increaseOnDemand xs
 where
   increaseOnDemand :: Integral n => n -> n -> n
   increaseOnDemand acc next = next * (1 + acc `div` next)

설명

scanl1목록을 접고 모든 중간 값을 다른 목록에 누적 할 수 있습니다. 의 전문화 scanl유형은 다음과 같습니다.

scanl  :: (acc  -> elem -> acc)  -> acc -> [elem] -> [acc]
scanl1 :: (elem -> elem -> elem) ->        [elem] -> [elem]

scanl1 f (x:xs) = scanl f x xs

따라서 우리가 필요로하는 것은리스트의 마지막 요소 ( acc확장 된 버전)와 처리하고자하는 것 ( next확장 된 버전) 중 2 개를 가져 와서 적절한 숫자를 반환하는 적절한 함수입니다 .

우리는 다음 숫자를 통해 누산기를 나누고 결과를 바닥으로 만들어이 숫자를 쉽게 도출 할 수 있습니다. div처리합니다. 그 후에 1목록을 실제로 늘리고로 끝나지 않도록 추가 하기 만하면 0됩니다.

C ++, 63 60 57 바이트

void s(int*f,int*e){for(int c=*f;++f!=e;c=*f+=c/ *f**f);}

주어진 범위 내에서 작동합니다 [first, last). 원래 템플릿 변형으로 작성되었지만 더 길었습니다.

template<class T>void s(T f,T e){for(auto c=*f;++f!=e;c=*f+=c/ *f**f);}

확장 버전

template <class ForwardIterator>
void sort(ForwardIterator first, ForwardIterator last){
    auto previous = *first;

    for(++first; first != last; ++first){
        auto & current = *first;
        current += current * (current / previous);
        previous = current;
    }
}

CJam, 13 바이트

q~{\_p1$/)*}*

CJam 스타일 목록으로 입력하십시오. 출력은 줄 바꿈으로 구분됩니다.

여기에서 테스트하십시오.

설명

q~    e# Read and evaluate input.
{     e# Fold this block over the list (i.e. "foreach except first")...
  \   e#   Swap with previous value.
  _p  e#   Duplicate and print previous value.
  1$  e#   Copy current value.
  /   e#   Integer division.
  )*  e#   Increment and multiply current value by the result.
}*

최종 값은 스택에 남고 마지막에 자동으로 인쇄됩니다.

수학, 36 32 바이트

 #2(Floor[#1/#2]+1)&~FoldList~#&

테스트

#2(Floor[#1/#2]+1)&~FoldList~#& /@ {{5, 4, 12, 1, 3}, 
   {15, 8, 12, 47, 22, 15, 4, 66, 72, 15, 3, 4}}
(* {{5, 8, 12, 13, 15}, {15, 16, 24, 47, 66, 75, 76, 132, 144, 
  150, 153, 156}} *)

펄, 17 + 3 = 20 바이트

$p=$_*=$==1+$p/$_

요구 사항 -p및 -l플래그 :

$ perl -ple'$p=$_*=$==1+$p/$_' <<< $'15\n8\n12\n47\n22\n15\n4\n66\n72\n15\n3\n4'
15
16
24
47
66
75
76
132
144
150
153
156

설명:

# '-p' reads each line into $_ and auto print
# '-l' chomp off newline on input and also inserts a new line when printing
# When assigning a number to `$=` it will automatic be truncated to an integer
# * Added newlines for each assignment 
$p=
  $_*=
    $==
      1+$p/$_

파이썬 (3.5), 63 62 바이트

def f(a):
 r=[0]
 for i in a:r+=i*(r[-1]//i+1),
 return r[1:]

테스트

>>> print('\n'.join([str(i)+' => '+str(f(i)) for i in [[9],[1,2],[2,1],[7,3],[1,1,1,1],[5,4,12,1,3],[3,3,3,8,16],[6,5,4,3,2,1],[9,4,6,6,5,78,12,88],[8,9,41,5,12,3,5,6],[15,8,12,47,22,15,4,66,72,15,3,4]]]))
[9] => [9]
[1, 2] => [1, 2]
[2, 1] => [2, 3]
[7, 3] => [7, 9]
[1, 1, 1, 1] => [1, 2, 3, 4]
[5, 4, 12, 1, 3] => [5, 8, 12, 13, 15]
[3, 3, 3, 8, 16] => [3, 6, 9, 16, 32]
[6, 5, 4, 3, 2, 1] => [6, 10, 12, 15, 16, 17]
[9, 4, 6, 6, 5, 78, 12, 88] => [9, 12, 18, 24, 25, 78, 84, 88]
[8, 9, 41, 5, 12, 3, 5, 6] => [8, 9, 41, 45, 48, 51, 55, 60]
[15, 8, 12, 47, 22, 15, 4, 66, 72, 15, 3, 4] => [15, 16, 24, 47, 66, 75, 76, 132, 144, 150, 153, 156]

이전 솔루션

일부 재귀 솔루션이지만 더 큽니다.

(68 bytes) f=lambda a,i=0:[i,*f(a[1:],a[0]*(i//a[0]+1))][i==0:]if a!=[]else[i]
(64 bytes) f=lambda a,i=0:a>[]and[i,*f(a[1:],a[0]*(i//a[0]+1))][i<1:]or[i]

Brachylog , 12 바이트

{≤.;?%0∧}ᵐ<₁

각 변수에 숫자를 곱하기 위해 충분히 노력하면 0이나 1이 아닌 2를 곱할 때 시작됩니다. 그러나 다른 Brachylog 구현을 능가합니다.

설명

{       }ᵐ          --  Map each number
 ≤.                 --      to a number greater or equal to the original
  .;?%0             --      and a multiple of the original
       ∧            --      no more constraints
          <₁        --  so that the list is strictly increasing

온라인으로 사용해보십시오!

Brachylog , 54 바이트

:_{h_.|[L:T],LhH,(T_,IH;0:$Ie*H=:T>I),Lb:I:1&:[I]rc.}.

설명

:_{...}.                § Call sub-predicate 1 with [Input, []] as input. Unify its output
                        § with the output of the main predicate


§ Sub-predicate 1

h_.                     § If the first element of the input is an empty list, unify the
                        § output with the empty list
|                       § Else
[L:T],LhH,              § Input = [L,T], first element of L is H
    (T_,IH              §     If T is the empty list, I = H
    ;                   §     Else
    0:$Ie*H=:T>I),      §     Enumerate integers between 0 and +inf, stop and unify the
                        §     enumerated integer with I only if I*H > T
Lb:I:1&                 § Call sub-predicate 1 with input [L minus its first element, I]
:[I]rc.                 § Unify the output of the sub-predicate with
                        § [I|Output of the recursive call]

피스, 11

t.u*Yh/NYQ0

테스트 스위트

으로 시작하는 모든 중간 값을 반환하는 누적 축소를 수행합니다 0. 입력에 양의 정수만 포함되어 있기 때문에 괜찮습니다. 각 단계에서 이전 값을 가져 와서 새 값으로 나누고 추가 1한 다음 새 값을 곱합니다.

C, 79 바이트

p;main(x,v)char**v;{for(;*++v;printf("%d ",p=((x+p-1)/x+!(p%x))*x))x=atoi(*v);}

언 골프

p; /* previous value */

main(x,v) char**v;
{
    /* While arguments, print out x such that x[i] > x[i-1] */
    for(;*++v; printf("%d ", p = ((x+p-1)/x + !(p%x)) * x))
        x = atoi(*v);
}

PowerShell, 26 바이트

$args[0]|%{($l+=$_-$l%$_)}

> .\sort-by-multiplying.ps1 @(6,5,4,3,2,1)via 등의 명시 적 배열로 입력 을 $args[0]받습니다.

우리는 그런 다음 그것을 |%{...}반복하고 각 반복은 마술을 수행 합니다 . 아니, 그냥 농담, 우리는 다른 답변 (나는 그것을 발견하기 때문에 소품 @aross하는 것과 같은 모듈로 트릭 사용 이 첫 번째).

캡슐화 패런 (...)은 수학 연산의 결과가 파이프 라인에 배치되어 출력되도록합니다. 우리가 그것들을 남겨두면, $l실행이 끝난 후 변수가 가비지 수집 되므로 아무것도 출력되지 않습니다 .

예

PS C:\Tools\Scripts\golfing> .\sort-by-multiplying.ps1 @(8,9,1,5,4)
8
9
10
15
16

apt, 11 바이트

Uå@Y*-~(X/Y

온라인으로 테스트하십시오!

작동 원리

          // Implicit: U = input array of integers
Uå@       // Cumulative reduce: map each previous value X and current value Y to:
-~(X/Y    //  floor(X/Y+1).
          // Implicit: output last expression

05AB1E , 11 바이트

암호:

R`[=sŽDŠ/ò*

온라인으로 사용해보십시오!

설명:

R            # Reverse input
 `           # Flatten the list
  [          # While loop
   =         # Print the last item
    s        # Swap the last two items
     Ž       # If the stack is empty, break
      D      # Duplicate top of the stack
       Š     # Pop a,b,c and push c,a,b
        /    # Divide a / b
         ò   # Inclusive round up
          *  # Multiply the last two items

CP-1252 인코딩을 사용합니다.

Minkolang 0.15 , 17 바이트

nd1+?.z0c:1+*d$zN

여기 사용해보십시오!

설명

nd                   Take number from input and duplicate it
  1+                 Add 1
    ?.               Stop if top of stack is 0 (i.e., when n => -1 because input is empty).
      z              Push value from register
       0c            Copy first item on stack
         :           Pop b,a and push a//b
          1+         Add 1
            *        Multiply
             d$z     Duplicate and store in register
                N    Output as number

기본적으로 레지스터는 오름차순 목록의 최신 멤버를 유지하며 입력으로 나누고 다음 멤버의 승수를 얻기 위해 증가합니다. Minkolang 코드 필드의 토 로이드 형 기능은 필요 ()하거나 []반복 하지 않고 수평으로 반복한다는 의미입니다 .

Brachylog , 21 바이트

l~lCℕ₁ᵐ≤ᵛ~+?&;Cz≜×ᵐ<₁

온라인으로 사용해보십시오!

입력 값의 합 을 계수 C 의 상한 으로 사용합니다 . 5 또는 6을 초과하는 입력 목록 길이 (값의 합에 따라)에 대해 TIO에서 시간이 너무 느립니다. 그러나 시간이 걸리지 않도록 작은 값을 가진 최대 3 개의 요소 목록이 필요한 원래 버전보다 느리지 않습니다.

21 바이트

l~l.&+^₂⟦₁⊇.;?z/ᵐℕ₁ᵐ∧

온라인으로 사용해보십시오!

C (gcc) , 37 바이트

o(int*_){for(;*++_;)*_*=_[~0]/ *_+1;}

온라인으로 사용해보십시오!

파이썬 2 , 53 바이트

lambda a:reduce(lambda b,v:b+[b[-1]/v*v+v],a,[0])[1:]

온라인으로 사용해보십시오!

k*x>y암시 k>y/x; 가장 작은 k수는 k=floor(y/x)+1입니다. 파이썬 2.7부터 정수 나누기는 이미 floor, 우리는 k=y/x+1, 및 으로 간주됩니다 k*x = (y/x+1)*x = y/x*x+x.

Oracle SQL 11.2, 210 바이트

WITH v AS(SELECT TO_NUMBER(COLUMN_VALUE)a,rownum i FROM XMLTABLE(('"'||REPLACE(:1,' ','","')||'"'))),c(p,n)AS(SELECT a,2 FROM v WHERE i=1UNION ALL SELECT a*CEIL((p+.1)/a),n+1 FROM c,v WHERE i=n)SELECT p FROM c;

언 골프

WITH v AS                                           
(
  SELECT TO_NUMBER(COLUMN_VALUE)a, rownum i            -- Convert the input string into rows 
  FROM   XMLTABLE(('"'||REPLACE(:1,' ','","')||'"'))   -- using space as the separator between elements
)
, c(p,n) AS                        
(
  SELECT a, 2 FROM v WHERE i=1                         -- Initialize the recursive view
  UNION ALL 
  SELECT a*CEIL((p+.1)/a),n+1 FROM c,v WHERE i=n       -- Compute the value for the nth element
)
SELECT p FROM c;

Chez Scheme (140 바이트)

골프 버전 :

(define(f l)(define(g l p m)(cond((null? l)l)((<(*(car l)m)(+ p 1))(g l p(+ m 1)))(else(cons(*(car l)m)(g(cdr l)(* m(car l))1)))))(g l 0 1))

언 골프 버전 :

(define(f l)
  (define(g l p m)
    (cond
      ((null? l) l)
      ((< (* (car l) m) (+ p 1)) (g l p (+ m 1)))
      (else (cons (* (car l) m) (g (cdr l) (* m (car l)) 1)))
    )
  )
  (g l 0 1)
)

온라인으로 사용해보십시오!

K (oK) , 11 바이트

{y*1+_x%y}\

온라인으로 사용해보십시오!