이 도전은 Fiona Watt와 Rachel Wells의 어린 아동 도서 시리즈에서 영감을 얻었습니다.

각 책에서 마우스 (그림에는 있지만 텍스트의 일부는 아님)는 같은 유형의 5 가지가 연속되지 않는다고 불평합니다. 그런 다음 사물의 일부 구성 요소에 예상되는 특성이 없음을 선언하여이를 백업합니다.

묻는 여섯 번째 시간에, 마우스는 그 물건을 찾고 기대되는 속성을 가지고 있기 때문에 기뻐합니다.

다음은 일반적인 예의 텍스트입니다.

That's not my bunny, its tail is too fluffy.
That's not my bunny, its paws are too rough.
That's not my bunny, its tail is too woolly.
That's not my bunny, its eyes are too shiny.
That's not my bunny, its nose is too wrinkled.
That's my bunny! Its ears are so soft.

이제 대부분의 프로그래밍 담당자는 이것이 텍스트를 생성하는 매우 알고리즘적인 방법이라는 것을 알고 있습니다. 그것은 분명한 과정이기 때문에 코드를 작성하여이를 재현 할 수 있어야합니다.

세 단어 모음으로 시작해 봅시다.

things = ["dinosaur", "lamb", "princess", "reindeer", "train"]
parts = ["back", "bells", "body", "bows", "crown", "dress", "ears",
  "engine", "fan", "flippers", "funnel", "hooves", "horns", "neck",
  "nose", "roof", "sash", "side", "spines", "spots", "tail", "teeth",
  "tiara", "wheels", "windows"]
properties = ["bumpy", "fluffy", "furry", "fuzzy", "glittery", "glossy",
  "hairy", "red", "rough", "rusty", "shiny", "silky", "slippery", 
  "soft", "sparkly", "squashy", "thick", "velvety", "woolly"]

• 먼저, 어떤 종류의 내용을 설명 할 것인지 결정합니다.
• 그런 다음 5 번, 우리는 "그건 내 [사물이 아니다.
• 마지막으로, 우리는 "그것이 나의 것"입니다. 그 부분은 [속성]입니다!

도전

• "내가 아니야 ..."스토리의 텍스트를 생성하십시오.
• 동일한 텍스트를 일관되게 재현해서는 안됩니다.
• 코드 골프이므로 가장 작은 바이트 수로 시도하십시오.
• 원하는 언어를 사용하십시오.
• 공백은 중요하지 않지만 줄 사이에 줄 바꿈 문자가 있어야합니다.
• 소스 단어 목록은 답변의 일부가 아닙니다 (TIO에서는 헤더에 추가 할 수 있음).
• 소스 단어 목록의 이름을 바꿀 수 있습니다.
• 출력은 터미널로 생성되거나 객체로 생성 된 텍스트로 출력 될 수 있습니다.
• 온라인 통역사 링크를 포함하십시오.
• 복수를 무시하고 "그 뿔은 괜찮습니다".
• 이해할 필요가 없습니다. 공주의 깔때기가 너무 푹신한 경우 그렇게 말합니다.

샘플 출력 :

That's not my train, its engine is too rusty.
That's not my train, its hooves is too thick.
That's not my train, its sash is too fuzzy.
That's not my train, its tail is too velvety.
That's not my train, its horns is too glittery.
That's my train! Its hooves is so hairy.

행복한 골프!

05AB1E , 63 바이트

ΩU6F€Ω`XN5Qi“€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“ë“€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“}.ª,

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

중복 된 부분이나 속성을 출력하지 않는 68 바이트 버전 :

ΩUε.r6£}øεXª`N5Qi“€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“ë“€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“}.ª,

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

두 프로그램 모두 사물의 목록이 첫 번째 입력이고 부품 목록과 특성 목록이 포함 된 목록이 두 번째 입력이라고 가정합니다.

설명:

