introduction

La chanson d'enfance Eeny, meeny, miny, moe était souvent utilisée pour sélectionner qui était "it" lors de la lecture du tag. Tout le monde se tenait en cercle et désignait une personne choisie au hasard. Ils chantaient:

Eeny, meeny, miny, moe,
Attrapez un tigre par l'orteil.
S'il hurle, laissez-le partir,
Eeny, meeny, miny, moe.

En chantant chaque mot, ils pointèrent la personne suivante dans le cercle. La personne désignée lorsque le "moe" final a été chanté serait "it". Les enfants se levaient immédiatement et se dispersaient.

Objectif

Implémentez le programme le plus court en octets qui prend une entrée, le nombre d'enfants et répertorie les mots qui ont été chantés lorsqu'ils étaient pointés du doigt.

Le gagnant sera sélectionné dans une semaine.

Contribution

De STDIN, un seul entier positif, le nombre d'enfants. Cela peut être plus que le nombre de mots de la chanson.

Production

Écrit dans STDOUT une liste où chaque ligne représente un enfant et contient le mot chanté alors qu'il était pointé du doigt. S'il y a trop d'enfants, les lignes vides peuvent être omises.

Exigences

• Commencez toujours par le premier enfant.
• Affichez les mots sans ponctuation.
• Le "moe" final doit être souligné comme "MOE!" y compris la ponctuation.

Exemple

Contribution

3

Production

Eeny moe tiger toe hollers go miny
meeny Catch by If let Eeny MOE!
miny a the he him meeny

Contribution

7

Production

Eeny by him
meeny the go
miny toe Eeny
moe If meeny
Catch he miny
a hollers MOE!
tiger let

Contribution

1

Production

Eeny meeny miny moe Catch a tiger by the toe If he hollers let him go Eeny meeny miny MOE!

Contribution

21

Production

Eeny
meeny
miny
moe
Catch
a
tiger
by
the
toe
If
he
hollers
let
him
go
Eeny
meeny
miny
MOE!

TeaScript , 82 octets

D`${a="Ey Ú9y ·ny "}¶e C® a g by e e If  Ò@s ¤t m go ${a}MOE!`q.KαtΣj═)j╝

Décompresser, fragmenter, transposer, joindre, sortir.

Explication

              // Implicit: x = input
D`...blah...` // Decompress "Eeny miny moe..."
q             // Split
Kα            // chunk into x-size blocks (α == x)
t             // Transpose
Σ             // Loop through lines
j═)             // Join with spaces
j╝            // Join with newline

Essayez-le en ligne

81 octets non concurrents

Le αn'était pas enchaîné .donc j'ai dû corriger un bug

D`${a="Ey Ú9y ·ny "}¶e C® a g by e e If  Ò@s ¤t m go ${a}MOE!`qKαtΣj═)j╝

Pyth, 103 89 84 caractères

18 octets enregistrés avec compression de chaîne, grâce à @Dennis et @FryAmTheEggman Un
autre octet enregistré grâce à @isaacg

Attention: il y a beaucoup de non imprimables dans le code; utilisez les liens ci-dessous pour l'essayer.

VQjd%Q>cs[J."@y)òÎ5O¹c×Ú"."@yæ\J}ÇZH66¥ÓÀD¸¶=ðÉ §J%ÔþÖúÅ="J"MOE!")\@N

Essayez-le en ligne | Suite de tests

Pourrait probablement être joué au golf. Suggestions bienvenues!

Comment ça fonctionne

VQjd%Q>cs[J."..."."..."J"MOE!")\@N    Implicit: Q = eval(input)
VQ                                    For each item N in range 0...int(Q):
         [                    )        Create an array out of the following:
          J."..."                       Set J to this string, decompressed. ("Eeny@meeny@miny@")
                 ."..."                 This string, decompressed. ("moe@Catch@...let@him@go@")
                       J                J.
                        "MOE!"          "MOE!".
        s                              Join the array with the empty string.
       c                       \@      Split the result on "@".
      >                          N     Cut off the first N items.
    %Q                                 Take every Qth item.
  jd                                   Join with spaces.

Gelée, 84 octets

“£Dṡ“Ṙ©“Ė“¡Ḳ⁵“=U“¡Ẹ⁵“¡Ṇm“ȯf“ŀQ“ÞṖċ¥“ṅ_“Ẉ1“¡æḷ“¡ƒmxĠ“¡ṇƭEỤr“¡Þ¦»ṫ-2;;“MOE!”W¤sƓZj€⁶j⁷

Essayez-le en ligne!

JavaScript (ES6), 167 octets

l=Array(n=+prompt()).fill``;`${s=`Eeny meeny miny `}moe Catch a tiger by the toe If he hollers let him go ${s}MOE!`.split` `.map((w,i)=>l[i%n]+=w+` `);alert(l.join`
`)

Explication

l=Array(              // l = array of lines
  n=+prompt()         // n = input number
).fill``;             // initialise l as empty strings

`${s=`Eeny meeny miny `}moe Catch a tiger by the toe If he hollers let him go ${s}MOE!`

.split` `.map((w,i)=> // for each word w
  l[i%n]+=w+` `       // add it to the lines
);
alert(l.join`
`)                    // output the lines

Haskell, 160 157 octets

import Data.Lists
unlines.map unwords.transpose.(`chunksOf`(["moe Catch a tiger by the toe If he hollers let him go","MOE!"]>>=words.("Eeny meeny miny "++)))

