이 아이디어는 @ TùxCräftîñg의 채팅 메시지를 기반으로 합니다.

아래 예제 시퀀스를 살펴보십시오.

INVALID0, INVALID1, INVALID2 INVALID3, INVALID4...INVALID9

후에 INVALID9는 다음과 같이 진행됩니다.

INVALI0, INVALI1, INVALI2, INVALI3...INVALI9

그리고 후에 INVALI9는 다음과 같습니다.

INVAL0, INVAL1, INVAL2, INVAL3...INVAL9

다음 INVAL9과 같습니다.

INVA0, INVA1, INVA2, INVA3, ...INVA9

우리가 INVALID매번 단어에서 문자를 어떻게 제거했는지 주목하십시오 .

단일 문자, 즉 문자에 도달 할 때까지이 작업을 계속 반복합니다 I.

I0, I1, I2, I3, I4...I9

이제 과제는 단어를 입력하고 위의 예와 같이 단어를 순서대로 만드는 것입니다. 코드는 단일 문자로도 작동해야하며이 경우 결과 시퀀스가 ​​짧아집니다.

원하는대로 입력 및 출력 형식을 선택할 수 있지만 (원하는대로 구분 기호가 있거나없는) 선택한 형식을 지정해야합니다.

순서는 지정된 순서대로되어 있어야합니다.

이 문제를 성공적으로 완료 한 가장 짧은 코드 (바이트)는 문제를 해결합니다.

위 예에서 전체 순서 :

INVALID0, INVALID1, INVALID2, INVALID3, INVALID4, INVALID5, INVALID6, INVALID7, INVALID8, INVALID9, INVALI0, INVALI1, INVALI2, INVALI3, INVALI4, INVALI5, INVALI6, INVALI7, INVALI8, INVALI9, INVAL0, INVAL1, INVAL2, INVAL3, INVAL4, INVAL5, INVAL6, INVAL7, INVAL8, INVAL9, INVA0, INVA1, INVA2, INVA3, INVA4, INVA5, INVA6, INVA7, INVA8, INVA9, INV0, INV1, INV2, INV3, INV4, INV5, INV6, INV7, INV8, INV9, IN0, IN1, IN2, IN3, IN4, IN5, IN6, IN7, IN8, IN9, I0, I1, I2, I3, I4, I5, I6, I7, I8, I9

다른 예 :

입력 : MAYBE(대문자와 소문자는 중요하지 않습니다)

산출:

MAYBE0, MAYBE1, MAYBE2, MAYBE3, MAYBE4, MAYBE5, MAYBE6, MAYBE7, MAYBE8, MAYBE9, MAYB0, MAYB1, MAYB2, MAYB3, MAYB4, MAYB5, MAYB6, MAYB7, MAYB8, MAYB9, MAY0, MAY1, MAY2, MAY3, MAY4, MAY5, MAY6, MAY7, MAY8, MAY9, MA0, MA1, MA2, MA3, MA4, MA5, MA6, MA7, MA8, MA9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9

입력: AFTER

산출:

AFTER0, AFTER1, AFTER2, AFTER3, AFTER4, AFTER5, AFTER6, AFTER7, AFTER8, AFTER9, AFTE0, AFTE1, AFTE2, AFTE3, AFTE4, AFTE5, AFTE6, AFTE7, AFTE8, AFTE9, AFT0, AFT1, AFT2, AFT3, AFT4, AFT5, AFT6, AFT7, AFT8, AFT9, AF0, AF1, AF2, AF3, AF4, AF5, AF6, AF7, AF8, AF9, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9

입력: WHAT ARE YOU DOING