Ω            # Pop and push a random element of the things-list
 U           # Pop and store it in variable `X`
  6F         # Loop 6 times:
    €Ω       #  Get a random element from both the parts and properties list
      `      #  Push them to the stack
       X     #  And also push variable `X`
             #  (the order on the stack is now: property, part, thing)
    N5Qi     #  If it's the last iteration:
        “€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“ 
            '#   Push dictionary string "that's my ÿ! its ÿ is so ÿ."
       ë     #  Else:
        “€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“
            '#   Push dictionary string "that's not my ÿ, its ÿ is too ÿ."
             #  (where the `ÿ` are automatically replaced with the words on the stack)
       }.ª   #  After the if-else: sentence-capitalize the strings
             #  (so the "That's " as well as the "! Its")
          ,  #  And output it with trailing newline


ΩU           # Pop and store a random thing in variable `X`
  ε          # Map the list of lists of parts/properties to:
   .r        #  Shuffle the list
     6£      #  And leave the first six elements
  }ø         # After the map: zip/transpose to create pairs of part & property
    ε        # Foreach over the pairs:
     `XN5Qi“€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“ë“€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“}.ª,
             #  And the rest of the code is the same as above

이 05AB1E 팁을 참조하십시오 ( 사전 사용법은 무엇입니까? ) 이유를 이해하는 “€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“것입니다 "that's my ÿ! its ÿ is so ÿ."하고 “€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“있다 "that's not my ÿ, its ÿ is too ÿ.".

파이썬 3 , 149 바이트

lambda a,*l:shuffle(a)or["That's "+s%(a[0],*map(choice,l))for s in["not my %s, its %s is too %s."]*5+["my %s! Its %s is so %s."]]
from random import*

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

movatica 덕분에 -9 바이트

숯 , 72 바이트

≔‽θθＦ⁵«That's not my θ, its ‽η is too ‽ζ.⸿»That's my θ! Its ‽η is so ‽ζ.

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 것들 부품 특성의 배열 변수에있을 것으로 예상하고 θ, η그리고 ζ가장 쉽게 입력보다는 헤더들을 제공함으로써 배치된다. 설명:

≔‽θθ

무작위로 선택하십시오.

Ｆ⁵«That's not my θ, its ‽η is too ‽ζ.⸿»

5 개의 부정적인 문장을 인쇄하십시오.

That's my θ! Its ‽η is so ‽ζ.

긍정적 인 문장을 인쇄하십시오.

apt v2.0a0-R , 73 바이트

ö
6Æ`Tt's {`not `pT=Y<5}my {+`!,`gT} {73dT*H}ts {Vö}  {`tÑ?`ë2!T} {Wö}.

세 목록을 다음과 같이 취합니다. U , V그리고W . 그것들은 어쨌든 기본 입력 변수이므로 입력 섹션에 세 개의 목록을 넣으십시오.

시도 해봐

ö                         Saves the random object in variable U
6Æ                        Range [0..6), and map each to the following string
`That's                   The string "That's " plus
{`not `pT=Y<5}            "not " if the index is less than 5 (and store that in variable T), else ""
my                        Literal "my " plus
{+`!,`gT}                 U plus ',' if T, else '!'
{73dT*H}ts                "its " if T, else "Its "
{Vö}                      Random item from V
is                         
{`tsooo`ë2!T}             "too" if T, else "so"
{Wö}.                     Random item from V, plus a period

PowerShell , 147 바이트

이 메인 프로그램은 실행에서 어떤 부분이나 속성을 반복하지 않으며 합리적인 무작위 화를가집니다.

$t=$l|Random
$a=$a|Random -c 6
$r=$r|Random -c 6
0..4|%{"That's not my $t, its $($a[$_]) is too "+$r[$_]}
"That's my $t! Its $($a[5]) is so "+$r[5]

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

get-random너무 많은 시간을 쓰면 너무 많은 캐릭터가 필요합니다! 그러나 부품과 속성을 반복하지 않으려는 경우 Powershell에서 더 이상 축소 할 수는 없습니다. 처음 3 개의 선 파이프를 헤더의 3 개의 지정 선 끝으로 이동하지 않는 한. 같은 것을 가지고

