Test di molteplicità

21

Utilizzare qualsiasi linguaggio di programmazione per visualizzare numeri compresi tra 1 e 99 (inclusi entrambi) in modo tale che:

  • i numeri sono separati da un singolo spazio,
  • se un numero è divisibile per 3, dovrebbe essere tra parentesi,
  • se un numero è divisibile per 4, dovrebbe essere tra parentesi quadre,
  • se un numero è divisibile per 3 e 4, dovrebbe essere tra parentesi e parentesi quadre (con parentesi quadre più vicine al numero).

Il programma dovrebbe visualizzare esattamente:

1 2 (3) [4] 5 (6) 7 [8] (9) 10 11 ([12]) 13 14 (15) [16] 17 (18) 19 [20] (21) 22 23 ([24]) 25 26 (27) [28] 29 (30) 31 [32] (33) 34 35 ([36]) 37 38 (39) [40] 41 (42) 43 [44] (45) 46 47 ([48]) 49 50 (51) [52] 53 (54) 55 [56] (57) 58 59 ([60]) 61 62 (63) [64] 65 (66) 67 [68] (69) 70 71 ([72]) 73 74 (75) [76] 77 (78) 79 [80] (81) 82 83 ([84]) 85 86 (87) [88] 89 (90) 91 [92] (93) 94 95 ([96]) 97 98 (99)
code-golf  kolmogorov-complexity 
— Monolica
fonte
6
— ETHproductions
3
È possibile emettere ciascuna voce su una nuova riga o l'output deve essere tutto su una riga?
— ETHproductions
4
L'output può terminare con uno spazio. Alcune risposte sembrano ipotizzarlo.
— Dennis,

Risposte:

4

Gelatina , 21 20 byte

³Ṗµ3,4ṚƬḍד([“])”j)K

Provalo online!

Come funziona

³Ṗµ3,4ṚƬḍד([“])”j)K  Main link. No arguments.

³                     Set the return value to 100.
 Ṗ                    Pop; yield [1, ..., 99].
  µ               )   Map the chain in between over [1, ..., 9]; for each integer k:
   3,4                    Set the return value to [3, 4].
      ṚƬ                  Reverse until a loop is reached. Yields [[3, 4], [4, 3]].
        ḍ                 Test k for divisibility by [[3, 4], [4, 3]], yielding a
                          matrix of Booleans.
         ד([“])”         Repeat the characters of [['(', '['], [']', ')']] as many
                          times as the Booleans indicate.
                 j        Join the resulting pair of strings, separated by k.
                   K  Join the resulting array of strings, separated by spaces.
— Dennis
fonte
3

D , 110 byte

import std.stdio;void f(){for(int i;i<99;)write(++i%3?"":"(",i%4?"":"[",i,i%4?"":"]",i%3?"":")",i%99?" ":"");}

Provalo online!

Portato dalla risposta C ++ di @ HatsuPointerKun.

— Zaccaria
fonte
3

Carbone , 30 byte

⪫ＥＥＥ⁹⁹Ｉ⊕ι⎇﹪⊕κ⁴ι⪫[]ι⎇﹪⊕κ³ι⪫()ι

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

    ⁹⁹                          Literal 99
   Ｅ                            Map over implicit range
        ι                       Current value
       ⊕                        Incrementd
      Ｉ                         Cast to string
  Ｅ                             Map over list of strings
            κ                   Current index
           ⊕                    Incremented
             ⁴                  Literal 4
          ﹪                     Modulo
              ι                 Current value
                []              Literal string `[]`
                  ι             Current value
               ⪫                Join i.e wrap value in `[]`
         ⎇                      Ternary
 Ｅ                              Map over list of strings
                      κ         Current index
                     ⊕          Incremented
                       ³        Literal 3
                    ﹪           Modulo
                        ι       Current value
                          ()    Literal string `()`
                            ι   Current value
                         ⪫      Join i.e wrap value in `()`
                   ⎇            Ternary
                                Literal space
⪫                               Join list
                                Implicitly print
— Neil
fonte
3

J , 54 53 byte

1 byte in meno grazie a @Jonah