WHAT ARE YOU DOING0, WHAT ARE YOU DOING1, WHAT ARE YOU DOING2, WHAT ARE YOU DOING3, WHAT ARE YOU DOING4, WHAT ARE YOU DOING5, WHAT ARE YOU DOING6, WHAT ARE YOU DOING7, WHAT ARE YOU DOING8, WHAT ARE YOU DOING9, WHAT ARE YOU DOIN0, WHAT ARE YOU DOIN1, WHAT ARE YOU DOIN2, WHAT ARE YOU DOIN3, WHAT ARE YOU DOIN4, WHAT ARE YOU DOIN5, WHAT ARE YOU DOIN6, WHAT ARE YOU DOIN7, WHAT ARE YOU DOIN8, WHAT ARE YOU DOIN9, WHAT ARE YOU DOI0, WHAT ARE YOU DOI1, WHAT ARE YOU DOI2, WHAT ARE YOU DOI3, WHAT ARE YOU DOI4, WHAT ARE YOU DOI5, WHAT ARE YOU DOI6, WHAT ARE YOU DOI7, WHAT ARE YOU DOI8, WHAT ARE YOU DOI9, WHAT ARE YOU DO0, WHAT ARE YOU DO1, WHAT ARE YOU DO2, WHAT ARE YOU DO3, WHAT ARE YOU DO4, WHAT ARE YOU DO5, WHAT ARE YOU DO6, WHAT ARE YOU DO7, WHAT ARE YOU DO8, WHAT ARE YOU DO9, WHAT ARE YOU D0, WHAT ARE YOU D1, WHAT ARE YOU D2, WHAT ARE YOU D3, WHAT ARE YOU D4, WHAT ARE YOU D5, WHAT ARE YOU D6, WHAT ARE YOU D7, WHAT ARE YOU D8, WHAT ARE YOU D9, WHAT ARE YOU 0, WHAT ARE YOU 1, WHAT ARE YOU 2, WHAT ARE YOU 3, WHAT ARE YOU 4, WHAT ARE YOU 5, WHAT ARE YOU 6, WHAT ARE YOU 7, WHAT ARE YOU 8, WHAT ARE YOU 9, WHAT ARE YOU0, WHAT ARE YOU1, WHAT ARE YOU2, WHAT ARE YOU3, WHAT ARE YOU4, WHAT ARE YOU5, WHAT ARE YOU6, WHAT ARE YOU7, WHAT ARE YOU8, WHAT ARE YOU9, WHAT ARE YO0, WHAT ARE YO1, WHAT ARE YO2, WHAT ARE YO3, WHAT ARE YO4, WHAT ARE YO5, WHAT ARE YO6, WHAT ARE YO7, WHAT ARE YO8, WHAT ARE YO9, WHAT ARE Y0, WHAT ARE Y1, WHAT ARE Y2, WHAT ARE Y3, WHAT ARE Y4, WHAT ARE Y5, WHAT ARE Y6, WHAT ARE Y7, WHAT ARE Y8, WHAT ARE Y9, WHAT ARE 0, WHAT ARE 1, WHAT ARE 2, WHAT ARE 3, WHAT ARE 4, WHAT ARE 5, WHAT ARE 6, WHAT ARE 7, WHAT ARE 8, WHAT ARE 9, WHAT ARE0, WHAT ARE1, WHAT ARE2, WHAT ARE3, WHAT ARE4, WHAT ARE5, WHAT ARE6, WHAT ARE7, WHAT ARE8, WHAT ARE9, WHAT AR0, WHAT AR1, WHAT AR2, WHAT AR3, WHAT AR4, WHAT AR5, WHAT AR6, WHAT AR7, WHAT AR8, WHAT AR9, WHAT A0, WHAT A1, WHAT A2, WHAT A3, WHAT A4, WHAT A5, WHAT A6, WHAT A7, WHAT A8, WHAT A9, WHAT 0, WHAT 1, WHAT 2, WHAT 3, WHAT 4, WHAT 5, WHAT 6, WHAT 7, WHAT 8, WHAT 9, WHAT0, WHAT1, WHAT2, WHAT3, WHAT4, WHAT5, WHAT6, WHAT7, WHAT8, WHAT9, WHA0, WHA1, WHA2, WHA3, WHA4, WHA5, WHA6, WHA7, WHA8, WHA9, WH0, WH1, WH2, WH3, WH4, WH5, WH6, WH7, WH8, WH9, W0, W1, W2, W3, W4, W5, W6, W7, W8, W9

리더 보드

var QUESTION_ID=92156,OVERRIDE_USER=58717;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

젤리 , 7 바이트

ḣJṚp⁵Ḷ¤

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

작동 원리

ḣJṚp⁵Ḷ¤  Main link. Argument: s (string)

 J       Yield all (1-based) indices of s.