# Header
$l = ("dinosaur", "lamb", "princess", "reindeer", "train")|Get-Random
$a = ("back", "bells", "body", "bows", "crown", "dress", "ears",
  "engine", "fan", "flippers", "funnel", "hooves", "horns", "neck",
  "nose", "roof", "sash", "side", "spines", "spots", "tail", "teeth",
  "tiara", "wheels", "windows")|sort{Get-Random}
$r = ("bumpy", "fluffy", "furry", "fuzzy", "glittery", "glossy",
  "hairy", "red", "rough", "rusty", "shiny", "silky", "slippery", 
  "soft", "sparkly", "squashy", "thick", "velvety", "woolly")|sort{Get-Random}

# Main
(1..5)|%{echo("That's not my $t, its "+$a[$_]+" is too "+$r[$_])}
"That's my $t! Its "+$a[6]+" is so "+$r[6]

그러나 그것은 속임수처럼 보이지만 여전히 Neil의 대답을이기는 것은 아닙니다.

편집 : Matt에게 팁을 주셔서 감사하고 AdmBorkBork가 그것을 살살 빼내어 3 세트의 get-텍스트를 제거하여 159 바이트로 줄인 다음 Adm에서 더 많은 골프를 147로 줄였습니다. 같은 골프 팁을 적용한 후 모순 된 진술은 144 자 입니다.

function n{(random 18)+1}
$t=$l[(n)%5]
0..4|%{"That's not my $t, its $($a[(n)]) is too "+$r[(n)]}
"That's my $t! Its $($a[$(n)]) is so "+$r[(n)]

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

그러나 동일한 내용을 여러 번 말하는 경향이있을뿐 아니라 입력이 동일한 수의 요소 여야합니다. 나는 사용되는 의사 난수 생성기가 시계에 크게 의존한다고 믿으며 그것에 대한 빠른 반복 호출은 종종 동일한 결과를 초래할 수 있습니다. 그런 다음 모든 목록의 길이가 같은 경우 전체 목록 만 사용하는 조건이 있습니다 .3 ~ 5 자만 저장하고주의해야 할 점이 많으 므로이 게시물의 시작 부분에서 코드를 선호합니다.

젤리 , 72 바이트

