Ja aber nein aber ja


46

Mein Kollege hat mir kürzlich das folgende Stück JavaScript als Scherz geschickt:

let butScript = (nrOfButs) => {
    for(var i = 0; i < nrOfButs; i++){
        if(i % 3 == 0){
            console.log("Yeah")
        }
        if(i % 2 == 0){
            console.log("But")
        }
        if(i % 3 == 1){
            console.log("No")
        }
    }
}

Da der Code während der Arbeitszeit geschrieben wurde, war dies offensichtlich eine enorme Verschwendung von Unternehmensressourcen. Um ähnliche Ereignisse in Zukunft zu vermeiden, müssen wir die Verschwendung von Arbeitsstunden minimieren. Und da es allgemein bekannt ist, dass ein kürzeres Programm schneller zu schreiben ist, müssen wir diesen Code so kurz wie möglich halten!

Eingang

Eine einzelne nicht negative Ganzzahl. Sie dürfen keine fehlerhaften Eingaben verarbeiten.

Ausgabe

Ihr Programm muss eine Ausgabe erzeugen, die mit der des obigen Skripts identisch ist. Sie sollten ein Wort pro Zeile ausgeben und die Anzahl der Wörter sollte mit dem ursprünglichen Skript übereinstimmen.

Es ist zulässig, am Ende jeder Zeile (aber nicht am Anfang) Nicht-Leerzeichen einzufügen, da sie unsichtbar sind. Ein zusätzliches Zeilenumbruchzeichen ist am Ende der Ausgabe zulässig.

Beispiele

Input: 0
Output:


Input: 1
Output:
Yeah
But

Input: 2
Output:
Yeah
But
No

Input: 10
Output:
Yeah
But
No
But
Yeah
But
No
Yeah
But
No
But
Yeah

3
Können wir eine Liste von Zeilen zurückgeben?
Jo King

10
Es muss unterhaltsam sein, mit so einem lustigen Kerl zu arbeiten! : s Etwas schwerwiegender: Die nrOfButsVariable hat einen schlechten Namen und ist irreführend. Trotzdem nette einfache Herausforderung.
Arnauld

10
Bekommen wir einen Bonus, wenn die letzte Zeile lautet "Gott kann nicht glauben, dass du das gerade gesagt hast!"
Ciaran_McCarthy

3
@EriktheOutgolfer die ifs fallen durch und fahren in der aktuellen Schleife fort, wenn ihre Bedingung erfüllt war.
Dzaima

4
Der australischste Codegolf überhaupt? Außer es sollte "nah" sein
Nacht - Reinstate Monica

Antworten:


48

Excel, 78 Bytes

Es wird davon ausgegangen, dass die Eingabe in Zelle A1 erfolgt und die Wordwrap-Formatierung für die Zelle aktiviert ist. Verwenden Sie Alt + Eingabetaste, um Zeilenvorschübe in die Zeichenfolge einzufügen und das Leerzeichen zu notieren. Kann aufgrund der eingeschränkten REPT-Funktion nur Eingaben bis zu 3570 verarbeiten.