Ajouter "Eeny meeny miny "les autres parties ( "moe Catch ..."et "MOE!"), concaténer les deux chaînes, diviser en mots, prendre des morceaux de la taille requise, transposer et concaténer à nouveau en une seule chaîne.

@Mauris a trouvé 3 octets en factorisant la sous-chaîne commune "Eeny meeny miny" et en la rendant sans fpoint.

Python 2, 154 147 octets

EDIT: Merci Joe Willis!

i=input()
s='Eeny meeny miny '
for j in range(i):print' '.join((s+'moe Catch a tiger by the toe If he hollers let him go '+s+'MOE!').split()[j::i]) 

Cela utilise l'astuce qui [0 :: n] affiche le nième élément de la liste.

Essayez-le ici

Rubis, 160 octets

puts (a=[*%w[Eeny meeny miny moe Catch a tiger by the toe If he hollers let him go Eeny meeny miny MOE!].each_slice(gets.to_i)])[0].zip(*a[1..-1]).map{|x|x*' '}

Toutes mes tentatives de "compression" de la chaîne viennent de l'allonger. En train d'essayer...

puts                      # output to STDOUT...
(a=                       # assign this stuff to the variable a
 [*                       # convert to array...
  %w[blah blah]           # %w splits on spaces
  .each_slice(gets.to_i)  # split into slices of input number
 ]
)[0]                      # take the first element of a
.zip(*a[1..-1])           # zip it with the remaining elements
                          #   because transpose complains about ragged 2D arrays
.map{|x|x*' '}            # join all sub-arrays on space
                          #   puts automatically inserts newlines for us

JavaScript (ES6), 189 octets:

a=prompt(),b=Array(a--).fill``,c=0;"Eeny meeny miny moe Catch a tiger by the toe If he hollers let him go Eeny meeny miny MOE!".split` `.map(v=>(b[c]+=v+' ',c+=c>a-1?-c:1));alert(b.join`\n`)

Explication:

a=prompt(), //Get the STDIN
b=Array(a--).fill``, //Make an array based on how many kids there are
c=0; //Start the iteration variable
"Eeny meeny miny moe Catch a tiger by the toe If he hollers let him go Eeny meeny miny MOE!"
.split` `.map(
    v=>(
        b[c] += v + ' ',
        c += c > a - 1 ? -c : 1
    )
);alert(b.join`\n`)

Python 3, 279 278 272 173 octets

(merci à Mathias Ettinger qui m'a littéralement sauvé plus de 100 octets! )

s=" Eeny meeny miny moe Catch a tiger by the toe If he hollers let him go Eeny meeny miny moe!";w=s.split();i=input();i=int(i)
for z in range(i):W=w[z::i];print(" ".join(W))  

Si quelqu'un a des conseils ou des suggestions, je les apprécierais vraiment. Merci!

Mathematica, 154 octets

StringRiffle[Thread@Partition[StringSplit@"Eeny meeny miny moe Catch a tiger by the toe If he hollers let him go Eeny meeny miny MOE!",#,#,1,""],"
"," "]&

Utilise la méthode split-chunk-transpose-join-output de la plupart des autres réponses.

MATLAB, 167 octets / caractères:

n=input('');s='Eeny meeny miny ';s=strsplit([s 'moe Catch a tiger by the toe If he hollers let him go ' s 'MOE!']);f=@fprintf;for i=1:n f('%s ',s{i:n:end});f('\n');end

Explication:

n=input('');             % Grab the input (number of children)
s='Eeny meeny miny ';    % Common string portion
% Build the full string and split into cell array at spaces
s=strsplit([s 'moe Catch a tiger by the toe If he hollers let him go ' s 'MOE!']);
f=@fprintf;              % Just a shorthand for later (only saves 1 char here)
for i=1:n                % Loop to the number of children
    f('%s ',s{i:n:end}); % Print each nth word, shifted by child
    f('\n');             % Start each child's words on a new line
end

Je ne gagnerai aucun prix pour la durée de celui-ci, mais c'était amusant. :-)

Japt, 90 87 86 octets

Uo mW{V=`EydÚ9yd·nyd` +`¶C®»dgdbydÈIfddÒ@sd¤tdmdgod{V}MOE!` qd f@Y%U¥W} m¸·

Beaucoup d'imprimables. Essayez-le en ligne!

Comment ça fonctionne

              // Implicit: U = input
Uo mW{     }  // Create the range 0...U and map each item W to:
V=`...`       //  Set V to this string, decompressed. "Eenydmeenydmined"
+`...{V}MOE!` //  Concatenate it with this string, decompressed, with V inserted.
qd            //  Split at "d"s.
f@Y%U¥W       //  Filter to only the items where (index % U == W).
m¸            // Map each item by joining with spaces.
·             // Join the result with newlines.

J'ai essayé de compresser la chaîne avec différents délimiteurs. La seule chose plus efficace que les espaces serait une lettre minuscule, mais la plupart d'entre elles sont déjà utilisées et ne peuvent donc pas être utilisées pour diviser la chaîne. Voici la quantité de compression obtenue avec les autres:

space -> 69 bytes
c -> 66 (including a null byte)
d -> 65
j -> 69
k -> 69
p -> 68
q -> 69
s -> 61 (but there's an s in "hollers")
u -> 65
w -> 67
x -> 69
y -> 69

Actuellement j'utilise d. Il peut être possible d'enregistrer un octet avec s, en remplaçant une autre lettre hollers.