(*stdout(3|.0=4 3 1 3 4&|,1=":)#3|.']) ([',":)@>i.100

Provalo online!

— FrownyFrog
fonte
Grazie per averlo fatto. Inoltre, perché devi fare stdoutqui ... Non l'ho mai visto prima. @FrownyFrog
— Jonah
@Jonah Non riesco ad emetterlo come una stringa completa, viene tagliato (...) Stdout non lo fa e non stampa nemmeno una nuova riga, quindi posso anche stampare ogni numero separatamente. Per qualche ragione, sebbene appaiano spazi finali (ce ne sono 4 e solo 1 è intenzionalmente lì)
— FrownyFrog
Questo approccio è davvero intelligente, sia la rotazione che la scelta da usare #. Avevo presentato un ausiliario verbo surround ()e []: g=. {.@[ , ":@] , {:@[. grazie alla verbosità!
— Giona
un'altra domanda: qualsiasi motivo tu abbia usato al LFposto di _. anche quest'ultimo sembra funzionare.
— Giona,
3

C, C ++, 136 133 131 129 128 124 byte

-5 byte grazie a Zacharý e ispirato alla funzione write () in linguaggio D (vedi risposta Zacharý)

-2 byte grazie a mriklojn

-12 byte per la versione C grazie a mriklojn

-4 byte grazie a ceilingcat

#include<cstdio>
void f(){for(int i=0;i++<99;)printf("(%s%d%s%s%s"+!!(i%3),i%4?"":"[",i,i%4?"":"]",i%3?"":")",i%99?" ":"");}

C Ottimizzazione specifica: 115 byte

#include<stdio.h>
i;f(){for(;i++<99;)printf("(%s%d%s%s%s"+!!(i%3),i%4?"":"[",i,i%4?"":"]",i%3?"":")",i%99?" ":"");}
— HatsuPointerKun
fonte
MSVC ti consente di fare la inf f()cosa? Mi dispiace per aver cancellato i miei commenti, pensavo di avere qualcosa di più corto (non l'ho fatto)
— Zacharý
@ Zacharý No, penso che la funzione sia troppo semplice e generi un "f deve restituire un int". A proposito, la tua soluzione è stata più corta di 3 byte (include la compressione associata allo spostamento dell'incremento di i)
— HatsuPointerKun
1
Dang, mi ero completamente dimenticato di una printfcosa. Non potresti usare la C stdio allora?
— Zacharý,
2
Un'altra cosa che potresti usare / sfruttare è il fatto che, almeno con gcc 5.3.1, non hai bisogno di #include, e puoi anche rimuovere il tipo restituito dalla funzione. Inoltre, se si dichiara l' int iesterno della funzione (nell'ambito globale), il valore predefinito è 0 e il tipo di dati predefinito int. Ciò comporterebbe il tuo ciclo a partire da 0, e per risolvere questo problema potresti spostare l'incremento nell'espressione condizione nel tuo ciclo for, facendolo apparire comei;f(){for(;++i<=99;)
— mriklojn
1
Suggerisci ")\0"+i%3invece di i%3?"":")". Inoltre, penso che devi aggiungere i=0all'inizio del ciclo.
— plafoniera
3

Powershell, 60 byte

"$(1..99|%{($_,"($_)","[$_]","([$_])")[!($_%3)+2*!($_%4)]})"

Spiegazione:

  • l'array con 4 elementi: $_, "($_)", "[$_]", "([$_])"
  • e l'indice: [!($_%3)+2*!($_%4)]
  • ripetere per ogni numero
  • converti il ​​risultato in una stringa

Script di test meno golfato:

$f = {

$r = 1..99|%{
    ($_, "($_)", "[$_]", "([$_])") [!($_%3)+2*!($_%4)]
}
"$($r)"

}

$expected = '1 2 (3) [4] 5 (6) 7 [8] (9) 10 11 ([12]) 13 14 (15) [16] 17 (18) 19 [20] (21) 22 23 ([24]) 25 26 (27) [28] 29 (30) 31 [32] (33) 34 35 ([36]) 37 38 (39) [40] 41 (42) 43 [44] (45) 46 47 ([48]) 49 50 (51) [52] 53 (54) 55 [56] (57) 58 59 ([60]) 61 62 (63) [64] 65 (66) 67 [68] (69) 70 71 ([72]) 73 74 (75) [76] 77 (78) 79 [80] (81) 82 83 ([84]) 85 86 (87) [88] 89 (90) 91 [92] (93) 94 95 ([96]) 97 98 (99)'
$result = &$f
$result-eq$expected
$result

Produzione:

True
1 2 (3) [4] 5 (6) 7 [8] (9) 10 11 ([12]) 13 14 (15) [16] 17 (18) 19 [20] (21) 22 23 ([24]) 25 26 (27) [28] 29 (30) 31 [32] (33) 34 35 ([36]) 37 38 (39) [40] 41 (42) 43 [44] (45) 46 47 ([48]) 49 50 (51) [52] 53 (54) 55 [56] (57) 58 59 ([60]) 61 62 (63) [64] 65 (66) 67 [68] (69) 70 71 ([72]) 73 74 (75) [76] 77 (78) 79 [80] (81) 82 83 ([84]) 85 86 (87) [88] 89 (90) 91 [92] (93) 94 95 ([96]) 97 98 (99)
— Mazzy
fonte
3

MathGolf , 41 40 34 29 byte

♀({îû)(î+╫îa_'(\')ßyΓî34α÷ä§

NOTA: ha uno spazio finale

Solo il mio secondo MathGolf risponde ..
-5 byte grazie a @JoKing .

Provalo online.

Spiegazione:

♀(             # Push 99 (100 decreased by 1)
  {            # Start a loop, which implicitly loops down to (and excluding) 0
   û)(         #  Push string ")("
      î+       #  Append the 1-indexed index
        ╫      #  Rotate the string once towards the right
   îa          #  Push the 1-indexed index of the loop, wrap in a list
   _           #  Duplicate it
    '(        '#  Push string "("
      \        #  Swap the top two items of the stack
       ')     '#  Push string ")"
         ßy    #  Wrap all three into a list, and join them
   Γ           #  Wrap all four into a list
               #  (We now have a list [N, "(N)", "[N]", "([N])"], where N is the index)
   î           #  Push the 1-indexed index of the loop
    34         #  Push 3 and 4 to the stack
      α        #  Wrap all three into a list
       ÷       #  Check for each if the index is divisible by it
               #  (resulting in either [0,0], [0,1], [1,0], or [1,1]
        ä      #  Convert from binary to integer
               #  (resulting in either 0, 1, 2, or 3
         §     #  Push the string at that index from the array
               #  Push a space
               # (After the loop, output the entire stack joined together implicitly)
— Kevin Cruijssen
fonte
@JoKing Grazie! Non sapevo che si qpotesse omettere ed è implicitamente fatto in loop. Inoltre, non sapevo che esistesse un built-in a 2/3/4-string. Peccato che il trucco di rotazione non funzioni con l'array spostato.
— Kevin Cruijssen,
Bene, è più che ho scambiato l'output esplicito ogni iterazione con output implicito alla fine del programma
— Jo King
@JoKing Sì, ma non sapevo che avrebbe prodotto l'intero stack unito, anziché solo all'inizio. :)
— Kevin Cruijssen,
La mia soluzione si stava avvicinando a 40 byte, anche se ho letto male e ho pensato che le parentesi graffe dovrebbero essere usate al posto delle parentesi quadre. Ottimo lavoro sulla soluzione!
— massimo
2

Lua, 161 123 byte

b=""for i=1,99 do;c,d=i%3==0,i%4==0;b=b..(c and"("or"")..(d and"["or"")..i..(d and"]"or"")..(c and")"or"").." "end;print(b)

Provalo online!

Ungolfed:

b = ""
for i = 1, 99 do
    c = 1 % 3 == 0
    d = 1 % 4 == 0
    a = ""
    if c then
        a = a .. "("
    end
    if d then
        a = a .. "["
    end
    a = a .. i
    if d then
        a = a .. "]"
    end
    if c then
        a = a .. ")"
    end
    b = b .. a .. " "
end
print(b)
— David Wheatley
fonte
2

C (gcc) , 84 byte

main(i){while(99/i++)printf("%s%s%d%s%s ","("+i%3,"["+i%4,i-1,"]"+i%4,")"+i%3);}

C'è un byte null all'inizio di ogni "stringa di parentesi".

Provalo online!

— Dennis
fonte
E in "(" + i% 3 come fai a sapere che l'indirizzo per i = 2 indica un valore di carattere zero? Lo stesso per "[" + i% 4 per i in {2,3}?
— RosLuP
Funziona con gcc, il che è abbastanza buono, poiché PPCG definisce i linguaggi in base alle loro implementazioni.
— Dennis,
Penso che non si possa dire che il codice sia ok compilato in ogni implementazione del compilatore gcc, forse solo quello eseguito sul PC (ma forse non troppo)
— RosLuP
@RosLuP gcc fa funzionano allo stesso modo maggior parte dei computer, però, almeno su qualsiasi cosa con la stessa architettura
— ASCII-only
@ ASCII possibile solo se è compilato ottimizzato per lo spazio o per la velocità il risultato è diverso ... Non so se è fuori standard ...
— RosLuP
2

PowerShell , 67 62 byte

"$(1..99|%{'('*!($x=$_%3)+'['*!($y=$_%4)+$_+']'*!$y+')'*!$x})"

Provalo online!

Fondamentalmente un FizzBuzz che usa moltiplicazioni di stringa per variabili booleane (implicitamente cast su 1 o 0). Tali stringhe vengono lasciate sulla pipeline e raccolte all'interno di un blocco di script tra virgolette. Poiché il valore predefinito $OutputFieldSeparatorper una matrice sono gli spazi, ciò ci dà implicitamente elementi della matrice delimitati da spazi.

— AdmBorkBork
fonte
2

C #, 124 117 123 byte

-5 byte grazie a Kevin Cruijssen

x=>{for(int i=0;i++<99;)System.Console.Write((i%3<1?"(":"")+(i%4<1?"[":"")+i+(i%4<1?"]":"")+(i%3<1?")":"")+(i>98?"":" "));}

Prova con:

Action<int> t = x=>{for(int i=0;i++<99;)System.Console.Write((i%3<1?"(":"")+(i%4<1?"[":"")+i+(i%4<1?"]":"")+(i%3<1?")":"")+(i>98?"":" "));}
t.Invoke(0);
Console.ReadKey();
— HatsuPointerKun
fonte
Vedo nell'incursione di C #. C # consente numeri interi come argomento di sinistra a un operatore ternario o deve essere un valore booleano?
— Zacharý,
Non so molto su C #, ma potresti usare xinvece di i, quindi non dovresti preoccuparti di int ? (Dovresti comunque impostarlo, ovviamente).
— Zacharý,
@ Zacharý No, genera un errore CS0029 "Impossibile convertire implicitamente int in booleano". E sì, potrei usare ie il fatto che posso inizializzarlo a 0 quando io Invoke. Ma ciò non significherebbe che dovrei includere la dichiarazione di t ( Action<int>) e la chiamata ( t.Invoke(0)) nel bytecount?
— HatsuPointerKun
Sto chiedendo se qualcosa del genere x=>{for(x=0;x++<99;)Console.Write((x%3==0?"(":"")+(x%4==0?"[":"")+x+(x%4==0?"]":"")+(x%3==0?")":"")+(x%99==0?"":" "));};funzionerebbe.
— Zacharý,
1
Tutti e cinque ==0possono essere <1.
— Kevin Cruijssen,
2

Rubino , 72 66 byte

p [*1..99].map{|x|a=x
a="[#{x}]"if x%4<1
a="(#{a})"if x%3<1
a}*' '

Grazie a @ jonathan-frech e @ conor-obrien per un ulteriore taglio.

— Attraverserà
fonte
Ciao e benvenuto in PPCG! 70 byte .
— Jonathan Frech,
Benvenuti in PPCG! Ecco altri 4 byte fuori dal suggerimento di @JonathanFrench, per 66 byte , poiché a.join bper un array ae una stringa bequivalgono aa*b
— Conor O'Brien,
2

PowerShell, 98 82 74 67 63 62 byte

Un enorme -31 byte grazie a @Veskah -5 byte grazie solo a @ ASCII

(1..99|%{(($a=($_,"[$_]")[!($_%4)]),"($a)")[!($_%3)]})-join' '

Provalo online!

Non sono ancora del tutto sicuro di quello che ho fatto qui.

— Gabriel Mills
fonte
Solo un po 'di golf veloce per 70 byte . Non devi lanciare $ a come stringa e "$a"sostituirai comunque il valore. (Nota: le virgolette singole non sostituiscono $foo, solo le virgolette doppie). Un altro trucco è se si preoccupa solo di 0 o 1, quindi è possibile utilizzare la logica booleana per salvare un byte
— Veskah,
67 byte se si utilizza anche l'indicizzazione dell'elenco.
— Veskah,
— ASCII, solo il
— ASCII il
— ASCII il
1

perl -E, 60 byte

$,=$";say map$_%12?$_%3?$_%4?$_:"[$_]":"($_)":"([$_])",1..99

Alcuni byte possono essere salvati se possiamo usare le nuove righe tra i numeri: in tal caso, possiamo rimuovere il $,=$";, cambiare il mapin un forciclo, mentre spostiamo il saynel ciclo.

1
Sei l' Abigail? Inventore di /^1$|^(11+?)\1+$/?
— msh210
1
Wow. Che onore averti qui!
— msh210,
1

Lotto, 145 byte

@set s=
@for /l %%i in (1,1,99)do @set/an=%%i,b=n%%4,p=n%%3&call:c
@echo%s%
:c
@if %b%==0 set n=[%n%]
@if %p%==0 set n=(%n%)
@set s=%s% %n%

Il codice rientra nella subroutine ma la stringa è già stata stampata da questo punto, quindi il codice viene eseguito in modo innocuo.

— Neil
fonte
1

sfk , 225 byte

for n from 1 to 99 +calc -var #(n)/3+1/3 -dig=0 +calc -var #text*3-#(n) +setvar t +calc -var #(n)/4 -dig=0 +calc -var #text*4-#(n) +xed -var _0_#(t)\[#(n)\]_ _*_#(t)#(n)_ +xed _0*_([part2])_ _?*_[part2]_ +xed "_\n_ _" +endfor

Provalo online!

— Οurous
fonte
1

Bash, 61 byte

-14 byte, grazie a Dennis

seq 99|awk '{ORS=" ";x=$1%4?$1:"["$1"]";print$1%3?x:"("x")"}'

spiegazione

Abbastanza diretto:

  • seq produce 1..99
  • lo colleghiamo awkcon il separatore del record di output ( ORS) impostato su spazio in modo che l'output sia una singola riga.
  • il corpo principale di Awk aggiunge "[]" quando il numero è divisibile per 4, quindi aggiunge "()" quando è divisibile per 3.

Provalo online!

— Giona
fonte
1

PHP, 65 byte

while($i++<99)echo$i%4?$i%3?$i:"($i)":($i%3?"[$i]":"([$i])")," ";

o

while($i++<99)echo"("[$i%3],"["[$i%4],$i,"]"[$i%4],")"[$i%3]," ";

(richiede PHP 5.5 o successivo)

Corri con -nro provali online .

— Titus
fonte
1

Python 2 , 78 byte

i=0
exec"i+=1;u=i%3/-2*(i%4/-3-1);print'([%0d])'[u:7-u:1+(i%3<1<=i%4)]%i,;"*99

Provalo online!

Ho immaginato questo approccio interessante, '([%0d])'ma non riesco ad ottenere espressioni più brevi.

— Lynn
fonte
1

Java 8, 92 91 byte

-1 byte grazie a @Dana

i->{for(;i++<99;)out.printf((i>1?" ":"")+(i%12<1?"([%d])":i%3<1?"(%d)":i%4<1?"[%d]":i),i);}

Provalo online!

Soluzione alternativa, 82 byte (con spazio finale nell'output - non sono sicuro che sia consentito):

i->{for(;i++<99;)out.printf((i%12<1?"([%d])":i%3<1?"(%d)":i%4<1?"[%d]":i)+" ",i);}

Spiegazione:

for(;i++<99;)- un ciclo for che va dal valore di i(riutilizzato come input, considerato 0 in questo caso) a 99

out.printf(<part1>+<part2>,i); - formatta la stringa prima di stamparla immediatamente su stdout con il valore di i

dove <part1>è (i>1?" ":"")- stampa lo spazio prima di stampare il numero a meno che che quel numero sia 1, nel qual caso omette lo spazio

ed <part2>è (i%12<1?"([%d])":i%3<1?"(%d)":i%4<1?"[%d]":i)- se iè divisibile per 3 e 4, iha parentesi quadre e rotonde attorno; altrimenti se iè divisibile per 3, iha parentesi tonde; altrimenti se iè divisibile per 4, iha parentesi quadre; altrimenti, inon ha parentesi.

— NotBaal
fonte
Salvare un byte spostando lo spazio all'inizio di ogni iterazione del ciclo(i>1:" ":"")
— dana,
Funzionerebbe solo se avessi stampato il risultato al contrario (vedi questo ) ma in realtà risparmierei 2 byte invece di 1.
— NotBaal
Sfortunatamente non è lo stesso dell'output atteso secondo la domanda, ma grazie comunque per il suggerimento!
— NotBaal,
1
I link "provalo online" sembrano non funzionare. Stavo pensando i->{for(;i++<99;)out.printf((i>1?" ":"")+(i%12<1?"([%d])":i%3<1?"(%d)":i%4<1?"[%d]":i),i);}?
— dana,
1
Ohhhh hai ragione che funziona! Grazie per quello!
— NotBaal,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.