Introducción

La canción de la infancia Eeny, meeny, miny, moe se usaba a menudo para seleccionar quién era "eso" cuando jugaba al tag. Todos se pararían en círculo y señalarían a una persona seleccionada al azar. Ellos cantaban:

Eeny, meeny, miny, moe,
atrapa un tigre por la punta del pie.
Si él grita, déjalo ir,
Eeny, meeny, miny, moe.

Mientras cantaban cada palabra, señalaban a la siguiente persona en el círculo. La persona a la que se señaló cuando se cantó el "moe" final sería "eso". Los niños se levantarían inmediatamente y se dispersarían.

Objetivo

Implemente el programa más corto en bytes que toma una entrada, el número de hijos y enumera las palabras que se cantaron cuando se señalaban.

El ganador será seleccionado en una semana.

Entrada

De STDIN, un número entero positivo, el número de hijos. Esto puede ser más que el número de palabras en la canción.

Salida

Escribe en STDOUT una lista donde cada línea representa a un niño y contiene la palabra cantada mientras se señalaba. Si hay demasiados hijos, se pueden omitir líneas vacías.

Requisitos

• Siempre comienza con el primer hijo.
• Muestra las palabras sin puntuación.
• El "moe" final debe enfatizarse como "MOE". incluyendo puntuación.

Ejemplo

Entrada

3

Salida

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

Entrada

7

Salida

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

Entrada

1

Salida

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

Entrada

21

Salida

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

TeaScript , 82 bytes

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

Descomprimir, fragmentar, transponer, unir, salida.

Explicación

              // 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

Pruébalo en línea

81 bytes no competitivos

El αno estaba encadenado, .así que tuve que arreglar esto

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 caracteres

Se guardaron 18 bytes con compresión de cadena, gracias a @Dennis y @FryAmTheEggman. Se guardó
otro byte gracias a @isaacg.

Advertencia: hay muchos no imprimibles en el código; usa los enlaces a continuación para probarlo.

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

Pruébalo en línea | Banco de pruebas

Probablemente podría jugar al golf. Sugerencias bienvenidas!

Cómo funciona

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.

Jalea, 84 bytes

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

Pruébalo en línea!

JavaScript (ES6), 167 bytes

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`
`)

Explicación

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 bytes

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 "++)))

Anteponga "Eeny meeny miny "a las otras partes ( "moe Catch ..."y "MOE!"), concatene ambas cadenas, divida en palabras, tome trozos del tamaño requerido, transponga y concatene nuevamente en una sola cadena.

@Mauris encontró 3 bytes factorizando la subcadena común "Eeny meeny miny" y haciendo que no ftenga ningún punto.

Python 2, 154 147 bytes

EDITAR: ¡ Gracias 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]) 

Esto utiliza el truco de que [0 :: n] imprime el enésimo elemento de la lista.

Pruébalo aquí

Ruby, 160 bytes

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*' '}

Todos mis intentos de "comprimir" la cadena lo han hecho más largo. Sigo intentando...

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 bytes:

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`)

Explicación:

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 bytes

(¡Gracias a Mathias Ettinger que literalmente me salvó más de 100 BYTES! )

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 alguien tiene consejos o sugerencias, realmente los agradecería. ¡Gracias!

Mathematica, 154 bytes

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,""],"
"," "]&

Utiliza el método split-chunk-transpose-join-output de la mayoría de las otras respuestas.

MATLAB, 167 bytes / caracteres:

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

Explicación:

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

No ganará ningún premio por la duración de este, pero fue divertido. :-)

Japt, 90 87 86 bytes

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

Un montón de no imprimibles. Pruébalo en línea!

Cómo funciona

              // 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.

Intenté comprimir la cadena con diferentes delimitadores. Lo único más eficiente que los espacios sería una letra minúscula, pero la mayoría de estos ya se usan y, por lo tanto, no se pueden usar para dividir la cadena. A continuación se indica cuánta compresión se logra con las restantes:

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

Actualmente estoy usando d. Es posible guardar un byte con s, sustituyendo alguna otra letra en hollers.