=LEFT(REPT("Yeah
But
No      
But     
Yeah    
But
No           
",595),A1*9)

Nachdruck mit Leerzeichen

=LEFT(REPT("Yeah
But
No......
But.....
Yeah....
But
No...........
",595),A1*9)

So funktioniert es: Das Muster wiederholt sich alle 6 Zahlen:

0 = Yeah and But      Yeah + linefeed + But + linefeed
1 = No                No + 6 whitespace + line feed
2 = But               But + 5 whitespace + linefeed
3 = Yeah              Yeah + 4 whitespace + linefeed
4 = But and No        But + linefeed + No + 3 whitespace
5 = Blank             8 whitespace + linefeed

Jedes dieser Zeichen kann mit 9 Zeichen ausgedrückt werden. Eine Zeichenfolge besteht also aus 54 Zeichen (9 * 6) und wird so oft wiederholt, wie Excel dies zulässt. Dann werden die linken 9 * (Anzahl der eingegebenen) Zeichen als Ausgabe verwendet.

Der Zeilenvorschub für das "aber und keiner" wird nach dem Leerzeichen eingefügt, sodass das Ja für # 6, # 12 (usw.) eher links als rechts formatiert wird und nicht jede 6. Zeile ein Leerzeilenvorschub hinzugefügt wird für diesen Artikel.

Ausgabe


1
Ich habe keine Möglichkeit, dies zu überprüfen, aber Ihre Beschreibung lässt es richtig erscheinen. Können Sie einige Beispiele für Eingabe / Ausgabe-Paare hinzufügen? Eine der lächerlichsten Sprachen, aber trotzdem eine großartige Antwort.
Maxb

16
@maxb Kann gar nicht so lächerlich sein, wenn es andere Sprachen schlägt.
Keeta

1
Tolle Erklärung und sehr coole Technik. Funktioniert auch in LibreOffice Calc, muss aber möglicherweise mit der Formatierung gespielt werden. +1
ElPedro

20

JavaScript (ES6), 59-57 Byte

f=n=>n?f(n-1)+[s=n&1?`But
`:'',`Yeah
`+s,s+`No
`][n%3]:''

Probieren Sie es online!

Wie?

Wir verwenden eine rekursive Funktion, die von ausgehtn10n1

1

  • wenn , "Yeah" ausn1(mod3)
  • wenn , "Aber" ausn1(mod2)
  • wenn , Ausgabe "Nein"n2(mod3)

Dies ermöglicht es uns, den einfacheren Fall als ersten Eintrag unseres Nachschlage-Arrays zu speichern , in dem wir definieren können : eine Variable, die entweder eine leere Zeichenfolge enthält.n0(mod3)s"But\n"

Die beiden anderen Einträge sind als "Yeah\n" + sund definiert s + "No\n".

Hinweis: Wenn Sie von bis iterieren , könnten Sie auch im ersten Eintrag definieren , dies würde jedoch zwei zusätzliche Klammern kosten .n10s

Kommentiert

f = n =>            // n = input
  n ?               // if n is not equal to 0:
    f(n - 1) +      //   prepend the result of a recursive call with n - 1
    [               //   define our lookup array:
      s = n & 1 ?   //     1st entry: if n is odd:
        `But\n`     //       set s to "But"
      :             //     else:
        '',         //       set s to an empty string
      `Yeah\n` + s, //     2nd entry: "Yeah" followed by s
      s + `No\n`    //     3rd entry: s followed by "No"
    ][n % 3]        //   append the correct entry for this iteration
  :                 // else:
    ''              //   return an empty string and stop recursion

16

LOLCODE , 257 Bytes

HAI 1.2
I HAS A B
GIMMEH B
B IS NOW A NUMBR
I HAS A C ITZ 0
IM IN YR L UPPIN YR C TIL BOTH SAEM B AN C
I HAS A D ITZ MOD OF C AN 3
D
WTF?
OMG 0
VISIBLE "Yeah"
OIC
MOD OF C AN 2
WTF?
OMG 0
VISIBLE "But"
OIC
D
WTF?
OMG 1
VISIBLE "No"
OIC
IM OUTTA YR L
KTHXBYE

Probieren Sie es online!


2
Es sieht fantastisch aus (ich würde es hassen, das zu codieren!), Aber im Testfall 10 werden das 2. "Nein" und das 3. "Aber" umgedreht ... Also ja, aber nein: D
seadoggie01

2
Hoppla, dachte ich könnte dort optimieren. Dies ist ein kniffliges Muster. Ich habe es jetzt behoben.
JosiahRyanW

1
Ich liebe die Art, wie es liest
LocustHorde

4
Bezieht VISIBLE "But"sich das auf den Hosenmangel des Programms?
JDL

12

Whitespace , 315 304 300 277 276 Bytes

Dank @JoKing für -11 Byte (Reduzierung der Anzahl der verwendeten Labels von 8 auf 7) und -24 Byte mehr (Änderung des allgemeinen Programmflusses und Reduzierung der Anzahl der verwendeten Labels von 7 auf 5).

[S S S N
_Push_0][T  N
T   T   _Read_STDIN_as_integer][N
S S N
_Create_Label_LOOP][S S S N
_Push_0][T  T   T   _Retrieve][N
T   S S N
_If_negative_jump_to_Label_PRINT][S S S N
_Push_0][T  T   T   _Retrieve][S S S T  T   N
_Push_3][T  S T T   _Modulo][S S S T    S N
_Push_2][T  S S T   _Subtract][N
T   T   T   N
_If_negative_jump_to_Label_SKIP_NO][S S T   T   S T T   T   T   S N
_Push_-94_\n][S S S T   T   T   N
_Push_7_o][S S T    T   T   S T S N
_Push_-26_N][N
S S T   N
_Create_Label_SKIP_NO][S S S N
_Push_0][T  T   T   _Retrieve][S S S T  S N
_Push_2][T  S T T   _Modulo][N
T   S S S N
_If_0_jump_to_Label_SKIP_BUT][S S T T   S T T   T   T   S N
_Push_-94_\n][S S S T   T   S S N
_Push_12_t][S S S T T   S T N
_Push_13_u][S S T   T   S S T   T   S N
_Push_-38_B][N
S S S S N
_Create_Label_RETURN_FROM_BUT][S S S N
_Push_0][S N
S _Duplicate_0][S N
S _Duplicate_0][T   T   T   _Retrieve][S S S T  N
_Push_1][T  S S T   _Subtract][T    T   S _Store][T T   T   _Retrieve][S S S T  T   N
_Push_3][T  S T T   _Modulo][N
T   S S T   N
_If_0_jump_to_Label_YEAH][N
S N
N
_Jump_to_Label_LOOP][N
S S S T N
_Create_Label_YEAH][S S T   T   S T T   T   T   S N
_Push_-94_\n][S S S N
_Push_0_h][S S T    T   T   T   N
_Push_-7_a][S S T   T   T   N
_Push_-3_e][S S T   T   T   T   T   N
_Push_-15_Y][N
S N
N
_Jump_to_Label_LOOP][N
S S S N
_Create_Label_PRINT][S S S T    T   S T S S S N
_Push_104][T    S S S _Add][T   N
S S _Print_as_character][N
S N
N
_Jump_to_Label_LOOP]

Buchstaben S(Leerzeichen), T(Tabulator) und (Zeilenvorschub) werden Nnur als Hervorhebungen hinzugefügt.
[..._some_action]nur als Erklärung hinzugefügt.

Probieren Sie es online aus (nur mit Leerzeichen, Tabulatoren und Zeilenumbrüchen).

Whitespace ist definitiv nicht die richtige Sprache für diese Herausforderung. In Whitespace werden sowohl Schleifen als auch if-Anweisungen mit Bezeichnungen und Sprüngen zu Bezeichnungen erstellt, und da es sich nicht um if-else-Fälle handelt, sondern um mehrere if-Fälle, bedeutet dies I muss nach jedem if zurückspringen, was bedeutet, dass ich die Checks leicht ändern muss, um einige Ausdrucke zu überspringen (danke @JoKing ).

Erklärung im Pseudocode:

Read STDIN as integer, and store it in the heap
Start LOOP:
  Integer i = retrieve integer from heap
  If(i is negative):
    Call function PRINT
  If(i modulo-3 is NOT 2):
    Jump to Label SKIP_NO
  Push "\noN" to the stack
  Label: SKIP_NO
  If(i modulo-2 is 0):
    Jump to Label SKIP_BUT
  Push "\ntuB" to the stack
  Label: SKIP_BUT
  i = i - 1
  Replace i in the heap with this updated value
  If(i modulo-3 is 0):
    Call function YEAH
  Go to next iteration of LOOP

function YEAH:
  Push "\nhaeY" to the stack
  Go to next iteration of LOOP

function PRINT:
  Print top of the stack as character to STDOUT
  Go to next iteration of LOOP (which will enter the if and then
                                comes back to this PRINT again)

Zusätzliche Erklärung:

Im Allgemeinen wird eine Schleife von der Eingabe bis auf 0 ausgeführt, wobei eine neue Zeile eingefügt und das Wort umgekehrt wird (also in der Reihenfolge "\ noN", "\ ntuB", "\ nhaeY" anstelle von "Yeah \ n", "But \ n "," Nein \ n "). Nachdem die Eingabe auf 0 zurückgesetzt wurde und sich alle Zeichen auf dem Stapel befinden, werden diese Zeichen in umgekehrter Reihenfolge gedruckt (also in der richtigen Ausgabereihenfolge).

Ausführlicher jedoch: Obwohl wir Wörter im Bereich drucken müssen (input, 0], wird [input, 0)stattdessen eine Schleife im Bereich ausgeführt . Aus diesem Grund können wir die Prüfung if(i%3 == 2)für "\ noN" verwenden (oder if(i%3 != 2)das Verschieben von "\ noN" überspringen), und wir können die Prüfung if(i%2 != 1)für "\ ntuB" verwenden (oder if(i%2 == 0)das Verschieben von "\ ntuB" tatsächlich überspringen ). Erst nach diesen beiden Überprüfungen wird die Iteration ium 1 verringert. Anschließend wird überprüft if(i%3 == 0), ob "\ nhaeY" gedrückt wurde, ähnlich wie im JS-Beispielcode in der Beschreibung der Herausforderung. Überspringen mit If-Not-Checks, anstatt zu einem Label zu wechseln, und Zurückkehren vom Label mit If-Checks, die 23 Byte gespeichert haben.

Außerdem werden in Whitespace Zeichenwerte als Unicode-Werte im Stapel gespeichert (dh 10für Zeilenumbrüche, 65für 'A', 97für 'a' usw.). Da ich den Stapel bereits durchlaufen muss, um die Zeichen zu drucken, kann ich auch meinen Whitespace-Tipp verwenden , um die Byteanzahl zu verringern , indem ich den Zahlenwerten eine Konstante hinzufüge, bevor ich sie als Zeichen drucke.
Diese Konstante ist 104in diesem Fall die Konstante , die mit diesem Java-Programm generiert wird, mit dem ich auch schon eine andere Whitespace-Antwort von mir gespielt habe . Das ist auch der Grund, warum dieser Teil des Codes:

[S S T  T   S T T   T   T   S N
_Push_-94_\n][S S S T   T   T   N
_Push_7_o][S S T    T   T   S T S N
_Push_-26_N]

hat die Werte -94für die Newline, 7für das 'o' und -26für das 'N'. Da das Hinzufügen der Konstante 104korrekt unsere Unicode - Werte geben 10, 111und 78für diese Zeichen sind.


1
Ich habe mit Sicherheit keine Whitespace-Antwort erwartet. Gut gemacht!
Maxb

@ maxb Danke! Leider ist es aufgrund der 8 benötigten Labels etwas länger als erwartet. Aber ich bin schon froh, dass es funktioniert. :)
Kevin Cruijssen

Konnten Sie die Beschriftungen nicht halbieren, indem Sie zur nächsten if-Anweisung springen, wenn die Bedingung falsch ist? zBif i modulo-3 != 1 jump to next if else push NO
Jo King

1
@JoKing Ah warte, ich habe einen Teil deines Pseudocodes falsch verstanden. Meine erste Ausgabe über das Abrufen nicht ivor dem if(i is 0) call PRINTist wahr, aber Ihre andere prüft das, ibevor sie es subtrahiert und über die Drucke überspringt. Eigentlich ziemlich schlau. Wird es weiterhin implementieren.
Kevin Cruijssen

1
Wenn Sie zum Anfang der Schleife springen, wird die if-Anweisung erneut ausgeführt und Sie kehren direkt zur Druckfunktion zurück. Vielleicht spart dies ein Byte, wenn Sie das Loop-Label in ein leeres Label ändern
Jo King,


11

Perl 6 , 63 50 Bytes

{<<"Yeah But"No But Yeah"But No">>[^$_ X%6].words}

Probieren Sie es online!

Anonymer Codeblock, der eine Nummer annimmt und eine Liste von Zeilen zurückgibt

Erläuterung:

{                                                }   # Anonymous code block
 <<"Yeah But"No But Yeah"But No">>  # Create the list of strings:
                                     # Yeah But
                                     # No
                                     # But
                                     # Yeah
                                     # But No
                                  [       ]  # Index into this list
                                   ^$_  # The range from 0 to n-1
                                       X%6  # All modulo 6
                                           .words  # Convert the list to a string 
                                                   # Which joins by spaces
                                                   # And split by whitespace


8

05AB1E (Legacy) , 27 25 24 Byte

Dank Kevin Cruijssen 1 Byte gespeichert .

F”¥æ€³€¸”#N3ÖNÈN3%‚‚˜Ï`»

Probieren Sie es online!

Erläuterung

F                          # for N in [0 ... input] do:
 ”¥æ€³€¸”#                 # push ['Yeah', 'But', 'No']
          N3Ö              # push N % 3 == 0
             NÈ            # push N % 2 == 0
               N3%         # push N % 3
                  ‚‚˜      # add the 3 numbers to a list
                     Ï     # keep only the strings whose corresponding value  
                           # in the int list is true (1)
                      `»   # push strings separately to stack and join stack on newlines

Scheiße, du hast mich verprügelt. Ich wollte gerade eine Antwort posten. Deine ist sowieso kürzer, also +1 von mir. Gute Verwendung ×, hatte nicht darüber nachgedacht!
Kevin Cruijssen

Wow, ich hätte gerne eine Erklärung dazu. Meine persönliche Bestzeit war 44 Bytes in CJam.
Maxb

@maxb: Ich werde natürlich eine Erklärung hinzufügen. Ich überprüfe nur, ob ich zuerst etwas mehr Golf spielen kann;)
Emigna

Sie können das Θjetzt entfernen, das Sie nicht mehr verwenden ×, da Ïnur 1s angezeigt werden, sodass es das ignoriert 2(und 0natürlich).
Kevin Cruijssen

@ KevinCruijssen: Danke! Nicht sicher, wie ich das verpasst habe: P
Emigna


6

Python 2 , 97 95 92 90 83 81 Bytes

lambda n:[w for i in range(n)for w in'Yeah','But','No'if('N'in w)==i%(3-(w<'N'))]

Probieren Sie es online!

-2 Bytes dank ovs


Python 3 , 92 90 85 83 Bytes

lambda n:[w for i in range(n)for w in['Yeah','But','No']if('N'in w)==i%(3-(w<'N'))]

Probieren Sie es online!

-4 Bytes dank ovs

-4 Bytes, danke an Jo King


86 Bytes durch Kombination der beiden und Rückkehr als Liste von Zeilen
Jo King

@JoKing Danke, wusste nicht, dass ich zurückkehren könnte, anstatt zu drucken, als ich es schrieb.
TFeld

82 Bytes : len(w)<3-> 'N'in w, 81 Bytes : len(w)%2->(w<'N')
ovs


6

Groovy (Funktion), 79 Bytes

Seit ich meine Antwort ursprünglich eingereicht habe, habe ich hier einige historische Diskussionen darüber durchgesehen, was eine geeignete Antwort darstellt. Da es allgemein anerkannt ist, nur eine Methode in Java bereitzustellen (einschließlich Rückgabetyp- und Parameterdeklarationen), ist hier eine kürzere Groovy-Methode, deren Rückgabewert die Antwort ist. Verwendung von defbedeutet, dass der Rückgabetyp abgeleitet wird.

def a(int n){n?a(--n)+(n%3?'':'Yeah\n')+(n%2?'':'But\n')+(n%3==1?'No\n':''):''}

Anders als die ursprüngliche Antwort unten, die von 0 bis n-1 durchläuft, ruft diese sich selbst von n bis 1 auf, dekrementiert jedoch die Eingabe für den Rest der Zeile im rekursiven Aufruf.

Probieren Sie es online!

Groovy (Programm), 87 Bytes

Groovy - Skripte erfordert keine bestimmten gemeinsame Importe, so dass dies ein Programm , das Drucken , ohne dass die Antwort auf Java STDOUT sein kann , erklären , System.out.vor print. Es werden auch einige gängige Dienstprogrammmethoden toLong()bereitgestellt, mit denen wir das Eingabeargument einigermaßen konsistent analysieren können.

Im Wesentlichen die Java 10-Antwort, aber unter Ausnutzung der kürzeren Loop-Syntax von Groovy und der Fähigkeit, wahrheitsgemäße Aussagen zu bewerten.

args[0].toLong().times{print((it%3?'':'Yeah\n')+(it%2?'':'But\n')+(it%3==1?'No\n':''))}

Probieren Sie es online!


Willkommen bei PPCG! Tolle erste Antwort! Ich habe selbst noch keinen Groovy-Code geschrieben, aber kann ich vorschlagen, Ihren Code auf TIO auszuführen ? Auf diese Weise kann es von anderen validiert und von allen genossen werden.
Maxb

1
@ maxb Danke! Ich habe eine hinzugefügt :)
archangel.mjj

Schöne erste Antwort und auch willkommen bei PPCG.
ElPedro

5

Retina 0,8,2 , 45 Bytes

.+
$*
1
$`Yeah¶$`But¶$`11No¶
+`11B
B
111

A`1

Probieren Sie es online! Erläuterung:

.+
$*

Konvertieren Sie die Eingabe in Unary.

1
$`Yeah¶$`But¶$`11No¶

0...n-1Generieren Sie für jede Ganzzahl drei Textzeilen, eine für jedes Wort mit einem i 1vorangestellten s, mit Ausnahme von Nozwei zusätzlichen 1s, damit wir berechnen, (i+2)%3==0was äquivalent zu ist i%3==1.

+`11B
B

Entfernen Sie Paare von 1s vor Bs.

111

Entferne 1s in Dreiergruppen überall.

A`1

Löschen Sie alle Zeilen mit einem 1.


Oh, jetzt, wo ich 11No¶rechnen sehe (i+2)%3==0(also sind alle drei If-Checks ==0), sieht es so offensichtlich aus, aber ich hätte das selbst nicht gedacht, also ist es eigentlich ziemlich genial. +1 von mir, nette Antwort!
Kevin Cruijssen

5

Java 10, 100 99 Bytes

n->{for(int i=0;i<n;)System.out.print((i%3<1?"Yeah\n":"")+(i%2<1?"But\n":"")+(++i%3>1?"No\n":""));}

-1 Byte danke an @ OlivierGrégoire .

Probieren Sie es online aus.

Erläuterung:

n->{                   // Method with integer parameter and no return-type
  for(int i=0;i<n;)    //  Loop `i` in the range [0, `n`)
    System.out.print(  //   Print to STDOUT:
      (i%3<1?          //    If `i` is divisible by 3:
        "Yeah\n"       //     Print "Yeah" with newline
      :"")+(i%2<1?     //    If `i` is even:
        "But\n"        //     Print "But" with newline
      :"")+(++i%3>1?   //    If `i` modulo-3 is 1:
        "No\n"         //     Print "No" with newline
      :                //    If none of the above three if's applied to the current `i`:
       ""));}          //     Print nothing for the current `i`

1
++i%3>1werden Sie wahrscheinlich ein Byte speichern
Olivier Grégoire

@ OlivierGrégoire Ah, natürlich. Vielen Dank!
Kevin Cruijssen

5

Powershell, 75 74 72 67 66 Bytes

-1 Byte danke TessellatingHeckler

param($n)(" Yeah
But No But Yeah But
No "*$n-split' ')[1..$n]-ne''

Testskript und Erklärung:

$f = {

param($n)(" Yeah
But No But Yeah But
No "*$n-split' ')[1..$n]-ne''

# 1. repeat the string $n times
# 2. split by space
# 3. get elements from 1 to $n
# some elements are multiline strings, some elements are $null:
# ($null,"Yeah`nBut","But","No","But","Yeah","But`nNo",$null,...)
# 4. remove $null elements from result array

}

# Output results
@(
    0,1,2,10
) | % {
    &$f $_
    "======"
}

# Advanced test
@(
    ,(0,'')
    ,(1,'Yeah But')
    ,(2,'Yeah But No')
    ,(3,'Yeah But No But')
    ,(4,'Yeah But No But Yeah')
    ,(5,'Yeah But No But Yeah But No')
    ,(6,'Yeah But No But Yeah But No')
    ,(7,'Yeah But No But Yeah But No Yeah But')
    ,(8,'Yeah But No But Yeah But No Yeah But No')
    ,(9,'Yeah But No But Yeah But No Yeah But No But')
    ,(10,'Yeah But No But Yeah But No Yeah But No But Yeah')
    ,(20,'Yeah But No But Yeah But No Yeah But No But Yeah But No Yeah But No But Yeah But No Yeah But No')
) | % {
    $n,$e = $_
    $r = &$f $n
    $r = $r-split"`n"       # simplify test string
    "$($e-eq$r): $n : $r"
}

Ausgabe:

======
Yeah
But
======
Yeah
But
No
======
Yeah
But
No
But
Yeah
But
No
Yeah
But
No
But
Yeah
======
True: 0 :
True: 1 : Yeah But
True: 2 : Yeah But No
True: 3 : Yeah But No But
True: 4 : Yeah But No But Yeah
True: 5 : Yeah But No But Yeah But No
True: 6 : Yeah But No But Yeah But No
True: 7 : Yeah But No But Yeah But No Yeah But
True: 8 : Yeah But No But Yeah But No Yeah But No
True: 9 : Yeah But No But Yeah But No Yeah But No But
True: 10 : Yeah But No But Yeah But No Yeah But No But Yeah
True: 20 : Yeah But No But Yeah But No Yeah But No But Yeah But No Yeah But No But Yeah But No Yeah But No

Einfaches Skript, 72 Bytes:

$args|?{$_}|%{0..--$_|%{@('Yeah')[$_%3]
@('But')[$_%2]
@{1='No'}[$_%3]}}

1
Gute Antwort! Wäre es möglich, der Antwort eine Ausgabe hinzuzufügen, da sie keinen Online-Dolmetscher enthält?
Maxb

Der Antwortskriptblock wird nicht zurückgegeben ======. Es werden Yeah,But,Nonur Strings generiert . Das Testskript enthält ein Trennzeichen, das nur das Lesen der Ergebnisse erleichtert.
mazzy

Diese Verwendung von Hashtabellen ist clever. Ich werde mich daran erinnern müssen.
AdmBorkBork


1
@mazzy Ich kann deine umformulieren, aber ich kann immer noch nicht 67 schlagen (ersetze die beiden durch echte Newlines)(" Yeah\nBut No But Yeah But\nNo "*($j="$args")|% s*t 32)[1..$j]-ne''
TessellatingHeckler

4

Haskell , 71 Bytes

f n=[1..n]>>=(3?1)"Yeah"<>(2?1)"But"<>(3?2)"No"
(a?b)c n=[c|n`mod`a==b]

Probieren Sie es online!

Erläuterung

Ziemlich einfach, zwei Bytes gespart, indem [1..n]stattdessen [0..n-1]die restlichen verwendet und angepasst werden: Der Operator (?)testet vier Argumente und gibt eine leere Liste oder die bereitgestellte Zeichenfolge als Singleton zurück, wenn das Ergebnis korrekt ist.

Durch Aufrufen des vierten Arguments von können (?)wir (<>)die Ergebnisse jeder Funktion verketten, dh:

(3?1)"Yeah" <> (2?1)"But" <> (3?2)"No"  \i-> (3?1)"Yeah" i ++ (2?1)"But" i ++ (3?2)"No" i


4

Pip , 37 35 33 Bytes

"But 
Yeah
No
"<>5@:^[t2io02x]@<a

(Beachten Sie das Leerzeichen danach But.) Nimmt Eingaben als Befehlszeilenargument entgegen. Probieren Sie es online!

Erläuterung

Diese Erklärung gilt für die vorherige Version - siehe unten für das Änderungsprotokoll

Inspiriert von Jo Kings Perl 6 Antwort . Wir erstellen diese Liste:

[
 "Yeah
 But
 ";
 "No
 ";
 "But
 ";
 "Yeah
 ";
 "But
 No
 ";
 ""
]

und die ersten aElemente davon unter Verwendung einer zyklischen Indizierung auszugeben .

[t2io02x]R,3["But""Yeah""No"].n@<:a
                                     i is 0; o is 1; t is 10; x is ""; n is newline;
                                     a is 1st cmdline arg (implicit)
[       ]                            Construct this list of scalars:
 t                                    10
  2                                   2
   i                                  0
    o                                 1
     02                               02
       x                              <empty string>
         R                           Treating each of these as a string, we're going to
                                     replace:
          ,3                          0, 1, and 2 (respectively)
                                     with the corresponding values from this list:
            ["But""Yeah""No"].n       These strings, each with a newline appended
                                     We now have constructed the list shown above
                               @<:a  Take the first a elements from this list, with
                                     cyclical indexing (the : is for parsing reasons)
                                     Concatenate them together and print (implicit)

Update: Ich habe festgestellt, dass ich "Ersetzen" nicht verwenden muss, um 0/1/2 in Zeichenfolgen zu ändern. Mit diesen Zahlen kann ich eine Liste direkt indizieren. Dazu müssen wir sicherstellen, dass die mehrstelligen Nummern in Listen mit ihren Ziffern aufgeteilt sind (andernfalls wählen wir Index 10 anstelle der Indizes 1 und 0). Glücklicherweise funktioniert die Verwendung einer willkürlich verschachtelten Liste als Index in Pip erwartungsgemäß und gibt eine (verschachtelte) Ergebnisliste aus. Für die Eingabe von 3 erhalten wir diesen Datenfortschritt (wobei _eine neue Zeile darstellt):

"But _Yeah_No_"<>5                       ["But _"; "Yeah_"; "No_"]
                     [t2io02x]           [10; 2; 0; 1; 02; ""]
                              @<a        [10; 2; 0]
                    ^                    [[1; 0]; [2]; [0]]
                  @:                     [["Yeah_"; "But _"]; ["No_"]; ["But _"]]

Nach wie vor wird das Endergebnis zusammengefügt und automatisch gedruckt.


4

Attache , 48 Bytes

Flat##{Mask[_%3'2'3=0'0'1,$Yeah'$But'$No]}=>Iota

Probieren Sie es online!

Erläuterung

Flat##{Mask[_%3'2'3=0'0'1,$Yeah'$But'$No]}=>Iota   input: an integer
      {                                  }=>Iota   over each number from 0 to that integer exclusive
       Mask[             ,$Yeah'$But'$No]          select values from that array according to:
            _%3'2'3                                    whether or not the input mod 3, 2, 3
                   =0'0'1                              is 0, 0, 1
Flat##                                             flatten the intermediate results

4

C (gcc) , 77 71 74 72 69 Bytes

Es gibt hier bereits eine bessere C- Antwort, aber diese ist rekursiv und ich habe einige Zeit gebraucht, um klar zu kommen, also poste ich sie.

Bis zu 69 Bytes dank @ceilingcat und @JonathanFrech

(Ich denke nie daran, n- ~ -i anstelle von n-i + 1 zu verwenden.)

i;f(n){i=n&&n-i>=~n/6&&f(n,i++,puts(i%7%4?i%7%2?"But":"No":"Yeah"));}

Probieren Sie es online!


@ JonathanFrech Schön, aber funktioniert nicht für null oder 5
Cleblanc

@cleblanc Oh, entschuldigung. Wusste nicht ... Zumindest das Entfernen jhat dir zwei Bytes erspart.
Jonathan Frech

1
70 Bytes - Einschließlich eines gespeicherten Bytes von @ ceilingcat.
Jonathan Frech

1
n-~-ientspricht n-i+1- nicht i<n+1- und speichert so eigentlich keine Bytes ...
Jonathan Frech

3

Rubin, 69 72 74 Bytes

->y{puts *(1..y).map{|i|[i%3==1&&:Yeah,i%2>0&&:But,i%3>1&&:No]-[!0]}}

Sehr direkte Antwort, die gerade nach einer kürzeren, rekursiven Methode sucht.

Zwei Bytes dank @BWO gespart :)

Weitere drei Bytes mit Symbolen anstelle von Zeichenfolgen gespeichert


3

Python 3, 93 Bytes

[print("Yeah\n"*(i%3<1)+"But\n"*(i%2<1)+"No\n"*(i%3==1),end="")for i in range(int(input()))]

Dies ist nicht gerade die beste Lösung, aber ich übernehme sie.

Probieren Sie es online!


1
Wenn Sie bereits einen Ausdruck haben, den Sie in einem Listenverständnis verwenden können, Ihr Listenverständnis jedoch nur dazu dient, die Nebenwirkungen dieses Ausdrucks hervorzurufen, benötigt eine einfache for-Schleife weniger Bytes.
Jonathan Frech

3

R, 65 Bytes

cat(c("yeah","but","no")[c(3,1:3,2,1,2)][1:scan()%%7+1],sep="\n")

Aufgrund der Tatsache, dass wir ein leicht fehlerhaftes Programm replizieren (es lässt jedes vierte "aber" aus - es sollte verwendet werden %4 == 1und %4 == 3nicht die %3Bedingungen), müssen wir einen umständlichen Aufruf an die cBasis 7 senden und in dieser arbeiten. Trotzdem ist es kürzer als LOLCODE ...

(Ich hatte gehofft, dass (3,1,2,3,2,1,2) oder eine ähnliche Permutation lhirgendwo im Datensatz erscheinen könnte, aber es sieht nicht so aus)


3

sed -E ,179 150 Bytes

/^0/!s:$:g:
:l;y:abcdefg:bcdefga:
/[ae]/iYeah
/[bdf]/iBut
/[cg]/iNo
s:.$:-&:;:s;s:0-:-9:;ts;h
y:123456789:012345678:;G
s:.*(.)-.*\n(.*).-:\2\1:;tl;c\ 

Das Schwierigste war, nicht die Liste zu erstellen, sondern die Dezimalzahl zu analysieren.

2 Bytes können gespeichert werden, wenn die Zeilenumbrüche am Ende nicht benötigt werden: c\ d.

Muss noch optimiert werden.

Probieren Sie es online aus .

Erläuterung

/^0/!                            | if the input number doesn`t begin with a '0'…
     s:$:g:                      | …then append a 'g' to it and proceed
                                 |
:l;                              | loop label 'l':
   y:abcdefg:bcdefga:            | shift all occurences of [abcdef] 1 letter forward, and all 'g'-s to 'a'-s
                                 |
/[ae]/                           | if there`s an 'a' or 'e' in the input…
      iYeah                      | …output 'Yeah'
                                 |
/[bdf]/                          | if there`s a 'b' or 'd' or 'f' in the input…
       iBut                      | …output 'But'
                                 |
/[cg]/                           | if there`s a 'c' or 'g' in the input…
      iNo                        | …output 'No' 
                                 |
s:.$:-&:;                        | insert '-' before the last character
         :s;                     | loop label 's':
            s:0-:-9:;            | transform the next consecutive '0' in the end of the number to '9', if any
                     ts;         | loop to 's' if more consecutive zeroes are available
                        h        | copy the result to the temporary buffer
                                 |
y:123456789:012345678:;          | decrement all digits except '0' (N.B.: digits, not numbers)
                       G         | append the temporary buffer to the result
                                 |
s:.*(.)-.*\n(.*).-:\2\1:;        | cut and replace the digit left to the last consecutive 0 in the original
                                 | number pasted from the temporary buffer, then discard all other digits decremented
                         tl;     | …then loop to 'l' if the number is ≥0
                            c\   | insert a carriage return and exit

Können Sie bitte einige Erklärungen hinzufügen?
user285259

1
@ user285259 Fertig.
Hidefromkgb


2

F #, 108 106 Bytes

let v p=seq{for i=1 to p do
 if i%3=1 then yield"Yeah"
 if i%2=1 then yield"But"
 if i%3=2 then yield"No"}

Probieren Sie es online!

-2 Bytes, die sich von i=0 to p-1zu ändern i=1 to pund Module anpassen. Ansonsten ziemlich unkompliziert.


1
Ich erhalte eine Art Build-Fehler für den TIO-Link, möglicherweise einen Syntaxfehler im Testcode.
Maxb

Dank dafür. Meine ursprüngliche Lösung wurde direkt auf die Konsole gedruckt, aber dann habe ich versucht, eine Sequenz zurückzugeben, und es stellte sich heraus, dass sie um etwa 2 Byte kürzer war. Also habe ich den Code im TIO geändert, aber vergessen, die Fußzeile zu aktualisieren - was immer noch erwartete, dass die vFunktion alles druckt.
Ciaran_McCarthy

2
Rasieren Sie 2 Bytes mit i=1 to p(und stellen Sie natürlich die Module ein). Umgekehrte Bereiche sind leer. :)