XWWẋ6;X€}⁶pʋ€s5“ʠĖµʋb⁵J¥\¢wBD®-Ƥd(CḤ!²kT“Ø!1ẆÑ⁹ṁṾƤṛḄėÄṂMƓṾṖ¿O*½»Ỵ€¤żⱮ"ẎY

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

자바 스크립트, 129

(a,b,c)=>(z='',a.forEach((f,i)=>z+=`That's ${q=i!=5?"not ":""}my ${f}${q?", i":"! I"}ts ${b[i]} is ${q?"to":"s"}o ${c[i]}.\n`),z)

입력은 3 개의 배열이며 문자열을 반환합니다.

루비 , 128 바이트

->a,*l{t=a.sample;6.times{|i|puts"That's#{' not'if i<5} my #{t}#{i<5?', i':'! I'}ts %s is #{i<5?'to':?s}o %s."%l.map(&:sample)}}

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

C 번호 , 204 203 바이트

()=>{int a(int x)=>new Random().Next(x);var j=t[a(5)];string s()=>$"That's not my {j}, its {p[a(25)]} is too {o[a(19)]}.\n";return s()+s()+s()+s()+s()+$"That's my {j}! Its {p[a(25)]} is so {o[a(19)]}.";};

이 사이트의 첫 번째 답변이므로 제대로 작동하기를 바랍니다. 또한 그 세 가지가 필요하지만 질문에 따르면 사람들은 계산하지 않습니다.

   var t = new[] { "dinosaur", "lamb", "princess", "reindeer", "train" };
   var p = new[] {"back", "bells", "body", "bows", "crown", "dress", "ears",
          "engine", "fan", "flippers", "funnel", "hooves", "horns", "neck",
          "nose", "roof", "sash", "side", "spines", "spots", "tail", "teeth",
          "tiara", "wheels", "windows" };
   var o = new[] {"bumpy", "fluffy", "furry", "fuzzy", "glittery", "glossy",
          "hairy", "red", "rough", "rusty", "shiny", "silky", "slippery",
          "soft", "sparkly", "squashy", "thick", "velvety", "woolly"};

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

Sok 덕분에 1 바이트도 줄었습니다.

APL (Dyalog Unicode) , 117 바이트 ^SBCS

↑('That''s not my ',(t←T⊃⍨?5),', its ')∘,¨P[5?25],¨' is too '∘,¨V[5?19]
'That''s my ',t,'! Its',P[?25],'is so',V[?19]

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

?N 첫 N 개의 인덱스 중 랜덤 인덱스를 생성합니다.

M?N 첫 N 개의 인덱스 중 M 개의 랜덤 인덱스 (대체없이)를 생성합니다.

, 연결이다

t←T⊃⍨… 무작위를 골라 그것을 부릅니다 t 마지막 줄에서 재사용을 .

∘,¨ 왼쪽의 문자열을 오른쪽의 각 문자열에 연결합니다.

,¨ 왼쪽의 각 문자열을 오른쪽의 각 문자열에 연결합니다.

↑ 문자열 목록을 문자 행렬로 변경하여 올바르게 인쇄합니다.

Pyth , 88 78 76 바이트

JONj_ms.ic"That's
 my 

ts 
 is 
o 
."b[?d" not"kJ?d", i""! I"OG?d\s"to"OH)6

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

위에 제시된 코드에는 다음 헤더가 필요합니다.

=N["dinosaur""lamb""princess""reindeer""train")=G["back""bells""body""bows""crown""dress""ears""engine""fan""flippers""funnel""hooves""horns""neck""nose""roof""sash""side""spines""spots""tail""teeth""tiara""wheels""windows")=H["bumpy""fluffy""furry""fuzzy""glittery""glossy""hairy""red""rough""rusty""shiny""silky""slippery""soft""sparkly""squashy""thick""velvety""woolly")

TIO가 Pyth와 함께 코드 블록에 합류하는 것처럼 보이고 Pyth에서 개행이 중요하기 때문에 Pyth와 함께 TIO에서 '헤더'기능을 사용하는 데 약간의 문제가 있습니다. 다음은 출력에 정크 라인이있는 'Header'블록을 사용하는 동일한 코드에 대한 링크 입니다.

JONj_ms.ic"That's¶ my ¶¶ts ¶ is ¶o ¶."b[?d" not"kJ?d", i""! I"OG?d"to"\sOH)6   Newlines replaced with ¶
                                                                               Implicit: k="", b=newline
                                                                               From header: N=things, G=parts, H=properties
JON                                                                            Choose a random element from N, store in J
     m                                                                     6   Map [0-6), as d, using:
                                        ?d" not"k                                If d is truthy (i.e. not 0), yield " not", else ""
                                                 J                               J (the chosen thing)
                                                  ?d", i""! I"                   ", i" if d else "! I"
                                                              OG                 Random element from G
                                                                ?d"to"\s         "to" if d else "s"
                                                                        OH       Random element from H
                                       [                                  )      Wrap the previous 6 results in an array
         c"That's¶ my ¶¶ts ¶ is ¶o ¶."b                                          Split the template string on newlines
       .i                                                                        Interleave the template string elements with the previous list
      s                                                                          Concatenate
    _                                                                          Reverse lines
   j                                                                           Join on newlines, implicit print

편집 : 골프 10 바이트, 이전 버전으로 다시 작성 : J+" my "ONV5%"That's not%s, its %s is too %s."[JOGOH;%"That's%s! Its %s is so %s."[JOGOH

Perl 5.10, 127 바이트

로 실행하십시오 perl -M5.010 -f filename.pl.

my @t = qw(dinosaur lamb princess reindeer train);
my @r = qw(back bells body bows crown dress ears engine fan flippers funnel
           hooves horns neck nose roof sash side spines spots tail teeth tiara
           wheels windows);
my @p = qw(bumpy fluffy furry fuzzy glittery glossy hairy red rough rusty shiny
           silky slippery soft sparkly squashy thick velvety woolly);

sub r{rand@_}$a=" my $t[r@t]";say"That's not$a, its $r[r@r] is too $p[r@p]."for(1..5);say"That's$a! Its $r[r@r] is so $p[r@p]."

JavaScript ES6, 149 (+15?) 바이트

a = ["dinosaur", "lamb", "princess", "reindeer", "train"]
b = ["back", "bells", "body", "bows", "crown", "dress", "ears",
  "engine", "fan", "flippers", "funnel", "hooves", "horns", "neck",
  "nose", "roof", "sash", "side", "spines", "spots", "tail", "teeth",
  "tiara", "wheels", "windows"]
c = ["bumpy", "fluffy", "furry", "fuzzy", "glittery", "glossy",
  "hairy", "red", "rough", "rusty", "shiny", "silky", "slippery", 
  "soft", "sparkly", "squashy", "thick", "velvety", "woolly"]

// r=x=>x[parseInt(Math.random()*x.length)] 164 for better random on fast pc

r=x=>x[new Date%x.length]
s=r(a)
g=j=>console.log(`That's ${j?`not my ${s}, its ${r(b)} is to`:`my ${s}! Its ${r(b)} is s`}o ${r(c)}.`)
a.map(g) 
g()

배치 파일, 434424 + 7 바이트

를 통해 실행됩니다 cmd/q/c.

계산되지 않은 코드

set a=dinosaur lamb princess reindeer train
set b=back bells body bows crown dress ears engine fan flippers funnel hoobes horns neck nose roof sash side spines spots tail teeth tiara wheels windows
set c=bumpy fluffy furry fizzy glittery glossy hair red rough rusty shiny silky slippery soft sparkly squashy thick velvety woolly

계산 된 코드

set q=random
set m=set/ar=1+%%%q%%%%%%%
call %m%5
for /f "tokens=%r%" %%x in ("%a%")do set x=%%x
:a
set/ad+=1
call %m%25
for /f "tokens=%r%" %%y in ("%b%")do set y=%%y
call %m%19
for /f "tokens=%r%" %%z in ("%c%")do echo That's not my %x%, its %y% is too %%z.
if %d% neq 5 goto a
call %m%25
for /f "tokens=%r%" %%y in ("%b%")do set y=%%y
call %m%19
for /f "tokens=%r%" %%z in ("%c%")do echo That's my %x%! Its %y% is so %%z.

나는 당신이 직면해야 할 몇 가지 도전을 겪고 다른 사람들이 개선 할 수 있도록 내가 한 일을 설명하고 정당화합니다.

배열에서 임의의 소자를 선택
I 사이의 난수를 발생시켜 이것을했다 1및 n곳은 n그 배열의 요소의 크기이다. 그런 다음이 임의의 숫자를 토큰으로 사용하여 각 for루프 를 잡습니다 ( tokens=%r%). 이 방법으로 했으므로 for더 이상 이 루프를 중첩 할 수 없었습니다.tokens=!r! 확장 가 지연 . 토큰을 변수로 저장해야 할 필요성을 제거했기 때문에 꽤 많은 바이트를 절약했습니다.set x=%%x ) 있습니다.

난수 생성
m 은 난수 생성 매크로입니다. 이렇게하면 set/ar=%random%%%n+1모든 줄 처럼 32 바이트를 절약 할 수 있습니다. 당신은 반 속임수 그 토큰을 결정할 수 y와 z같은 요소 수 있습니다 :

call %m%19
for /f "tokens=%r%" %%y in ("%b%")do set y=%%y
for /f "tokens=%r%" %%z in ("%c%")do echo That's not my %x%, its %y% is too %%z.

이것은 여전히 ​​임의성을 유지하면서의 마지막 6 개 요소를 제외합니다 c. 이것은 최소 20 바이트를 절약 할 수 있지만 이것이 op의 요구 사항에 해당한다고 생각하지 않습니다.

이론적 인 개선
나는 바이트를 절약하면서이 "의사 코드"를 작동 시키려고 꽤 오랜 시간을 보냈다.

set 1-5=echo That's not my %x%, its %y% is too %%z.
set 6=echo That's my %x%! Its %y% is so %%z.
...
set/ad+=1
for /f "tokens=%r%" %%z in ("%c%")do call %%d%%

불행히도 이것에 대한 설정은 너무 많은 바이트를 사용하여 수익성을 갖지 못하고 있음을 입증하지만 (<144 바이트로 구현해야 함) 마지막 4 줄의 코드를 추가하는 것이 불필요하고 멍청하다는 느낌을 흔들 수 없습니다.

잉크 , 119 바이트

~a=LIST_RANDOM(a)
-(l)That's{l<6: not} my {a}{l<6:, i|! I}ts {LIST_RANDOM(b)} is {l<6:to|s}o {LIST_RANDOM(c)}
{l<6:->l}

목록이 다음과 같이 정의 된 상태에서

LIST a=(dinosaur),(lamb),(princess),(reindeer),(train)
LIST b=(back),(bells),(body),(bows),(crown),(dress),(ears),(engine),(fan),(flippers),(funnel),(hooves),(horns),(neck),(nose),(roof),(sash),(side),(spines),(spots),(tail),(teeth),(tiara),(wheels),(windows)
LIST c=(bumpy),(fluffy),(furry),(fuzzy),(glittery),(glossy),(hairy),(red),(rough),(rusty),(shiny),(silky),(slippery),(soft),(sparkly),(squashy),(thick),(velvety),(woolly)

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

목록으로 계산되는 내용에 따라 다른 방법이 있습니다. 목록이 임의로 목록 항목을 반환하는 함수일 수있는 경우 다음 방법은 91 바이트에 불과합니다.

~temp t=u()
-(l)That's{l<6: not} my {t}{l<6:, i|! I}ts {p()} is {l<6:to|s}o {q()}
{l<6:->l}

( "리스트"는 다음과 같이 정의 됨)

==function u
~return "{~dinosaur|lamb|princess|reindeer|train}"
==function p
~return "{~back|bells|body|bows|crown|dress|ears|engine|fan|flippers|funnel|hooves|horns|neck|nose|roof|sash|side|spines|spots|tail|teeth|tiara|wheels|windows}"
==function q
~return " {~bumpy|fluffy|furry|fuzzy|glittery|glossy|hairy|red|rough|rusty|shiny|silky|slippery|soft|sparkly|squashy|thick|velvety|woolly}."

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

다음과 같은 접근 방식도 있습니다.

~temp t="{~dinosaur|lamb|princess|reindeer|train}"
-(l)That's{l<6: not} my {t}{l<6:, i|! I}ts {~back|bells|body|bows|crown|dress|ears|engine|fan|flippers|funnel|hooves|horns|neck|nose|roof|sash|side|spines|spots|tail|teeth|tiara|wheels|windows} is {l<6:to|s}o {~bumpy|fluffy|furry|fuzzy|glittery|glossy|hairy|red|rough|rusty|shiny|silky|slippery|soft|sparkly|squashy|thick|velvety|woolly}
{l<6:->l}

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

이 솔루션은 389 바이트이지만 셔플 리터럴 (이 시나리오에서는 실제로 이동할 수 없음)이 목록 정의로 계산되고 바이트 수에서 제외 될 수 있으면 80 바이트로 줄어 듭니다.

배쉬 + awk, 209 바이트

T=$(shuf $1|head -1)
join <(sed "s/.*/$T\t&/" $2) <(sed "s/.*/$T\t&/" $3)|shuf|awk 'NR<6{printf "That'\''s not my %s, its %s is too %s.\n",$1,$2,$3}NR==6{printf "That'\''s my %s! Its %s is so %s.\n",$1,$2,$3}'

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

입력을 다음과 같이 받아들입니다. things parts properties 이 원하는 유형의 행당 하나의 항목이있는 파일 인 위치를 합니다.

이것은 파일 중심 접근 방식입니다. 나중에 배열 중심 접근 방식을 시도하여 개선 가능한지 확인할 수 있습니다.

파이썬 3, 130 바이트

문자 그대로 요구 사항을 취하고 캐리지를 사용하면 각각 1 바이트가 반환됩니다.

y=0
def x():
    global y
    y=1-y 
    print(("That's not my lamb, it's "+b[0:1][y]+" is too red\n")*5+"That's my lamb! Its fan is so red")