ḣ        Head; for each index k, take the first k characters of s.
  Ṛ      Reverse the result.
      ¤  Combine the two links to the left into a niladic chain.
    ⁵      Yield 10.
     Ḷ     Unlength; yield [0, ..., 9].
   p     Return the Cartesian product of the prefixes and the range.
         (implicit) Print the Cartesian product without separators.

05AB1E , 10 8 바이트

.pžmâ€JR

설명

.p        # get prefixes of input
  žmâ     # cartesian product with [9..0]
     €J   # join each
       R  # reverse

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

Adnan 덕분에 2 바이트 절약

자바 스크립트 (ES6), 53 47 바이트

f=(s,n=0)=>s&&s+n+f(n-9?s:s.slice(0,-1),++n%10)

Peanut & Neil 덕분에 6 바이트 절약

출력 : 모든 단어를 구분자가없는 단일 문자열로 표시합니다.

예

var f=(s,n=0)=>s&&s+n+f(n-9?s:s.slice(0,-1),++n%10)

document.getElementsByTagName('div')[0].innerHTML = f('INVALID')

<div style="word-wrap:break-word"></div>

펄, 29 바이트

에 +1 포함 -n

STDIN의 입력으로 실행 :

perl -nE '/^.+(?{map{say$&.$_}0..9})^/' <<< PERL

코드 만 :

/^.+(?{map{say$&.$_}0..9})^/

하스켈, 47 43 바이트

f""=[]
f x=map((x++).show)[0..9]++f(init x)

사용 예 : f "IN" -> ["IN0","IN1","IN2","IN3","IN4","IN5","IN6","IN7","IN8","IN9","I0","I1","I2","I3","I4","I5","I6","I7","I8","I9"].

간단한 재귀 접근. 각 숫자를 단어에 추가하고 마지막 문자가 제거 된 재귀 호출을 추가하십시오.

Pyth, 9 바이트

sM*_._QUT

STDIN에 인용 된 문자열을 입력하고 문자열 목록을 인쇄하는 프로그램입니다.

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

작동 원리

sM*_._QUT  Program. Input: Q
    ._     List of prefixes of Q
   _       Reverse
       UT  Unary range up to 10, yielding [0, 1, 2, ..., 9]
  *        Cartesian product of the above two
sM         Map concatenate over the above
           Implicitly print

핍 , 12 11 바이트

단어를 cmdline 인수로 사용합니다. 구분자가없는 출력.

Wa&Oa.,tDQa

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

설명:

             Implicit: a = 1st cmdline arg, t = 10