Nett! Ich habe das hinzugefügt. Vielen Dank! :)
Ciaran_McCarthy

2

PHP, 65 68 Bytes

while($i<$argn)echo["Yeah
"][$i%3],["But
"][$i%2],["No
"][~-$i++%3];

Laufen Sie als Pipe mit -nRoder versuchen Sie es online .


Es sieht gut aus, aber es erzeugt eine zusätzliche Zeile in der Mitte für n = 10
maxb

@maxb Danke für den Hinweis. Ich hätte es mit 9 zusätzlichen Bytes reparieren können; Der andere Ansatz ist jedoch kürzer.
Titus

2

VBA (Excel), 105, 101, 99 Bytes

Edit: -4 Bytes von Keeta! Vielen Dank!

Editiere 2: -2 Bytes von Chronocidal! Woot! (Es wurde erkannt, dass Testfälle nur für 10 funktionierten. Jetzt behoben)

Ja, Excel hat diesmal VBA geschlagen. Wie auch immer. (Wir kommen für Sie)

d=vbCr:For i=1To[a1]:a=i Mod 3:?IIf(a=1,"Yeah"+d,"")IIf(i/2=i\2,"","But"+d)IIf(a=2,"No"+d,"");:Next

^ Dies wird in das Direktfenster eingefügt und in das Debug-Fenster ausgegeben

Ungolfed

d = vbCr
'For 1 to the value in A1 (using 0 gave extra values, and VBA skips the for loop if 0)
For i = 1 To [a1]    'aka: Range("A1").value
    a = i mod 3
    '? is the same as Print (Debug.Print when not in the Immediate Window)
    Print IIf(a = 1, "Yeah" + d, "") _ '<-- Just a line continuation
          'Keeta taught me that the \ operator is division with truncation,
          '     so if they are equal then there is no remainder!
          IIf(i / 2 = i \ 2, "", "But" + d) _
          IIf(a = 2, "No" + d, "");
    'Print usually prints a newline, but it still outputs if the string is blank...
    '   So we append a newline -if true- and use a semi-colon to kill the newline
Next

@ Keeta gute Idee, aber nein ... Wenn Sie sich meinen ersten Code ansehen, verwende ich [a1], was bedeutet, Range / cell .value :) Ich hätte klarer machen sollen, dass dies eine Erklärung war, sorry: /
seadoggie01

