Koalas, Krabben und Commapillars

21

Geben Sie bei zwei positiven Ganzzahlen X und Y eine beliebige Kombination der folgenden drei ASCII-artigen Tiere aus, sodass die Ausgabe genau X Kommas ( ,) und Y Punkte ( .) enthält, sofern dies möglich ist.

  1. Koala: 1 Komma, 2 Punkte

    <.,.>
    
  2. Krabbe: 2 Kommas, 2 Punkte

    ,<..>,
    
  3. Commapillar: 3 oder mehr Kommas, 1 Punkt

    <,,,.>
    

    oder <,,,,.>oder <,,,,,.>oder <,,,,,,.>oder <,,,,,,,.>usw.

Wenn keine Kombination dieser Tiere genau X Kommas und Y Perioden erzeugen kann, geben Sie ein einzelnes Kommaleon aus, das den Fehler tarnt:

~<.,,>~~

Die Ausgabetiere können in beliebiger Menge und beliebiger Reihenfolge sein. Sie können in einer Zeichenfolge, einem Leerzeichen oder einer durch Zeilenumbrüche getrennten Liste oder in einer Liste enthalten sein, in der jedes Tier ein Element ist.

Für X = 7, Y = 5 wären dies beispielsweise gültige Ausgaben (durch Leerzeilen getrennt):

<.,.> <.,.> <,,,,,.>

<.,.>
<,,,,,.>
<.,.>

,<..>, <.,.> <,,,,.>

<,,,,.>
,<..>,
<.,.>

,<..>, <,,,.> ,<..>,

[",<..>,", ",<..>,", "<,,,.>"] (list syntax depends on language)

Beachten Sie, dass (zumindest in diesem Beispiel) mehrere Tiergruppen vorhanden sind, die funktionieren können. Denken Sie jedoch daran, dass Sie nur eine gültige Lösung ausgeben müssen , wenn eine existiert. Die Anzahl der Tiere oder die Anzahl der verschiedenen Tiere spielt keine Rolle.

Bei Eingaben wie X = 3, Y = 3 oder X = 1, Y = 5, bei denen es keine Lösung gibt, ist die Ausgabe immer

~<.,,>~~

Vielleicht in einer Einzelelementliste.

Der kürzeste Code in Bytes gewinnt.

Calvins Hobbys
quelle
6
Der Koala sieht einfach so aus :-)
Luis Mendo
Ich habe ein kleines Programm erstellt, das die Anzahl der Kombinationen für jedes Paar (X, Y) ausgibt. Leider konnte ich es nur bis (128, 128) laufen lassen, weil das ungefähr das Maximum für ist __int128und ich zu faul war, um eine Bignum-Bibliothek zu benutzen. Hier ist der CSV-Dump: pastebin.com/ght5xkRu Die erste Zeile und Spalte sind die X- und Y-Werte
Fytch

Antworten:

4

Rubin, 139 Bytes

Lambda-Funktion, nimmt x und y als Argumente und gibt einen String zurück

->x,y{c=y-2*n=y-(x>y ?1:0)>>1
x+=-c/2*s=[x-n,c*3].max
x<n||x>n*2?'~<.,,>~~':',<..>, '*(x-n)+'<.,.> '*(2*n-x)+"<%s.> "*c%[?,*s-=c/2*3,?,*3]}

Wenn es eine Lösung gibt, kann diese mit allen Koalas + Commapillars oder allen Koalas + Krabben durchgeführt werden.

Das Prinzip ist, ein Minimum an Kommapillaren zu verwenden. Wenn die Zahl ungerade ist, verwenden wir 1 Commapillar. Wenn wir sogar 0 Kommapillaren verwenden, es sei denn, es gibt mehr Kommas als Punkte, dann verwenden wir 2.

Die Anzahl der Perioden, die bei Nicht-Komapillaren (Krabben + Koalas) verwendet werden, ist zwangsläufig gerade, und die Anzahl der Nicht-Komapillaren ist die Hälfte (number of periods)-(number of commapillars). Wenn es nicht genügend Kommas für alle Koalas oder zu viele für alle Krabben gibt, ist keine Lösung möglich. Andernfalls geben wir eine Lösung zurück.