Wa           While a (i.e. while it's not the empty string)
   Oa.,t     Concatenate range(10) to a and output
               (Pip concatenates a string to a range itemwise)
  &          The output operation is &-ed to the loop condition to save on curly braces
        DQa  Dequeue from a, removing the final character on each iteration

V , 20 바이트

A0òYpó.10/0/e
$hòd

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

여기에는 인쇄 할 수없는 문자가 포함되어 있으므로 읽을 수있는 형식은 다음과 같습니다.

A0<esc>òYp<C-a>ó.10/0/e
$hòd

그리고 여기 hexdump가 있습니다 :

0000000: 4130 1bf2 5970 01f3 2e31 302f 302f 650a  A0..Yp...10/0/e.
0000010: 2468 f264                                $h.d

설명:

A0<esc>                 "Append a '0' to the input
       ò                "Recursively:
        Yp              "  Yank this line and paste it
          <C-a>         "  Increment the first number on this line
               ó        "  Substitute:
                .10     "    Any single character followed by '10'
                   /0   "    Replace it with a '0'
                     /e "    Ignore errors if this is not found
$h                      "  Move to the end of the end of this line than back one.
                        "  This makes it so the loop ends once there is only one
                        "  character on this line.
  ò                     "End the loop
   d                    "Delete a line (since we create one too many)  

Bash + coreutils, 54 바이트 :

for i in `seq ${#1} 1`;{ printf "${1:0:i}%s " {0..9};}

단순히 시퀀스 [Length of Input,1]를 반복하고 각 반복 중에 입력 단어 를 각 단어 의 사본 9에 [0,9]첨부 된 각 숫자와 함께 현재 반복 값의 길이로 출력합니다 9. 파일과 따옴표로 묶은 단어 내에서 실행하십시오 bash A.sh "blah blah blah".

Floroid - 50 47 31 바이트

f=Ba:aM[a+b KbIhd]+f(a[:-1])H[]

현재 @JonathanAllan이 두 번째 재귀 방법에서 사용하는 것과 유사한 방법을 사용합니다.

직교 제품을 언어로보다 신중하게 구현 한 경우이 작업이 가능했을 수 있습니다 Bc:ca([c]+[c[:-a-1]KaIw(Z(c)-1)],hd).

테스트 케이스

Input: ABC
Output: ['ABC0', 'ABC1', 'ABC2', 'ABC3', 'ABC4', 'ABC5', 'ABC6', 'ABC7', 'ABC8', 'ABC9', 'AB0', 'AB1', 'AB2', 'AB3', 'AB4', 'AB5', 'AB6', 'AB7', 'AB8', 'AB9', 'A0', 'A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7', 'A8', 'A9']

Input: M
Output: ['M0', 'M1', 'M2', 'M3', 'M4', 'M5', 'M6', 'M7', 'M8', 'M9']

(람다 보트) Haskell-49 bytes

f q=[x++show n|x<-reverse.tail$inits q,n<-[0..9]]

Lambdabot은 #haskell의 IRC 봇입니다. 자동 포함, 모듈의 무리를 가져 오는 Data.List곳이다 inits살고 있습니다. 그리고 언어는 구현에 의해 정의되기 때문에이 람다 봇 하스켈을 호출하고 가져 오기에 바이트를 지불하지 않을 수 있습니다.

정규 하스켈 :

import Data.List
f q=[x++show n|x<-reverse.tail$inits q,n<-[0..9]]

braingasm , 34 33 31 28 바이트

현재 상태에서 braingasm은 몇 가지로 추가 기능 예 : 3? )으로 합니다. 실제로 기능을 추가하는 대신 가능한 한 "엔터프라이즈"로 만드는 데 대부분의 개발 시간을 소비했습니다 ...

어쨌든 다음 코드는 최신 개발 스냅 샷과 함께 작동해야합니다. stdin 등에서 개행없는 입력을 받아 $ echo -n INVALID | braingasm invalid.bgstdout으로 인쇄합니다.

,[>,]#[48+10[#<[.>]<+]0,<0,]

설명:

,[>,]                 lay down the input on the tape
#[                    (length of input - 1) times do
  48+                   add '0' at the end of the tape
  10[                   10 times do
     #<[.>]               move to start of tape, then print the tape
     <+                   increase the number at the end of the tape
  ]                     done printing current word with 0 through 9
  0,                    erase the number by writing 0 onto it
  <0,                   likewise, remove one character
]                     done

편집 : Appearantly 그것의 확인을합니다 건너 뛸 구분 기호로 빈 문자열을 사용

파이썬 2, 53 55 바이트

+2 바이트 : 재귀와 함께 f가 필요함을 선언 함

f=lambda s:s and[s+`n`for n in range(10)]+f(s[:-1])or[]

빈 문자열로 돌아가서 (빈 목록을 생성 함) 한 번에 문자를 잘라 내고 각 문자열에 0-9의 숫자가 추가 된 10 개의 현재 문자열 목록이 앞에옵니다.

이데온 테스트

파이썬 3, 54 56 바이트

f=lambda s:s and[s+n for n in'0123456789']+f(s[:-1])or[]

이데온 테스트

스위프트 3, 150 바이트

가장 짧은 해결책은 아니지만 Swift에게는 끔찍하지 않습니다.

func a(s: String){var c=s.characters,r="";while(c.count>0){var k = "";for d in c{k+=String(d)};for i in 0...9{r+="\(k)\(i) "};c.removeLast()};print(r);}

IBM Swift Sandbox에서 온라인으로 테스트

언 골프

func a(s s: String){
    var c = s.characters, r = ""
    while(c.count > 0){
        var k = ""
        for d in c{
            k+=String(d)
        }
        for i in 0...9{
            r+="\(k)\(i) "
        }
        c.removeLast()
    }
    print(r)
}

루비, 51

분리기가 사용되지 않습니다.

->s{(10*n=s.size).times{|i|print s[0,n-i/10],i%10}}

i%10구분 기호 뒤에 다음을 추가하십시오 .