1
Ja, das habe ich gesehen und versucht, den Kommentar zu löschen. Wie wäre es mit i / 3 = i \ 3 anstelle von i mod 3 = 0 (und dasselbe für mod 2 = 0). Ich habe es nicht ausprobiert, aber würde es funktionieren?
Keeta

@ Keeta Ich habe den Operator \ noch nie zuvor gesehen ... Ich glaube aber nicht, er gibt den Wert der Division ohne den Rest zurück ... wie das Gegenteil von Mod, denke ich
seadoggie01

Eins ist Ganzzahldivision und eins ist Gleitkomma. 7/3 = 2.3333, wobei 7 \ 3 = 2 (Teilung abschneiden). 6/3 sollte 2 sein, und 6 \ 3 sollte auch 2 sein, so dass es funktionieren sollte, wenn der Rest Null ist (denke ich).
Keeta,

1
VBA verkettet die Funktionsausgaben automatisch, sodass Sie die &IIf(..)
Werte

2

Jelly , 22 Bytes

5Rż7FṚṁị“'⁴\ÆẓNƇ»ḲŒP¤Ẏ

Ein monadischer Link mit einer Liste von Zeilen (was in Kommentaren erlaubt zu sein scheint)

Probieren Sie es online! (Die Fußzeile nennt den Link usingÇund verbindet sich mit Newlines using,Yda implizites Drucken in Jelly alles zusammenbricht, wenn es geht.)