Kommentiert im Testprogramm

verwendet aus Gründen der Übersichtlichkeit "fail" anstelle von chameleon

f=->x,y{c=y-2*n=y-(x>y ?1:0)>>1
#n=noncommapillars=y>>1 as they have 2 periods. c=commapillars=y-2*n, 1 for odd y, 0 for even y.
#if x>y there are too many commas to have 0 commapillars for even y. noncommapillars= y-1 >> 1, so 2 commapillars

x+=-c/2*s=[x-n,c*3].max
# s=number of commas allocated to commapillars. x-n to allow all noncommapillars to be koalas, but at least 3 per commapillar.
#-c/2 == -1 if there are commapillars, 0 if not (Ruby truncates toward -inf). Subtract commas for commapillars from x if necessary

x<n||x>n*2?'fail':',<..>, '*(x-n)+'<.,.> '*(2*n-x)+"<%s.> "*c%[?,*s-=c/2*3,?,*3]}
#if x<n (insufficient commas for all koalas) or x>n*2 (too many for all crabs) return fail. Else...
#return string off crabs, koalas, and (using % operator like sprintf) c commapillars (0..2), the second with 3 commas (if present) and the first with the rest.  



10.times{|j|10.times{|i|puts "%-20s %s"%[?.*j+?,*i,f[i,j]]}}
#all x,y from 0..9

Ausgabe

,                    fail
,,                   fail
,,,                  fail
,,,,                 fail
,,,,,                fail
,,,,,,               fail
,,,,,,,              fail
,,,,,,,,             fail
,,,,,,,,,            fail
.                    fail
.,                   fail
.,,                  fail
.,,,                 <,,,.>
.,,,,                <,,,,.>
.,,,,,               <,,,,,.>
.,,,,,,              <,,,,,,.>
.,,,,,,,             <,,,,,,,.>
.,,,,,,,,            <,,,,,,,,.>
.,,,,,,,,,           <,,,,,,,,,.>
..                   fail
..,                  <.,.>
..,,                 ,<..>,
..,,,                fail
..,,,,               fail
..,,,,,              fail
..,,,,,,             <,,,.> <,,,.>
..,,,,,,,            <,,,,.> <,,,.>
..,,,,,,,,           <,,,,,.> <,,,.>
..,,,,,,,,,          <,,,,,,.> <,,,.>
...                  fail
...,                 fail
...,,                fail
...,,,               fail
...,,,,              <.,.> <,,,.>
...,,,,,             <.,.> <,,,,.>
...,,,,,,            <.,.> <,,,,,.>
...,,,,,,,           <.,.> <,,,,,,.>
...,,,,,,,,          <.,.> <,,,,,,,.>
...,,,,,,,,,         <.,.> <,,,,,,,,.>
....                 fail
....,                fail
....,,               <.,.> <.,.>
....,,,              ,<..>, <.,.>
....,,,,             ,<..>, ,<..>,
....,,,,,            fail
....,,,,,,           fail
....,,,,,,,          <.,.> <,,,.> <,,,.>
....,,,,,,,,         <.,.> <,,,,.> <,,,.>
....,,,,,,,,,        <.,.> <,,,,,.> <,,,.>
.....                fail
.....,               fail
.....,,              fail
.....,,,             fail
.....,,,,            fail
.....,,,,,           <.,.> <.,.> <,,,.>
.....,,,,,,          <.,.> <.,.> <,,,,.>
.....,,,,,,,         <.,.> <.,.> <,,,,,.>
.....,,,,,,,,        <.,.> <.,.> <,,,,,,.>
.....,,,,,,,,,       <.,.> <.,.> <,,,,,,,.>
......               fail
......,              fail
......,,             fail
......,,,            <.,.> <.,.> <.,.>
......,,,,           ,<..>, <.,.> <.,.>
......,,,,,          ,<..>, ,<..>, <.,.>
......,,,,,,         ,<..>, ,<..>, ,<..>,
......,,,,,,,        fail
......,,,,,,,,       <.,.> <.,.> <,,,.> <,,,.>
......,,,,,,,,,      <.,.> <.,.> <,,,,.> <,,,.>
.......              fail
.......,             fail
.......,,            fail
.......,,,           fail
.......,,,,          fail
.......,,,,,         fail
.......,,,,,,        <.,.> <.,.> <.,.> <,,,.>
.......,,,,,,,       <.,.> <.,.> <.,.> <,,,,.>
.......,,,,,,,,      <.,.> <.,.> <.,.> <,,,,,.>
.......,,,,,,,,,     <.,.> <.,.> <.,.> <,,,,,,.>
........             fail
........,            fail
........,,           fail
........,,,          fail
........,,,,         <.,.> <.,.> <.,.> <.,.>
........,,,,,        ,<..>, <.,.> <.,.> <.,.>
........,,,,,,       ,<..>, ,<..>, <.,.> <.,.>
........,,,,,,,      ,<..>, ,<..>, ,<..>, <.,.>
........,,,,,,,,     ,<..>, ,<..>, ,<..>, ,<..>,
........,,,,,,,,,    <.,.> <.,.> <.,.> <,,,.> <,,,.>
.........            fail
.........,           fail
.........,,          fail
.........,,,         fail
.........,,,,        fail
.........,,,,,       fail
.........,,,,,,      fail
.........,,,,,,,     <.,.> <.,.> <.,.> <.,.> <,,,.>
.........,,,,,,,,    <.,.> <.,.> <.,.> <.,.> <,,,,.>
.........,,,,,,,,,   <.,.> <.,.> <.,.> <.,.> <,,,,,.>
Level River St
quelle
4