,$/줄 바꿈에 대한 ,?|위해 |(프린트 가능 문자와 유사), ,' '공간.

테스트 프로그램에서

f=->s{(10*n=s.size).times{|i|print s[0,n-i/10],i%10}}

f[gets.chomp]

PHP, 64 56 바이트

for($i=9;$a=substr($argv[1].a,0,-++$i/10);)echo$a.$i%10;

for(;$a=substr($argv[1].a,$i=0,-++$l);)for(;$i<10;)echo $a.$i++;

하스켈, 49 46 바이트

f=(>>=(<$>['0'..'9']).snoc).reverse.tail.inits

C #, 107102 바이트

string f(string i){var o="";while(i!=""){for(int k=0;k<=9;)o+=i+k++;i=i.Remove(i.Length-1);}return o;}

언 골프

string f(string i)
{
   string o = "";
   while(i != "")
   {
      for (int k = 0; k <= 9;)
         o += i + k++;
      i = i.Remove(i.Length - 1);
   }
   return o;
}

루비, 90 85 바이트

f=->s{if s=="";return[];end;(0..9).map{|i|s+i.to_s}+f[s.chars.take(s.length-1).join]}

문자열이 비어 있으면 빈 배열을 반환하십시오. 그렇지 않으면 문자열 + 0에서 9까지의 각 숫자의 숫자를 생성 f하고 마지막 문자없이 문자열을 호출 하십시오.

@LevelRiverSt 덕분에 5 바이트 절약

Perl 6, 32 = 31 바이트 + -p의 경우 1

나는 Perl 6에 능숙하지 않으므로 더 줄일 수있는 방법이있을 수 있습니다.

$_= ~((~$_,*.chop...^!*)X~ ^10)

-p각 입력 라인에 대해 한 번 평가 하는 데 사용 됩니다. 라인은 $_프로그램이 실행 된 후에 배치되고 인쇄됩니다.$_ .

(가) (~$_,*.chop...^!*)제 요소 캐릭터 라인 화 된 목록 (인 ~) 입력을, 이후의 각 요소는 이전 (OFF 마지막 문자 마에 의해 얻어진다 *.chop() 및 문자열이 빌 때까지 그것이 계속 !*빈 문자열 경우 제외)합니다 ( ^의 ...^) .

X~지정된 연산을 사용하여이 경우 문자열 연결 ( ~)을 사용하여 왼쪽과 오른쪽에 모든 목록 쌍을 생성 합니다. ^100, 1, ... 9의 목록입니다.

마지막으로 목록은으로 다시 문자열 화 ~되어 공백으로 필요한 단어를 구분 기호로 제공합니다.

PowerShell v2 +, 60 바이트

param($n)$n.length..1|%{$i=$_-1;0..9|%{-join$n[0..$i]+"$_"}}

입력 문자열 길이에서로 아래로 반복합니다 1. 각 반복마다 도우미 $i를 현재 수 빼기와 같습니다 1. 이것은 .length총 문자 수 이므로 필요 하지만 문자열 색인화는 0을 기준으로합니다. 그런 다음에서 0로 반복 합니다 9. 각 내부 루프 $n는 외부 루프의 값에 따라 입력 문자열을 슬라이스하고 -join다시 문자열로 만들고 내부 루프 수에 따라 문자열을 연결합니다. 각 개별 루프 결과는 파이프 라인에 배치되며 프로그램 완료시 출력이 내재됩니다.

PS C:\Tools\Scripts\golfing> .\invalid-invali-inval.ps1 'foo'
foo0
foo1
foo2
foo3
foo4
foo5
foo6
foo7
foo8
foo9
fo0
fo1
fo2
fo3
fo4
fo5
fo6
fo7
fo8
fo9
f0
f1
f2
f3
f4
f5
f6
f7
f8
f9

Dyalog APL , 14 11 바이트

문자열 목록을 반환합니다.

,⎕D∘.,⍨⌽,\⍞

, listify (테이블을 목록으로 만듭니다)

⎕D 모든 자리

∘.,⍨ 모두에 추가됨 (즉, 모든 조합을 수행)

⌽ 반대의 목록

,\ 누적 연결

⍞ 텍스트 입력

TryAPL 온라인!

그루비 (58 바이트)