Wie?

2×3=6

Beachten Sie nun, dass die ersten sechs Werte sind:

["Yeah", "But"]
["No"]
["But"]
["Yeah"]
["But", "No"]
[]

In der resultierenden Zeilenliste sollten diese Werte also wiederholt (oder abgeschnitten) werden, um die Länge miteinander zu nverketten.

Beachten Sie nun, dass die Potenz von "Yeah", "But", "No":

[]
["Yeah"]
["But"]
["No"]
["Yeah", "But"]
["Yeah", "No"]
["But", "No"]
["Yeah", "But", "No"]

Also ist jede Periode diese 1-indizierten Werte der Potenzmenge von "Yeah", "But", "No":

5, 4, 3, 2, 7, 1

Der Code erstellt diese Liste, formt sie auf Länge n, indiziert sie im Power-Set und entfernt dann die inneren Listen (wodurch auch die leeren Zeichenfolgen entfernt werden, da Zeichenfolgen Listen in Jelly sind) ...

5Rż7FṚṁị“'⁴\ÆẓNƇ»ḲŒP¤Ẏ - Link: integer, n   e.g. 10
5                      - literal five            5
 R                     - range                   [1,2,3,4,5]
   7                   - literal seven           7
  ż                    - zip together            [[1,7],[2],[3],[4],[5]]
    F                  - flatten                 [1,7,2,3,4,5]
     Ṛ                 - reverse                 [5,4,3,2,7,1]
      ṁ                - mould like (n)          [5,4,3,2,7,1,5,4,3,2]
                    ¤  - nilad followed by link(s) as a nilad:
        “'⁴\ÆẓNƇ»      -   compressed string     "Yeah But No"
                 Ḳ     -   split at spaces       ["Yeah","But","No"]
                  ŒP   -   power-set             [[],["Yeah"],["But"],["No"],["Yeah","But"],["Yeah","No"],["But","No"],["Yeah","But","No"]]
       ị               - index into              [["Yeah","But"],["No"],["But"],["Yeah"],["But","No"],[],["Yeah","But"],["No"],["But"],["Yeah"]]
                     Ẏ - tighten                 ["Yeah","But","No","But","Yeah","But","No","Yeah","But","No","But","Yeah"]

Ich bezweifle, dass es kürzer wird. Fantastische Antwort und eine tolle Erklärung, gut gemacht!
Maxb

2

Python 2 , 93 92 83 Bytes

lambda i:''.join('Yeah\n'*(x%3<1)+'But\n'*(x%2<1)+'No\n'*(x%3==1)for x in range(i))

Probieren Sie es online!

Massive 9 Bytes, die dank @Jonathan Frech gespeichert wurden


Sie können anstelle der Tupelindizierung auch die Wiederholung von Zeichenfolgen verwenden - ('','Yeah\n')[x%3<1]entspricht "Yeah\n"*(x%3<1).
Jonathan Frech

@ JonathanFrech - sehr cool! Eine ähnliche Technik kann auch auf die anderen Fälle angewendet werden. Danke vielmals!
ElPedro
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.