Befunge, 249 218 Bytes

&::00p&::00g\`-2/:20p2*-3*:30p\20g-`:!00g20g-*\30g*+:30g-v>:#,_@
"~<.,,>~~"0_v#\g03+`g050`\0:-g02\p05:-\*2g02:-*/6+3g03p04<^
$"<">:#,_40p>:!#|_3-0" >.,,"40g3>3g#<\#-:#1_
0" ,>..<,">:#,_$>:!#|_1-
#@_1-0" >.,.<">:#,_$>:!

Probieren Sie es online!

Dies basiert nun auf dem Algorithmus in der Ruby-Antwort von Level River St , der im Vergleich zu meiner ursprünglichen Lösung mehr Spielraum für das Golfen und eine erhebliche Größenreduzierung bot.

James Holderness
quelle
2

C # 6, 321 303 Bytes

using System.Linq;string F(int x,int y)=>S(x,y)??"~<.,,>~~";string S(int x,int y)=>x<0|y<0?null:y<1?x<1?"":null:y*3>x?S(x-1,y-2)!=null?S(x-1,y-2)+"<.,.> ":S(x-2,y-2)!=null?S(x-2,y-2)+",<..>, ":null:string.Concat(new int[y].Select((_,k)=>k<1?C(x-y*3+3):C(3)));string C(int x)=>$"<{new string(',',x)}.> ";

Rufen Sie an F(). Die beiden anderen Funktionen sind Helfer. Repl.it Demo

// Coalesce failed combinations with commaleon
string F(int x,int y)=>S(x,y)??"~<.,,>~~";
// Get successful combination or null
string S(int x,int y)=>
    x<0|y<0
        // Fail: Out of range
        ?null
        :y<1
            ?x<1
                // Successful: All commas and periods accounted for
                ?""
                // Fail: Not enough periods for commas
                :null
            :y*3>x
                // Not all commapillars
                ?S(x-1,y-2)!=null
                    // Try koala
                    ?S(x-1,y-2)+"<.,.> "
                    // Try crab
                    :S(x-2,y-2)!=null
                        ?S(x-2,y-2)+",<..>, "
                        // Epic fail
                        :null
                // All commapillars
                :string.Concat(new int[y].Select((_,k)=>k<1
                    // This commapillar takes most of commas
                    ?C(x-y*3+3)
                    // The rest each takes 3
                    :C(3)));
// Generate single commapillar
string C(int x)=>$"<{new string(',',x)}.> ";
Link Ng
quelle