왜 Groovy 답변을 게시해야하는지 모르겠습니다. Groovy 골프에 필요한 최소 크기는 폐쇄 필요에 따라 2이므로, 가장 좋은 대답은 최소 크기의 두 배입니다.

   {s->(s.length()-1..0).each{c->10.times{print s[0..c]+it}}}

여기에서보십시오 : https://groovyconsole.appspot.com/script/5148433803378688

배치, 85 83 바이트

@for /l %%i in (0,1,9)do @echo %1%%i
@set s=%1
@if not "%s:~,-1%"=="" %0 %s:~,-1%

자바 7, 105 98 바이트

void c(String s){for(int x=0,l=s.length();x<l*10;)System.out.print(s.substring(0,l-x/10)+x++%10);}

@Poke 덕분에 -7 바이트 .

언 골프 :

void c(String s){
  for(int x = 0, l = s.length(); x < l*10; ){
    System.out.print(s.substring(0, l - x/10) + x++ % 10);
  }
}

테스트 코드 :

여기에서 시도하십시오.

class M{
  static void c(String s){for(int x=0,l=s.length();x<l*10;)System.out.print(s.substring(0,l-x/10)+x++%10);}

  public static void main(String[] a){
    c("INVALID");
    System.out.println();
    c("MAYBE");
    System.out.println();
    c("AFTER");
    System.out.println();
    c("WHAT ARE YOU DOING");
  }
}

산출:

INVALID0INVALID1INVALID2INVALID3INVALID4INVALID5INVALID6INVALID7INVALID8INVALID9INVALID0INVALID1INVALID2INVALID3INVALID4INVALID5INVALID6INVALID7INVALID8INVALID9INVALI0INVALI1INVALI2INVALI3INVALI4INVALI5INVALI6INVALI7INVALI8INVALI9INVAL0INVAL1INVAL2INVAL3INVAL4INVAL5INVAL6INVAL7INVAL8INVAL9INVA0INVA1INVA2INVA3INVA4INVA5INVA6INVA7INVA8INVA9INV0INV1INV2INV3INV4INV5INV6INV7INV8INV9IN0IN1IN2IN3IN4IN5IN6IN7IN8IN9I0I1I2I3I4I5I6I7I8I9
MAYBE0MAYBE1MAYBE2MAYBE3MAYBE4MAYBE5MAYBE6MAYBE7MAYBE8MAYBE9MAYBE0MAYBE1MAYBE2MAYBE3MAYBE4MAYBE5MAYBE6MAYBE7MAYBE8MAYBE9MAYB0MAYB1MAYB2MAYB3MAYB4MAYB5MAYB6MAYB7MAYB8MAYB9MAY0MAY1MAY2MAY3MAY4MAY5MAY6MAY7MAY8MAY9MA0MA1MA2MA3MA4MA5MA6MA7MA8MA9M0M1M2M3M4M5M6M7M8M9
AFTER0AFTER1AFTER2AFTER3AFTER4AFTER5AFTER6AFTER7AFTER8AFTER9AFTER0AFTER1AFTER2AFTER3AFTER4AFTER5AFTER6AFTER7AFTER8AFTER9AFTE0AFTE1AFTE2AFTE3AFTE4AFTE5AFTE6AFTE7AFTE8AFTE9AFT0AFT1AFT2AFT3AFT4AFT5AFT6AFT7AFT8AFT9AF0AF1AF2AF3AF4AF5AF6AF7AF8AF9A0A1A2A3A4A5A6A7A8A9
WHAT ARE YOU DOING0WHAT ARE YOU DOING1WHAT ARE YOU DOING2WHAT ARE YOU DOING3WHAT ARE YOU DOING4WHAT ARE YOU DOING5WHAT ARE YOU DOING6WHAT ARE YOU DOING7WHAT ARE YOU DOING8WHAT ARE YOU DOING9WHAT ARE YOU DOING0WHAT ARE YOU DOING1WHAT ARE YOU DOING2WHAT ARE YOU DOING3WHAT ARE YOU DOING4WHAT ARE YOU DOING5WHAT ARE YOU DOING6WHAT ARE YOU DOING7WHAT ARE YOU DOING8WHAT ARE YOU DOING9WHAT ARE YOU DOIN0WHAT ARE YOU DOIN1WHAT ARE YOU DOIN2WHAT ARE YOU DOIN3WHAT ARE YOU DOIN4WHAT ARE YOU DOIN5WHAT ARE YOU DOIN6WHAT ARE YOU DOIN7WHAT ARE YOU DOIN8WHAT ARE YOU DOIN9WHAT ARE YOU DOI0WHAT ARE YOU DOI1WHAT ARE YOU DOI2WHAT ARE YOU DOI3WHAT ARE YOU DOI4WHAT ARE YOU DOI5WHAT ARE YOU DOI6WHAT ARE YOU DOI7WHAT ARE YOU DOI8WHAT ARE YOU DOI9WHAT ARE YOU DO0WHAT ARE YOU DO1WHAT ARE YOU DO2WHAT ARE YOU DO3WHAT ARE YOU DO4WHAT ARE YOU DO5WHAT ARE YOU DO6WHAT ARE YOU DO7WHAT ARE YOU DO8WHAT ARE YOU DO9WHAT ARE YOU D0WHAT ARE YOU D1WHAT ARE YOU D2WHAT ARE YOU D3WHAT ARE YOU D4WHAT ARE YOU D5WHAT ARE YOU D6WHAT ARE YOU D7WHAT ARE YOU D8WHAT ARE YOU D9WHAT ARE YOU 0WHAT ARE YOU 1WHAT ARE YOU 2WHAT ARE YOU 3WHAT ARE YOU 4WHAT ARE YOU 5WHAT ARE YOU 6WHAT ARE YOU 7WHAT ARE YOU 8WHAT ARE YOU 9WHAT ARE YOU0WHAT ARE YOU1WHAT ARE YOU2WHAT ARE YOU3WHAT ARE YOU4WHAT ARE YOU5WHAT ARE YOU6WHAT ARE YOU7WHAT ARE YOU8WHAT ARE YOU9WHAT ARE YO0WHAT ARE YO1WHAT ARE YO2WHAT ARE YO3WHAT ARE YO4WHAT ARE YO5WHAT ARE YO6WHAT ARE YO7WHAT ARE YO8WHAT ARE YO9WHAT ARE Y0WHAT ARE Y1WHAT ARE Y2WHAT ARE Y3WHAT ARE Y4WHAT ARE Y5WHAT ARE Y6WHAT ARE Y7WHAT ARE Y8WHAT ARE Y9WHAT ARE 0WHAT ARE 1WHAT ARE 2WHAT ARE 3WHAT ARE 4WHAT ARE 5WHAT ARE 6WHAT ARE 7WHAT ARE 8WHAT ARE 9WHAT ARE0WHAT ARE1WHAT ARE2WHAT ARE3WHAT ARE4WHAT ARE5WHAT ARE6WHAT ARE7WHAT ARE8WHAT ARE9WHAT AR0WHAT AR1WHAT AR2WHAT AR3WHAT AR4WHAT AR5WHAT AR6WHAT AR7WHAT AR8WHAT AR9WHAT A0WHAT A1WHAT A2WHAT A3WHAT A4WHAT A5WHAT A6WHAT A7WHAT A8WHAT A9WHAT 0WHAT 1WHAT 2WHAT 3WHAT 4WHAT 5WHAT 6WHAT 7WHAT 8WHAT 9WHAT0WHAT1WHAT2WHAT3WHAT4WHAT5WHAT6WHAT7WHAT8WHAT9WHA0WHA1WHA2WHA3WHA4WHA5WHA6WHA7WHA8WHA9WH0WH1WH2WH3WH4WH5WH6WH7WH8WH9W0W1W2W3W4W5W6W7W8W9

파이썬 3, 62 바이트

lambda x:[(x+" ")[:~i//10]+str(i%10)for i in range(len(x)*10)]

다른 답변과 같이 재귀를 사용하지 않습니다.

""가있는 이유 x+" ": -0은 여전히 ​​0이므로,이 방법으로 모든 문자열을 가져 오기 위해 빼기 표기법을 사용할 수 없으므로 가장 높은 것은 빼기 1이므로 ""는 패드입니다. 문자열

C, 72 , 70 바이트

j;F(char*s,int l){while(l--)for(j=0;j<10;)printf("%.*s%d",l+1,s,j++);}

문자열을 포인터 / 크기 쌍으로 사용합니다. 메인 테스트 :

int main() {
  F("INVALID", 7); putchar('\n');
  F("MAYBE", 5); putchar('\n');
  F("AFTER", 5); putchar('\n');
  F("WHAT ARE YOU DOING", 18); putchar('\n');
}

망막 , 37 바이트

바이트 수는 ISO 8859-1 인코딩을 가정합니다.

M&!r`.+
m`$
0
%{`$
¶$%`
T`w`d`.$
G10`

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

설명

M&!r`.+

오른쪽에서 겹치는 모든 일치 항목을 일치시키고 인쇄하여 입력의 모든 접두사를 가져옵니다.

m`$
0

0각 줄에 a 를 추가하십시오 .

%{`$
¶$%`

는 {그들이 문자열을 변경하는 데 실패 할 때까지 나머지 세 단계는 루프에서 실행하고 있음을 나타냅니다. 는 %그들이 개별적으로 각 라인에 적용되어야 함을 말한다.

스테이지 자체는 단순히 마지막 라인을 복제합니다 (처음에는 이것이 실행되는 라인 일 뿐이지 만 세 단계의 각 반복은 다른 라인을 추가합니다).

T`w`d`.$

다음 문자 대체를 수행하여 마지막 행의 숫자를 늘리십시오.

from: _0123456789AB...
to:   0123456789

그리고 마지막으로:

G10`

처음에 추가 한 행을 제거 할 수 있도록 처음 10 개의 행만 유지하십시오 INPUT9.

스칼라, 73 70 바이트

def g(s:String):String=if(s=="")""else(0 to 9 flatMap(s+_))++g(s.init)

처럼 부르십시오 f("INVALID"). 문자 시퀀스를 반환합니다.

설명

def g(s:String):String= //defines a method g taking a String as a parameter
                        //and returning a String
if(s=="")""             //guard to prevent infinite recursion
else
    (0 to 9             //create a Range from 0 to 9 (inclusive)
    flatMap(            //map:
        s+_                 //append each number to the string
    ))                  //and flatten
    ++ g(s.init)        //concatenate with g applied to everything but the last element of s

대체 솔루션, 73 바이트

(s:String)=>s.scanLeft("")(_+_).tail.reverse.flatMap(x=>(0 to 9)map(x+_))

익명 함수를 정의합니다. 전화를 걸려면

val f = ...

이걸 이렇게 불러

f("INVALID")

일련의 문자열을 반환하며 인쇄시 다음과 같이 표시됩니다.

Vector(INVALID0, INVALID1, INVALID2, INVALID3, INVALID4, INVALID5, INVALID6, INVALID7, INVALID8, INVALID9, INVALI0, INVALI1, INVALI2, INVALI3, INVALI4, INVALI5, INVALI6, INVALI7, INVALI8, INVALI9, INVAL0, INVAL1, INVAL2, INVAL3, INVAL4, INVAL5, INVAL6, INVAL7, INVAL8, INVAL9, INVA0, INVA1, INVA2, INVA3, INVA4, INVA5, INVA6, INVA7, INVA8, INVA9, INV0, INV1, INV2, INV3, INV4, INV5, INV6, INV7, INV8, INV9, IN0, IN1, IN2, IN3, IN4, IN5, IN6, IN7, IN8, IN9, I0, I1, I2, I3, I4, I5, I6, I7, I8, I9)

설명

s.scanLeft("")(_+_)    //accumulate letters from left to right -> Vector("", "I", "IN", "INV", "INVA", "INVAL", "INVALI", "INVALID")
.tail                  //drop the first element
.reverse               //reverse it
.flatMap(x =>          //map each element called x
    (0 to 9)           //create a Range from 0 to 9 (inclusive)
    map(x+_)           //append each number to x
)                      //and flatten

CJam, 29 28 바이트

ls_,,:)W%]~{_[X<aA*A,]zo}fX;

설명:

ls                              read input as string
  _                             duplicate input
   ,,                           create range of length input
      :)W%]                     add 1 to all elements and reverse
           ~                    dump array on stack
            {            }fX    for loop
             _                  duplicate input string
              [X<aA*            slice input string and multiply by 10
                    A,]         range(10)
                       zo       zip array and print (no separator)
                            ;   clear stack

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